DriverRegistroServiziDB.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.registry.driver.db;



  27. import java.sql.Connection;
  28. import java.sql.SQLException;
  29. import java.util.List;
  30. import java.util.Map;
  31. import java.util.Properties;

  33. import javax.sql.DataSource;

  35. import org.openspcoop2.core.byok.IDriverBYOK;
  36. import org.openspcoop2.core.byok.IDriverBYOKConfig;
  37. import org.openspcoop2.core.commons.CoreException;
  38. import org.openspcoop2.core.commons.DBUtils;
  39. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  40. import org.openspcoop2.core.commons.IDriverWS;
  41. import org.openspcoop2.core.commons.IMonitoraggioRisorsa;
  42. import org.openspcoop2.core.commons.ISearch;
  43. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  44. import org.openspcoop2.core.constants.Costanti;
  45. import org.openspcoop2.core.constants.CostantiDB;
  46. import org.openspcoop2.core.constants.ProprietariProtocolProperty;
  47. import org.openspcoop2.core.id.IDAccordo;
  48. import org.openspcoop2.core.id.IDAccordoAzione;
  49. import org.openspcoop2.core.id.IDAccordoCooperazione;
  50. import org.openspcoop2.core.id.IDFruizione;
  51. import org.openspcoop2.core.id.IDGruppo;
  52. import org.openspcoop2.core.id.IDPortType;
  53. import org.openspcoop2.core.id.IDPortTypeAzione;
  54. import org.openspcoop2.core.id.IDResource;
  55. import org.openspcoop2.core.id.IDRuolo;
  56. import org.openspcoop2.core.id.IDScope;
  57. import org.openspcoop2.core.id.IDServizio;
  58. import org.openspcoop2.core.id.IDSoggetto;
  59. import org.openspcoop2.core.registry.AccordoCooperazione;
  60. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  61. import org.openspcoop2.core.registry.AccordoServizioParteComuneServizioCompostoServizioComponente;
  62. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  63. import org.openspcoop2.core.registry.Azione;
  64. import org.openspcoop2.core.registry.Connettore;
  65. import org.openspcoop2.core.registry.Documento;
  66. import org.openspcoop2.core.registry.Fruitore;
  67. import org.openspcoop2.core.registry.Gruppo;
  68. import org.openspcoop2.core.registry.MessagePart;
  69. import org.openspcoop2.core.registry.Operation;
  70. import org.openspcoop2.core.registry.PortType;
  71. import org.openspcoop2.core.registry.PortaDominio;
  72. import org.openspcoop2.core.registry.Property;
  73. import org.openspcoop2.core.registry.Proprieta;
  74. import org.openspcoop2.core.registry.ProtocolProperty;
  75. import org.openspcoop2.core.registry.Resource;
  76. import org.openspcoop2.core.registry.ResourceParameter;
  77. import org.openspcoop2.core.registry.ResourceRepresentation;
  78. import org.openspcoop2.core.registry.ResourceResponse;
  79. import org.openspcoop2.core.registry.Ruolo;
  80. import org.openspcoop2.core.registry.Scope;
  81. import org.openspcoop2.core.registry.Soggetto;
  82. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  83. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  84. import org.openspcoop2.core.registry.constants.CredenzialeTipo;
  85. import org.openspcoop2.core.registry.constants.ParameterType;
  86. import org.openspcoop2.core.registry.constants.PddTipologia;
  87. import org.openspcoop2.core.registry.constants.ProprietariDocumento;
  88. import org.openspcoop2.core.registry.constants.TipiDocumentoLivelloServizio;
  89. import org.openspcoop2.core.registry.constants.TipiDocumentoSemiformale;
  90. import org.openspcoop2.core.registry.constants.TipiDocumentoSicurezza;
  91. import org.openspcoop2.core.registry.driver.BeanUtilities;
  92. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  93. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  94. import org.openspcoop2.core.registry.driver.FiltroRicerca;
  95. import org.openspcoop2.core.registry.driver.FiltroRicercaAccordi;
  96. import org.openspcoop2.core.registry.driver.FiltroRicercaAzioni;
  97. import org.openspcoop2.core.registry.driver.FiltroRicercaFruizioniServizio;
  98. import org.openspcoop2.core.registry.driver.FiltroRicercaGruppi;
  99. import org.openspcoop2.core.registry.driver.FiltroRicercaOperations;
  100. import org.openspcoop2.core.registry.driver.FiltroRicercaPortTypes;
  101. import org.openspcoop2.core.registry.driver.FiltroRicercaResources;
  102. import org.openspcoop2.core.registry.driver.FiltroRicercaRuoli;
  103. import org.openspcoop2.core.registry.driver.FiltroRicercaScope;
  104. import org.openspcoop2.core.registry.driver.FiltroRicercaServizi;
  105. import org.openspcoop2.core.registry.driver.FiltroRicercaSoggetti;
  106. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  107. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  108. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  109. import org.openspcoop2.core.registry.driver.IDriverRegistroServiziCRUD;
  110. import org.openspcoop2.core.registry.driver.IDriverRegistroServiziGet;
  111. import org.openspcoop2.core.registry.driver.ValidazioneStatoPackageException;
  112. import org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject;
  113. import org.openspcoop2.utils.LoggerWrapperFactory;
  114. import org.openspcoop2.utils.UtilsAlreadyExistsException;
  115. import org.openspcoop2.utils.UtilsException;
  116. import org.openspcoop2.utils.UtilsRuntimeException;
  117. import org.openspcoop2.utils.certificate.CertificateInfo;
  118. import org.openspcoop2.utils.crypt.CryptConfig;
  119. import org.openspcoop2.utils.datasource.DataSourceFactory;
  120. import org.openspcoop2.utils.datasource.DataSourceParams;
  121. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  122. import org.openspcoop2.utils.resources.GestoreJNDI;
  123. import org.openspcoop2.utils.sql.ISQLQueryObject;
  124. import org.slf4j.Logger;

  126. /**
  127.  * Classe utilizzata per effettuare query ad un registro dei servizi openspcoop
  128.  * formato da un db.
  129.  * 
  130.  * 
  131.  * @author Sandra Giangrandi (sandra@link.it)
  132.  * @author Stefano Corallo (corallo@link.it)
  133.  * @author $Author$
  134.  * @version $Rev$, $Date$
  135.  */

  137. public class DriverRegistroServiziDB extends BeanUtilities implements IDriverRegistroServiziGet,
  138. IDriverRegistroServiziCRUD, 
  139. IDriverWS ,IMonitoraggioRisorsa, IDriverBYOKConfig{

  141.     /* ******** F I E L D S P R I V A T I ******** */

  143.     /** Indicazione di una corretta creazione */
  144.     public boolean create = false;

  146.     // Datasource per la connessione al DB
  147.     private DataSource datasource = null;
  148.     // Connection passata al momento della creazione dell'oggetto
  149.     protected Connection globalConnection = null;
  150.     // Variabile di controllo del tipo di operazione da effettuare
  151.     // l'autoCommit viene gestito internamente a questa classe
  152.     protected boolean atomica = true;
  153.     public boolean isAtomica() {
  154.         return this.atomica;
  155.     }
  156.     
  157.     private static Logger checkLogger = null;
  158.     private static boolean checkIsClosed = true;
  159.     private static boolean checkAutocommit = true;
  160.     public static boolean isCheckIsClosed() {
  161.         return checkIsClosed;
  162.     }
  163.     public static void setCheckIsClosed(boolean checkIsClosed) {
  164.         DriverRegistroServiziDB.checkIsClosed = checkIsClosed;
  165.     }
  166.     public static boolean isCheckAutocommit() {
  167.         return checkAutocommit;
  168.     }
  169.     public static void setCheckAutocommit(boolean checkAutocommit) {
  170.         DriverRegistroServiziDB.checkAutocommit = checkAutocommit;
  171.     }
  172.     public static Logger getCheckLogger() {
  173.         return checkLogger;
  174.     }
  175.     public static void setCheckLogger(Logger checkLogger) {
  176.         DriverRegistroServiziDB.checkLogger = checkLogger;
  177.     }

  179.     /** Tabella soggetti */
  180.     protected String tabellaSoggetti = CostantiDB.SOGGETTI;

  182.     /** Logger utilizzato per info. */
  183.     protected Logger log = null;
  184.     void logDebug(String msg) {
  185.         if(this.log!=null) {
  186.             this.log.debug(msg);
  187.         }
  188.     }
  189.     void logDebug(String msg, Exception e) {
  190.         if(this.log!=null) {
  191.             this.log.debug(msg,e);
  192.         }
  193.     }

  195.     // Tipo database passato al momento della creazione dell'oggetto
  196.     protected String tipoDB = null;

  198.     public String getTipoDB() {
  199.         return this.tipoDB;
  200.     }

  202.     protected boolean useSuperUser = true;
  203.     public boolean isUseSuperUser() {
  204.         return this.useSuperUser;
  205.     }
  206.     public void setUseSuperUser(boolean useSuperUser) {
  207.         this.useSuperUser = useSuperUser;
  208.     }
  209.     

  211.     // Factory
  212.     protected IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  213.     protected IDAccordoCooperazioneFactory idAccordoCooperazioneFactory = IDAccordoCooperazioneFactory.getInstance();
  214.     protected IDServizioFactory idServizioFactory = IDServizioFactory.getInstance();

  216.     
  217.     // Driver
  218.     
  219.     private DriverRegistroServiziDB_accordiCooperazioneDriver accordiCooperazioneDriver = null;
  220.     
  221.     private DriverRegistroServiziDB_accordiDriver accordiDriver = null;
  222.     private DriverRegistroServiziDB_accordiSinteticiDriver accordiSinteticiDriver = null;
  223.     private DriverRegistroServiziDB_accordiSoapDriver accordiSoapDriver = null;
  224.     private DriverRegistroServiziDB_accordiRestDriver accordiRestDriver = null;
  225.     private DriverRegistroServiziDB_accordiFindAllDriver accordiFindAllDriver = null;
  226.     private DriverRegistroServiziDB_accordiExistsDriver accordiExistsDriver = null;
  227.     private DriverRegistroServiziDB_accordiServiziCompostiDriver accordiServiziCompostiDriver = null;
  228.     
  229.     private DriverRegistroServiziDB_pddDriver pddDriver = null;
  230.     
  231.     private DriverRegistroServiziDB_gruppiDriver gruppiDriver = null;
  232.     
  233.     private DriverRegistroServiziDB_ruoliDriver ruoliDriver = null;
  234.     
  235.     private DriverRegistroServiziDB_scopeDriver scopeDriver = null;
  236.     
  237.     private DriverRegistroServiziDB_soggettiDriver soggettiDriver = null;
  238.     private DriverRegistroServiziDB_soggettiCredenzialiDriver soggettiCredenzialiDriver = null;
  239.     private DriverRegistroServiziDB_soggettiSearchDriver soggettiSearchDriver = null;
  240.     
  241.     private DriverRegistroServiziDB_accordiParteSpecificaDriver accordiParteSpecificaDriver = null;
  242.     private DriverRegistroServiziDB_accordiParteSpecificaFruitoreDriver accordiParteSpecificaFruitoreDriver = null;
  243.     private DriverRegistroServiziDB_accordiParteSpecificaSearchDriver accordiParteSpecificaSearchDriver = null;
  244.     
  245.     private DriverRegistroServiziDB_connettoriDriver connettoriDriver = null;

  247.     private DriverRegistroServiziDB_documentiDriver documentiDriver = null;
  248.     
  249.     private DriverRegistroServiziDB_protocolPropertiesDriver protocolPropertiesDriver = null;
  250.     
  251.     private DriverRegistroServiziDB_utilsDriver utilsDriver = null;



  255.     

  257.     /* ******** COSTRUTTORI e METODI DI RELOAD ******** */

  259.     /**
  260.      * Costruttore.
  261.      * 
  262.      * @param nomeDataSource
  263.      *                Nome del Datasource da utilizzare per prelevare le
  264.      *                connessioni
  265.      * 
  266.      */
  267.     public DriverRegistroServiziDB(String nomeDataSource, Properties prop,String tipoDB) {
  268.         this(nomeDataSource,prop,null,tipoDB,false,false);
  269.     }
  270.     public DriverRegistroServiziDB(String nomeDataSource, Properties prop,Logger alog,String tipoDB){
  271.         this(nomeDataSource,prop,alog,tipoDB,false,false);
  272.     }
  273.     public DriverRegistroServiziDB(String nomeDataSource, Properties prop,Logger alog,String tipoDB, 
  274.             boolean useOp2UtilsDatasource, boolean bindJMX){


  277.         if(alog==null)
  278.             this.log = LoggerWrapperFactory.getLogger(CostantiRegistroServizi.REGISTRO_DRIVER_DB_LOGGER);
  279.         else{
  280.             this.log = alog;
  281.             DriverRegistroServiziDB_LIB.initStaticLogger(this.log);
  282.         }
  283.         if(this.log==null) {
  284.             throw new UtilsRuntimeException("Logger unavailable");
  285.         }
  286.         try {
  287.             this.log.info("Inizializzo DriverRegistroServiziDB..");
  288.             if(useOp2UtilsDatasource){
  289.                 DataSourceParams dsParams = Costanti.getDataSourceParamsPdD(bindJMX, tipoDB);
  290.                 try{
  291.                     this.datasource = DataSourceFactory.newInstance(nomeDataSource, prop, dsParams);
  292.                 }catch(UtilsAlreadyExistsException exists){
  293.                     this.datasource = DataSourceFactory.getInstance(nomeDataSource); 
  294.                     if(this.datasource==null){
  295.                         throw new CoreException("Lookup datasource non riuscita ("+exists.getMessage()+")",exists);
  296.                     }
  297.                 }
  298.             }
  299.             else{
  300.                 GestoreJNDI gestoreJNDI = new GestoreJNDI(prop);
  301.                 this.datasource = (DataSource) gestoreJNDI.lookup(nomeDataSource);
  302.             }
  303.             if (this.datasource != null)
  304.                 this.create = true;
  305.         } catch (Exception ne) {
  306.             this.log.error("Eccezione acquisendo il datasource: "+ne.getMessage(),ne);
  307.             this.create = false;
  308.         }

  310.         if (tipoDB == null) {
  311.             this.log.error("Il tipoDatabase non puo essere null.");
  312.             this.create = false;
  313.         }

  315.         this.atomica = true;
  316.         this.tipoDB = tipoDB;
  317.         // Setto il tipoDB anche in DriverRegistroServiziDB_LIB
  318.         DriverRegistroServiziDB_LIB.setTipoDB(tipoDB);
  319.         
  320.         // Driver
  321.         
  322.         this.accordiCooperazioneDriver = new DriverRegistroServiziDB_accordiCooperazioneDriver(this);
  323.         
  324.         this.accordiDriver = new DriverRegistroServiziDB_accordiDriver(this);
  325.         this.accordiSinteticiDriver = new DriverRegistroServiziDB_accordiSinteticiDriver(this);
  326.         this.accordiSoapDriver = new DriverRegistroServiziDB_accordiSoapDriver(this);
  327.         this.accordiRestDriver = new DriverRegistroServiziDB_accordiRestDriver(this);
  328.         this.accordiFindAllDriver = new DriverRegistroServiziDB_accordiFindAllDriver(this);
  329.         this.accordiExistsDriver = new DriverRegistroServiziDB_accordiExistsDriver(this);
  330.         this.accordiServiziCompostiDriver = new DriverRegistroServiziDB_accordiServiziCompostiDriver(this);
  331.         
  332.         this.pddDriver = new DriverRegistroServiziDB_pddDriver(this);
  333.         
  334.         this.gruppiDriver = new DriverRegistroServiziDB_gruppiDriver(this);
  335.         
  336.         this.ruoliDriver = new DriverRegistroServiziDB_ruoliDriver(this);
  337.         
  338.         this.scopeDriver = new DriverRegistroServiziDB_scopeDriver(this);
  339.         
  340.         this.soggettiDriver = new DriverRegistroServiziDB_soggettiDriver(this);
  341.         this.soggettiCredenzialiDriver = new DriverRegistroServiziDB_soggettiCredenzialiDriver(this);
  342.         this.soggettiSearchDriver = new DriverRegistroServiziDB_soggettiSearchDriver(this);
  343.         
  344.         this.accordiParteSpecificaDriver = new DriverRegistroServiziDB_accordiParteSpecificaDriver(this);
  345.         this.accordiParteSpecificaFruitoreDriver = new DriverRegistroServiziDB_accordiParteSpecificaFruitoreDriver(this);
  346.         this.accordiParteSpecificaSearchDriver = new DriverRegistroServiziDB_accordiParteSpecificaSearchDriver(this);
  347.         
  348.         this.connettoriDriver = new DriverRegistroServiziDB_connettoriDriver(this);
  349.         
  350.         this.documentiDriver = new DriverRegistroServiziDB_documentiDriver(this);
  351.         
  352.         this.protocolPropertiesDriver = new DriverRegistroServiziDB_protocolPropertiesDriver(this);
  353.         
  354.         this.utilsDriver = new DriverRegistroServiziDB_utilsDriver(this);

  356.     }

  358.     /**
  359.      * Costruttore Utilizzato dalle classi estese che gestiscono direttamente la
  360.      * connessione con il DB e si occupano di getstire il commit delle
  361.      * transazioni complesse
  362.      * 
  363.      * @param connection
  364.      * @throws DriverRegistroServiziException
  365.      */
  366.     public DriverRegistroServiziDB(Connection connection,String tipoDB) throws DriverRegistroServiziException {
  367.         this(connection,null,tipoDB);
  368.     }
  369.     public DriverRegistroServiziDB(Connection connection,Logger alog,String tipoDB) throws DriverRegistroServiziException {

  371.         if(alog==null)
  372.             this.log = LoggerWrapperFactory.getLogger(CostantiRegistroServizi.REGISTRO_DRIVER_DB_LOGGER);
  373.         else{
  374.             this.log = alog;
  375.             DriverRegistroServiziDB_LIB.initStaticLogger(this.log);
  376.         }

  378.         //  this.log.info("Inizializzo DriverRegistroServiziDB...");
  379.         if (connection == null) {
  380.             this.create = false;
  381.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB::DriverRegistroServiziDB(Connection ) La connection non puo essere null.");
  382.         }
  383.         if (tipoDB == null) {
  384.             this.create = false;
  385.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB::DriverRegistroServiziDB(Connection ) Il tipoDatabase non puo essere null.");
  386.         }
  387.         this.globalConnection = connection;
  388.         this.create = true;
  389.         this.atomica = false;       
  390.         this.tipoDB = tipoDB;
  391.         // Setto il tipoDB anche in DriverRegistroServiziDB_LIB
  392.         DriverRegistroServiziDB_LIB.setTipoDB(tipoDB);

  394.         // Driver
  395.         
  396.         this.accordiCooperazioneDriver = new DriverRegistroServiziDB_accordiCooperazioneDriver(this);
  397.         
  398.         this.accordiDriver = new DriverRegistroServiziDB_accordiDriver(this);
  399.         this.accordiSinteticiDriver = new DriverRegistroServiziDB_accordiSinteticiDriver(this);
  400.         this.accordiSoapDriver = new DriverRegistroServiziDB_accordiSoapDriver(this);
  401.         this.accordiRestDriver = new DriverRegistroServiziDB_accordiRestDriver(this);
  402.         this.accordiFindAllDriver = new DriverRegistroServiziDB_accordiFindAllDriver(this);
  403.         this.accordiExistsDriver = new DriverRegistroServiziDB_accordiExistsDriver(this);
  404.         this.accordiServiziCompostiDriver = new DriverRegistroServiziDB_accordiServiziCompostiDriver(this);
  405.         
  406.         this.pddDriver = new DriverRegistroServiziDB_pddDriver(this);
  407.         
  408.         this.gruppiDriver = new DriverRegistroServiziDB_gruppiDriver(this);
  409.         
  410.         this.ruoliDriver = new DriverRegistroServiziDB_ruoliDriver(this);
  411.         
  412.         this.scopeDriver = new DriverRegistroServiziDB_scopeDriver(this);
  413.         
  414.         this.soggettiDriver = new DriverRegistroServiziDB_soggettiDriver(this);
  415.         this.soggettiCredenzialiDriver = new DriverRegistroServiziDB_soggettiCredenzialiDriver(this);
  416.         this.soggettiSearchDriver = new DriverRegistroServiziDB_soggettiSearchDriver(this);
  417.         
  418.         this.accordiParteSpecificaDriver = new DriverRegistroServiziDB_accordiParteSpecificaDriver(this);
  419.         this.accordiParteSpecificaFruitoreDriver = new DriverRegistroServiziDB_accordiParteSpecificaFruitoreDriver(this);
  420.         this.accordiParteSpecificaSearchDriver = new DriverRegistroServiziDB_accordiParteSpecificaSearchDriver(this);
  421.         
  422.         this.connettoriDriver = new DriverRegistroServiziDB_connettoriDriver(this);
  423.         
  424.         this.documentiDriver = new DriverRegistroServiziDB_documentiDriver(this);
  425.         
  426.         this.protocolPropertiesDriver = new DriverRegistroServiziDB_protocolPropertiesDriver(this);
  427.         
  428.         this.utilsDriver = new DriverRegistroServiziDB_utilsDriver(this);
  429.     }
  430.     
  431.     
  432.     
  433.     public Connection getConnection(String methodName) throws DriverRegistroServiziException{
  434.         Connection con = null;
  435.         
  436.         if (this.atomica) {
  437.             try {
  438.                 con = this.getConnectionFromDatasource(methodName);
  439.             } catch (Exception e) {
  440.                 throw new DriverRegistroServiziException("[DriverRegistroServiziDB::getConnection] Exception accedendo al datasource :" + e.getMessage(),e);

  442.             }

  444.         } else
  445.             con = this.globalConnection;
  446.         
  447.         return con;
  448.     }
  449.     
  450.     public void releaseConnection(Connection con){
  451.         if (this.atomica) {
  452.             try {
  453.                 JDBCUtilities.closeConnection(checkLogger, con, checkAutocommit, checkIsClosed);
  454.             } catch (Exception e) {
  455.                 // ignore
  456.             }
  457.         }
  458.     }


  461.     Connection getConnectionFromDatasource(String methodName) throws SQLException {
  462.         if(this.datasource instanceof org.openspcoop2.utils.datasource.DataSource){
  463.             return ((org.openspcoop2.utils.datasource.DataSource)this.datasource).getWrappedConnection(null, "DriverRegistroServizi."+methodName);
  464.         }
  465.         else{
  466.             return this.datasource.getConnection();
  467.         }
  468.     }

  470.     
  471.     public List<List<Object>> readCustom(ISQLQueryObject sqlQueryObject, List<Class<?>> returnTypes, List<JDBCObject> paramTypes) throws DriverRegistroServiziException
  472.     {
  473.         Connection con = null;
  474.         try {

  476.             this.log.debug("operazione atomica = " + this.atomica);
  477.             // prendo la connessione dal pool
  478.             if (this.atomica)
  479.                 con = this.getConnectionFromDatasource("readCustom");
  480.             else
  481.                 con = this.globalConnection;
  482.         
  483.             return DBUtils.readCustom(this.log, con, this.tipoDB, sqlQueryObject, returnTypes, paramTypes);
  484.             
  485.         }catch (Exception se) {
  486.             throw new DriverRegistroServiziException("[DriverRegistroServiziDB::readCustom]: " + se.getMessage(),se);
  487.         } finally {
  488.             closeConnection(con);
  489.         }
  490.     }
  491.     
  492.     public void closeConnection(Connection conParam, Connection con) {
  493.         try {
  494.             if (conParam==null && this.atomica) {
  495.                 this.log.debug("rilascio connessione al db...");
  496.                 JDBCUtilities.closeConnection(checkLogger, con, checkAutocommit, checkIsClosed);
  497.             }
  498.         } catch (Exception e) {
  499.             // ignore
  500.         }
  501.     }
  502.     
  503.     public void closeConnection(Connection con) {
  504.         try {
  505.             if (this.atomica) {
  506.                 this.log.debug("rilascio connessioni al db...");
  507.                 JDBCUtilities.closeConnection(checkLogger, con, checkAutocommit, checkIsClosed);
  508.             }
  509.         } catch (Exception e) {
  510.             // ignore exception
  511.         }
  512.     }
  513.     
  514.     public void closeConnection(boolean error, Connection con) {
  515.         try {
  516.             if (error && this.atomica) {
  517.                 this.log.debug("eseguo rollback a causa di errori e rilascio connessioni...");
  518.                 if(con!=null) {
  519.                     con.rollback();
  520.                     con.setAutoCommit(true);
  521.                     JDBCUtilities.closeConnection(checkLogger, con, checkAutocommit, checkIsClosed);
  522.                 }

  524.             } else if (!error && this.atomica) {
  525.                 this.log.debug("eseguo commit e rilascio connessioni...");
  526.                 if(con!=null) {
  527.                     con.commit();
  528.                     con.setAutoCommit(true);
  529.                     JDBCUtilities.closeConnection(checkLogger, con, checkAutocommit, checkIsClosed);
  530.                 }
  531.             }

  533.         } catch (Exception e) {
  534.             // ignore exception
  535.         }
  536.     }
  537.     
  538.     
  539.     
  540.     
  541.     // *** BYOK ***
  542.     
  543.     private IDriverBYOK driverBYOK = null;
  544.     private boolean wrapBYOK;
  545.     private boolean unwrapBYOK;
  546.     
  547.     @Override
  548.     public void initialize(IDriverBYOK driver, 
  549.             boolean wrap, boolean unwrap) throws UtilsException{
  550.         this.driverBYOK = driver;
  551.         this.wrapBYOK = wrap;
  552.         this.unwrapBYOK = unwrap;
  553.     }

  555.     public IDriverBYOK getDriverWrapBYOK() {
  556.         return this.wrapBYOK ? this.driverBYOK : null;
  557.     }
  558.     public IDriverBYOK getDriverUnwrapBYOK() {
  559.         return this.unwrapBYOK ? this.driverBYOK : null;
  560.     }
  561.     
  562.     
  563.     


  566.     /* Accordi di Cooperazione */

  568.     /**
  569.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.AccordoCooperazione}, 
  570.      * identificato grazie al parametro 
  571.      * <var>nomeAccordo</var> 
  572.      *
  573.      * @param idAccordo Identificativo dell'accordo di Cooperazione
  574.      * @return un oggetto di tipo {@link org.openspcoop2.core.registry.AccordoCooperazione}.
  575.      * 
  576.      */
  577.     @Override
  578.     public org.openspcoop2.core.registry.AccordoCooperazione getAccordoCooperazione(IDAccordoCooperazione idAccordo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  579.         return this.accordiCooperazioneDriver.getAccordoCooperazione(idAccordo);
  580.     }
  581.     public org.openspcoop2.core.registry.AccordoCooperazione getAccordoCooperazione(IDAccordoCooperazione idAccordo,boolean readContenutoAllegati) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  582.         return this.accordiCooperazioneDriver.getAccordoCooperazione(idAccordo,readContenutoAllegati);
  583.     }

  585.     public IDAccordoCooperazione getIdAccordoCooperazione(long id) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  586.         return this.accordiCooperazioneDriver.getIdAccordoCooperazione(id);
  587.     }
  588.     public IDAccordoCooperazione getIdAccordoCooperazione(long id,Connection conParam) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  589.         return this.accordiCooperazioneDriver.getIdAccordoCooperazione(id, conParam);
  590.     }

  592.     public AccordoCooperazione getAccordoCooperazione(long id) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  593.         return this.accordiCooperazioneDriver.getAccordoCooperazione(id);
  594.     }
  595.     public AccordoCooperazione getAccordoCooperazione(long id,Connection conParam) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  596.         return this.accordiCooperazioneDriver.getAccordoCooperazione(id,conParam);
  597.     }

  599.     /**
  600.      * Ritorna gli identificatori degli accordi che rispettano il parametro di ricerca
  601.      * 
  602.      * @param filtroRicerca
  603.      * @return Una lista di ID degli accordi trovati
  604.      * @throws DriverRegistroServiziException
  605.      * @throws DriverRegistroServiziNotFound
  606.      */
  607.     @Override
  608.     public List<IDAccordoCooperazione> getAllIdAccordiCooperazione(FiltroRicercaAccordi filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  609.         return this.accordiCooperazioneDriver.getAllIdAccordiCooperazione(filtroRicerca);
  610.     }

  612.     /**
  613.      * Crea un nuovo AccordoCooperazione
  614.      * 
  615.      * @param accordoCooperazione
  616.      * @throws DriverRegistroServiziException
  617.      */
  618.     @Override
  619.     public void createAccordoCooperazione(AccordoCooperazione accordoCooperazione) throws DriverRegistroServiziException{
  620.         this.accordiCooperazioneDriver.createAccordoCooperazione(accordoCooperazione);
  621.     }

  623.     /**
  624.      * Verifica l'esistenza di un accordo registrato.
  625.      *
  626.      * @param idAccordo dell'accordo da verificare
  627.      * @return true se l'accordo esiste, false altrimenti
  628.      * @throws DriverRegistroServiziException
  629.      */    
  630.     @Override
  631.     public boolean existsAccordoCooperazione(IDAccordoCooperazione idAccordo) throws DriverRegistroServiziException{
  632.         return this.accordiCooperazioneDriver.existsAccordoCooperazione(idAccordo);
  633.     }

  635.     /**
  636.      * Aggiorna l'AccordoCooperazione con i nuovi valori.
  637.      *  
  638.      * @param accordoCooperazione
  639.      * @throws DriverRegistroServiziException
  640.      */
  641.     @Override
  642.     public void updateAccordoCooperazione(AccordoCooperazione accordoCooperazione) throws DriverRegistroServiziException{
  643.         this.accordiCooperazioneDriver.updateAccordoCooperazione(accordoCooperazione);
  644.     }

  646.     /**
  647.      * Elimina un AccordoCooperazione 
  648.      *  
  649.      * @param accordoCooperazione
  650.      * @throws DriverRegistroServiziException
  651.      */
  652.     @Override
  653.     public void deleteAccordoCooperazione(AccordoCooperazione accordoCooperazione) throws DriverRegistroServiziException{
  654.         this.accordiCooperazioneDriver.deleteAccordoCooperazione(accordoCooperazione);
  655.     }
  656.     
  657.     public List<AccordoCooperazione> accordiCooperazioneList(String superuser, ISearch ricerca) throws DriverRegistroServiziException {
  658.         return this.accordiCooperazioneDriver.accordiCooperazioneList(superuser, ricerca);
  659.     }

  661.     public List<IDSoggetto> accordiCoopPartecipantiList(long idAccordo,ISearch ricerca) throws DriverRegistroServiziException {
  662.         return this.accordiCooperazioneDriver.accordiCoopPartecipantiList(idAccordo, ricerca);
  663.     }

  665.     public List<AccordoCooperazione> accordiCoopWithSoggettoPartecipante(IDSoggetto idSoggetto) throws DriverRegistroServiziException {
  666.         return this.accordiCooperazioneDriver.accordiCoopWithSoggettoPartecipante(idSoggetto);
  667.     }

  669.     public void validaStatoAccordoCooperazione(AccordoCooperazione ac) throws ValidazioneStatoPackageException{
  670.         this.accordiCooperazioneDriver.validaStatoAccordoCooperazione(ac);
  671.     }
  672.     

  674.     /* Accordi di Servizio Parte Comune Sintetici */
  675.     
  676.     public org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico getAccordoServizioParteComuneSintetico(IDAccordo idAccordo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  677.         return this.accordiSinteticiDriver.getAccordoServizioParteComuneSintetico(idAccordo);
  678.     }   
  679.     
  680.     public org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico getAccordoServizioParteComuneSintetico(long idAccordo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  681.         return this.accordiSinteticiDriver.getAccordoServizioParteComuneSintetico(idAccordo);
  682.     }
  683.     
  684.     public List<AccordoServizioParteComuneSintetico> accordiList(String superuser, ISearch ricerca) throws DriverRegistroServiziException {
  685.         return this.accordiSinteticiDriver.accordiList(superuser, ricerca);
  686.     }
  687.     public List<AccordoServizioParteComuneSintetico> accordiServizioParteComuneList(String superuser, ISearch ricerca) throws DriverRegistroServiziException {
  688.         return this.accordiSinteticiDriver.accordiServizioParteComuneList(superuser, ricerca);
  689.     }
  690.     public List<AccordoServizioParteComuneSintetico> accordiServizioCompostiList(String superuser, ISearch ricerca) throws DriverRegistroServiziException {
  691.         return this.accordiSinteticiDriver.accordiServizioCompostiList(superuser, ricerca);
  692.     }
  693.     
  694.     
  695.     /* Accordi di Servizio Parte Comune */
  696.     
  697.     public int getAccordoServizioParteComuneNextVersion(IDAccordo idAccordo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  698.         return this.accordiDriver.getAccordoServizioParteComuneNextVersion(idAccordo);
  699.     }   

  701.     /**
  702.      * Si occupa di ritornare l'oggetto
  703.      * {@link org.openspcoop2.core.registry.AccordoServizioParteComune}, identificato grazie
  704.      * al parametro <var>nomeAccordo</var>
  705.      * 
  706.      * @param idAccordo
  707.      *                Nome dell'accordo di Servizio
  708.      * @return l'oggetto di tipo
  709.      *         {@link org.openspcoop2.core.registry.AccordoServizioParteComune}
  710.      * 
  711.      */
  712.     @Override
  713.     public org.openspcoop2.core.registry.AccordoServizioParteComune getAccordoServizioParteComune(IDAccordo idAccordo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  714.         return this.accordiDriver.getAccordoServizioParteComune(idAccordo);
  715.     }
  716.     public org.openspcoop2.core.registry.AccordoServizioParteComune getAccordoServizioParteComune(IDAccordo idAccordo,boolean readContenutoAllegati,boolean readDatiRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  717.         return this.accordiDriver.getAccordoServizioParteComune(idAccordo, readContenutoAllegati, readDatiRegistro);
  718.     }

  720.     public IDAccordo getIdAccordoServizioParteComune(long id) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  721.         return this.accordiDriver.getIdAccordoServizioParteComune(id);
  722.     }
  723.     public IDAccordo getIdAccordoServizioParteComune(long id,Connection conParam) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  724.         return this.accordiDriver.getIdAccordoServizioParteComune(id, conParam);
  725.     }

  727.     public AccordoServizioParteComune getAccordoServizioParteComune(long id) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  728.         return this.accordiDriver.getAccordoServizioParteComune(id);
  729.     }
  730.     public AccordoServizioParteComune getAccordoServizioParteComune(long id, boolean readContenutoAllegati,boolean readDatiRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  731.         return this.accordiDriver.getAccordoServizioParteComune(id, readContenutoAllegati, readDatiRegistro);
  732.     }
  733.     public AccordoServizioParteComune getAccordoServizioParteComune(long id,Connection conParam) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  734.         return this.accordiDriver.getAccordoServizioParteComune(id, conParam);
  735.     }
  736.     public AccordoServizioParteComune getAccordoServizioParteComune(long id, boolean readContenutoAllegati,boolean readDatiRegistro,Connection conParam) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  737.         return this.accordiDriver.getAccordoServizioParteComune(id, readContenutoAllegati, readDatiRegistro, conParam);
  738.     }

  740.     @Override
  741.     public List<IDAccordo> getAllIdAccordiServizioParteComune(FiltroRicercaAccordi filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  742.         return this.accordiFindAllDriver.getAllIdAccordiServizioParteComune(filtroRicerca);
  743.     }
  744.     
  745.     @Override
  746.     public List<IDPortType> getAllIdPortType(FiltroRicercaPortTypes filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  747.         return this.accordiFindAllDriver.getAllIdPortType(filtroRicerca);
  748.     }
  749.     
  750.     @Override
  751.     public List<IDPortTypeAzione> getAllIdAzionePortType(FiltroRicercaOperations filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  752.         return this.accordiFindAllDriver.getAllIdAzionePortType(filtroRicerca);
  753.     }
  754.     
  755.     @Override
  756.     public List<IDAccordoAzione> getAllIdAzioneAccordo(FiltroRicercaAzioni filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  757.         return this.accordiFindAllDriver.getAllIdAzioneAccordo(filtroRicerca);
  758.     }
  759.     
  760.     @Override
  761.     public List<IDResource> getAllIdResource(FiltroRicercaResources filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  762.         return this.accordiFindAllDriver.getAllIdResource(filtroRicerca);
  763.     }
  764.     

  766.     /**
  767.      * Crea un nuovo AccordoServizio inserendolo nel DB Se il parametro
  768.      * Connection e' null vuol dire che e' un'operazione atomica, altrimenti
  769.      * vuol dire che l'operazione e' stata richiesta dalla parte 'estesa' (GUI)
  770.      * e che non bisogna fare il commit a questo livello
  771.      * 
  772.      * @param accordoServizio
  773.      * @throws DriverRegistroServiziException
  774.      */
  775.     @Override
  776.     public void createAccordoServizioParteComune(org.openspcoop2.core.registry.AccordoServizioParteComune accordoServizio) throws DriverRegistroServiziException {
  777.         this.accordiDriver.createAccordoServizioParteComune(accordoServizio);
  778.     }

  780.     /**
  781.      * Verifica l'esistenza di un accordo registrato.
  782.      * 
  783.      * @param idAccordo id 
  784.      *                dell'accordo da verificare
  785.      * @return true se l'accordo esiste, false altrimenti
  786.      */
  787.     @Override
  788.     public boolean existsAccordoServizioParteComune(IDAccordo idAccordo) throws DriverRegistroServiziException {
  789.         return this.accordiExistsDriver.existsAccordoServizioParteComune(idAccordo);
  790.     }

  792.     /**
  793.      * Verifica l'esistenza di un accordo registrato.
  794.      * 
  795.      * @param idAccordo
  796.      *                dell'accordo da verificare
  797.      * @return true se l'accordo esiste, false altrimenti
  798.      */
  799.     public boolean existsAccordoServizioParteComune(long idAccordo) throws DriverRegistroServiziException {
  800.         return this.accordiExistsDriver.existsAccordoServizioParteComune(idAccordo);
  801.     }

  803.     /**
  804.      * Verifica l'esistenza di un'azione in un accordo
  805.      * 
  806.      * @param nome
  807.      *                dell'azione da verificare
  808.      * @param idAccordo Identificativo dell'accordi di servizio
  809.      *               
  810.      * @return true se l'azione esiste, false altrimenti
  811.      */
  812.     public boolean existsAccordoServizioParteComuneAzione(String nome, IDAccordo idAccordo) throws DriverRegistroServiziException {
  813.         return this.accordiExistsDriver.existsAccordoServizioParteComuneAzione(nome, idAccordo);
  814.     }

  816.     /**
  817.      * Verifica l'esistenza di un'azione in un accordo
  818.      * 
  819.      * @param nome
  820.      *                dell'azione da verificare
  821.      * @param idAccordo
  822.      *                dell'accordo
  823.      * @return true se l'azione esiste, false altrimenti
  824.      */
  825.     public boolean existsAccordoServizioParteComuneAzione(String nome, long idAccordo) throws DriverRegistroServiziException {
  826.         return this.accordiExistsDriver.existsAccordoServizioParteComuneAzione(nome, idAccordo);
  827.     }

  829.     /**
  830.      * Verifica l'esistenza di un'azione in un accordo
  831.      * 
  832.      * @param idAzione dell'azione
  833.      * @return true se l'azione esiste, false altrimenti
  834.      */
  835.     public boolean existsAccordoServizioParteComuneAzione(long idAzione) throws DriverRegistroServiziException {
  836.         return this.accordiExistsDriver.existsAccordoServizioParteComuneAzione(idAzione);
  837.     }

  839.     public boolean existsAccordoServizioParteComunePorttype(String nome, IDAccordo idAccordo) throws DriverRegistroServiziException {
  840.         return this.accordiExistsDriver.existsAccordoServizioParteComunePorttype(nome, idAccordo);
  841.     }

  843.     /**
  844.      * Verifica l'esistenza di un'operation in un accordo
  845.      * 
  846.      * @param idAzione dell'azione
  847.      * @return true se l'azione esiste, false altrimenti
  848.      */
  849.     public boolean existsAccordoServizioParteComuneOperation(long idAzione) throws DriverRegistroServiziException {
  850.         return this.accordiExistsDriver.existsAccordoServizioParteComuneOperation(idAzione);
  851.     }

  853.     /**
  854.      * Verifica l'esistenza di un port-type in un accordo
  855.      * 
  856.      * @param nome
  857.      *                del port-type da verificare
  858.      * @param idAccordo
  859.      *                dell'accordo
  860.      * @return true se il port-type esiste, false altrimenti
  861.      */
  862.     public boolean existsAccordoServizioParteComunePorttype(String nome, long idAccordo) throws DriverRegistroServiziException {
  863.         return this.accordiExistsDriver.existsAccordoServizioParteComunePorttype(nome, idAccordo);
  864.     }

  866.     /**
  867.      * 
  868.      * @param nome Nome dell'operation
  869.      * @param idPortType L'identificativo del PortType
  870.      * @return true se esiste, false altrimenti.
  871.      * @throws DriverRegistroServiziException
  872.      */
  873.     public boolean existsAccordoServizioParteComunePorttypeOperation(String nome, IDPortType idPortType) throws DriverRegistroServiziException {
  874.         return this.accordiExistsDriver.existsAccordoServizioParteComunePorttypeOperation(nome, idPortType);
  875.     }

  877.     /**
  878.      * Verifica l'esistenza di un operation in un port-type
  879.      * 
  880.      * @param nome
  881.      *                dell'operation da verificare
  882.      * @param idPortType
  883.      *                del port-type
  884.      * @return true se l'operation esiste, false altrimenti
  885.      */
  886.     public boolean existsAccordoServizioParteComunePorttypeOperation(String nome, long idPortType) throws DriverRegistroServiziException {
  887.         return this.accordiExistsDriver.existsAccordoServizioParteComunePorttypeOperation(nome, idPortType);
  888.     }
  889.     
  890.     /**
  891.      * Verifica l'esistenza di un risorsa con determinato nome in un accordo
  892.      * 
  893.      * @param nome
  894.      *                del port-type da verificare
  895.      * @param idAccordo
  896.      *                dell'accordo
  897.      * @return true se il port-type esiste, false altrimenti
  898.      */
  899.     public boolean existsAccordoServizioParteComuneResource(String nome, long idAccordo) throws DriverRegistroServiziException {
  900.         return this.accordiExistsDriver.existsAccordoServizioParteComuneResource(nome, idAccordo);
  901.     }
  902.     
  903.     public boolean existsAccordoServizioParteComuneResource(String httpMethod, String path, long idAccordo, String excludeResourceWithName) throws DriverRegistroServiziException {
  904.         return this.accordiExistsDriver.existsAccordoServizioParteComuneResource(httpMethod, path, idAccordo, excludeResourceWithName);
  905.     }
  906.     
  907.     /**
  908.      * Verifica l'esistenza di un response con Status in una Resource
  909.      * 
  910.      * @param httpStatus
  911.      *                 della response da verificare
  912.      * @param idRisorsa
  913.      *                della resource
  914.      * @return true se la risposta esiste, false altrimenti
  915.      */
  916.     public boolean existsAccordoServizioResourceResponse(long idRisorsa, int httpStatus) throws DriverRegistroServiziException {
  917.         return this.accordiExistsDriver.existsAccordoServizioResourceResponse(idRisorsa, httpStatus);
  918.     }
  919.     
  920.     public boolean existsAccordoServizioResourceRepresentation(Long idRisorsa, boolean isRequest, Long idResponse, String mediaType) throws DriverRegistroServiziException {
  921.         return this.accordiExistsDriver.existsAccordoServizioResourceRepresentation(idRisorsa, isRequest, idResponse, mediaType);
  922.     }
  923.     
  924.     public boolean existsAccordoServizioResourceParameter(Long idRisorsa, boolean isRequest, Long idResponse, ParameterType tipo, String nome) throws DriverRegistroServiziException {
  925.         return this.accordiExistsDriver.existsAccordoServizioResourceParameter(idRisorsa, isRequest, idResponse, tipo, nome);
  926.     }

  928.     /**
  929.      * Aggiorna l'elemento nel database con i nuovi valori. Se il parametro
  930.      * Connection e' null vuol dire che e' un'operazione atomica, altrimenti
  931.      * vuol dire che l'operazione e' stata richiesta dalla parte 'estesa' (GUI)
  932.      * e che non bisogna fare il commit a questo livello
  933.      * 
  934.      * @param accordoServizio
  935.      * @throws DriverRegistroServiziException
  936.      */
  937.     @Override
  938.     public void updateAccordoServizioParteComune(org.openspcoop2.core.registry.AccordoServizioParteComune accordoServizio) throws DriverRegistroServiziException {
  939.         this.accordiDriver.updateAccordoServizioParteComune(accordoServizio);
  940.     }

  942.     /**
  943.      * Aggiorna l'elemento nel database con i nuovi valori. Se il parametro
  944.      * Connection e' null vuol dire che e' un'operazione atomica, altrimenti
  945.      * vuol dire che l'operazione e' stata richiesta dalla parte 'estesa' (GUI)
  946.      * e che non bisogna fare il commit a questo livello
  947.      * 
  948.      * @param portType
  949.      * @throws DriverRegistroServiziException
  950.      */
  951.     public void updatePortType(org.openspcoop2.core.registry.PortType portType, String user) throws DriverRegistroServiziException {
  952.         this.accordiSoapDriver.updatePortType(portType, user);
  953.     }
  954.     
  955.     /**
  956.      * Elimina un AccordoServizio nel database e le eventuali azioni collegate
  957.      * Se il parametro Connection e' null vuol dire che e' un'operazione
  958.      * atomica, altrimenti vuol dire che l'operazione e' stata richiesta dalla
  959.      * parte 'estesa' (GUI) e che non bisogna fare il commit a questo livello
  960.      * 
  961.      * @param accordoServizio
  962.      * @throws DriverRegistroServiziException
  963.      */
  964.     @Override
  965.     public void deleteAccordoServizioParteComune(org.openspcoop2.core.registry.AccordoServizioParteComune accordoServizio) throws DriverRegistroServiziException {
  966.         this.accordiDriver.deleteAccordoServizioParteComune(accordoServizio);
  967.     }

  969.     public List<Azione> accordiAzioniList(long idAccordo, ISearch ricerca) throws DriverRegistroServiziException{
  970.         return this.accordiSoapDriver.accordiAzioniList(idAccordo, ricerca);
  971.     }

  973.     /**
  974.      * Recupera la lista di azioni dell'Accordo con id idAccordo, con il profilo di collaborazione specificato
  975.      * Il profilo di collaborazione viene ricercato nell'accordo di servizio se l'azione ha profilo di defaul
  976.      * altrimenti viene controllato il profilo di collaborazione dell'azione 
  977.      * @param idAccordo
  978.      * @param profiloCollaborazione Opzionale
  979.      * @param ricerca
  980.      * @return Lista di {@link Azione} dell'accordo idAccordo con profilo di collaborazione 'profiloCollaborazione' se specificato altrimenti tutte.
  981.      * @throws DriverRegistroServiziException
  982.      */
  983.     public List<Azione> accordiAzioniList(long idAccordo,String profiloCollaborazione, ISearch ricerca) throws DriverRegistroServiziException {
  984.         return this.accordiSoapDriver.accordiAzioniList(idAccordo, profiloCollaborazione, ricerca);
  985.     }
  986.     
  987.     public List<IDAccordoDB> idAccordiList(String superuser, ISearch ricerca, 
  988.             boolean soloAccordiConsistentiRest, boolean soloAccordiConsistentiSoap) throws DriverRegistroServiziException {
  989.         return this.accordiDriver.idAccordiList(superuser, ricerca, 
  990.                 soloAccordiConsistentiRest, soloAccordiConsistentiSoap);
  991.     }
  992.     public List<IDAccordoDB> idAccordiServizioParteComuneList(String superuser, ISearch ricerca, 
  993.             boolean soloAccordiConsistentiRest, boolean soloAccordiConsistentiSoap) throws DriverRegistroServiziException {
  994.         return this.accordiDriver.idAccordiServizioParteComuneList(superuser, ricerca, 
  995.                 soloAccordiConsistentiRest, soloAccordiConsistentiSoap);
  996.     }
  997.     public List<IDAccordoDB> idAccordiServizioCompostiList(String superuser, ISearch ricerca, 
  998.             boolean soloAccordiConsistentiRest, boolean soloAccordiConsistentiSoap) throws DriverRegistroServiziException {
  999.         return this.accordiDriver.idAccordiServizioCompostiList(superuser, ricerca, 
  1000.                 soloAccordiConsistentiRest, soloAccordiConsistentiSoap);
  1001.     }
  1002.     
  1003.     public List<Documento> accordiAllegatiList(long idAccordo, ISearch ricerca) throws DriverRegistroServiziException {
  1004.         return this.accordiDriver.accordiAllegatiList(idAccordo, ricerca);
  1005.     }
  1006.     
  1007.     public List<IDServizio> getIdServiziWithAccordo(IDAccordo idAccordo,boolean checkPTisNull) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1008.         return this.accordiDriver.getIdServiziWithAccordo(idAccordo, checkPTisNull);
  1009.     }
  1010.     
  1011.     public void controlloUnicitaImplementazioneAccordoPerSoggetto(String portType,
  1012.             IDSoggetto idSoggettoErogatore, long idSoggettoErogatoreLong, 
  1013.             IDAccordo idAccordoServizioParteComune, long idAccordoServizioParteComuneLong,
  1014.             IDServizio idAccordoServizioParteSpecifica, long idAccordoServizioParteSpecificaLong,
  1015.             boolean isUpdate,boolean isServizioCorrelato,
  1016.             boolean isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
  1017.             boolean isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto) throws DriverRegistroServiziException{
  1018.         this.accordiDriver.controlloUnicitaImplementazioneAccordoPerSoggetto(portType,
  1019.                 idSoggettoErogatore, idSoggettoErogatoreLong, 
  1020.                 idAccordoServizioParteComune, idAccordoServizioParteComuneLong,
  1021.                 idAccordoServizioParteSpecifica, idAccordoServizioParteSpecificaLong,
  1022.                 isUpdate,isServizioCorrelato,
  1023.                 isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto,
  1024.                 isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto);
  1025.     }

  1027.     /**
  1028.      * Restituisce gli accordi compatibili
  1029.      * @param ricerca
  1030.      * @return accordiCompatibiliList
  1031.      * @throws DriverRegistroServiziException
  1032.      */
  1033.     public List<AccordoServizioParteComune> accordiCompatibiliList(ISearch ricerca) throws DriverRegistroServiziException {
  1034.         return this.accordiDriver.accordiCompatibiliList(ricerca);
  1035.     }
  1036.     
  1037.     public void validaStatoAccordoServizio(AccordoServizioParteComune as,boolean utilizzoAzioniDiretteInAccordoAbilitato) throws ValidazioneStatoPackageException{
  1038.         this.accordiDriver.validaStatoAccordoServizio(as, utilizzoAzioniDiretteInAccordoAbilitato);
  1039.     }
  1040.     
  1041.     /* Accordi di Servizio Composti */
  1042.     
  1043.     public List<AccordoServizioParteComune> accordiServizio_serviziComponentiConSoggettoErogatore(IDSoggetto idSoggetto) throws DriverRegistroServiziException {
  1044.         return this.accordiServiziCompostiDriver.accordiServizio_serviziComponentiConSoggettoErogatore(idSoggetto);
  1045.     }

  1047.     public List<AccordoServizioParteComune> accordiServizio_serviziComponenti(IDServizio idServizio) throws DriverRegistroServiziException {
  1048.         return this.accordiServiziCompostiDriver.accordiServizio_serviziComponenti(idServizio);
  1049.     }

  1051.     public List<AccordoServizioParteComune> accordiServizioWithAccordoCooperazione(IDAccordoCooperazione idAccordoCooperazione) throws DriverRegistroServiziException {
  1052.         return this.accordiServiziCompostiDriver.accordiServizioWithAccordoCooperazione(idAccordoCooperazione);
  1053.     }
  1054.     
  1055.     public AccordoServizioParteComune[] getAllIdAccordiWithSoggettoReferente(IDSoggetto idsoggetto) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1056.         return this.accordiDriver.getAllIdAccordiWithSoggettoReferente(idsoggetto);
  1057.     }
  1058.     
  1059.     public long getIdServizioCorrelato(String nomeServizio, String tipoServizio, String nomeProprietario, String tipoProprietario, Connection con) throws DriverRegistroServiziException {
  1060.         return this.accordiServiziCompostiDriver.getIdServizioCorrelato(nomeServizio, tipoServizio, nomeProprietario, tipoProprietario, con);
  1061.     }
  1062.     
  1063.     public List<AccordoServizioParteComuneServizioCompostoServizioComponente> accordiComponentiList(long idAccordo, ISearch ricerca) throws DriverRegistroServiziException {
  1064.         return this.accordiServiziCompostiDriver.accordiComponentiList(idAccordo, ricerca);
  1065.     }

  1067.     public List<Documento> accordiCoopAllegatiList(long idAccordo, ISearch ricerca) throws DriverRegistroServiziException {
  1068.         return this.accordiServiziCompostiDriver.accordiCoopAllegatiList(idAccordo, ricerca);
  1069.     }
  1070.     
  1071.     /* Accordi di Servizio SOAP */
  1072.     
  1073.     public void deleteAzione(long idAccordo, String nomeAzione) throws DriverRegistroServiziException {
  1074.         this.accordiSoapDriver.deleteAzione(idAccordo, nomeAzione);
  1075.     }   
  1076.     
  1077.     public List<PortType> accordiPorttypeList(long idAccordo, ISearch ricerca) throws DriverRegistroServiziException {
  1078.         return this.accordiSoapDriver.accordiPorttypeList(idAccordo, ricerca);
  1079.     }

  1081.     public List<PortType> accordiPorttypeList(long idAccordo, String profiloCollaborazione, ISearch ricerca) throws DriverRegistroServiziException {
  1082.         return this.accordiSoapDriver.accordiPorttypeList(idAccordo, profiloCollaborazione, ricerca);
  1083.     }
  1084.     
  1085.     public List<Operation> accordiPorttypeOperationList(long idPortType,String profiloCollaborazione, ISearch ricerca) throws DriverRegistroServiziException {
  1086.         return this.accordiSoapDriver.accordiPorttypeOperationList(idPortType, profiloCollaborazione, ricerca);
  1087.     }

  1089.     public List<Operation> accordiPorttypeOperationList(long idPortType, ISearch ricerca) throws DriverRegistroServiziException {
  1090.         return this.accordiSoapDriver.accordiPorttypeOperationList(idPortType, ricerca);
  1091.     }
  1092.     
  1093.     public List<MessagePart> accordiPorttypeOperationMessagePartList(long idOperation, boolean isInput, ISearch ricerca) throws DriverRegistroServiziException {
  1094.         return this.accordiSoapDriver.accordiPorttypeOperationMessagePartList(idOperation, isInput, ricerca);
  1095.     }
  1096.     
  1097.     /**
  1098.      * Controlla se l'azione e' usata come Azione correlata in qualche azione dell'accordo con id idAccordo 
  1099.      * @param idAccordo
  1100.      * @param nomeAzione
  1101.      * @return true se se l'azione e' usata come Azione correlata in qualche azione dell'accordo con id idAccordo 
  1102.      * @throws DriverRegistroServiziException
  1103.      */
  1104.     public boolean isCorrelata(long idAccordo,String nomeAzione,String owner) throws DriverRegistroServiziException {
  1105.         return this.accordiSoapDriver.isCorrelata(idAccordo, nomeAzione, owner);
  1106.     }

  1108.     /**
  1109.      * Controlla se l'azione e' usata come Azione correlata in qualche azione dell'accordo con id idAccordo 
  1110.      * @param idPortType
  1111.      * @param nomeCorrelata
  1112.      * @return true se l'azione e' usata come Azione correlata in qualche azione dell'accordo con id idAccordo 
  1113.      * @throws DriverRegistroServiziException
  1114.      */
  1115.     public boolean isOperationCorrelata(long idPortType,String nomeCorrelata,String owner) throws DriverRegistroServiziException {
  1116.         return this.accordiSoapDriver.isOperationCorrelata(idPortType, nomeCorrelata, owner);
  1117.     }

  1119.     public boolean isOperationCorrelataDaAltraAzione(String nomePortType,long idPortType,String azioneDaVerificare,long idAzioneDaVerificare) throws DriverRegistroServiziException {
  1120.         return this.accordiSoapDriver.isOperationCorrelataDaAltraAzione(nomePortType, idPortType, azioneDaVerificare, idAzioneDaVerificare);
  1121.     }
  1122.     public boolean isOperationCorrelataRichiesta(String nomePortType,long idPortType,String azioneDaVerificare,long idAzioneDaVerificare) throws DriverRegistroServiziException {
  1123.         return this.accordiSoapDriver.isOperationCorrelataRichiesta(nomePortType, idPortType, azioneDaVerificare, idAzioneDaVerificare);
  1124.     }
  1125.     public boolean isOperationCorrelata(String nomePortType,long idPortType,String azioneDaVerificare,long idAzioneDaVerificare) throws DriverRegistroServiziException {
  1126.         return this.accordiSoapDriver.isOperationCorrelata(nomePortType, idPortType, azioneDaVerificare, idAzioneDaVerificare);
  1127.     }
  1128.     
  1129.     public PortType getPortType(IDPortType idPT) throws DriverRegistroServiziException {
  1130.         return this.accordiSoapDriver.getPortType(idPT);
  1131.         
  1132.     }
  1133.     public PortType getPortType(long id) throws DriverRegistroServiziException {
  1134.         return this.accordiSoapDriver.getPortType(id);
  1135.     }

  1137.     public List<IDServizio> getIdServiziWithPortType(IDPortType idPT) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1138.         return this.accordiSoapDriver.getIdServiziWithPortType(idPT);
  1139.     }
  1140.     
  1141.     // Controlla che esista solo un'azione, direttamente negli accordi e tra i port type con tale nome
  1142.     public boolean isUnicaAzioneInAccordi(String azione) throws DriverRegistroServiziException {
  1143.         return this.accordiSoapDriver.isUnicaAzioneInAccordi(azione);
  1144.     }
  1145.     
  1146.     public List<PortType> accordiPorttypeCompatibiliList(long idAccordo,boolean isErogazione, ISearch ricerca) throws DriverRegistroServiziException {
  1147.         return this.accordiSoapDriver.accordiPorttypeCompatibiliList(idAccordo,isErogazione, ricerca);
  1148.     }

  1150.     /* Accordi di Servizio REST */
  1151.     
  1152.     public List<Resource> accordiResourceList(long idAccordo, ISearch ricerca) throws DriverRegistroServiziException {
  1153.         return this.accordiRestDriver.accordiResourceList(idAccordo, ricerca);
  1154.     }
  1155.     
  1156.     public List<ResourceResponse> accordiResourceResponseList(long idRisorsa, ISearch ricerca) throws DriverRegistroServiziException {
  1157.         return this.accordiRestDriver.accordiResourceResponseList(idRisorsa, ricerca);
  1158.     }
  1159.     
  1160.     public List<ResourceRepresentation> accordiResourceRepresentationsList(Long idRisorsa, boolean isRequest, Long idRisposta, ISearch ricerca)  throws DriverRegistroServiziException {
  1161.         return this.accordiRestDriver.accordiResourceRepresentationsList(idRisorsa, isRequest, idRisposta, ricerca);
  1162.     }
  1163.     
  1164.     public List<ResourceParameter> accordiResourceParametersList(Long idRisorsa, boolean isRequest, Long idRisposta, ISearch ricerca)  throws DriverRegistroServiziException {
  1165.         return this.accordiRestDriver.accordiResourceParametersList(idRisorsa, isRequest, idRisposta, ricerca);
  1166.     }

  1168.     
  1169.     /* Documenti*/
  1170.     
  1171.     public boolean existsDocumento(String nome, String tipo, String ruolo, long idProprietario, ProprietariDocumento proprietarioDocumento) throws DriverRegistroServiziException {
  1172.         return this.documentiDriver.existsDocumento(nome, tipo, ruolo, idProprietario, proprietarioDocumento);
  1173.     }

  1175.     public Documento getDocumento(String nome, String tipo, String ruolo, long idProprietario,boolean readBytes,ProprietariDocumento tipoProprietario) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  1176.         return this.documentiDriver.getDocumento(nome, tipo, ruolo, idProprietario, readBytes, tipoProprietario);
  1177.     }

  1179.     public Documento getDocumento(long idDocumento,boolean readBytes) throws DriverRegistroServiziException {
  1180.         return this.documentiDriver.getDocumento(idDocumento,readBytes);
  1181.     }

  1183.     public List<Documento> serviziAllegatiList(long idServizio, ISearch ricerca) throws DriverRegistroServiziException {
  1184.         return this.documentiDriver.serviziAllegatiList(idServizio,ricerca);
  1185.     }

  1187.     @Override
  1188.     public Documento getAllegato(IDServizio idASPS, String nome)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1189.         return this.documentiDriver.getAllegato(idASPS,nome);
  1190.     }
  1191.     @Override
  1192.     public Documento getSpecificaSemiformale(IDServizio idASPS, TipiDocumentoSemiformale tipo, String nome)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1193.         return this.documentiDriver.getSpecificaSemiformale(idASPS,tipo,nome);
  1194.     }
  1195.     @Override
  1196.     public Documento getSpecificaSicurezza(IDServizio idASPS, TipiDocumentoSicurezza tipo, String nome)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1197.         return this.documentiDriver.getSpecificaSicurezza(idASPS,tipo,nome);
  1198.     }
  1199.     @Override
  1200.     public Documento getSpecificaLivelloServizio(IDServizio idASPS, TipiDocumentoLivelloServizio tipo, String nome)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1201.         return this.documentiDriver.getSpecificaLivelloServizio(idASPS,tipo,nome);
  1202.     }
  1203.     
  1204.     @Override
  1205.     public Documento getAllegato(IDAccordo idAccordo, String nome)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1206.         return this.documentiDriver.getAllegato(idAccordo,nome);
  1207.     }
  1208.     @Override
  1209.     public Documento getSpecificaSemiformale(IDAccordo idAccordo, TipiDocumentoSemiformale tipo, String nome)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1210.         return this.documentiDriver.getSpecificaSemiformale(idAccordo,tipo,nome);
  1211.     }
  1212.     
  1213.     
  1214.     /* Porte di Dominio */

  1216.     /**
  1217.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.PortaDominio}, 
  1218.      * identificato grazie al parametro 
  1219.      * <var>nomePdD</var> 
  1220.      *
  1221.      * @param nomePdD Nome della Porta di Dominio
  1222.      * @return un oggetto di tipo {@link org.openspcoop2.core.registry.PortaDominio}.
  1223.      * 
  1224.      */
  1225.     @Override
  1226.     public org.openspcoop2.core.registry.PortaDominio getPortaDominio(String nomePdD) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1227.         return this.pddDriver.getPortaDominio(nomePdD);
  1228.     }

  1230.     /**
  1231.      * Ritorna gli identificatori delle PdD che rispettano il parametro di ricerca
  1232.      * 
  1233.      * @param filtroRicerca
  1234.      * @return Una lista di ID degli accordi trovati
  1235.      * @throws DriverRegistroServiziException
  1236.      * @throws DriverRegistroServiziNotFound
  1237.      */
  1238.     @Override
  1239.     public List<String> getAllIdPorteDominio(FiltroRicerca filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1240.         return this.pddDriver.getAllIdPorteDominio(filtroRicerca);
  1241.     }

  1243.     /**
  1244.      * Crea una nuova Porta di Dominio 
  1245.      * 
  1246.      * @param pdd
  1247.      * @throws DriverRegistroServiziException
  1248.      */
  1249.     @Override
  1250.     public void createPortaDominio(PortaDominio pdd) throws DriverRegistroServiziException{
  1251.         this.pddDriver.createPortaDominio(pdd);
  1252.     }

  1254.     /**
  1255.      * Verifica l'esistenza di una Porta di Dominio.
  1256.      *
  1257.      * @param nome della porta di dominio da verificare
  1258.      * @return true se la porta di dominio esiste, false altrimenti
  1259.      * @throws DriverRegistroServiziException
  1260.      */    
  1261.     @Override
  1262.     public boolean existsPortaDominio(String nome) throws DriverRegistroServiziException{
  1263.         return this.pddDriver.existsPortaDominio(nome);
  1264.     }

  1266.     /**
  1267.      * Aggiorna la Porta di Dominio con i nuovi valori.
  1268.      *  
  1269.      * @param pdd
  1270.      * @throws DriverRegistroServiziException
  1271.      */
  1272.     @Override
  1273.     public void updatePortaDominio(PortaDominio pdd) throws DriverRegistroServiziException{
  1274.         this.pddDriver.updatePortaDominio(pdd);
  1275.     }   

  1277.     /**
  1278.      * Aggiorna la Porta di Dominio con i nuovi valori.
  1279.      *  
  1280.      * @param nomePdd
  1281.      * @param tipo
  1282.      * @throws DriverRegistroServiziException
  1283.      */
  1284.     public void updateTipoPortaDominio(String nomePdd,String tipo) throws DriverRegistroServiziException{
  1285.         this.pddDriver.updateTipoPortaDominio(nomePdd, tipo);
  1286.     }   
  1287.     
  1288.     public String getTipoPortaDominio(String nome) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1289.         return this.pddDriver.getTipoPortaDominio(nome);
  1290.     }

  1292.     /**
  1293.      * Elimina una Porta di Dominio 
  1294.      *  
  1295.      * @param pdd
  1296.      * @throws DriverRegistroServiziException
  1297.      */
  1298.     @Override
  1299.     public void deletePortaDominio(PortaDominio pdd) throws DriverRegistroServiziException{
  1300.         this.pddDriver.deletePortaDominio(pdd);
  1301.     }
  1302.     
  1303.     /**
  1304.      * Ritorna la lista di Porte di Dominio
  1305.      * Tiene conto dei criteri di ricerca Settati
  1306.      * @param ricerca
  1307.      * @return la lista degli accordi di servizio che soddisfa la ricerca
  1308.      */
  1309.     public List<PortaDominio> porteDominioList(String superuser, ISearch ricerca) throws DriverRegistroServiziException{
  1310.         return this.pddDriver.porteDominioList(superuser, ricerca);
  1311.     }
  1312.     public List<PortaDominio> porteDominioList(String superuser,String tipo, ISearch ricerca) throws DriverRegistroServiziException{
  1313.         return this.pddDriver.porteDominioList(superuser, tipo, ricerca);
  1314.     }

  1316.     public boolean isPddInUso(PortaDominio pdd, List<String> whereIsInUso)
  1317.             throws DriverRegistroServiziException {
  1318.         return this.pddDriver.isPddInUso(pdd, whereIsInUso);
  1319.     }

  1321.     public List<Soggetto> pddSoggettiList(long idPdd, ISearch ricerca) throws DriverRegistroServiziException {
  1322.         return this.pddDriver.pddSoggettiList(idPdd, ricerca);
  1323.     }
  1324.     
  1325.     public List<PortaDominio> porteDominioWithSubject(String subject)throws DriverRegistroServiziException {
  1326.         return this.pddDriver.porteDominioWithSubject(subject);
  1327.     }
  1328.     
  1329.     
  1330.     
  1331.     /* Gruppi */

  1333.     /**
  1334.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.Gruppo}, 
  1335.      * identificato grazie al parametro 
  1336.      * <var>nome</var> 
  1337.      *
  1338.      * @param idGruppo Identificativo del gruppo
  1339.      * @return un oggetto di tipo {@link org.openspcoop2.core.registry.Gruppo}.
  1340.      * 
  1341.      */
  1342.     @Override
  1343.     public Gruppo getGruppo(IDGruppo idGruppo) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1344.         return this.gruppiDriver.getGruppo(idGruppo);
  1345.     }

  1347.     public Gruppo getGruppo(long idGruppo) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1348.         return this.gruppiDriver.getGruppo(idGruppo);
  1349.     }

  1351.     /**
  1352.      * Ritorna gli identificatori dei Gruppi che rispettano il parametro di ricerca
  1353.      * 
  1354.      * @param filtroRicerca
  1355.      * @return Una lista di ID dei gruppi trovati
  1356.      * @throws DriverRegistroServiziException
  1357.      * @throws DriverRegistroServiziNotFound
  1358.      */
  1359.     @Override
  1360.     public List<IDGruppo> getAllIdGruppi(FiltroRicercaGruppi filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1361.         return this.gruppiDriver.getAllIdGruppi(filtroRicerca);
  1362.     }

  1364.     /**
  1365.      * Crea una nuovo Gruppo
  1366.      * 
  1367.      * @param gruppo
  1368.      * @throws DriverRegistroServiziException
  1369.      */
  1370.     @Override
  1371.     public void createGruppo(Gruppo gruppo) throws DriverRegistroServiziException{
  1372.         this.gruppiDriver.createGruppo(gruppo);
  1373.     }

  1375.     /**
  1376.      * Verifica l'esistenza di un Gruppo
  1377.      *
  1378.      * @param idGruppo idGruppo del gruppo da verificare
  1379.      * @return true se il gruppo esiste, false altrimenti
  1380.      * @throws DriverRegistroServiziException
  1381.      */    
  1382.     @Override
  1383.     public boolean existsGruppo(IDGruppo idGruppo) throws DriverRegistroServiziException{
  1384.         return this.gruppiDriver.existsGruppo(idGruppo);
  1385.     }

  1387.     /**
  1388.      * Aggiorna il Gruppo con i nuovi valori.
  1389.      *  
  1390.      * @param gruppo
  1391.      * @throws DriverRegistroServiziException
  1392.      */
  1393.     @Override
  1394.     public void updateGruppo(Gruppo gruppo) throws DriverRegistroServiziException{
  1395.         this.gruppiDriver.updateGruppo(gruppo);
  1396.     }   

  1398.     /**
  1399.      * Elimina un Gruppo
  1400.      *  
  1401.      * @param gruppo
  1402.      * @throws DriverRegistroServiziException
  1403.      */
  1404.     @Override
  1405.     public void deleteGruppo(Gruppo gruppo) throws DriverRegistroServiziException{
  1406.         this.gruppiDriver.deleteGruppo(gruppo);
  1407.     }
  1408.     
  1409.     public List<Gruppo> gruppiList(String superuser, ISearch ricerca) throws DriverRegistroServiziException {
  1410.         return this.gruppiDriver.gruppiList(superuser, ricerca);
  1411.     }
  1412.     
  1413.     
  1414.     /* Ruoli */

  1416.     /**
  1417.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.Ruolo}, 
  1418.      * identificato grazie al parametro 
  1419.      * <var>nome</var> 
  1420.      *
  1421.      * @param idRuolo Identificativo del ruolo
  1422.      * @return un oggetto di tipo {@link org.openspcoop2.core.registry.Ruolo}.
  1423.      * 
  1424.      */
  1425.     @Override
  1426.     public Ruolo getRuolo(IDRuolo idRuolo) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1427.         return this.ruoliDriver.getRuolo(idRuolo);
  1428.     }
  1429.     public Ruolo getRuolo(Connection conParam, IDRuolo idRuolo) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1430.         return this.ruoliDriver.getRuolo(conParam, idRuolo);
  1431.     }

  1433.     public Ruolo getRuolo(long idRuolo) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1434.         return this.ruoliDriver.getRuolo(idRuolo);
  1435.     }
  1436.     public Ruolo getRuolo(Connection conParam, long idRuolo) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1437.         return this.ruoliDriver.getRuolo(conParam, idRuolo);
  1438.     }

  1440.     /**
  1441.      * Ritorna gli identificatori dei Ruoli che rispettano il parametro di ricerca
  1442.      * 
  1443.      * @param filtroRicerca
  1444.      * @return Una lista di ID dei ruoli trovati
  1445.      * @throws DriverRegistroServiziException
  1446.      * @throws DriverRegistroServiziNotFound
  1447.      */
  1448.     @Override
  1449.     public List<IDRuolo> getAllIdRuoli(FiltroRicercaRuoli filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1450.         return this.ruoliDriver.getAllIdRuoli(filtroRicerca);
  1451.     }

  1453.     /**
  1454.      * Crea una nuovo Ruolo
  1455.      * 
  1456.      * @param ruolo
  1457.      * @throws DriverRegistroServiziException
  1458.      */
  1459.     @Override
  1460.     public void createRuolo(Ruolo ruolo) throws DriverRegistroServiziException{
  1461.         this.ruoliDriver.createRuolo(ruolo);
  1462.     }

  1464.     /**
  1465.      * Verifica l'esistenza di un Ruolo
  1466.      *
  1467.      * @param idRuolo idRuolo del ruolo da verificare
  1468.      * @return true se il ruolo esiste, false altrimenti
  1469.      * @throws DriverRegistroServiziException
  1470.      */    
  1471.     @Override
  1472.     public boolean existsRuolo(IDRuolo idRuolo) throws DriverRegistroServiziException{
  1473.         return this.ruoliDriver.existsRuolo(idRuolo);
  1474.     }

  1476.     /**
  1477.      * Aggiorna il Ruolo con i nuovi valori.
  1478.      *  
  1479.      * @param ruolo
  1480.      * @throws DriverRegistroServiziException
  1481.      */
  1482.     @Override
  1483.     public void updateRuolo(Ruolo ruolo) throws DriverRegistroServiziException{
  1484.         this.ruoliDriver.updateRuolo(ruolo);
  1485.     }   

  1487.     /**
  1488.      * Elimina un Ruolo
  1489.      *  
  1490.      * @param ruolo
  1491.      * @throws DriverRegistroServiziException
  1492.      */
  1493.     @Override
  1494.     public void deleteRuolo(Ruolo ruolo) throws DriverRegistroServiziException{
  1495.         this.ruoliDriver.deleteRuolo(ruolo);
  1496.     }
  1497.     
  1498.     public List<Ruolo> ruoliList(String superuser, ISearch ricerca) throws DriverRegistroServiziException {
  1499.         return this.ruoliDriver.ruoliList(superuser, ricerca);
  1500.     }
  1501.     
  1502.     
  1503.     
  1504.     /* Scope */

  1506.     /**
  1507.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.Scope}, 
  1508.      * identificato grazie al parametro 
  1509.      * <var>nome</var> 
  1510.      *
  1511.      * @param idScope Identificativo del scope
  1512.      * @return un oggetto di tipo {@link org.openspcoop2.core.registry.Scope}.
  1513.      * 
  1514.      */
  1515.     @Override
  1516.     public Scope getScope(IDScope idScope) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1517.         return this.scopeDriver.getScope(idScope);
  1518.     }

  1520.     public Scope getScope(long idScope) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1521.         return this.scopeDriver.getScope(idScope);
  1522.     }

  1524.     /**
  1525.      * Ritorna gli identificatori dei Scope che rispettano il parametro di ricerca
  1526.      * 
  1527.      * @param filtroRicerca
  1528.      * @return Una lista di ID dei scope trovati
  1529.      * @throws DriverRegistroServiziException
  1530.      * @throws DriverRegistroServiziNotFound
  1531.      */
  1532.     @Override
  1533.     public List<IDScope> getAllIdScope(FiltroRicercaScope filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1534.         return this.scopeDriver.getAllIdScope(filtroRicerca);
  1535.     }

  1537.     /**
  1538.      * Crea una nuovo Scope
  1539.      * 
  1540.      * @param scope
  1541.      * @throws DriverRegistroServiziException
  1542.      */
  1543.     @Override
  1544.     public void createScope(Scope scope) throws DriverRegistroServiziException{
  1545.         this.scopeDriver.createScope(scope);
  1546.     }

  1548.     /**
  1549.      * Verifica l'esistenza di un Scope
  1550.      *
  1551.      * @param idScope idScope del scope da verificare
  1552.      * @return true se il scope esiste, false altrimenti
  1553.      * @throws DriverRegistroServiziException
  1554.      */    
  1555.     @Override
  1556.     public boolean existsScope(IDScope idScope) throws DriverRegistroServiziException{
  1557.         return this.scopeDriver.existsScope(idScope);
  1558.     }

  1560.     /**
  1561.      * Aggiorna il Scope con i nuovi valori.
  1562.      *  
  1563.      * @param scope
  1564.      * @throws DriverRegistroServiziException
  1565.      */
  1566.     @Override
  1567.     public void updateScope(Scope scope) throws DriverRegistroServiziException{
  1568.         this.scopeDriver.updateScope(scope);
  1569.     }   

  1571.     /**
  1572.      * Elimina un Scope
  1573.      *  
  1574.      * @param scope
  1575.      * @throws DriverRegistroServiziException
  1576.      */
  1577.     @Override
  1578.     public void deleteScope(Scope scope) throws DriverRegistroServiziException{
  1579.         this.scopeDriver.deleteScope(scope);
  1580.     }
  1581.     
  1582.     public List<Scope> scopeList(String superuser, ISearch ricerca) throws DriverRegistroServiziException {
  1583.         return this.scopeDriver.scopeList(superuser, ricerca);
  1584.     }
  1585.     
  1586.     
  1587.     /* Soggetti */

  1589.     /**
  1590.      * Si occupa di ritornare l'oggetto
  1591.      * {@link org.openspcoop2.core.registry.Soggetto}, identificato grazie
  1592.      * al parametro <var>idSoggetto</var> di tipo
  1593.      * {@link org.openspcoop2.core.id.IDSoggetto}.
  1594.      * 
  1595.      * @param idSoggetto
  1596.      *                Identificatore del Soggetto di tipo
  1597.      *                {@link org.openspcoop2.core.id.IDSoggetto}.
  1598.      * @return l'oggetto di tipo
  1599.      *         {@link org.openspcoop2.core.registry.Soggetto} se la ricerca
  1600.      *         nel registro ha successo, null altrimenti.
  1601.      * 
  1602.      */
  1603.     @Override
  1604.     public org.openspcoop2.core.registry.Soggetto getSoggetto(IDSoggetto idSoggetto) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1605.         return this.soggettiDriver.getSoggetto(idSoggetto);
  1606.     }

  1608.     public Soggetto getSoggetto(long idSoggetto) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1609.         return this.soggettiDriver.getSoggetto(idSoggetto);
  1610.     }
  1611.     public Soggetto getSoggetto(long idSoggetto,Connection conParam) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1612.         return this.soggettiDriver.getSoggetto(idSoggetto, conParam);
  1613.     }
  1614.     
  1615.     public Soggetto soggettoWithCredenzialiBasic(String utente, String password, boolean checkPassword) throws DriverRegistroServiziException {
  1616.         return this.soggettiCredenzialiDriver.soggettoWithCredenzialiBasic(utente, password, checkPassword);
  1617.     }
  1618.     
  1619.     public Soggetto soggettoWithCredenzialiApiKey(String utente, boolean appId) throws DriverRegistroServiziException {
  1620.         return this.soggettiCredenzialiDriver.soggettoWithCredenzialiApiKey(utente, appId);
  1621.     }
  1622.     
  1623.     @Override
  1624.     public Soggetto getSoggettoByCredenzialiBasic(String user,String password, CryptConfig config) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1625.         return this.soggettiCredenzialiDriver.getSoggettoByCredenzialiBasic(user, password, config);
  1626.     }
  1627.     
  1628.     @Override
  1629.     public Soggetto getSoggettoByCredenzialiApiKey(String user,String password, boolean appId, CryptConfig config) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1630.         return this.soggettiCredenzialiDriver.getSoggettoByCredenzialiApiKey(user, password, appId, config);
  1631.     }
  1632.     
  1633.     @Override
  1634.     public Soggetto getSoggettoByCredenzialiSsl(String subject, String issuer) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1635.         return this.soggettiCredenzialiDriver.getSoggettoByCredenzialiSsl(subject, issuer);
  1636.     }
  1637.     
  1638.     @Override
  1639.     public Soggetto getSoggettoByCredenzialiSsl(CertificateInfo certificate, boolean strictVerifier) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1640.         return this.soggettiCredenzialiDriver.getSoggettoByCredenzialiSsl(certificate, strictVerifier);
  1641.     }
  1642.     
  1643.     @Override
  1644.     public Soggetto getSoggettoByCredenzialiPrincipal(String principal) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1645.         return this.soggettiCredenzialiDriver.getSoggettoByCredenzialiPrincipal(principal);
  1646.     }
  1647.         
  1648.     public List<Soggetto> soggettoWithCredenzialiSslList(CertificateInfo certificate, boolean strictVerifier) throws DriverRegistroServiziException {
  1649.         return this.soggettiCredenzialiDriver.soggettoWithCredenzialiSslList(certificate, strictVerifier);
  1650.     }
  1651.     
  1652.     /***
  1653.      * Restituisce tutti i soggetti con i tipi indicati che utilizzano le credenziali indicate
  1654.      * 
  1655.      * @param tipiSoggetto
  1656.      * @param superuser
  1657.      * @param credenziale
  1658.      * @return tutti i soggetti con i tipi indicati che utilizzano le credenziali indicate
  1659.      */
  1660.     public List<IDSoggettoDB> getSoggettiFromTipoAutenticazione(List<String> tipiSoggetto, String superuser, CredenzialeTipo credenziale, Boolean appId, PddTipologia pddTipologia) throws DriverRegistroServiziException {
  1661.         return this.soggettiCredenzialiDriver.getSoggettiFromTipoAutenticazione(tipiSoggetto, superuser, credenziale, appId, pddTipologia);
  1662.     }
  1663.     
  1664.     /**
  1665.      *  Ritorna gli identificatori dei soggetti che rispettano il parametro di ricerca
  1666.      * 
  1667.      * @param filtroRicerca
  1668.      * @return Una lista di ID dei soggetti trovati
  1669.      * @throws DriverRegistroServiziException
  1670.      * @throws DriverRegistroServiziNotFound
  1671.      */
  1672.     @Override
  1673.     public List<IDSoggetto> getAllIdSoggetti(FiltroRicercaSoggetti filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1674.         return this.soggettiDriver.getAllIdSoggetti(filtroRicerca);
  1675.     }

  1677.     /**
  1678.      * Crea un nuovo Soggetto
  1679.      * 
  1680.      * @param soggetto
  1681.      * @throws DriverRegistroServiziException
  1682.      */
  1683.     @Override
  1684.     public void createSoggetto(org.openspcoop2.core.registry.Soggetto soggetto) throws DriverRegistroServiziException {
  1685.         this.soggettiDriver.createSoggetto(soggetto);
  1686.     }

  1688.     /**
  1689.      * Verifica l'esistenza di un soggetto registrato.
  1690.      * 
  1691.      * @param idSoggetto
  1692.      *                Identificativo del soggetto
  1693.      * @return true se il soggetto esiste, false altrimenti
  1694.      */
  1695.     @Override
  1696.     public boolean existsSoggetto(IDSoggetto idSoggetto) throws DriverRegistroServiziException {
  1697.         return this.soggettiDriver.existsSoggetto(idSoggetto);
  1698.     }
  1699.     public boolean existsSoggetto(Connection conParam, IDSoggetto idSoggetto) throws DriverRegistroServiziException {
  1700.         return this.soggettiDriver.existsSoggetto(conParam, idSoggetto);
  1701.     }

  1703.     public boolean existsSoggetto(long idSoggetto) throws DriverRegistroServiziException {
  1704.         return this.soggettiDriver.existsSoggetto(idSoggetto);
  1705.     }

  1707.     public boolean existsSoggetto(String codiceIPA) throws DriverRegistroServiziException {
  1708.         return this.soggettiDriver.existsSoggetto(codiceIPA);
  1709.     }

  1711.     public Soggetto getSoggetto(String codiceIPA) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1712.         return this.soggettiDriver.getSoggetto(codiceIPA);
  1713.     }

  1715.     public String getCodiceIPA(IDSoggetto idSoggetto) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1716.         return this.soggettiDriver.getCodiceIPA(idSoggetto);
  1717.     }

  1719.     /**
  1720.      * Aggiorna un Soggetto e il Connettore con i nuovi dati passati
  1721.      * 
  1722.      * @param soggetto
  1723.      * @throws DriverRegistroServiziException
  1724.      */
  1725.     @Override
  1726.     public void updateSoggetto(org.openspcoop2.core.registry.Soggetto soggetto) throws DriverRegistroServiziException {
  1727.         this.soggettiDriver.updateSoggetto(soggetto);
  1728.     }

  1730.     /**
  1731.      * Cancella un Soggetto e il Connettore
  1732.      * 
  1733.      * @param soggetto
  1734.      * @throws DriverRegistroServiziException
  1735.      */
  1736.     @Override
  1737.     public void deleteSoggetto(org.openspcoop2.core.registry.Soggetto soggetto) throws DriverRegistroServiziException {
  1738.         this.soggettiDriver.deleteSoggetto(soggetto);
  1739.     }

  1741.     public IDSoggetto[] getSoggettiWithSuperuser(String user) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1742.         return this.soggettiDriver.getSoggettiWithSuperuser(user);
  1743.     }

  1745.     public List<String> soggettiRuoliList(long idSoggetto, ISearch ricerca) throws DriverRegistroServiziException {
  1746.         return this.soggettiSearchDriver.soggettiRuoliList(idSoggetto, ricerca);
  1747.     }
  1748.     
  1749.     public List<Proprieta> soggettiProprietaList(long idSoggetto, ISearch ricerca) throws DriverRegistroServiziException {
  1750.         return this.soggettiSearchDriver.soggettiProprietaList(idSoggetto, ricerca);
  1751.     }
  1752.     
  1753.     /**
  1754.      * Ritorna la lista di nomi delle proprieta registrate
  1755.      */
  1756.     public List<String> nomiProprietaSoggetti(List<String> tipoSoggettiProtocollo) throws DriverConfigurazioneException {
  1757.         return this.soggettiDriver.nomiProprietaSoggetti(tipoSoggettiProtocollo);
  1758.     }
  1759.     
  1760.     /**
  1761.      * Controlla se il soggetto e' in uso
  1762.      */
  1763.     public boolean isSoggettoInUsoInPackageFinali(Soggetto ss, Map<ErrorsHandlerCostant,String> whereIsInUso) throws DriverRegistroServiziException {
  1764.         return this.soggettiDriver.isSoggettoInUsoInPackageFinali(ss,whereIsInUso);
  1765.     }
  1766.     public boolean isSoggettoInUsoInPackagePubblici(Soggetto ss, Map<ErrorsHandlerCostant,String> whereIsInUso) throws DriverRegistroServiziException {
  1767.         return this.soggettiDriver.isSoggettoInUsoInPackagePubblici(ss,whereIsInUso);
  1768.     }
  1769.     public boolean isSoggettoInUso(Soggetto ss, Map<ErrorsHandlerCostant,String> whereIsInUso) throws DriverRegistroServiziException {
  1770.         return this.soggettiDriver.isSoggettoInUso(ss,whereIsInUso);
  1771.     }
  1772.     
  1773.     public List<Soggetto> soggettiRegistroListByTipo(String tipoSoggetto,ISearch ricerca) throws DriverRegistroServiziException{
  1774.         return this.soggettiSearchDriver.soggettiRegistroListByTipo(tipoSoggetto, ricerca);
  1775.     }

  1777.     public List<Soggetto> soggettiRegistroList(String superuser, ISearch ricerca) throws DriverRegistroServiziException {
  1778.         return this.soggettiSearchDriver.soggettiRegistroList(superuser, ricerca);
  1779.     }
  1780.     
  1781.     public List<IDSoggetto> idSoggettiRegistroListByTipo(String tipoSoggetto,ISearch ricerca) throws DriverRegistroServiziException{
  1782.         return this.soggettiSearchDriver.idSoggettiRegistroListByTipo(tipoSoggetto, ricerca);
  1783.     }

  1785.     public List<IDSoggetto> idSoggettiRegistroList(String superuser, ISearch ricerca) throws DriverRegistroServiziException {
  1786.         return this.soggettiSearchDriver.idSoggettiRegistroList(superuser, ricerca);
  1787.     }
  1788.     
  1789.     public IDSoggetto getIdSoggetto(long idSoggetto) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1790.         return this.soggettiDriver.getIdSoggetto(idSoggetto);
  1791.     }
  1792.     public IDSoggetto getIdSoggetto(long idSoggetto,Connection conParam) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1793.         return this.soggettiDriver.getIdSoggetto(idSoggetto, conParam);
  1794.     }
  1795.     
  1796.     public List<IDSoggetto> getSoggettiDefault() throws DriverRegistroServiziException {
  1797.         return this.soggettiDriver.getSoggettiDefault();
  1798.     }
  1799.     public List<IDSoggetto> getSoggettiDefault(Connection conParam) throws DriverRegistroServiziException {
  1800.         return this.soggettiDriver.getSoggettiDefault(conParam);
  1801.     }
  1802.     
  1803.     
  1804.     /* Accordi Servizio Parte Specifica */
  1805.     
  1806.     @Override
  1807.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(IDServizio idServizio) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1808.         return this.accordiParteSpecificaDriver.getAccordoServizioParteSpecifica(idServizio);
  1809.     }
  1810.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(IDServizio idServizio,Connection con) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1811.         return this.accordiParteSpecificaDriver.getAccordoServizioParteSpecifica(idServizio, con);
  1812.     }
  1813.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(IDServizio idServizio,boolean readContenutoAllegati) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1814.         return this.accordiParteSpecificaDriver.getAccordoServizioParteSpecifica(idServizio, readContenutoAllegati);
  1815.     }
  1816.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(IDServizio idServizio,boolean readContenutoAllegati,Connection con) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1817.         return this.accordiParteSpecificaDriver.getAccordoServizioParteSpecifica(idServizio, readContenutoAllegati, con);
  1818.     }

  1820.     @Override
  1821.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica_ServizioCorrelato(IDSoggetto idSoggetto,IDAccordo idAccordoServizioParteComune) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1822.         return this.accordiParteSpecificaDriver.getAccordoServizioParteSpecifica_ServizioCorrelato(idSoggetto, idAccordoServizioParteComune);
  1823.     }
  1824.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica_ServizioCorrelato(IDSoggetto idSoggetto,IDAccordo idAccordoServizioParteComune,Connection con) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1825.         return this.accordiParteSpecificaDriver.getAccordoServizioParteSpecifica_ServizioCorrelato(idSoggetto, idAccordoServizioParteComune, con);
  1826.     }
  1827.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica_ServizioCorrelato(IDSoggetto idSoggetto,IDAccordo idAccordoServizioParteComune,boolean readContenutoAllegati) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1828.         return this.accordiParteSpecificaDriver.getAccordoServizioParteSpecifica_ServizioCorrelato(idSoggetto, idAccordoServizioParteComune, readContenutoAllegati);
  1829.     }
  1830.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica_ServizioCorrelato(IDSoggetto idSoggetto,IDAccordo idAccordoServizioParteComune,boolean readContenutoAllegati,Connection con) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1831.         return this.accordiParteSpecificaDriver.getAccordoServizioParteSpecifica_ServizioCorrelato(idSoggetto, idAccordoServizioParteComune, readContenutoAllegati, con);
  1832.     }

  1834.     @Override
  1835.     public List<IDServizio> getAllIdServizi(FiltroRicercaServizi filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1836.         return this.accordiParteSpecificaDriver.getAllIdServizi(filtroRicerca);
  1837.     }
  1838.     
  1839.     @Override
  1840.     public List<IDFruizione> getAllIdFruizioniServizio(FiltroRicercaFruizioniServizio filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1841.         return this.accordiParteSpecificaDriver.getAllIdFruizioniServizio(filtroRicerca);
  1842.     }

  1844.     /**
  1845.      *  Ritorna gli identificatori dei servizi del soggetto dato
  1846.      * 
  1847.      * @param idSoggetto
  1848.      * @return identificatori dei servizi del soggetto dato
  1849.      * @throws DriverRegistroServiziException
  1850.      * @throws DriverRegistroServiziNotFound
  1851.      */
  1852.     public IDServizio[] getAllIdServiziWithSoggettoErogatore(Long idSoggetto) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1853.         return this.accordiParteSpecificaDriver.getAllIdServiziWithSoggettoErogatore(idSoggetto);
  1854.     }

  1856.     @Override
  1857.     public void createAccordoServizioParteSpecifica(AccordoServizioParteSpecifica accordoServizioParteSpecifica) throws DriverRegistroServiziException {
  1858.         this.accordiParteSpecificaDriver.createAccordoServizioParteSpecifica(accordoServizioParteSpecifica);
  1859.     }

  1861.     /**
  1862.      * Verifica l'esistenza di un servizio registrato.
  1863.      * 
  1864.      * @param idServizio
  1865.      *                Identificativo del servizio
  1866.      * @return true se il servizio esiste, false altrimenti
  1867.      */
  1868.     @Override
  1869.     public boolean existsAccordoServizioParteSpecifica(IDServizio idServizio) throws DriverRegistroServiziException {
  1870.         return this.accordiParteSpecificaDriver.existsAccordoServizioParteSpecifica(idServizio);
  1871.     }

  1873.     public boolean existsAccordoServizioParteSpecifica(long idServizio) throws DriverRegistroServiziException {
  1874.         return this.accordiParteSpecificaDriver.existsAccordoServizioParteSpecifica(idServizio);
  1875.     }

  1877.     /**
  1878.      * Verifica l'esistenza di un servizio con un certo soggetto
  1879.      * accordo e servizio correlato
  1880.      */
  1881.     public long getServizioWithSoggettoAccordoServCorr(long idSoggetto, long idAccordo, String servizioCorrelato) throws DriverRegistroServiziException {
  1882.         return this.accordiParteSpecificaDriver.getServizioWithSoggettoAccordoServCorr(idSoggetto, idAccordo, servizioCorrelato);
  1883.     }

  1885.     /**
  1886.      * Verifica l'esistenza di un servizio con un certo soggetto,
  1887.      * accordo e servizio correlato
  1888.      */
  1889.     public long getServizioWithSoggettoAccordoServCorrPt(long idSoggetto, long idAccordo, String servizioCorrelato,String portType) throws DriverRegistroServiziException {
  1890.         return this.accordiParteSpecificaDriver.getServizioWithSoggettoAccordoServCorrPt(idSoggetto, idAccordo, servizioCorrelato, portType);
  1891.     }

  1893.     /**
  1894.      * Verifica l'esistenza di un fruitore con un certo soggetto,
  1895.      * ed un certo servizio
  1896.      */
  1897.     public long getServizioFruitore(IDServizio idServizio, long idSogg) throws DriverRegistroServiziException {
  1898.         return this.accordiParteSpecificaFruitoreDriver.getServizioFruitore(idServizio, idSogg);
  1899.     }

  1901.     /**
  1902.      * Ritorna l'id del soggetto fruitore di un servizio fruitore
  1903.      * 
  1904.      * @param idServizioFruitore
  1905.      *                del servizio fruitore
  1906.      * @return l'id del soggetto fruitore
  1907.      */
  1908.     public long getServizioFruitoreSoggettoFruitoreID(long idServizioFruitore) throws DriverRegistroServiziException {
  1909.         return this.accordiParteSpecificaFruitoreDriver.getServizioFruitoreSoggettoFruitoreID(idServizioFruitore);
  1910.     }

  1912.     /**
  1913.      * Ritorna l'id del servizio di un servizio fruitore
  1914.      * 
  1915.      * @param idServizioFruitore
  1916.      *                del servizio fruitore
  1917.      * @return l'id del servizio
  1918.      */
  1919.     public long getServizioFruitoreServizioID(long idServizioFruitore) throws DriverRegistroServiziException {
  1920.         return this.accordiParteSpecificaFruitoreDriver.getServizioFruitoreServizioID(idServizioFruitore);
  1921.     }

  1923.     @Override
  1924.     public void updateAccordoServizioParteSpecifica(AccordoServizioParteSpecifica servizio) throws DriverRegistroServiziException {
  1925.         this.accordiParteSpecificaDriver.updateAccordoServizioParteSpecifica(servizio);
  1926.     }

  1928.     @Override
  1929.     public void deleteAccordoServizioParteSpecifica(AccordoServizioParteSpecifica servizio) throws DriverRegistroServiziException {
  1930.         this.accordiParteSpecificaDriver.deleteAccordoServizioParteSpecifica(servizio);
  1931.     }

  1933.     /**
  1934.      * Dato un soggetto, verifica che i suoi servizi non abbiano
  1935.      * il connettore disabilitato
  1936.      * 
  1937.      * @param idSoggetto
  1938.      *                Identificativo del soggetto
  1939.      * @return true se esistono servizi senza connettore, false altrimenti
  1940.      */
  1941.     public boolean existsSoggettoServiziWithoutConnettore(long idSoggetto) throws DriverRegistroServiziException {
  1942.         return this.accordiParteSpecificaDriver.existsSoggettoServiziWithoutConnettore(idSoggetto);
  1943.     }
  1944.     
  1945.     public boolean existFruizioniServiziSoggettoWithoutConnettore(long idSoggetto, boolean escludiSoggettiEsterni) throws DriverRegistroServiziException {
  1946.         return this.accordiParteSpecificaFruitoreDriver.existFruizioniServiziSoggettoWithoutConnettore(idSoggetto, escludiSoggettiEsterni);
  1947.     }

  1949.     public boolean existFruizioniServizioWithoutConnettore(long idServizio, boolean escludiSoggettiEsterni) throws DriverRegistroServiziException {
  1950.         return this.accordiParteSpecificaFruitoreDriver.existFruizioniServizioWithoutConnettore(idServizio, escludiSoggettiEsterni);
  1951.     }
  1952.     
  1953.     public List<AccordoServizioParteSpecifica> serviziList(String superuser,ISearch ricerca) throws DriverRegistroServiziException {
  1954.         return this.accordiParteSpecificaSearchDriver.serviziList(superuser, ricerca);
  1955.     }

  1957.     public List<AccordoServizioParteSpecifica> servizioWithSoggettoFruitore(IDSoggetto idSoggetto) throws DriverRegistroServiziException {
  1958.         return this.accordiParteSpecificaFruitoreDriver.servizioWithSoggettoFruitore(idSoggetto);
  1959.     }
  1960.     
  1961.     public List<Soggetto> accordiErogatoriList(long idAccordo, ISearch ricerca) throws DriverRegistroServiziException {
  1962.         return this.accordiParteSpecificaSearchDriver.accordiErogatoriList(idAccordo, ricerca);
  1963.     }

  1965.     public Fruitore getAccordoErogatoreFruitore(long id) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1966.         return this.accordiParteSpecificaFruitoreDriver.getAccordoErogatoreFruitore(id);
  1967.     }

  1969.     public Fruitore getErogatoreFruitore(long id) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1970.         return this.accordiParteSpecificaFruitoreDriver.getErogatoreFruitore(id);
  1971.     }
  1972.     
  1973.     public Fruitore getServizioFruitore(long idServFru) throws DriverRegistroServiziException {
  1974.         return this.accordiParteSpecificaFruitoreDriver.getServizioFruitore(idServFru);
  1975.     }
  1976.     
  1977.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(long idServizio) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1978.         return this.accordiParteSpecificaDriver.getAccordoServizioParteSpecifica(idServizio);
  1979.     }
  1980.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(long idServizio,boolean readContenutoAllegati) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1981.         return this.accordiParteSpecificaDriver.getAccordoServizioParteSpecifica(idServizio,readContenutoAllegati);
  1982.     }

  1984.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(long idServizio,Connection conParam) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1985.         return this.accordiParteSpecificaDriver.getAccordoServizioParteSpecifica(idServizio,conParam);
  1986.     }
  1987.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(long idServizio,Connection conParam,boolean readContenutoAllegati) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  1988.         return this.accordiParteSpecificaDriver.getAccordoServizioParteSpecifica(idServizio,conParam,readContenutoAllegati);
  1989.     }
  1990.     
  1991.     public List<Fruitore> serviziFruitoriList(long idServizi, ISearch ricerca) throws DriverRegistroServiziException {
  1992.         return this.accordiParteSpecificaFruitoreDriver.serviziFruitoriList(idServizi, ricerca);
  1993.     }

  1995.     public List<AccordoServizioParteSpecifica> serviziWithIdAccordoList(long idAccordo) throws DriverRegistroServiziException {
  1996.         return this.accordiParteSpecificaDriver.serviziWithIdAccordoList(idAccordo);
  1997.     }

  1999.     /**
  2000.      * Recupero l'id del servizio fruitore
  2001.      * @param idServizio
  2002.      * @param idSoggetto
  2003.      * @return L'id del servizio fruitore
  2004.      * @throws DriverRegistroServiziException
  2005.      */
  2006.     public long getIdServizioFruitore(long idServizio, long idSoggetto) throws DriverRegistroServiziException {
  2007.         return this.accordiParteSpecificaFruitoreDriver.getIdServizioFruitore(idServizio, idSoggetto);
  2008.     }

  2010.     public List<Fruitore> getServiziFruitoriWithServizio(long idServizio) throws DriverRegistroServiziException {
  2011.         return this.accordiParteSpecificaFruitoreDriver.getServiziFruitoriWithServizio(idServizio);
  2012.     }

  2014.     public List<AccordoServizioParteSpecifica> getServiziByIdErogatore(long idErogatore,ISearch filters) throws DriverRegistroServiziException {
  2015.         return this.accordiParteSpecificaSearchDriver.getServiziByIdErogatore(idErogatore, filters);
  2016.     }

  2018.     public List<AccordoServizioParteSpecifica> getServiziByFruitore(Fruitore fruitore) throws DriverRegistroServiziException {
  2019.         return this.accordiParteSpecificaFruitoreDriver.getServiziByFruitore(fruitore);
  2020.     }

  2022.     public List<Fruitore> getSoggettiWithServizioNotFruitori(long idServizio, boolean escludiSoggettiEsterni, CredenzialeTipo credenzialeTipo) throws DriverRegistroServiziException {
  2023.         return this.accordiParteSpecificaFruitoreDriver.getSoggettiWithServizioNotFruitori(idServizio, escludiSoggettiEsterni, credenzialeTipo);
  2024.     }
  2025.     
  2026.     /***
  2027.      * 
  2028.      * @param superuser
  2029.      * @param ricerca
  2030.      * @param permessiUtente se permessiUtente[0] = true l'utente ha permessi per la categoria Servizi 'S', se permessiUtente[1] = true l'utente ha permessi per la categoria Accordi Cooperazione 'P'
  2031.      * @return lista di accordi di servizio parte specifica
  2032.      * @throws DriverRegistroServiziException
  2033.      */
  2034.     public List<AccordoServizioParteSpecifica> soggettiServizioList(String superuser, ISearch ricerca,boolean [] permessiUtente, 
  2035.             boolean gestioneFruitori, boolean gestioneErogatori) throws DriverRegistroServiziException {
  2036.         return this.accordiParteSpecificaSearchDriver.soggettiServizioList(superuser, ricerca, permessiUtente, 
  2037.                 gestioneFruitori, gestioneErogatori);
  2038.     }
  2039.     
  2040.     /**
  2041.      * Recupera gli id dei soggetti che erogano un determinato servizio
  2042.      * Si puo passare il tipo di soggetti che si desidera controllare, oppure null per tutti i soggetti. 
  2043.      * @param tipoServizio
  2044.      * @param nomeServizio
  2045.      * @param uriAccordo
  2046.      * @param nomePortType
  2047.      * @param tipoSoggetto Il tipo del soggetto erogatore
  2048.      * @return List<IDSoggetto>
  2049.      * @throws DriverRegistroServiziException
  2050.      */
  2051.     public List<IDSoggetto> getAllIdSoggettiErogatori(String tipoServizio,String nomeServizio,String uriAccordo,String nomePortType,String tipoSoggetto) throws DriverRegistroServiziException {
  2052.         return this.accordiParteSpecificaDriver.getAllIdSoggettiErogatori(tipoServizio, nomeServizio,uriAccordo, nomePortType, tipoSoggetto);
  2053.     }
  2054.     
  2055.     public void validaStatoAccordoServizioParteSpecifica(AccordoServizioParteSpecifica servizio, boolean gestioneWsdlImplementativo, boolean checkConnettore) throws ValidazioneStatoPackageException{
  2056.         this.accordiParteSpecificaDriver.validaStatoAccordoServizioParteSpecifica(servizio, gestioneWsdlImplementativo, checkConnettore);
  2057.     }

  2059.     public void validaStatoFruitoreServizio(Fruitore fruitore,AccordoServizioParteSpecifica serv) throws ValidazioneStatoPackageException{
  2060.         this.accordiParteSpecificaFruitoreDriver.validaStatoFruitoreServizio(fruitore, serv);
  2061.     }
  2062.     
  2063.     public void updateProprietaOggettoErogazione(IDServizio idServizio, String user) throws DriverRegistroServiziException {
  2064.         this.accordiParteSpecificaDriver.updateProprietaOggettoErogazione(idServizio, user);
  2065.     }
  2066.     public void updateProprietaOggettoErogazione(long idServizio, String user) throws DriverRegistroServiziException {
  2067.         this.accordiParteSpecificaDriver.updateProprietaOggettoErogazione(idServizio, user);
  2068.     }
  2069.     public void updateProprietaOggettoFruizione(IDServizio idServizio, IDSoggetto idFruitore, String user) throws DriverRegistroServiziException {
  2070.         this.accordiParteSpecificaDriver.updateProprietaOggettoFruizione(idServizio, idFruitore, user);
  2071.     }
  2072.     public void updateProprietaOggettoFruizione(long idFruizione, String user) throws DriverRegistroServiziException {
  2073.         this.accordiParteSpecificaDriver.updateProprietaOggettoFruizione(idFruizione, user);
  2074.     }
  2075.     


  2078.     /* Connettori */

  2080.     public Connettore getConnettore(long idConnettore) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  2081.         return this.connettoriDriver.getConnettore(idConnettore);
  2082.     }
  2083.     public Connettore getConnettore(String nomeConnettore) throws DriverRegistroServiziException {
  2084.         return this.connettoriDriver.getConnettore(nomeConnettore);
  2085.     }
  2086.     
  2087.     /**
  2088.      * Accede alla tabella connettori, recupera il connettore con idConnettore
  2089.      * in caso di errore lancia un'eccezione.
  2090.      * 
  2091.      * @param idConnettore -
  2092.      *                id da prelevare
  2093.      * @param connection -
  2094.      *                una connesione con il db
  2095.      * @return Connettore
  2096.      * 
  2097.      */
  2098.     public Connettore getConnettore(long idConnettore, Connection connection) throws DriverRegistroServiziException {
  2099.         return this.connettoriDriver.getConnettore(idConnettore, connection);
  2100.     }

  2102.     /**
  2103.      * Accede alla tabella connettori_properties, recupera le properties del connettore con nomeConnettore
  2104.      * in caso di errore lancia un'eccezione.
  2105.      * 
  2106.      * @param nomeConnettore -
  2107.      *                nome da prelevare
  2108.      * @return Property[]
  2109.      * 
  2110.      */
  2111.     public Property[] getPropertiesConnettore(String nomeConnettore) throws DriverRegistroServiziException {
  2112.         return this.connettoriDriver.getPropertiesConnettore(nomeConnettore);
  2113.     }
  2114.     public Property[] getPropertiesConnettore(String nomeConnettore, Connection connection) throws DriverRegistroServiziException {
  2115.         return this.connettoriDriver.getPropertiesConnettore(nomeConnettore, connection);
  2116.     }
  2117.     
  2118.     /**
  2119.      * Crea un nuovo Connettore
  2120.      * 
  2121.      * @param connettore
  2122.      * @throws DriverRegistroServiziException
  2123.      */
  2124.     public void createConnettore(Connettore connettore) throws DriverRegistroServiziException {
  2125.         this.connettoriDriver.createConnettore(connettore);
  2126.     }

  2128.     /**
  2129.      * Aggiorna un Connettore
  2130.      * 
  2131.      * @param connettore
  2132.      * @throws DriverRegistroServiziException
  2133.      */
  2134.     public void updateConnettore(Connettore connettore) throws DriverRegistroServiziException {
  2135.         this.connettoriDriver.updateConnettore(connettore);
  2136.     }

  2138.     /**
  2139.      * Elimina un Connettore
  2140.      * 
  2141.      * @param connettore
  2142.      * @throws DriverRegistroServiziException
  2143.      */
  2144.     public void deleteConnettore(Connettore connettore) throws DriverRegistroServiziException {
  2145.         this.connettoriDriver.deleteConnettore(connettore);
  2146.     }

  2148.     
  2149.     /* Protocol Properties */
  2150.     
  2151.     public boolean existsProtocolProperty(ProprietariProtocolProperty proprietarioProtocolProperty, long idProprietario, String nome) throws DriverRegistroServiziException {
  2152.         return this.protocolPropertiesDriver.existsProtocolProperty(proprietarioProtocolProperty, idProprietario, nome);
  2153.     }

  2155.     public ProtocolProperty getProtocolProperty(ProprietariProtocolProperty proprietarioProtocolProperty, long idProprietario, String nome) throws DriverRegistroServiziException {
  2156.         return this.protocolPropertiesDriver.getProtocolProperty(proprietarioProtocolProperty, idProprietario, nome);
  2157.     }

  2159.     public ProtocolProperty getProtocolProperty(long idProtocolProperty) throws DriverRegistroServiziException {
  2160.         return this.protocolPropertiesDriver.getProtocolProperty(idProtocolProperty);
  2161.     }
  2162.     
  2163.     

  2165.     /* RESET */
  2166.     
  2167.     @Override
  2168.     public void reset() throws DriverRegistroServiziException {
  2169.         this.utilsDriver.reset();
  2170.     }

  2172.     /**
  2173.      * Reset delle tabelle del db govwayConsole gestito da questo driver
  2174.      */
  2175.     public void resetCtrlstat() throws DriverRegistroServiziException {
  2176.         this.utilsDriver.resetCtrlstat();
  2177.     }

  2179.     /**
  2180.      * Metodo che verica la connessione ad una risorsa.
  2181.      * Se la connessione non e' presente, viene lanciata una eccezione che contiene il motivo della mancata connessione
  2182.      * 
  2183.      * @throws CoreException eccezione che contiene il motivo della mancata connessione
  2184.      */
  2185.     @Override
  2186.     public void isAlive() throws CoreException{
  2187.         this.utilsDriver.isAlive();
  2188.     }
  2189.     

  2191. }
Created with JaCoCo 0.8.8.202204050719