DriverConfigurazioneDB.java

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


package org.openspcoop2.core.config.driver.db;

import java.sql.Connection;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.openspcoop2.core.allarmi.Allarme;
import org.openspcoop2.core.allarmi.constants.StatoAllarme;
import org.openspcoop2.core.commons.CoreException;
import org.openspcoop2.core.commons.DBUtils;
import org.openspcoop2.core.commons.ErrorsHandlerCostant;
import org.openspcoop2.core.commons.IDriverWS;
import org.openspcoop2.core.commons.IMonitoraggioRisorsa;
import org.openspcoop2.core.commons.ISearch;
import org.openspcoop2.core.config.AccessoConfigurazione;
import org.openspcoop2.core.config.AccessoDatiAttributeAuthority;
import org.openspcoop2.core.config.AccessoDatiAutenticazione;
import org.openspcoop2.core.config.AccessoDatiAutorizzazione;
import org.openspcoop2.core.config.AccessoDatiConsegnaApplicativi;
import org.openspcoop2.core.config.AccessoDatiGestioneToken;
import org.openspcoop2.core.config.AccessoDatiKeystore;
import org.openspcoop2.core.config.AccessoDatiRichieste;
import org.openspcoop2.core.config.AccessoRegistro;
import org.openspcoop2.core.config.AccessoRegistroRegistro;
import org.openspcoop2.core.config.CanaleConfigurazione;
import org.openspcoop2.core.config.CanaleConfigurazioneNodo;
import org.openspcoop2.core.config.CanaliConfigurazione;
import org.openspcoop2.core.config.Configurazione;
import org.openspcoop2.core.config.ConfigurazioneGestioneErrore;
import org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola;
import org.openspcoop2.core.config.Connettore;
import org.openspcoop2.core.config.CorrelazioneApplicativaElemento;
import org.openspcoop2.core.config.CorrelazioneApplicativaRispostaElemento;
import org.openspcoop2.core.config.GenericProperties;
import org.openspcoop2.core.config.GestioneErrore;
import org.openspcoop2.core.config.MessageSecurityFlowParameter;
import org.openspcoop2.core.config.MtomProcessorFlowParameter;
import org.openspcoop2.core.config.Openspcoop2;
import org.openspcoop2.core.config.PortaApplicativa;
import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneServizioApplicativo;
import org.openspcoop2.core.config.PortaApplicativaAutorizzazioneSoggetto;
import org.openspcoop2.core.config.PortaApplicativaAzione;
import org.openspcoop2.core.config.PortaDelegata;
import org.openspcoop2.core.config.Property;
import org.openspcoop2.core.config.Proprieta;
import org.openspcoop2.core.config.ProprietaOggetto;
import org.openspcoop2.core.config.ProtocolProperty;
import org.openspcoop2.core.config.RegistroPlugin;
import org.openspcoop2.core.config.RegistroPluginArchivio;
import org.openspcoop2.core.config.RegistroPlugins;
import org.openspcoop2.core.config.ResponseCachingConfigurazioneRegola;
import org.openspcoop2.core.config.RoutingTable;
import org.openspcoop2.core.config.RoutingTableDestinazione;
import org.openspcoop2.core.config.ServizioApplicativo;
import org.openspcoop2.core.config.Soggetto;
import org.openspcoop2.core.config.StatoServiziPdd;
import org.openspcoop2.core.config.SystemProperties;
import org.openspcoop2.core.config.TrasformazioneRegola;
import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaServizioApplicativo;
import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaSoggetto;
import org.openspcoop2.core.config.TrasformazioneRegolaParametro;
import org.openspcoop2.core.config.TrasformazioneRegolaRisposta;
import org.openspcoop2.core.config.constants.CostantiConfigurazione;
import org.openspcoop2.core.config.constants.CredenzialeTipo;
import org.openspcoop2.core.config.constants.PluginSorgenteArchivio;
import org.openspcoop2.core.config.constants.RicercaTipologiaErogazione;
import org.openspcoop2.core.config.constants.RicercaTipologiaFruizione;
import org.openspcoop2.core.config.constants.TipologiaErogazione;
import org.openspcoop2.core.config.driver.BeanUtilities;
import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
import org.openspcoop2.core.config.driver.FiltroRicercaPorteApplicative;
import org.openspcoop2.core.config.driver.FiltroRicercaPorteDelegate;
import org.openspcoop2.core.config.driver.FiltroRicercaServiziApplicativi;
import org.openspcoop2.core.config.driver.FiltroRicercaSoggetti;
import org.openspcoop2.core.config.driver.IDriverConfigurazioneCRUD;
import org.openspcoop2.core.config.driver.IDriverConfigurazioneGet;
import org.openspcoop2.core.config.driver.TipologiaServizioApplicativo;
import org.openspcoop2.core.constants.Costanti;
import org.openspcoop2.core.constants.CostantiDB;
import org.openspcoop2.core.constants.ProprietariProtocolProperty;
import org.openspcoop2.core.id.IDConnettore;
import org.openspcoop2.core.id.IDPortaApplicativa;
import org.openspcoop2.core.id.IDPortaDelegata;
import org.openspcoop2.core.id.IDServizio;
import org.openspcoop2.core.id.IDServizioApplicativo;
import org.openspcoop2.core.id.IDSoggetto;
import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
import org.openspcoop2.generic_project.dao.jdbc.utils.JDBCObject;
import org.openspcoop2.utils.LoggerWrapperFactory;
import org.openspcoop2.utils.UtilsAlreadyExistsException;
import org.openspcoop2.utils.certificate.CertificateInfo;
import org.openspcoop2.utils.crypt.CryptConfig;
import org.openspcoop2.utils.datasource.DataSourceFactory;
import org.openspcoop2.utils.datasource.DataSourceParams;
import org.openspcoop2.utils.resources.GestoreJNDI;
import org.openspcoop2.utils.sql.ISQLQueryObject;
import org.slf4j.Logger;

/**
 * Contiene l'implementazione dell'interfaccia {@link CostantiConfigurazione}.
 * Viene definito un 'reader' della configurazione dell'infrastruttura
 * OpenSPCoop.
 * <p>
 * Sono forniti metodi per la lettura della configurazione la quale contiene i
 * seguenti soggetti :
 * <ul>
 * <li>Porte Delegate
 * <li>Porte Applicative
 * <li>SIL-Mittenti
 * <li>Porta di Dominio
 * </ul>get
 * 
 * @author Stefano Corallo (corallo@link.it)
 * @author Sandra Giangrandi (sandra@link.it)
 * @author Lorenzo Nardi (nardi@link.it)
 * 
 * @author $Author$
 * @version $Rev$, $Date$
 */

public class DriverConfigurazioneDB extends BeanUtilities
implements IDriverConfigurazioneGet, IDriverConfigurazioneCRUD, IDriverWS, IMonitoraggioRisorsa {

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

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

	// Datasource per la connessione al DB
	private DataSource datasource = null;

	// Connection passata al momento della creazione dell'oggetto
	protected Connection globalConnection = null;
	// Variabile di controllo del tipo di operazione da effettuare
	// l'autoCommit viene gestito internamente a questa classe
	protected boolean atomica = true;
	public boolean isAtomica() {
		return this.atomica;
	}

	/** Logger utilizzato per debug. */
	protected org.slf4j.Logger log = null;
	void logDebug(String msg) {
		if(this.log!=null) {
			this.log.debug(msg);
		}
	}
	void logDebug(String msg, Exception e) {
		if(this.log!=null) {
			this.log.debug(msg,e);
		}
	}
	void logInfo(String msg) {
		if(this.log!=null) {
			this.log.info(msg);
		}
	}
	void logError(String msg) {
		if(this.log!=null) {
			this.log.error(msg);
		}
	}
	void logError(String msg, Exception e) {
		if(this.log!=null) {
			this.log.error(msg,e);
		}
	}

	// Tipo database passato al momento della creazione dell'oggetto
	protected String tipoDB = null;
	public String getTipoDB() {
		return this.tipoDB;
	}

	/** Tabella soggetti */
	protected String tabellaSoggetti = CostantiDB.SOGGETTI;
	
	protected boolean useSuperUser = true;
	public boolean isUseSuperUser() {
		return this.useSuperUser;
	}
	public void setUseSuperUser(boolean useSuperUser) {
		this.useSuperUser = useSuperUser;
	}

	// Driver
	
	private DriverConfigurazioneDBSoggetti soggettiDriver = null;
	private DriverConfigurazioneDBSoggettiSearch soggettiSearchDriver = null;
	
	private DriverConfigurazioneDB_connettoriDriver connettoriDriver = null;
	
	private DriverConfigurazioneDB_porteDelegateDriver porteDelegateDriver = null;
	private DriverConfigurazioneDB_porteDelegateSearchDriver porteDelegateSearchDriver = null;
	private DriverConfigurazioneDB_porteApplicativeDriver porteApplicativeDriver = null;
	private DriverConfigurazioneDB_porteApplicativeSearchDriver porteApplicativeSearchDriver = null;
	private DriverConfigurazioneDB_porteTrasformazioniDriver porteTrasformazioniDriver = null;
	private DriverConfigurazioneDB_porteDriver porteDriver = null;
	
	private DriverConfigurazioneDB_serviziApplicativiDriver serviziApplicativiDriver = null;
	private DriverConfigurazioneDBServiziApplicativiSearch serviziApplicativiSearchDriver = null;
	
	private DriverConfigurazioneDB_protocolPropertiesDriver protocolPropertiesDriver = null;
	
	private DriverConfigurazioneDB_routingTableDriver routingTableDriver = null;
	private DriverConfigurazioneDB_gestioneErroreDriver gestioneErroreDriver = null;
	private DriverConfigurazioneDB_genericPropertiesDriver genericPropertiesDriver = null;
	private DriverConfigurazioneDB_configDriver configDriver = null;
	private DriverConfigurazioneDB_configSearchDriver configSearchDriver = null;
	
	private DriverConfigurazioneDB_pluginsDriver pluginsDriver = null;
	
	private DriverConfigurazioneDB_allarmiDriver allarmiDriver = null;
	
	private DriverConfigurazioneDBUtils utilsDriver = null;
	
	
	
	
	
	/* ******** COSTRUTTORI e METODI DI RELOAD ******** */

	public DriverConfigurazioneDB() {
		
		this.soggettiDriver = new DriverConfigurazioneDBSoggetti(this);
		this.soggettiSearchDriver = new DriverConfigurazioneDBSoggettiSearch(this);
		
		this.connettoriDriver = new DriverConfigurazioneDB_connettoriDriver(this);
		
		this.porteDelegateDriver = new DriverConfigurazioneDB_porteDelegateDriver(this);
		this.porteDelegateSearchDriver = new DriverConfigurazioneDB_porteDelegateSearchDriver(this);
		this.porteApplicativeDriver = new DriverConfigurazioneDB_porteApplicativeDriver(this);
		this.porteApplicativeSearchDriver = new DriverConfigurazioneDB_porteApplicativeSearchDriver(this);
		this.porteTrasformazioniDriver = new DriverConfigurazioneDB_porteTrasformazioniDriver(this);
		this.porteDriver = new DriverConfigurazioneDB_porteDriver(this);
		
		this.serviziApplicativiDriver = new DriverConfigurazioneDB_serviziApplicativiDriver(this);
		this.serviziApplicativiSearchDriver = new DriverConfigurazioneDBServiziApplicativiSearch(this);
		
		this.protocolPropertiesDriver = new DriverConfigurazioneDB_protocolPropertiesDriver(this);
		
		this.routingTableDriver = new DriverConfigurazioneDB_routingTableDriver(this);
		this.gestioneErroreDriver = new DriverConfigurazioneDB_gestioneErroreDriver(this);
		this.genericPropertiesDriver = new DriverConfigurazioneDB_genericPropertiesDriver(this);
		this.configDriver = new DriverConfigurazioneDB_configDriver(this);
		this.configSearchDriver = new DriverConfigurazioneDB_configSearchDriver(this);
		
		this.pluginsDriver = new DriverConfigurazioneDB_pluginsDriver(this);
		
		this.allarmiDriver = new DriverConfigurazioneDB_allarmiDriver(this);
		
		this.utilsDriver = new DriverConfigurazioneDBUtils(this);
		
	}
	/**
	 * Viene chiamato in causa per istanziare il contesto di unmarshall
	 * all'istanziazione dell'oggetto, ed inoltre viene effettuato l'unmarshall
	 * del file di configurazione.
	 * 
	 * @param nomeDataSource
	 *                Nome del Datasource da utilizzare per prelevare le
	 *                connessioni
	 * @param context
	 *                Contesto di lookup del Datasource
	 * 
	 */
	public DriverConfigurazioneDB(String nomeDataSource, java.util.Properties context,String tipoDB) {
		this(nomeDataSource,context,null,tipoDB);
	}
	public DriverConfigurazioneDB(String nomeDataSource, java.util.Properties context,Logger alog,String tipoDB) {
		this(nomeDataSource,context,alog,tipoDB,false);
	}
	public DriverConfigurazioneDB(String nomeDataSource, java.util.Properties context,Logger alog,String tipoDB, boolean tabellaSoggettiPDD) {
		initDriverConfigurazioneDB(nomeDataSource, context, alog, tipoDB, tabellaSoggettiPDD, false, false);
	}
	public DriverConfigurazioneDB(String nomeDataSource, java.util.Properties context,Logger alog,String tipoDB, boolean tabellaSoggettiPDD,
			boolean useOp2UtilsDatasource, boolean bindJMX) {
		initDriverConfigurazioneDB(nomeDataSource, context, alog, tipoDB, tabellaSoggettiPDD, useOp2UtilsDatasource, bindJMX);
	}

	public void initDriverConfigurazioneDB(String nomeDataSource, java.util.Properties context,Logger alog,String tipoDB, 
			boolean tabellaSoggettiPDD, boolean useOp2UtilsDatasource, boolean bindJMX) {
		try {
			if(alog==null)
				this.log = LoggerWrapperFactory.getLogger(CostantiConfigurazione.DRIVER_DB_LOGGER);
			else{
				this.log = alog;
				DriverConfigurazioneDBLib.initStaticLogger(this.log);
			}

			if(useOp2UtilsDatasource){
				DataSourceParams dsParams = Costanti.getDataSourceParamsPdD(bindJMX, tipoDB);
				try{
					this.datasource = DataSourceFactory.newInstance(nomeDataSource, context, dsParams);
				}catch(UtilsAlreadyExistsException exists){
					this.datasource = DataSourceFactory.getInstance(nomeDataSource); 
					if(this.datasource==null){
						throw new DriverConfigurazioneException("Lookup datasource non riuscita ("+exists.getMessage()+")",exists);
					}
				}
			}
			else{
				GestoreJNDI gestoreJNDI = new GestoreJNDI(context);
				this.datasource = (DataSource) gestoreJNDI.lookup(nomeDataSource);
			}
			if (this.datasource != null)
				this.create = true;
		} catch (Exception ne) {
			this.create = false;
			this.log.error("Impossibile recuperare il context: " + ne.getMessage(),ne);
		}

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

		this.atomica = true;
		this.tipoDB = tipoDB;
		if(tabellaSoggettiPDD){
			this.tabellaSoggetti = CostantiDB.SOGGETTI_PDD;
		}else{
			this.tabellaSoggetti = CostantiDB.SOGGETTI;
		}
		// Setto il tipoDB anche in DriverConfigurazioneDB_LIB
		DriverConfigurazioneDBLib.setTipoDB(tipoDB);
		DriverConfigurazioneDBLib.setTabellaSoggetti(this.tabellaSoggetti);
		
		// driver
		
		this.soggettiDriver = new DriverConfigurazioneDBSoggetti(this);
		this.soggettiSearchDriver = new DriverConfigurazioneDBSoggettiSearch(this);
		
		this.connettoriDriver = new DriverConfigurazioneDB_connettoriDriver(this);
		
		this.porteDelegateDriver = new DriverConfigurazioneDB_porteDelegateDriver(this);
		this.porteDelegateSearchDriver = new DriverConfigurazioneDB_porteDelegateSearchDriver(this);
		this.porteApplicativeDriver = new DriverConfigurazioneDB_porteApplicativeDriver(this);
		this.porteApplicativeSearchDriver = new DriverConfigurazioneDB_porteApplicativeSearchDriver(this);
		this.porteTrasformazioniDriver = new DriverConfigurazioneDB_porteTrasformazioniDriver(this);
		this.porteDriver = new DriverConfigurazioneDB_porteDriver(this);
		
		this.serviziApplicativiDriver = new DriverConfigurazioneDB_serviziApplicativiDriver(this);
		this.serviziApplicativiSearchDriver = new DriverConfigurazioneDBServiziApplicativiSearch(this);
		
		this.protocolPropertiesDriver = new DriverConfigurazioneDB_protocolPropertiesDriver(this);
		
		this.routingTableDriver = new DriverConfigurazioneDB_routingTableDriver(this);
		this.gestioneErroreDriver = new DriverConfigurazioneDB_gestioneErroreDriver(this);
		this.genericPropertiesDriver = new DriverConfigurazioneDB_genericPropertiesDriver(this);
		this.configDriver = new DriverConfigurazioneDB_configDriver(this);
		this.configSearchDriver = new DriverConfigurazioneDB_configSearchDriver(this);
		
		this.pluginsDriver = new DriverConfigurazioneDB_pluginsDriver(this);
		
		this.allarmiDriver = new DriverConfigurazioneDB_allarmiDriver(this);
		
		this.utilsDriver = new DriverConfigurazioneDBUtils(this);
	}

	public DriverConfigurazioneDB(Connection connection,String tipoDB) throws DriverConfigurazioneException {
		this(connection,null,tipoDB);
	}
	public DriverConfigurazioneDB(Connection connection,Logger alog,String tipoDB) throws DriverConfigurazioneException {
		this(connection,alog,tipoDB,false);
	}
	public DriverConfigurazioneDB(Connection connection,Logger alog,String tipoDB,boolean tabellaSoggettiPDD) throws DriverConfigurazioneException {

		if(alog==null)
			this.log = LoggerWrapperFactory.getLogger(CostantiConfigurazione.DRIVER_DB_LOGGER);
		else{
			this.log = alog;
			DriverConfigurazioneDBLib.initStaticLogger(this.log);
		}

		if (connection == null) {
			this.create = false;
			throw new DriverConfigurazioneException("[DriverConfigurazioneDB::DriverConfigurazioneDB(Connection con, Properties context) La connection non puo essere null.");
		}

		if (tipoDB == null) {
			this.create = false;
			throw new DriverConfigurazioneException("[DriverConfigurazioneDB::DriverConfigurazioneDB(Connection ) Il tipoDatabase non puo essere null.");
		}

		this.globalConnection = connection;
		this.create = true;
		this.atomica = false;
		this.tipoDB = tipoDB;
		if(tabellaSoggettiPDD){
			this.tabellaSoggetti = CostantiDB.SOGGETTI_PDD;
		}else{
			this.tabellaSoggetti = CostantiDB.SOGGETTI;
		}
		
		// Setto il tipoDB anche in DriverConfigurazioneDB_LIB
		DriverConfigurazioneDBLib.setTipoDB(tipoDB);
		DriverConfigurazioneDBLib.setTabellaSoggetti(this.tabellaSoggetti);

		// driver
		
		this.soggettiDriver = new DriverConfigurazioneDBSoggetti(this);
		this.soggettiSearchDriver = new DriverConfigurazioneDBSoggettiSearch(this);
		
		this.connettoriDriver = new DriverConfigurazioneDB_connettoriDriver(this);
		
		this.porteDelegateDriver = new DriverConfigurazioneDB_porteDelegateDriver(this);
		this.porteDelegateSearchDriver = new DriverConfigurazioneDB_porteDelegateSearchDriver(this);
		this.porteApplicativeDriver = new DriverConfigurazioneDB_porteApplicativeDriver(this);
		this.porteApplicativeSearchDriver = new DriverConfigurazioneDB_porteApplicativeSearchDriver(this);
		this.porteTrasformazioniDriver = new DriverConfigurazioneDB_porteTrasformazioniDriver(this);
		this.porteDriver = new DriverConfigurazioneDB_porteDriver(this);
		
		this.serviziApplicativiDriver = new DriverConfigurazioneDB_serviziApplicativiDriver(this);
		this.serviziApplicativiSearchDriver = new DriverConfigurazioneDBServiziApplicativiSearch(this);
		
		this.protocolPropertiesDriver = new DriverConfigurazioneDB_protocolPropertiesDriver(this);
		
		this.routingTableDriver = new DriverConfigurazioneDB_routingTableDriver(this);
		this.gestioneErroreDriver = new DriverConfigurazioneDB_gestioneErroreDriver(this);
		this.genericPropertiesDriver = new DriverConfigurazioneDB_genericPropertiesDriver(this);
		this.configDriver = new DriverConfigurazioneDB_configDriver(this);
		this.configSearchDriver = new DriverConfigurazioneDB_configSearchDriver(this);
		
		this.pluginsDriver = new DriverConfigurazioneDB_pluginsDriver(this);
		
		this.allarmiDriver = new DriverConfigurazioneDB_allarmiDriver(this);
		
		this.utilsDriver = new DriverConfigurazioneDBUtils(this);
	}

	
	
	public Connection getConnection(String methodName) throws DriverConfigurazioneException{
		return getConnection(methodName, true);
	}
	public Connection getConnection(String methodName, boolean disableAutoCommit) throws DriverConfigurazioneException{
		Connection con = null;
		
		if (this.atomica) {
			try {
				/**System.out.println("GET FROM DS ["+methodName+"]");*/
				con = getConnectionFromDatasource(methodName);
				if(disableAutoCommit) {
					con.setAutoCommit(false);
				}
			} catch (Exception e) {
				throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getConnection] Exception accedendo al datasource :" + e.getMessage(),e);

			}

		} else {
			/**System.out.println("GET GLOBAL ["+methodName+"]");*/
			con = this.globalConnection;
		}
		
		return con;
	}
	
	public void releaseConnection(Connection con){
		releaseConnection(null, con);
	}
	public void releaseConnection(String methodName, Connection con){
		if (this.atomica) {
			try {
				if(methodName!=null) {
					// nop
				}
				/**System.out.println("RELEASE ["+methodName+"]");*/
				con.close();
			} catch (Exception e) {
				// ignore
			}
		}
	}
	
	protected Connection getConnectionFromDatasource(String methodName) throws DriverConfigurazioneException{
		try {
			if(this.datasource instanceof org.openspcoop2.utils.datasource.DataSource){
				return ((org.openspcoop2.utils.datasource.DataSource)this.datasource).getWrappedConnection(null, "DriverConfigurazione."+methodName);
			}
			else{
				return this.datasource.getConnection();
			}
		}catch(Exception e) {
			throw new DriverConfigurazioneException(e.getMessage(),e);
		}
	}

	
	
	public List<List<Object>> readCustom(ISQLQueryObject sqlQueryObject, List<Class<?>> returnTypes, List<JDBCObject> paramTypes) throws DriverConfigurazioneException
	{
		Connection con = null;
		try {

			this.logDebug("operazione atomica = " + this.atomica);
			// prendo la connessione dal pool
			if (this.atomica)
				con = getConnectionFromDatasource("readCustom");
			else
				con = this.globalConnection;
		
			return DBUtils.readCustom(this.log, con, this.tipoDB, sqlQueryObject, returnTypes, paramTypes);
			
		}catch (Exception se) {
			throw new DriverConfigurazioneException("[DriverConfigurazioneDB::readCustom]: " + se.getMessage(),se);
		} finally {

			this.closeConnection(con);

		}
	}
	
	public void closeConnection(Connection conParam, Connection con) {
		try {
			if (conParam==null && this.atomica) {
				this.log.debug("rilascio connessione al db...");
				if(con!=null) {
					con.close();
				}
			}
		} catch (Exception e) {
			// ignore
		}
	}
	
	public void closeConnection(Connection con) {
		try {
			if (this.atomica) {
				this.log.debug("rilascio connessioni al db...");
				if(con!=null) {
					con.close();
				}
			}
		} catch (Exception e) {
			// ignore exception
		}
	}
	
	public void closeConnection(boolean error, Connection con) {
		try {
			if (error && this.atomica) {
				this.log.debug("eseguo rollback a causa di errori e rilascio connessioni...");
				if(con!=null) {
					con.rollback();
					con.setAutoCommit(true);
					con.close();
				}

			} else if (!error && this.atomica) {
				this.log.debug("eseguo commit e rilascio connessioni...");
				if(con!=null) {
					con.commit();
					con.setAutoCommit(true);
					con.close();
				}
			}

		} catch (Exception e) {
			// ignore exception
		}
	}
	
	
	
	
	// *** Soggetti ***
	
	public IDSoggetto getIdSoggetto(long idSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.soggettiDriver.getIdSoggetto(idSoggetto);
	}
	public IDSoggetto getIdSoggetto(long idSoggetto,Connection conParam) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.soggettiDriver.getIdSoggetto(idSoggetto, conParam);
	}
	
	/**
	 * Restituisce Il soggetto identificato da <var>idSoggetto</var>
	 * 
	 * @param aSoggetto
	 *                Identificatore di un soggetto
	 * @return Il Soggetto identificato dal parametro.
	 * 
	 */
	@Override
	public Soggetto getSoggetto(IDSoggetto aSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.soggettiDriver.getSoggetto(aSoggetto);
	}

	/**
	 * Crea un nuovo Soggetto
	 * 
	 * @param soggetto
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void createSoggetto(org.openspcoop2.core.config.Soggetto soggetto) throws DriverConfigurazioneException {
		this.soggettiDriver.createSoggetto(soggetto);
	}

	/**
	 * Aggiorna un Soggetto e il Connettore con i nuovi dati passati
	 * 
	 * @param soggetto
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void updateSoggetto(org.openspcoop2.core.config.Soggetto soggetto) throws DriverConfigurazioneException {
		this.soggettiDriver.updateSoggetto(soggetto);
	}
	
	/**
	 * Cancella un Soggetto e il Connettore
	 * 
	 * @param soggetto
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void deleteSoggetto(org.openspcoop2.core.config.Soggetto soggetto) throws DriverConfigurazioneException {
		this.soggettiDriver.deleteSoggetto(soggetto);
	}
	
	/**
	 * Restituisce il soggetto configurato come router, se esiste nella Porta di
	 * Dominio un soggetto registrato come Router
	 * 
	 * @return il soggetto configurato come router, se esiste nella Porta di
	 *         Dominio un soggetto registrato come Router
	 * 
	 */
	@Override
	public Soggetto getRouter() throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.soggettiDriver.getRouter();
	}

	public List<IDSoggetto> getSoggettiWithSuperuser(String user) throws DriverConfigurazioneException {
		return this.soggettiDriver.getSoggettiWithSuperuser(user);
	}

	/**
	 * Restituisce la lista dei soggetti virtuali gestiti dalla PdD
	 * 
	 * @return Restituisce la lista dei soggetti virtuali gestiti dalla PdD
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public List<IDSoggetto> getSoggettiVirtuali() throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.soggettiDriver.getSoggettiVirtuali();
	}

	/**
	 * Ritorna il {@linkplain Soggetto} utilizzando il {@link DriverConfigurazioneDB} che ha l'id passato come parametro 
	 */
	public Soggetto getSoggetto(long idSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.soggettiDriver.getSoggetto(idSoggetto);
	}
	public Soggetto getSoggetto(long idSoggetto,Connection conParam) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.soggettiDriver.getSoggetto(idSoggetto, conParam);
	}
	
	public List<Soggetto> soggettiList(String superuser, ISearch ricerca) throws DriverConfigurazioneException {
		return this.soggettiSearchDriver.soggettiList(superuser, ricerca);
	}

	public List<Soggetto> soggettiWithServiziList(ISearch ricerca) throws DriverConfigurazioneException {
		return this.soggettiSearchDriver.soggettiWithServiziList(ricerca);
	}
	public List<Soggetto> soggettiWithServiziList(String superuser,ISearch ricerca) throws DriverConfigurazioneException {
		return this.soggettiSearchDriver.soggettiWithServiziList(superuser, ricerca);
	}
	
	@Override
	public List<IDServizio> getServiziSoggettiVirtuali() throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.soggettiDriver.getServiziSoggettiVirtuali();
	}
	
	@Override
	public boolean existsSoggetto(IDSoggetto idSoggetto) throws DriverConfigurazioneException {
		return this.soggettiDriver.existsSoggetto(idSoggetto);
	}
	
	public List<Soggetto> getAllSoggetti() throws DriverConfigurazioneException {
		return this.soggettiDriver.getAllSoggetti();
	}
	
	/**
	 * Restituisce la lista degli identificativi dei soggetti
	 * 
	 * @param filtroRicerca
	 * @return lista degli identificativi dei soggetti
	 * @throws DriverConfigurazioneException
	 * @throws DriverConfigurazioneNotFound
	 */
	@Override
	public List<IDSoggetto> getAllIdSoggetti(FiltroRicercaSoggetti filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.soggettiDriver.getAllIdSoggetti(filtroRicerca);
	}
	
	
	
	
	// *** Connettori ***
	
	/**
	 * Crea un nuovo Connettore
	 * 
	 * @param connettore
	 * @throws DriverConfigurazioneException
	 */
	public void createConnettore(Connettore connettore) throws DriverConfigurazioneException {
		this.connettoriDriver.createConnettore(connettore);
	}

	/**
	 * Aggiorna un Connettore
	 * 
	 * @param connettore
	 * @throws DriverConfigurazioneException
	 */
	public void updateConnettore(Connettore connettore) throws DriverConfigurazioneException {
		this.connettoriDriver.updateConnettore(connettore);
	}

	/**
	 * Elimina un Connettore
	 * 
	 * @param connettore
	 * @throws DriverConfigurazioneException
	 */
	public void deleteConnettore(Connettore connettore) throws DriverConfigurazioneException {
		this.connettoriDriver.deleteConnettore(connettore);
	}
	
	public List<String> connettoriList() throws DriverConfigurazioneException {
		return this.connettoriDriver.connettoriList();
	}
	
	/**
	 * Accede alla tabella connettori_properties, recupera le properties del connettore con nomeConnettore
	 * in caso di errore lancia un'eccezione.
	 * 
	 * @param nomeConnettore -
	 *                nome da prelevare
	 * @return ConnettoreProperty[]
	 * 
	 */
	public Property[] getPropertiesConnettore(String nomeConnettore) throws DriverConfigurazioneException {
		return this.connettoriDriver.getPropertiesConnettore(nomeConnettore);
	}
	public Property[] getPropertiesConnettore(String nomeConnettore, Connection connection) throws DriverConfigurazioneException {
		return this.connettoriDriver.getPropertiesConnettore(nomeConnettore, connection);
	}

	public boolean isPolicyNegoziazioneTokenUsedInConnettore(String nome) throws DriverConfigurazioneException{
		return this.connettoriDriver.isPolicyNegoziazioneTokenUsedInConnettore(nome);
	}
	
	public Connettore getConnettore(long idConnettore) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
		return this.connettoriDriver.getConnettore(idConnettore);
	}
	public Connettore getConnettore(String nomeConnettore) throws DriverConfigurazioneException {
		return this.connettoriDriver.getConnettore(nomeConnettore);
	}



	
	// *** Porte Delegate ***
	
	@Override
	public IDPortaDelegata getIDPortaDelegata(String nome) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.porteDelegateDriver.getIDPortaDelegata(nome);
	}
	
	@Override
	public PortaDelegata getPortaDelegata(IDPortaDelegata idPD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.porteDelegateDriver.getPortaDelegata(idPD);
	}

	public PortaDelegata getPortaDelegata(long id) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.porteDelegateDriver.getPortaDelegata(id);
	}
	public PortaDelegata getPortaDelegata(long id,Connection conParam) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.porteDelegateDriver.getPortaDelegata(id, conParam);
	}
	
	@Override
	public void createPortaDelegata(PortaDelegata aPD) throws DriverConfigurazioneException {
		this.porteDelegateDriver.createPortaDelegata(aPD);
	}
	
	@Override
	public void updatePortaDelegata(PortaDelegata aPD) throws DriverConfigurazioneException {
		this.porteDelegateDriver.updatePortaDelegata(aPD);
	}

	@Override
	public void deletePortaDelegata(PortaDelegata aPD) throws DriverConfigurazioneException {
		this.porteDelegateDriver.deletePortaDelegata(aPD);
	}
	
	public List<String> portaDelegataRuoliList(long idPD, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.portaDelegataRuoliList(idPD, ricerca);
	}
	public List<String> portaDelegataRuoliTokenList(long idPD, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.portaDelegataRuoliTokenList(idPD, ricerca);
	}	
	
	public List<String> portaDelegataScopeList(long idPD, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.portaDelegataScopeList(idPD, ricerca);
	}
	
	public List<TrasformazioneRegola> porteDelegateTrasformazioniList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteDelegateTrasformazioniList(idPA, ricerca);
	}
	
	public boolean azioneUsataInTrasformazioniPortaDelegata(String azione) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.azioneUsataInTrasformazioniPortaDelegata(azione);
	}

	public TrasformazioneRegola getPortaDelegataTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori,
			List<TrasformazioneRegolaApplicabilitaServizioApplicativo> applicativi) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaDelegataTrasformazione(idPorta, azioni, pattern, contentType, connettori,
				applicativi);
	}
	
	public TrasformazioneRegola getPortaDelegataTrasformazione(long idPorta, String nome) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaDelegataTrasformazione(idPorta, nome);
	}
	
	public boolean existsPortaDelegataTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaDelegataTrasformazione(idPorta, azioni, pattern, contentType, connettori);
	}
	
	public boolean existsPortaDelegataTrasformazione(long idPorta, String nome) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaDelegataTrasformazione(idPorta, nome);
	}
	
	public List<TrasformazioneRegolaRisposta> porteDelegateTrasformazioniRispostaList(long idPD, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteDelegateTrasformazioniRispostaList(idPD, idTrasformazione, ricerca);
	}
	
	public TrasformazioneRegolaRisposta getPortaDelegataTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaDelegataTrasformazioneRisposta(idPorta, idTrasformazione, statusMin, statusMax, pattern, contentType);
	}
	
	public TrasformazioneRegolaRisposta getPortaDelegataTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaDelegataTrasformazioneRisposta(idPorta, idTrasformazione, nome);
	}
	
	public boolean existsPortaDelegataTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaDelegataTrasformazioneRisposta(idPorta, idTrasformazione, statusMin, statusMax, pattern, contentType);
	}
	
	public boolean existsPortaDelegataTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaDelegataTrasformazioneRisposta(idPorta, idTrasformazione, nome);
	}
	
	public List<TrasformazioneRegolaApplicabilitaServizioApplicativo> porteDelegateTrasformazioniServiziApplicativiList(long idPD, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteDelegateTrasformazioniServiziApplicativiList(idPD, idTrasformazione, ricerca);
	}
	
	public List<TrasformazioneRegolaParametro> porteDelegateTrasformazioniRispostaHeaderList(long idPD, long idTrasformazione, long idTrasformazioneRisposta, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteDelegateTrasformazioniRispostaHeaderList(idPD, idTrasformazione, idTrasformazioneRisposta, ricerca);
	}

	public List<TrasformazioneRegolaParametro> porteDelegateTrasformazioniRichiestaHeaderList(long idPD, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteDelegateTrasformazioniRichiestaHeaderList(idPD, idTrasformazione, ricerca);
	}
	
	public boolean existsPortaDelegataTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaDelegataTrasformazioneRichiestaHeader(idPorta, idTrasformazione, nome, tipo, checkTipo);
	}
	
	public TrasformazioneRegolaParametro getPortaDelegataTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaDelegataTrasformazioneRichiestaHeader(idPorta, idTrasformazione, nome, tipo, checkTipo);
	}
	
	public List<TrasformazioneRegolaParametro> porteDelegateTrasformazioniRichiestaUrlParameterList(long idPD, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteDelegateTrasformazioniRichiestaUrlParameterList(idPD, idTrasformazione, ricerca);
	}
	
	public boolean existsPortaDelegataTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaDelegataTrasformazioneRichiestaUrlParameter(idPorta, idTrasformazione, nome, tipo, checkTipo);
	}
	
	public TrasformazioneRegolaParametro getPortaDelegataTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaDelegataTrasformazioneRichiestaUrlParameter(idPorta, idTrasformazione, nome, tipo, checkTipo);
	}
	
	public List<ResponseCachingConfigurazioneRegola> portaDelegataResponseCachingConfigurazioneRegolaList(long idPD, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDriver.portaDelegataResponseCachingConfigurazioneRegolaList(idPD, ricerca);
	}
	
	public boolean existsPortaDelegataResponseCachingConfigurazioneRegola(long idPA, Integer statusMin, Integer statusMax, boolean fault) throws DriverConfigurazioneException {
		return this.porteDriver.existsPortaDelegataResponseCachingConfigurazioneRegola(idPA, statusMin, statusMax, fault);
	}
	
	public List<String> porteDelegateRateLimitingValoriUnivoci(String pName) throws DriverConfigurazioneException {
		return this.porteDelegateDriver.porteDelegateRateLimitingValoriUnivoci(pName);
	}
	
	public List<PortaDelegata> porteDelegateList(long idSoggetto, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateList(idSoggetto, ricerca);
	}
	
	public List<Proprieta> porteDelegatePropList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegatePropList(idPortaDelegata, ricerca);
	}
	
	/**
	 * Ritorna la lista di nomi delle proprieta registrate
	 */
	public List<String> nomiProprietaPD(String filterSoggettoTipo, String filterSoggettoNome, List<String> tipoServiziProtocollo) throws DriverConfigurazioneException {
		return this.porteDelegateDriver.nomiProprietaPD(filterSoggettoTipo, filterSoggettoNome, tipoServiziProtocollo);
	}
	
	public List<Proprieta> porteDelegateAutenticazioneCustomPropList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateAutenticazioneCustomPropList(idPortaDelegata, ricerca);
	}
	
	public List<Proprieta> porteDelegateAutorizzazioneCustomPropList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateAutorizzazioneCustomPropList(idPortaDelegata, ricerca);
	}
	
	public List<Proprieta> porteDelegateAutorizzazioneContenutoCustomPropList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateAutorizzazioneContenutoCustomPropList(idPortaDelegata, ricerca);
	}

	public List<PortaDelegata> porteDelegateList(String superuser, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateList(superuser, ricerca);
	}

	public List<PortaDelegata> porteDelegateWithSoggettoErogatoreList(long idSoggettoErogatore) throws DriverConfigurazioneException {
		return this.porteDelegateDriver.porteDelegateWithSoggettoErogatoreList(idSoggettoErogatore);
	}

	public List<PortaDelegata> porteDelegateWithTipoNomeErogatoreList(String tipoSoggettoErogatore, String nomeSoggettoErogatore) throws DriverConfigurazioneException {
		return this.porteDelegateDriver.porteDelegateWithTipoNomeErogatoreList(tipoSoggettoErogatore, nomeSoggettoErogatore);
	}
	
	public List<ServizioApplicativo> porteDelegateServizioApplicativoList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateServizioApplicativoList(idPortaDelegata, ricerca);
	}
	public List<ServizioApplicativo> porteDelegateServizioApplicativoTokenList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateServizioApplicativoTokenList(idPortaDelegata, ricerca);
	}
	
	public List<MessageSecurityFlowParameter> porteDelegateMessageSecurityRequestList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateMessageSecurityRequestList(idPortaDelegata, ricerca);
	}

	public List<MessageSecurityFlowParameter> porteDelegateMessageSecurityResponseList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateMessageSecurityResponseList(idPortaDelegata, ricerca);
	}

	public List<CorrelazioneApplicativaElemento> porteDelegateCorrelazioneApplicativaList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateCorrelazioneApplicativaList(idPortaDelegata, ricerca);
	}

	public List<CorrelazioneApplicativaRispostaElemento> porteDelegateCorrelazioneApplicativaRispostaList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateCorrelazioneApplicativaRispostaList(idPortaDelegata, ricerca);
	}
	
	@Override
	public boolean existsPortaDelegata(IDPortaDelegata idPD) throws DriverConfigurazioneException {
		return this.porteDelegateDriver.existsPortaDelegata(idPD);
	}

	public List<PortaDelegata> getPorteDelegateWithServizio(Long idServizio, String tiposervizio, String nomeservizio,
			Integer versioneServizio,
			Long idSoggetto, String tiposoggetto, String nomesoggetto) throws DriverConfigurazioneException {
		return this.porteDelegateDriver.getPorteDelegateWithServizio(idServizio, tiposervizio, nomeservizio,
				versioneServizio,
				idSoggetto, tiposoggetto, nomesoggetto);
	}

	public List<PortaDelegata> getPorteDelegateWithServizio(Long idServizio) throws DriverConfigurazioneException {
		return this.porteDelegateDriver.getPorteDelegateWithServizio(idServizio);
	}

	// NOTA: Metodo non sicuro!!! Possono esistere piu' azioni di port type diversi o accordi diversi !!!!!
	public List<IDPortaDelegata> getPortaDelegataAzione(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
		return this.porteDelegateDriver.getPortaDelegataAzione(nome);
	}

	// NOTA: Metodo non sicuro!!! Possono esistere piu' azioni di port type diversi o accordi diversi !!!!!
	public boolean existsPortaDelegataAzione(String nome) throws DriverConfigurazioneException {
		return this.porteDelegateDriver.existsPortaDelegataAzione(nome);
	}
	
	public List<PortaDelegata> serviziFruitoriPorteDelegateList(long idSoggetto, String tipoServizio,String nomeServizio,Long idServizio, 
			String tipoSoggettoErogatore, String nomeSoggettoErogatore, Long idSoggettoErogatore, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.serviziFruitoriPorteDelegateList(idSoggetto, tipoServizio, nomeServizio, idServizio, 
				tipoSoggettoErogatore, nomeSoggettoErogatore, idSoggettoErogatore, ricerca);
	}
	
	/**
	 * Recupera tutte le porte delegate appartenenti al soggetto 'fruitore'
	 * @param fruitore
	 * @return Lista di {@link PortaDelegata}
	 * @throws DriverConfigurazioneException
	 */
	public List<PortaDelegata> getPorteDelegateByFruitore(IDSoggetto fruitore,ISearch filters) throws DriverConfigurazioneException{
		return this.porteDelegateSearchDriver.getPorteDelegateByFruitore(fruitore, filters);
	}

	/**
	 * Recupera tutte le porte delegate del soggetto fruitore, relative al servizio idServizio (se diverso da null), erogato dal soggetto erogatore del servizio.
	 * @param idSE L'id del servizio, puo essere null in tal caso si comporta come il metodo getPorteDelegateByFruitore
	 * @return List<PortaDelegata>
	 * @throws DriverConfigurazioneException
	 */
	public List<PortaDelegata> getPorteDelegate(IDServizio idSE,IDSoggetto fruitore,ISearch filters) throws DriverConfigurazioneException{
		return this.porteDelegateSearchDriver.getPorteDelegate(idSE, fruitore, filters);
	}
	
	public List<PortaDelegata> getPorteDelegateBySoggetto(long idSoggetto) throws DriverConfigurazioneException {
		return this.porteDelegateDriver.getPorteDelegateBySoggetto(idSoggetto);
	}
	
	/**
	 * Restituisce la lista degli identificativi delle porte delegate
	 * 
	 * @param filtroRicerca
	 * @return lista degli identificativi delle porte delegate
	 * @throws DriverConfigurazioneException
	 * @throws DriverConfigurazioneNotFound
	 */
	@Override
	public List<IDPortaDelegata> getAllIdPorteDelegate(FiltroRicercaPorteDelegate filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.porteDelegateDriver.getAllIdPorteDelegate(filtroRicerca);
	}
	
	public List<MtomProcessorFlowParameter> porteDelegateMTOMRequestList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateMTOMRequestList(idPortaDelegata, ricerca);
	}

	public List<MtomProcessorFlowParameter> porteDelegateMTOMResponseList(long idPortaDelegata, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDelegateSearchDriver.porteDelegateMTOMResponseList(idPortaDelegata, ricerca);
	}
	
	public List<PortaDelegata> getPorteDelegateByPolicyGestioneToken(String nome) throws DriverConfigurazioneException{
		return this.porteDelegateDriver.getPorteDelegateByPolicyGestioneToken(nome);
	}
	
	public MappingFruizionePortaDelegata getMappingFruizione(IDServizio idServizio, IDSoggetto idSoggetto, IDPortaDelegata idPortaDelegata) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.porteDelegateDriver.getMappingFruizione(idServizio, idSoggetto, idPortaDelegata);		
	}
		
	public ProprietaOggetto getProprietaOggetto(IDPortaDelegata idPD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.porteDelegateDriver.getProprietaOggetto(idPD);
	}
	
	public void updateProprietaOggetto(IDPortaDelegata idPD, String user) throws DriverConfigurazioneException {
		this.porteDelegateDriver.updateProprietaOggetto(idPD, user);
	}

	

	
	// *** Porte Applicative ***
	
	@Override
	public IDPortaApplicativa getIDPortaApplicativa(String nome) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.porteApplicativeDriver.getIDPortaApplicativa(nome);
	}
	
	@Override
	public PortaApplicativa getPortaApplicativa(IDPortaApplicativa idPA) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.porteApplicativeDriver.getPortaApplicativa(idPA);
	}
	
	public PortaApplicativa getPortaApplicativa(long id) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.porteApplicativeDriver.getPortaApplicativa(id);
	}
	public PortaApplicativa getPortaApplicativa(long id,Connection conParam) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.porteApplicativeDriver.getPortaApplicativa(id, conParam);
	}
	
	@Override
	public List<PortaApplicativa> getPorteApplicative(IDServizio idServizio, boolean ricercaPuntuale) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.porteApplicativeDriver.getPorteApplicative(idServizio, ricercaPuntuale);
	}
	
	@Override
	public List<PortaApplicativa> getPorteApplicativeVirtuali(IDSoggetto soggettoVirtuale,IDServizio idServizio, boolean ricercaPuntuale) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.porteApplicativeDriver.getPorteApplicativeVirtuali(soggettoVirtuale, idServizio, ricercaPuntuale);
	}
	
	@Override
	public void createPortaApplicativa(PortaApplicativa aPA) throws DriverConfigurazioneException {
		this.porteApplicativeDriver.createPortaApplicativa(aPA);
	}
	
	@Override
	public void updatePortaApplicativa(PortaApplicativa aPA) throws DriverConfigurazioneException {
		this.porteApplicativeDriver.updatePortaApplicativa(aPA);
	}

	@Override
	public void deletePortaApplicativa(PortaApplicativa aPA) throws DriverConfigurazioneException {
		this.porteApplicativeDriver.deletePortaApplicativa(aPA);
	}

	@Override
	public Map<IDSoggetto, PortaApplicativa> getPorteApplicativeSoggettiVirtuali(IDServizio idServizio) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.porteApplicativeDriver.getPorteApplicativeSoggettiVirtuali(idServizio);
	}
	
	public List<String> portaApplicativaRuoliList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.portaApplicativaRuoliList(idPA, ricerca);
	}
	public List<String> portaApplicativaRuoliTokenList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.portaApplicativaRuoliTokenList(idPA, ricerca);
	}
	
	public List<String> portaApplicativaScopeList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.portaApplicativaScopeList(idPA, ricerca);
	}
	
	public List<IDPortaApplicativa> porteApplicativeWithApplicativoErogatore(IDServizioApplicativo idSA) throws DriverConfigurazioneException {
		return this.porteApplicativeDriver.porteApplicativeWithApplicativoErogatore(idSA);
	}
	
	public List<TrasformazioneRegola> porteApplicativeTrasformazioniList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteApplicativeTrasformazioniList(idPA, ricerca);
	}
	
	public boolean azioneUsataInTrasformazioniPortaApplicativa(String azione) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.azioneUsataInTrasformazioniPortaApplicativa(azione);
	}
	
	public TrasformazioneRegola getPortaApplicativaTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori,
			List<TrasformazioneRegolaApplicabilitaSoggetto> soggetti,
			List<TrasformazioneRegolaApplicabilitaServizioApplicativo> applicativi,
			boolean interpretaNullList) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaApplicativaTrasformazione(idPorta, azioni, pattern, contentType, connettori,
			soggetti,
			applicativi,
			interpretaNullList);
	}
	
	public TrasformazioneRegola getPortaApplicativaTrasformazione(long idPorta, String nome) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaApplicativaTrasformazione(idPorta, nome);
	}
	
	public boolean existsPortaApplicativaTrasformazione(long idPorta, String azioni, String pattern, String contentType, String connettori) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaApplicativaTrasformazione(idPorta, azioni, pattern, contentType, connettori);
	}
	
	public boolean existsPortaApplicativaTrasformazione(long idPorta, String nome) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaApplicativaTrasformazione(idPorta, nome);
	}
	
	public List<TrasformazioneRegolaRisposta> porteApplicativeTrasformazioniRispostaList(long idPA, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteApplicativeTrasformazioniRispostaList(idPA, idTrasformazione, ricerca);
	}
	
	public TrasformazioneRegolaRisposta getPortaApplicativaTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaApplicativaTrasformazioneRisposta(idPorta, idTrasformazione, statusMin, statusMax, pattern, contentType);
	}

	public TrasformazioneRegolaRisposta getPortaApplicativaTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaApplicativaTrasformazioneRisposta(idPorta, idTrasformazione, nome);
	}
		
	public boolean existsPortaApplicativaTrasformazioneRisposta(long idPorta, long idTrasformazione, Integer statusMin, Integer statusMax, String pattern, String contentType) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaApplicativaTrasformazioneRisposta(idPorta, idTrasformazione, statusMin, statusMax, pattern, contentType);
	}
	
	public boolean existsPortaApplicativaTrasformazioneRisposta(long idPorta, long idTrasformazione, String nome) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaApplicativaTrasformazioneRisposta(idPorta, idTrasformazione, nome);
	}
	
	public List<TrasformazioneRegolaApplicabilitaServizioApplicativo> porteApplicativeTrasformazioniServiziApplicativiList(long idPA, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteApplicativeTrasformazioniServiziApplicativiList(idPA, idTrasformazione, ricerca);
	}
	
	public List<TrasformazioneRegolaApplicabilitaSoggetto> porteApplicativeTrasformazioniSoggettiList(long idPA, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteApplicativeTrasformazioniSoggettiList(idPA, idTrasformazione, ricerca);
	}
	
	public List<TrasformazioneRegolaParametro> porteApplicativeTrasformazioniRispostaHeaderList(long idPA, long idTrasformazione, long idTrasformazioneRisposta, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteApplicativeTrasformazioniRispostaHeaderList(idPA, idTrasformazione, idTrasformazioneRisposta, ricerca);
	}
	
	public boolean existsPortaApplicativaTrasformazioneRispostaHeader(long idPorta, long idTrasformazione, long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaApplicativaTrasformazioneRispostaHeader(idPorta, idTrasformazione, idTrasformazioneRisposta,  nome, tipo, checkTipo);
	}
	
	public boolean existsPortaDelegataTrasformazioneRispostaHeader(long idPorta, long idTrasformazione, long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaDelegataTrasformazioneRispostaHeader(idPorta, idTrasformazione, idTrasformazioneRisposta,  nome, tipo, checkTipo);
	}
	
	public TrasformazioneRegolaParametro getPortaApplicativaTrasformazioneRispostaHeader(long idPorta, long idTrasformazione, long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaApplicativaTrasformazioneRispostaHeader(idPorta, idTrasformazione, idTrasformazioneRisposta, nome, tipo, checkTipo);
	}
	
	public TrasformazioneRegolaParametro getPortaDelegataTrasformazioneRispostaHeader(long idPorta, long idTrasformazione, long idTrasformazioneRisposta,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaDelegataTrasformazioneRispostaHeader(idPorta, idTrasformazione, idTrasformazioneRisposta, nome, tipo, checkTipo);
	}
	
	public List<TrasformazioneRegolaParametro> porteApplicativeTrasformazioniRichiestaHeaderList(long idPA, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteApplicativeTrasformazioniRichiestaHeaderList(idPA, idTrasformazione, ricerca);
	}
	
	public boolean existsPortaApplicativaTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaApplicativaTrasformazioneRichiestaHeader(idPorta, idTrasformazione, nome, tipo, checkTipo);
	}	
	
	public TrasformazioneRegolaParametro getPortaApplicativaTrasformazioneRichiestaHeader(long idPorta, long idTrasformazione,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaApplicativaTrasformazioneRichiestaHeader(idPorta, idTrasformazione, nome, tipo, checkTipo);
	}
	
	public List<TrasformazioneRegolaParametro> porteApplicativeTrasformazioniRichiestaUrlParameterList(long idPA, long idTrasformazione, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.porteApplicativeTrasformazioniRichiestaUrlParameterList(idPA, idTrasformazione, ricerca);
	}
	
	public boolean existsPortaApplicativaTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione, String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.existsPortaApplicativaTrasformazioneRichiestaUrlParameter(idPorta, idTrasformazione, nome, tipo, checkTipo);
	}
	
	public TrasformazioneRegolaParametro getPortaApplicativaTrasformazioneRichiestaUrlParameter(long idPorta, long idTrasformazione,  String nome, String tipo, boolean checkTipo) throws DriverConfigurazioneException {
		return this.porteTrasformazioniDriver.getPortaApplicativaTrasformazioneRichiestaUrlParameter(idPorta, idTrasformazione, nome, tipo, checkTipo);
	}
	
	public List<ResponseCachingConfigurazioneRegola> portaApplicativaResponseCachingConfigurazioneRegolaList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteDriver.portaApplicativaResponseCachingConfigurazioneRegolaList(idPA, ricerca);
	}
	
	public boolean existsPortaApplicativaResponseCachingConfigurazioneRegola(long idPA, Integer statusMin, Integer statusMax, boolean fault) throws DriverConfigurazioneException {
		return this.porteDriver.existsPortaApplicativaResponseCachingConfigurazioneRegola(idPA, statusMin, statusMax, fault);
	}
	
	/**
	 * Ritorna la lista di porte applicative con settati i campi id, nome,
	 * descrizione e se il security e' abilitato allora crea un oggetto
	 * MessageSecurity vuoto altrimenti null.
	 */
	public List<PortaApplicativa> porteAppList(long idSoggetto, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteAppList(idSoggetto, ricerca);
	}
	/**
	 * Ritorna la lista di tutte le Porte Applicative
	 * @param ricerca
	 * @return Una lista di Porte Applicative
	 * @throws DriverConfigurazioneException
	 */
	public List<PortaApplicativa> porteAppList(String superuser, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteAppList(superuser, ricerca);
	}

	/**
	 * Ritorna la lista di proprieta di una Porta Applicativa
	 */
	public List<Proprieta> porteAppPropList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteAppPropList(idPortaApplicativa, ricerca);
	}
	
	/**
	 * Ritorna la lista di nomi delle proprieta registrate
	 */
	public List<String> nomiProprietaPA(String filterSoggettoTipo, String filterSoggettoNome, List<String> tipoServiziProtocollo) throws DriverConfigurazioneException {
		return this.porteApplicativeDriver.nomiProprietaPA(filterSoggettoTipo, filterSoggettoNome, tipoServiziProtocollo);
	}
	
	/**
	 * Ritorna la lista di proprieta per l'autenticazione custom di una Porta Applicativa
	 */
	public List<Proprieta> porteApplicativeAutenticazioneCustomPropList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteApplicativeAutenticazioneCustomPropList(idPortaApplicativa, ricerca);
	}
	
	/**
	 * Ritorna la lista di proprieta per l'autorizzazione custom di una Porta Applicativa
	 */
	public List<Proprieta> porteApplicativeAutorizzazioneCustomPropList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteApplicativeAutorizzazioneCustomPropList(idPortaApplicativa, ricerca);
	}
	
	public List<String> porteApplicativeRateLimitingValoriUnivoci(String pName) throws DriverConfigurazioneException {
		return this.porteApplicativeDriver.porteApplicativeRateLimitingValoriUnivoci(pName);
	}
	
	/**
	 * Ritorna la lista di proprieta per l'autorizzazione contenuti custom di una Porta Applicativa
	 */
	public List<Proprieta> porteApplicativeAutorizzazioneContenutoCustomPropList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteApplicativeAutorizzazioneContenutoCustomPropList(idPortaApplicativa, ricerca);
	}
	
	/**
	 * Ritorna la lista di Azioni di una  Porta Applicativa
	 */
	public List<PortaApplicativaAzione> porteAppAzioneList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteAppAzioneList(idPortaApplicativa, ricerca);
	}

	public List<ServizioApplicativo> porteAppServizioApplicativoList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteAppServizioApplicativoList(idPortaApplicativa, ricerca);
	}
	
	public List<PortaApplicativaAutorizzazioneSoggetto> porteAppSoggettoList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteAppSoggettoList(idPortaApplicativa, ricerca);
	}
	
	public List<PortaApplicativaAutorizzazioneServizioApplicativo> porteAppServiziApplicativiAutorizzatiList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteAppServiziApplicativiAutorizzatiList(idPortaApplicativa, ricerca);
	}
	
	public List<PortaApplicativaAutorizzazioneServizioApplicativo> porteAppServiziApplicativiAutorizzatiTokenList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteAppServiziApplicativiAutorizzatiTokenList(idPortaApplicativa, ricerca);
	}
	
	public List<MessageSecurityFlowParameter> porteAppMessageSecurityRequestList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteAppMessageSecurityRequestList(idPortaApplicativa, ricerca);
	}

	public List<MessageSecurityFlowParameter> porteAppMessageSecurityResponseList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteAppMessageSecurityResponseList(idPortaApplicativa, ricerca);
	}
	
	public List<PortaApplicativa> porteAppWithServizio(long idSoggettoErogatore, String tipoServizio,String nomeServizio, Integer versioneServizio) throws DriverConfigurazioneException {
		return this.porteApplicativeDriver.porteAppWithServizio(idSoggettoErogatore, tipoServizio, nomeServizio, versioneServizio);
	}

	public List<PortaApplicativa> porteAppWithIdServizio(long idServizio) throws DriverConfigurazioneException {
		return this.porteApplicativeDriver.porteAppWithIdServizio(idServizio);
	}
	
	public List<CorrelazioneApplicativaElemento> porteApplicativeCorrelazioneApplicativaList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteApplicativeCorrelazioneApplicativaList(idPortaApplicativa, ricerca);
	}

	public List<CorrelazioneApplicativaRispostaElemento> porteApplicativeCorrelazioneApplicativaRispostaList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteApplicativeCorrelazioneApplicativaRispostaList(idPortaApplicativa, ricerca);
	}
	
	/**
	 * Verifica l'esistenza di una porta applicativa.
	 * se l'azione e' specificata ma non vi sono porte applicative che mathcano i criteri allora
	 * effettua la ricerca senza tener conto dell'azione. Per una ricerca piu precisa utilizzare 
	 * existsPortaApplicativa(IDPortaApplicativa idPA,boolean ricercaPuntuale) con il parametro ricercaPuntuale a true
	 * @param idPA id della porta applicativa da verificare
	 * @return true se la porta applicativa esiste, false altrimenti
	 * @throws DriverConfigurazioneException 
	 */    
	@Override
	public boolean existsPortaApplicativa(IDPortaApplicativa idPA) throws DriverConfigurazioneException {
		return this.porteApplicativeDriver.existsPortaApplicativa(idPA);
	}

	public List<PortaApplicativa> getPorteApplicativeWithServizio(Long idServizio, String tiposervizio, String nomeservizio, Integer versioneServizio,
			Long idSoggetto, String tiposoggetto, String nomesoggetto) throws DriverConfigurazioneException {
		return this.porteApplicativeDriver.getPorteApplicativeWithServizio(idServizio, tiposervizio, nomeservizio, versioneServizio,
				idSoggetto, tiposoggetto, nomesoggetto);
	}

	public PortaApplicativa getPortaApplicativaWithSoggettoAndServizio(String nome, Long idSoggetto, Long idServizio, 
			String tipoServizio, String nomeServizio, Integer versioneServizio) throws DriverConfigurazioneException {
		return this.porteApplicativeDriver.getPortaApplicativaWithSoggettoAndServizio(nome, idSoggetto, idServizio, 
				tipoServizio, nomeServizio, versioneServizio);
	}

	// NOTA: Metodo non sicuro!!! Possono esistere piu' azioni di port type diversi o accordi diversi !!!!!
	public List<IDPortaApplicativa> getPortaApplicativaAzione(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
		return this.porteApplicativeDriver.getPortaApplicativaAzione(nome);
	}

	// NOTA: Metodo non sicuro!!! Possono esistere piu' azioni di port type diversi o accordi diversi !!!!!
	public boolean existsPortaApplicativaAzione(String nome) throws DriverConfigurazioneException {
		return this.porteApplicativeDriver.existsPortaApplicativaAzione(nome);
	}
	
	public List<PortaApplicativa> serviziPorteAppList(String tipoServizio,String nomeServizio, Integer versioneServizio,
			long idServizio, long idSoggettoErogatore, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.serviziPorteAppList(tipoServizio, nomeServizio, versioneServizio,
				idServizio, idSoggettoErogatore, ricerca);
	}
	
	public List<PortaApplicativa> getPorteApplicativaByIdProprietario(long idProprietario) throws DriverConfigurazioneException{
		return this.porteApplicativeDriver.getPorteApplicativaByIdProprietario(idProprietario);
	}

	/**
	 * Recupera tutte le porte applicative relative al servizio idServizio, erogato dal soggetto erogatore del servizio.
	 * @param idSE
	 * @return List<PortaApplicativa>
	 * @throws DriverConfigurazioneException
	 */
	public List<PortaApplicativa> getPorteApplicative(IDServizio idSE) throws DriverConfigurazioneException{
		return this.porteApplicativeDriver.getPorteApplicative(idSE);
	}

	public List<PortaApplicativa> getPorteApplicativeBySoggetto(long idSoggetto) throws DriverConfigurazioneException {
		return this.porteApplicativeDriver.getPorteApplicativeBySoggetto(idSoggetto);
	}
	
	public List<PortaApplicativa> getPorteApplicativeBySoggettoVirtuale(IDSoggetto soggettoVirtuale) throws DriverConfigurazioneException {
		return this.porteApplicativeDriver.getPorteApplicativeBySoggettoVirtuale(soggettoVirtuale);
	}
	
	/**
	 * Restituisce la lista degli identificativi delle porte applicative
	 * 
	 * @param filtroRicerca
	 * @return lista degli identificativi delle porte applicative
	 * @throws DriverConfigurazioneException
	 * @throws DriverConfigurazioneNotFound
	 */
	@Override
	public List<IDPortaApplicativa> getAllIdPorteApplicative(FiltroRicercaPorteApplicative filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.porteApplicativeDriver.getAllIdPorteApplicative(filtroRicerca);
	}

	@Override
	public List<IDConnettore> getConnettoriConsegnaNotifichePrioritarie(String queueName) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.porteApplicativeDriver.getConnettoriConsegnaNotifichePrioritarie(queueName);
	}
	
	public int resetConnettoriConsegnaNotifichePrioritarie(String queueName) throws DriverConfigurazioneException {
		return this.porteApplicativeDriver.resetConnettoriConsegnaNotifichePrioritarie(queueName);
	}
	
	public List<MtomProcessorFlowParameter> porteApplicativeMTOMRequestList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteApplicativeMTOMRequestList(idPortaApplicativa, ricerca);
	}

	public List<MtomProcessorFlowParameter> porteApplicativeMTOMResponseList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteApplicativeMTOMResponseList(idPortaApplicativa, ricerca);
	}
	
	public List<PortaApplicativa> getPorteApplicativeByPolicyGestioneToken(String nome) throws DriverConfigurazioneException{
		return this.porteApplicativeDriver.getPorteApplicativeByPolicyGestioneToken(nome);
	}
	
	/**
	 * Ritorna la lista di proprieta per la configurazione custom dei connettori multipli di una Porta Applicativa
	 */
	public List<Proprieta> porteApplicativeConnettoriMultipliConfigPropList(long idPortaApplicativa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteApplicativeConnettoriMultipliConfigPropList(idPortaApplicativa, ricerca);
	}
	
	/**
	 * Ritorna la lista di proprieta di un connettore multiplo di una Porta Applicativa 
	 */
	public List<Proprieta> porteApplicativeConnettoriMultipliPropList(long idPaSa, ISearch ricerca) throws DriverConfigurazioneException {
		return this.porteApplicativeSearchDriver.porteApplicativeConnettoriMultipliPropList(idPaSa, ricerca);
	}

	public MappingErogazionePortaApplicativa getMappingErogazione(IDServizio idServizio, IDPortaApplicativa idPortaApplicativa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.porteApplicativeDriver.getMappingErogazione(idServizio, idPortaApplicativa);
	}
	
	public static List<String> normalizeConnettoriMultpliById(List<String> sa, PortaApplicativa pa){
		return DriverConfigurazioneDB_porteApplicativeDriver.normalizeConnettoriMultpliById(sa, pa);
	}
	
	public ProprietaOggetto getProprietaOggetto(IDPortaApplicativa idPA) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.porteApplicativeDriver.getProprietaOggetto(idPA);
	}
	
	public void updateProprietaOggetto(IDPortaApplicativa idPA, String user) throws DriverConfigurazioneException {
		this.porteApplicativeDriver.updateProprietaOggetto(idPA, user);
	}
	
	
	
	
	
	// *** Servizi Applicativi ***

    @Override
	public ServizioApplicativo getServizioApplicativo(IDServizioApplicativo idServizioApplicativo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativo(idServizioApplicativo);
    }
    @Override
    public ServizioApplicativo getServizioApplicativoByCredenzialiBasic(String aUser,String aPassword, CryptConfig config) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiBasic(aUser, aPassword, config);
    }
    public ServizioApplicativo getServizioApplicativoByCredenzialiBasic(String aUser,String aPassword, CryptConfig config,
    		List<String> tipiSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiBasic(aUser, aPassword, config,
        		tipiSoggetto);
    }
    @Override
    public ServizioApplicativo getServizioApplicativoByCredenzialiApiKey(String aUser,String aPassword, boolean appId, CryptConfig config) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiApiKey(aUser, aPassword, appId, config);
    }
    public ServizioApplicativo getServizioApplicativoByCredenzialiApiKey(String aUser,String aPassword, boolean appId, CryptConfig config,
    		List<String> tipiSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiApiKey(aUser, aPassword, appId, config,
        		tipiSoggetto);
    }
    @Override
    public ServizioApplicativo getServizioApplicativoByCredenzialiToken(String tokenPolicy, String tokenClientId, boolean tokenWithHttpsEnabled) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiToken(tokenPolicy, tokenClientId, tokenWithHttpsEnabled);
    }
    public ServizioApplicativo getServizioApplicativoByCredenzialiToken(String tokenPolicy, String tokenClientId, boolean tokenWithHttpsEnabled,
    		List<String> tipiSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiToken(tokenPolicy, tokenClientId, tokenWithHttpsEnabled,
        		tipiSoggetto);
    }
    @Override
    public ServizioApplicativo getServizioApplicativoByCredenzialiSsl(String aSubject, String aIssuer) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiSsl(aSubject, aIssuer);
    }
    public ServizioApplicativo getServizioApplicativoByCredenzialiSsl(String aSubject, String aIssuer,
    		List<String> tipiSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiSsl(aSubject, aIssuer,
        		tipiSoggetto);
    }
    public ServizioApplicativo getServizioApplicativoByCredenzialiSsl(String aSubject, String aIssuer,
    		List<String> tipiSoggetto,
    		boolean includiApplicativiNonModI,boolean includiApplicativiModIEsterni,boolean includiApplicativiModIInterni) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiSsl(aSubject, aIssuer,
        		tipiSoggetto,
        		includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
    }
    @Override
    public ServizioApplicativo getServizioApplicativoByCredenzialiSsl(CertificateInfo certificate, boolean strictVerifier) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiSsl(certificate, strictVerifier);
    }
    public ServizioApplicativo getServizioApplicativoByCredenzialiSsl(CertificateInfo certificate, boolean strictVerifier,
    		List<String> tipiSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiSsl(certificate, strictVerifier,
        		tipiSoggetto);
    }
    public ServizioApplicativo getServizioApplicativoByCredenzialiSsl(CertificateInfo certificate, boolean strictVerifier,
    		List<String> tipiSoggetto,
    		boolean includiApplicativiNonModI,boolean includiApplicativiModIEsterni,boolean includiApplicativiModIInterni) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiSsl(certificate, strictVerifier,
        		tipiSoggetto,
        		includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
    }
    @Override
    public ServizioApplicativo getServizioApplicativoByCredenzialiPrincipal(String principal) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiPrincipal(principal);
    }
    public ServizioApplicativo getServizioApplicativoByCredenzialiPrincipal(String principal,
    		List<String> tipiSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
    	return this.serviziApplicativiDriver.getServizioApplicativoByCredenzialiPrincipal(principal,
        		tipiSoggetto);
    }
    public ServizioApplicativo getServizioApplicativo(long idServizioApplicativo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
    	return this.serviziApplicativiDriver.getServizioApplicativo(idServizioApplicativo);
    }
    
	/**
	 * 
	 * @param aSA
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void createServizioApplicativo(ServizioApplicativo aSA) throws DriverConfigurazioneException {
		this.serviziApplicativiDriver.createServizioApplicativo(aSA);
	}

	/**
	 * 
	 * @param aSA
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void updateServizioApplicativo(ServizioApplicativo aSA) throws DriverConfigurazioneException {
		this.serviziApplicativiDriver.updateServizioApplicativo(aSA);
	}

	/**
	 * 
	 * @param aSA
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void deleteServizioApplicativo(ServizioApplicativo aSA) throws DriverConfigurazioneException {
		this.serviziApplicativiDriver.deleteServizioApplicativo(aSA);
	}
	
	/**
	 * Recupera tutti i servizi applicativi in base ai parametri di ricerca passati
	 */
	public List<ServizioApplicativo> servizioApplicativoList(ISearch ricerca) throws DriverConfigurazioneException {
		return this.serviziApplicativiSearchDriver.servizioApplicativoList(ricerca);
	}

	public List<ServizioApplicativo> servizioApplicativoList(IDSoggetto idSO,ISearch ricerca) throws DriverConfigurazioneException {
		return this.serviziApplicativiSearchDriver.servizioApplicativoList(idSO, ricerca);
	}

	public List<ServizioApplicativo> servizioApplicativoWithCredenzialiBasicList(String utente, String password, boolean checkPassword) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.servizioApplicativoWithCredenzialiBasicList(utente, password, checkPassword);
	}
	
	public List<ServizioApplicativo> servizioApplicativoWithCredenzialiApiKeyList(String utente, boolean appId) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.servizioApplicativoWithCredenzialiApiKeyList(utente, appId);
	}

	public List<ServizioApplicativo> servizioApplicativoWithCredenzialiSslList(String subject, String issuer,
			List<String> tipiSoggetto, 
			boolean includiApplicativiNonModI, boolean includiApplicativiModIEsterni, boolean includiApplicativiModIInterni) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.servizioApplicativoWithCredenzialiSslList(subject, issuer,
				tipiSoggetto,
				includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
	}
	
	public List<ServizioApplicativo> servizioApplicativoWithCredenzialiSslList(CertificateInfo certificate, boolean strictVerifier,
			List<String> tipiSoggetto, 
			boolean includiApplicativiNonModI, boolean includiApplicativiModIEsterni, boolean includiApplicativiModIInterni) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.servizioApplicativoWithCredenzialiSslList(certificate, strictVerifier,
				tipiSoggetto,
				includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
	}
	
	public List<ServizioApplicativo> servizioApplicativoWithCredenzialiPrincipalList(String principal) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.servizioApplicativoWithCredenzialiPrincipalList(principal);
	}
	
	public List<ServizioApplicativo> servizioApplicativoWithCredenzialiTokenList(String tokenPolicy, String tokenClientId, boolean tokenWithHttpsEnabled) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.servizioApplicativoWithCredenzialiTokenList(tokenPolicy, tokenClientId, tokenWithHttpsEnabled);
	}
	
	public String[] soggettiServizioApplicativoList(long idSoggetto) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.soggettiServizioApplicativoList(idSoggetto);
	}

	public List<IDServizioApplicativoDB> soggettiServizioApplicativoList(IDSoggetto idSoggetto,String superuser,CredenzialeTipo credenziale, Boolean appId, String tipoSA, 
			boolean bothSslAndToken, String tokenPolicy) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.soggettiServizioApplicativoList(idSoggetto, superuser, credenziale, appId, tipoSA, 
				bothSslAndToken, tokenPolicy);
	}
	public List<IDServizioApplicativoDB> soggettiServizioApplicativoList(IDSoggetto idSoggetto,String superuser,CredenzialeTipo credenziale, Boolean appId, String tipoSA, 
			boolean bothSslAndToken, String tokenPolicy, boolean tokenPolicyOR) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.soggettiServizioApplicativoList(idSoggetto, superuser, credenziale, appId, tipoSA, 
				bothSslAndToken, tokenPolicy, tokenPolicyOR);
	}
	
	public List<ServizioApplicativo> soggettiServizioApplicativoList(String superuser, ISearch ricerca) throws DriverConfigurazioneException {
		return this.serviziApplicativiSearchDriver.soggettiServizioApplicativoList(superuser, ricerca);
	}

	public List<ServizioApplicativo> soggettiServizioApplicativoList(Long idSoggetto, ISearch ricerca) throws DriverConfigurazioneException {
		return this.serviziApplicativiSearchDriver.soggettiServizioApplicativoList(idSoggetto, ricerca);
	}
	
	public List<String> servizioApplicativoRuoliList(long idSA, ISearch ricerca) throws DriverConfigurazioneException {
		return this.serviziApplicativiSearchDriver.servizioApplicativoRuoliList(idSA, ricerca);
	}
	
	public List<Proprieta> serviziApplicativiProprietaList(int idSA, ISearch ricerca) throws DriverConfigurazioneException {
		return this.serviziApplicativiSearchDriver.serviziApplicativiProprietaList(idSA, ricerca);
	}
	
	/**
	 * Ritorna la lista di nomi delle proprieta registrate
	 */
	public List<String> nomiProprietaSA(String filterSoggettoTipo, String filterSoggettoNome, List<String> tipoSoggettiProtocollo) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.nomiProprietaSA(filterSoggettoTipo, filterSoggettoNome, tipoSoggettiProtocollo);
	}
	
	public List<IDServizioApplicativoDB> getIdServiziApplicativiWithIdErogatore(Long idErogatore, String tipo, 
			boolean checkIM, boolean checkConnettoreAbilitato) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.getIdServiziApplicativiWithIdErogatore(idErogatore, tipo, 
				checkIM, checkConnettoreAbilitato);
	}

	/**
	 * Verifica l'esistenza di un servizio applicativo.
	 *
	 * @param idServizioApplicativo id del servizio applicativo
	 * @return true se il servizio applicativo esiste, false altrimenti
	 * @throws DriverConfigurazioneException
	 */    
	@Override
	public boolean existsServizioApplicativo(IDServizioApplicativo idServizioApplicativo) throws DriverConfigurazioneException{
		return this.serviziApplicativiDriver.existsServizioApplicativo(idServizioApplicativo);
	}

	public long getIdServizioApplicativo(IDSoggetto idSoggetto, String nomeServizioApplicativo) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.getIdServizioApplicativo(idSoggetto, nomeServizioApplicativo);
	}

	public boolean existsServizioApplicativoSoggetto(Long idSoggetto) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.existsServizioApplicativoSoggetto(idSoggetto);
	}
	
	public boolean isServizioApplicativoInUsoComeErogatore(ServizioApplicativo sa, Map<ErrorsHandlerCostant, String> whereIsInUso) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.isServizioApplicativoInUsoComeErogatore(sa, whereIsInUso);
	}
	
	// all
	public int countTipologieServiziApplicativi(ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieServiziApplicativi(filters);
	}
	public int countTipologieServiziApplicativi(IDSoggetto proprietario,ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieServiziApplicativi(proprietario, filters);
	}

	// fruizione

	public int countTipologieFruizioneServiziApplicativi(ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieFruizioneServiziApplicativi(filters);
	}
	public int countTipologieFruizioneServiziApplicativi(ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieFruizioneServiziApplicativi(filters, checkAssociazionePorta);
	}
	public int countTipologieFruizioneServiziApplicativi(ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieFruizioneServiziApplicativi(filters, checkAssociazionePorta, isBound);
	}

	public int countTipologieFruizioneServiziApplicativi(RicercaTipologiaFruizione fruizione, ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieFruizioneServiziApplicativi(fruizione, filters);
	}
	public int countTipologieFruizioneServiziApplicativi(RicercaTipologiaFruizione fruizione, ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieFruizioneServiziApplicativi(fruizione, filters, checkAssociazionePorta);
	}
	public int countTipologieFruizioneServiziApplicativi(RicercaTipologiaFruizione fruizione, ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieFruizioneServiziApplicativi(fruizione, filters, checkAssociazionePorta, isBound);
	}

	public int countTipologieFruizioneServiziApplicativi(IDSoggetto proprietario, ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieFruizioneServiziApplicativi(proprietario, filters);
	}
	public int countTipologieFruizioneServiziApplicativi(IDSoggetto proprietario, ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieFruizioneServiziApplicativi(proprietario, filters, checkAssociazionePorta);
	}
	public int countTipologieFruizioneServiziApplicativi(IDSoggetto proprietario, ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieFruizioneServiziApplicativi(proprietario, filters, checkAssociazionePorta, isBound);
	}

	public int countTipologieFruizioneServiziApplicativi(IDSoggetto proprietario, RicercaTipologiaFruizione fruizione, ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieFruizioneServiziApplicativi(proprietario, fruizione, filters);
	}
	public int countTipologieFruizioneServiziApplicativi(IDSoggetto proprietario, RicercaTipologiaFruizione fruizione, ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieFruizioneServiziApplicativi(proprietario, fruizione, filters, checkAssociazionePorta);
	}
	public int countTipologieFruizioneServiziApplicativi(IDSoggetto proprietario, RicercaTipologiaFruizione fruizione, ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieFruizioneServiziApplicativi(proprietario, fruizione, filters, checkAssociazionePorta, isBound);
	}

	// erogazione

	public int countTipologieErogazioneServiziApplicativi(ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieErogazioneServiziApplicativi(filters);
	}
	public int countTipologieErogazioneServiziApplicativi(ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieErogazioneServiziApplicativi(filters, checkAssociazionePorta);
	}
	public int countTipologieErogazioneServiziApplicativi(ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieErogazioneServiziApplicativi(filters, checkAssociazionePorta, isBound);
	}
	
	public int countTipologieErogazioneServiziApplicativi(RicercaTipologiaErogazione erogazione, ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieErogazioneServiziApplicativi(erogazione, filters);
	}
	public int countTipologieErogazioneServiziApplicativi(RicercaTipologiaErogazione erogazione, ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieErogazioneServiziApplicativi(erogazione, filters, checkAssociazionePorta);
	}
	public int countTipologieErogazioneServiziApplicativi(RicercaTipologiaErogazione erogazione, ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieErogazioneServiziApplicativi(erogazione, filters, checkAssociazionePorta, isBound);
	}

	public int countTipologieErogazioneServiziApplicativi(IDSoggetto proprietario, RicercaTipologiaErogazione erogazione, ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieErogazioneServiziApplicativi(proprietario, erogazione, filters);
	}
	public int countTipologieErogazioneServiziApplicativi(IDSoggetto proprietario, RicercaTipologiaErogazione erogazione, ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieErogazioneServiziApplicativi(proprietario, erogazione, filters, checkAssociazionePorta);
	}
	public int countTipologieErogazioneServiziApplicativi(IDSoggetto proprietario, RicercaTipologiaErogazione erogazione, ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieErogazioneServiziApplicativi(proprietario, erogazione, filters, checkAssociazionePorta, isBound);
	}

	public int countTipologieErogazioneServiziApplicativi(IDSoggetto proprietario, ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieErogazioneServiziApplicativi(proprietario, filters);
	}
	public int countTipologieErogazioneServiziApplicativi(IDSoggetto proprietario, ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieErogazioneServiziApplicativi(proprietario, filters, checkAssociazionePorta);
	}
	public int countTipologieErogazioneServiziApplicativi(IDSoggetto proprietario, ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.countTipologieErogazioneServiziApplicativi(proprietario, filters, checkAssociazionePorta, isBound);
	}

	// all
	public List<TipologiaServizioApplicativo> getTipologieServiziApplicativi(ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieServiziApplicativi(filters);
	}
	public List<TipologiaServizioApplicativo> getTipologieServiziApplicativi(IDSoggetto proprietario,ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieServiziApplicativi(proprietario, filters);
	}

	// fruizione

	public List<TipologiaServizioApplicativo> getTipologieFruizioneServiziApplicativi(ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieFruizioneServiziApplicativi(filters);
	}
	public List<TipologiaServizioApplicativo> getTipologieFruizioneServiziApplicativi(ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieFruizioneServiziApplicativi(filters, checkAssociazionePorta);
	}
	public List<TipologiaServizioApplicativo> getTipologieFruizioneServiziApplicativi(ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieFruizioneServiziApplicativi(filters, checkAssociazionePorta, isBound);
	}

	public List<TipologiaServizioApplicativo> getTipologieFruizioneServiziApplicativi(RicercaTipologiaFruizione fruizione, ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieFruizioneServiziApplicativi(fruizione, filters);
	}
	public List<TipologiaServizioApplicativo> getTipologieFruizioneServiziApplicativi(RicercaTipologiaFruizione fruizione, ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieFruizioneServiziApplicativi(fruizione, filters, checkAssociazionePorta);
	}
	public List<TipologiaServizioApplicativo> getTipologieFruizioneServiziApplicativi(RicercaTipologiaFruizione fruizione, ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieFruizioneServiziApplicativi(fruizione, filters, checkAssociazionePorta, isBound);
	}

	public List<TipologiaServizioApplicativo> getTipologieFruizioneServiziApplicativi(IDSoggetto proprietario, ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieFruizioneServiziApplicativi(proprietario, filters);
	}
	public List<TipologiaServizioApplicativo> getTipologieFruizioneServiziApplicativi(IDSoggetto proprietario, ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieFruizioneServiziApplicativi(proprietario, filters, checkAssociazionePorta);
	}
	public List<TipologiaServizioApplicativo> getTipologieFruizioneServiziApplicativi(IDSoggetto proprietario, ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieFruizioneServiziApplicativi(proprietario, filters, checkAssociazionePorta, isBound);
	}

	public List<TipologiaServizioApplicativo> getTipologieFruizioneServiziApplicativi(IDSoggetto proprietario, RicercaTipologiaFruizione fruizione, ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieFruizioneServiziApplicativi(proprietario, fruizione, filters);
	}
	public List<TipologiaServizioApplicativo> getTipologieFruizioneServiziApplicativi(IDSoggetto proprietario, RicercaTipologiaFruizione fruizione, ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieFruizioneServiziApplicativi(proprietario, fruizione, filters, checkAssociazionePorta);
	}
	public List<TipologiaServizioApplicativo> getTipologieFruizioneServiziApplicativi(IDSoggetto proprietario, RicercaTipologiaFruizione fruizione, ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieFruizioneServiziApplicativi(proprietario, fruizione, filters, checkAssociazionePorta, isBound);
	}

	// erogazione

	public List<TipologiaServizioApplicativo> getTipologieErogazioneServiziApplicativi(ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieErogazioneServiziApplicativi(filters);
	}
	public List<TipologiaServizioApplicativo> getTipologieErogazioneServiziApplicativi(ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieErogazioneServiziApplicativi(filters, checkAssociazionePorta);
	}
	public List<TipologiaServizioApplicativo> getTipologieErogazioneServiziApplicativi(ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieErogazioneServiziApplicativi(filters, checkAssociazionePorta, isBound);
	}

	public List<TipologiaServizioApplicativo> getTipologieErogazioneServiziApplicativi(RicercaTipologiaErogazione erogazione, ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieErogazioneServiziApplicativi(erogazione, filters);
	}
	public List<TipologiaServizioApplicativo> getTipologieErogazioneServiziApplicativi(RicercaTipologiaErogazione erogazione, ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieErogazioneServiziApplicativi(erogazione, filters, checkAssociazionePorta);
	}
	public List<TipologiaServizioApplicativo> getTipologieErogazioneServiziApplicativi(RicercaTipologiaErogazione erogazione, ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieErogazioneServiziApplicativi(erogazione, filters, checkAssociazionePorta, isBound);
	}

	public List<TipologiaServizioApplicativo> getTipologieErogazioneServiziApplicativi(IDSoggetto proprietario, RicercaTipologiaErogazione erogazione, ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieErogazioneServiziApplicativi(proprietario, erogazione, filters);
	}
	public List<TipologiaServizioApplicativo> getTipologieErogazioneServiziApplicativi(IDSoggetto proprietario, RicercaTipologiaErogazione erogazione, ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieErogazioneServiziApplicativi(proprietario, erogazione, filters, checkAssociazionePorta);
	}
	public List<TipologiaServizioApplicativo> getTipologieErogazioneServiziApplicativi(IDSoggetto proprietario, RicercaTipologiaErogazione erogazione, ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieErogazioneServiziApplicativi(proprietario, erogazione, filters, checkAssociazionePorta, isBound);
	}

	public List<TipologiaServizioApplicativo> getTipologieErogazioneServiziApplicativi(IDSoggetto proprietario, ISearch filters) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieErogazioneServiziApplicativi(proprietario, filters);
	}
	public List<TipologiaServizioApplicativo> getTipologieErogazioneServiziApplicativi(IDSoggetto proprietario, ISearch filters,boolean checkAssociazionePorta) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieErogazioneServiziApplicativi(proprietario, filters, checkAssociazionePorta);
	}
	public List<TipologiaServizioApplicativo> getTipologieErogazioneServiziApplicativi(IDSoggetto proprietario, ISearch filters,boolean checkAssociazionePorta, Boolean isBound) throws DriverConfigurazioneException
	{
		return this.serviziApplicativiSearchDriver.getTipologieErogazioneServiziApplicativi(proprietario, filters, checkAssociazionePorta, isBound);
	}

	/**
	 * Recupera i servizi applicativi che hanno come tipologia di erogazione una tra quelle passate come parametro
	 * @param filters
	 * @param proprietario
	 * @return List<IDServizioApplicativo>
	 * @throws DriverConfigurazioneException
	 */
	public List<IDServizioApplicativo> serviziApplicativiList(ISearch filters, IDSoggetto proprietario, TipologiaErogazione... erogazione) throws DriverConfigurazioneException {
		return this.serviziApplicativiSearchDriver.serviziApplicativiList(filters, proprietario, erogazione);
	}
	
	public List<ServizioApplicativo> getServiziApplicativiBySoggetto(long idSoggetto) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.getServiziApplicativiBySoggetto(idSoggetto);
	}
	
	/**
	 * Restituisce la lista degli identificativi dei servizi applicativi
	 * 
	 * @param filtroRicerca
	 * @return lista degli identificativi dei servizi applicativi
	 * @throws DriverConfigurazioneException
	 * @throws DriverConfigurazioneNotFound
	 */
	@Override
	public List<IDServizioApplicativo> getAllIdServiziApplicativi(FiltroRicercaServiziApplicativi filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.serviziApplicativiDriver.getAllIdServiziApplicativi(filtroRicerca);
	}
	
	public long getIdServizioApplicativoByConnettore(long idConnettore) throws DriverConfigurazioneException {
		return this.serviziApplicativiDriver.getIdServizioApplicativoByConnettore(idConnettore);
	}
	
	public IDServizio getLabelNomeServizioApplicativo(String nomeServizioApplicativo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.serviziApplicativiDriver.getLabelNomeServizioApplicativo(nomeServizioApplicativo);
	}
	
	public ProprietaOggetto getProprietaOggetto(IDServizioApplicativo idServizioApplicativo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.serviziApplicativiDriver.getProprietaOggetto(idServizioApplicativo);
	}
	
	public void updateProprietaOggetto(IDServizioApplicativo idServizioApplicativo, String user) throws DriverConfigurazioneException {
		this.serviziApplicativiDriver.updateProprietaOggetto(idServizioApplicativo, user);
	}
	
	
	

	// *** Protocol Properties ***

	public boolean existsProtocolProperty(ProprietariProtocolProperty proprietarioProtocolProperty, long idProprietario, String nome) throws DriverConfigurazioneException {
		return this.protocolPropertiesDriver.existsProtocolProperty(proprietarioProtocolProperty, idProprietario, nome);
	}

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

	public ProtocolProperty getProtocolProperty(long idProtocolProperty) throws DriverConfigurazioneException {
		return this.protocolPropertiesDriver.getProtocolProperty(idProtocolProperty);
	}
	
	

	
	// *** Routing Table ***
	
	/**
	 * Restituisce la RoutingTable definita nella Porta di Dominio
	 * 
	 * @return RoutingTable
	 * 
	 */
	@Override
	public RoutingTable getRoutingTable() throws DriverConfigurazioneException {
		return this.routingTableDriver.getRoutingTable();
	}

	@Override
	public void createRoutingTable(RoutingTable routingTable) throws DriverConfigurazioneException {
		this.routingTableDriver.createRoutingTable(routingTable);
	}

	@Override
	public void updateRoutingTable(RoutingTable routingTable) throws DriverConfigurazioneException {
		this.routingTableDriver.updateRoutingTable(routingTable);
	}

	@Override
	public void deleteRoutingTable(RoutingTable routingTable) throws DriverConfigurazioneException {
		this.routingTableDriver.deleteRoutingTable(routingTable);
	}

	public List<RoutingTableDestinazione> routingList(ISearch ricerca) throws DriverConfigurazioneException {
		return this.routingTableDriver.routingList(ricerca); 
	}

	
	// *** Configurazione (Accesso Registro) ***
	
	/**
	 * Restituisce l'accesso al registro definito nella Porta di Dominio
	 * 
	 * @return AccessoRegistro
	 * 
	 */
	@Override
	public AccessoRegistro getAccessoRegistro() throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
		return this.configDriver.getAccessoRegistro();
	}

	/**
	 * Crea le informazioni per l'accesso ai registri
	 * 
	 * @param registro
	 * @throws DriverConfigurazioneException
	 */

	@Override
	public void createAccessoRegistro(AccessoRegistro registro) throws DriverConfigurazioneException {
		this.configDriver.createAccessoRegistro(registro);
	}

	/**
	 * Aggiorna le informazioni per l'accesso ai registri
	 * 
	 * @param registro
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void updateAccessoRegistro(AccessoRegistro registro) throws DriverConfigurazioneException {
		this.configDriver.updateAccessoRegistro(registro);
	}

	/**
	 * Elimina le informazioni per l'accesso ai registri
	 * 
	 * @param registro
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void deleteAccessoRegistro(AccessoRegistro registro) throws DriverConfigurazioneException {
		this.configDriver.deleteAccessoRegistro(registro);
	}
	
	public void createAccessoRegistro(AccessoRegistroRegistro registro) throws DriverConfigurazioneException {
		this.configDriver.createAccessoRegistro(registro);
	}

	public void updateAccessoRegistro(AccessoRegistroRegistro registro) throws DriverConfigurazioneException {
		this.configDriver.updateAccessoRegistro(registro);
	}

	public void deleteAccessoRegistro(AccessoRegistroRegistro registro) throws DriverConfigurazioneException {
		this.configDriver.deleteAccessoRegistro(registro);
	}

	public List<AccessoRegistroRegistro> registriList(ISearch ricerca) throws DriverConfigurazioneException {
		return this.configSearchDriver.registriList(ricerca);
	}
	
	
	// *** Configurazione (Accesso Configurazione) ***
	
	@Override
	public AccessoConfigurazione getAccessoConfigurazione() throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
		return this.configDriver.getAccessoConfigurazione();
	}

	public void createAccessoConfigurazione(AccessoConfigurazione accessoConfigurazione) throws DriverConfigurazioneException {
		this.configDriver.createAccessoConfigurazione(accessoConfigurazione);
	}

	public void updateAccessoConfigurazione(AccessoConfigurazione accessoConfigurazione) throws DriverConfigurazioneException {
		this.configDriver.updateAccessoConfigurazione(accessoConfigurazione);
	}

	public void deleteAccessoConfigurazione(AccessoConfigurazione accessoConfigurazione) throws DriverConfigurazioneException {
		this.configDriver.deleteAccessoConfigurazione(accessoConfigurazione);
	}

	
	// *** Configurazione (Accesso Dati Autorizzazione) ***	
	
	@Override
	public AccessoDatiAutorizzazione getAccessoDatiAutorizzazione() throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
		return this.configDriver.getAccessoDatiAutorizzazione();
	}
	
	public void createAccessoDatiAutorizzazione(AccessoDatiAutorizzazione accessoDatiAutorizzazione) throws DriverConfigurazioneException {
		this.configDriver.createAccessoDatiAutorizzazione(accessoDatiAutorizzazione);
	}

	public void updateAccessoDatiAutorizzazione(AccessoDatiAutorizzazione accessoDatiAutorizzazione) throws DriverConfigurazioneException {
		this.configDriver.updateAccessoDatiAutorizzazione(accessoDatiAutorizzazione);
	}

	public void deleteAccessoDatiAutorizzazione(AccessoDatiAutorizzazione accessoDatiAutorizzazione) throws DriverConfigurazioneException {
		this.configDriver.deleteAccessoDatiAutorizzazione(accessoDatiAutorizzazione);
	}

	
	// *** Configurazione (Accesso Dati Autenticazione) ***	
		
	@Override
	public AccessoDatiAutenticazione getAccessoDatiAutenticazione() throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
		return this.configDriver.getAccessoDatiAutenticazione();
	}

	
	// *** Configurazione (Accesso Dati GestioneToke) ***	
		
	@Override
	public AccessoDatiGestioneToken getAccessoDatiGestioneToken() throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
		return this.configDriver.getAccessoDatiGestioneToken();
	}
	
	// *** Configurazione (Accesso Dati AttributeAuthority) ***	
	
	@Override
	public AccessoDatiAttributeAuthority getAccessoDatiAttributeAuthority() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.configDriver.getAccessoDatiAttributeAuthority();
	}

	
	// *** Configurazione (Accesso Dati Keystore) ***	
	
	@Override
	public AccessoDatiKeystore getAccessoDatiKeystore() throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
		return this.configDriver.getAccessoDatiKeystore();
	}

	
	// *** Configurazione (Accesso Dati Load Balancer) ***	
		
	@Override
	public AccessoDatiConsegnaApplicativi getAccessoDatiConsegnaApplicativi() throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
		return this.configDriver.getAccessoDatiConsegnaApplicativi();
	}

	
	// *** Configurazione (Accesso Dati Richieste) ***	
			
	@Override
	public AccessoDatiRichieste getAccessoDatiRichieste() throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
		return this.configDriver.getAccessoDatiRichieste();
	}

	
	// *** Configurazione (Gestione Errore) ***	

	/**
	 * Restituisce la gestione dell'errore di default definita nella Porta di Dominio per il componente di cooperazione
	 *
	 * @return La gestione dell'errore
	 * 
	 */
	@Override
	public GestioneErrore getGestioneErroreComponenteCooperazione() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.gestioneErroreDriver.getGestioneErroreComponenteCooperazione();
	}

	/**
	 * Restituisce la gestione dell'errore di default definita nella Porta di Dominio per il componente di integrazione
	 *
	 * @return La gestione dell'errore
	 * 
	 */
	@Override
	public GestioneErrore getGestioneErroreComponenteIntegrazione() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.gestioneErroreDriver.getGestioneErroreComponenteIntegrazione();
	}
	
	/**
	 * Crea le informazioni per la gestione dell'errore per il ComponenteCooperazione
	 * 
	 * @param gestione
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void createGestioneErroreComponenteCooperazione(GestioneErrore gestione) throws DriverConfigurazioneException{
		this.gestioneErroreDriver.createGestioneErroreComponenteCooperazione(gestione);
	}

	/**
	 * Aggiorna le informazioni per la gestione dell'errore per il ComponenteCooperazione
	 * 
	 * @param gestione
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void updateGestioneErroreComponenteCooperazione(GestioneErrore gestione) throws DriverConfigurazioneException{
		this.gestioneErroreDriver.updateGestioneErroreComponenteCooperazione(gestione);
	}

	/**
	 * Elimina le informazioni per la gestione dell'errore per il ComponenteCooperazione
	 * 
	 * @param gestione
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void deleteGestioneErroreComponenteCooperazione(GestioneErrore gestione) throws DriverConfigurazioneException{
		this.gestioneErroreDriver.deleteGestioneErroreComponenteCooperazione(gestione);
	}

	/**
	 * Crea le informazioni per la gestione dell'errore per il ComponenteIntegrazione
	 * 
	 * @param gestione
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void createGestioneErroreComponenteIntegrazione(GestioneErrore gestione) throws DriverConfigurazioneException{
		this.gestioneErroreDriver.createGestioneErroreComponenteIntegrazione(gestione);
	}

	/**
	 * Aggiorna le informazioni per la gestione dell'errore per il ComponenteIntegrazione
	 * 
	 * @param gestione
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void updateGestioneErroreComponenteIntegrazione(GestioneErrore gestione) throws DriverConfigurazioneException{
		this.gestioneErroreDriver.updateGestioneErroreComponenteIntegrazione(gestione);
	}

	/**
	 * Elimina le informazioni per la gestione dell'errore per il ComponenteIntegrazione
	 * 
	 * @param gestione
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void deleteGestioneErroreComponenteIntegrazione(GestioneErrore gestione) throws DriverConfigurazioneException{
		this.gestioneErroreDriver.deleteGestioneErroreComponenteIntegrazione(gestione);
	}

	
	// *** Configurazione (Stato Servizi) ***	

	/**
	 * Restituisce la gestione dell'errore di default definita nella Porta di
	 * Dominio
	 * 
	 * @return La gestione dell'errore
	 * 
	 */
	@Override
	public StatoServiziPdd getStatoServiziPdD() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.configDriver.getStatoServiziPdD();
	}

	/**
	 * Crea le informazioni sui servizi attivi della PdD
	 * 
	 * @param servizi
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void createStatoServiziPdD(StatoServiziPdd servizi) throws DriverConfigurazioneException{
		this.configDriver.createStatoServiziPdD(servizi);
	}

	/**
	 * Aggiorna le informazioni sui servizi attivi della PdD
	 * 
	 * @param servizi
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void updateStatoServiziPdD(StatoServiziPdd servizi) throws DriverConfigurazioneException{
		this.configDriver.updateStatoServiziPdD(servizi);
	}


	/**
	 * Elimina le informazioni sui servizi attivi della PdD
	 * 
	 * @param servizi
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void deleteStatoServiziPdD(StatoServiziPdd servizi) throws DriverConfigurazioneException{
		this.configDriver.deleteStatoServiziPdD(servizi);
	}

	
	// *** Configurazione (Proprieta' Sistema) ***	

	public List<Property> systemPropertyList(ISearch ricerca) throws DriverConfigurazioneException {
		return this.configSearchDriver.systemPropertyList(ricerca);
	}

	/**
	 * Restituisce le proprieta' di sistema utilizzate dalla PdD
	 *
	 * @return proprieta' di sistema
	 * 
	 */
	@Override
	public SystemProperties getSystemPropertiesPdD() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.configDriver.getSystemPropertiesPdD();
	}
	
	/**
	 * Crea le informazioni sulle proprieta' di sistema utilizzate dalla PdD
	 * 
	 * @param systemProperties
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void createSystemPropertiesPdD(SystemProperties systemProperties) throws DriverConfigurazioneException{
		this.configDriver.createSystemPropertiesPdD(systemProperties);
	}

	/**
	 * Aggiorna le informazioni sulle proprieta' di sistema utilizzate dalla PdD
	 * 
	 * @param systemProperties
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void updateSystemPropertiesPdD(SystemProperties systemProperties) throws DriverConfigurazioneException{
		this.configDriver.updateSystemPropertiesPdD(systemProperties);
	}

	/**
	 * Elimina le informazioni sulle proprieta' di sistema utilizzate dalla PdD
	 * 
	 * @param systemProperties
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void deleteSystemPropertiesPdD(SystemProperties systemProperties) throws DriverConfigurazioneException{
		this.configDriver.deleteSystemPropertiesPdD(systemProperties);
	}

	
	// *** Configurazione (URL Invocazione) ***
	
	@Override
	public ConfigurazioneUrlInvocazioneRegola getUrlInvocazioneRegola(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.configDriver.getUrlInvocazioneRegola(nome);
	}
	
	public boolean existsUrlInvocazioneRegola(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.configDriver.existsUrlInvocazioneRegola(nome);
	}

	@Override
	public void createUrlInvocazioneRegola(ConfigurazioneUrlInvocazioneRegola regola) throws DriverConfigurazioneException{
		this.configDriver.createUrlInvocazioneRegola(regola);
	}

	@Override
	public void updateUrlInvocazioneRegola(ConfigurazioneUrlInvocazioneRegola regola) throws DriverConfigurazioneException{
		this.configDriver.updateUrlInvocazioneRegola(regola);
	}

	@Override
	public void deleteUrlInvocazioneRegola(ConfigurazioneUrlInvocazioneRegola regola) throws DriverConfigurazioneException{
		this.configDriver.deleteUrlInvocazioneRegola(regola);
	}
		
	public List<ConfigurazioneUrlInvocazioneRegola> proxyPassConfigurazioneRegolaList(ISearch ricerca) throws DriverConfigurazioneException {
		return this.configSearchDriver.proxyPassConfigurazioneRegolaList(ricerca);
	}
	
	public boolean existsProxyPassConfigurazioneRegola(String nome) throws DriverConfigurazioneException {
		return this.configDriver.existsProxyPassConfigurazioneRegola(nome);
	}

	
	// *** Configurazione (Response Cache) ***
	
	public List<ResponseCachingConfigurazioneRegola> responseCachingConfigurazioneRegolaList(ISearch ricerca) throws DriverConfigurazioneException {
		return this.configSearchDriver.responseCachingConfigurazioneRegolaList(ricerca);
	}
	
	public boolean existsResponseCachingConfigurazioneRegola(Integer statusMin, Integer statusMax, boolean fault) throws DriverConfigurazioneException {
		return this.configDriver.existsResponseCachingConfigurazioneRegola(statusMin, statusMax, fault);
	}
	
	
	
	// *** Configurazione (Canali) ***
	
	public List<CanaleConfigurazione> canaleConfigurazioneList(ISearch ricerca) throws DriverConfigurazioneException {
		return this.configSearchDriver.canaleConfigurazioneList(ricerca);
	}
	
	public boolean existsCanale(String nome) throws DriverConfigurazioneException {
		return this.configDriver.existsCanale(nome);
	}
	public List<CanaleConfigurazioneNodo> canaleNodoConfigurazioneList(ISearch ricerca) throws DriverConfigurazioneException {
		return this.configSearchDriver.canaleNodoConfigurazioneList(ricerca);
	}
	public boolean existsCanaleNodo(String nome) throws DriverConfigurazioneException {
		return this.configDriver.existsCanaleNodo(nome);
	}
	
	/**
	 * Restituisce la configurazione dei canali
	 * 
	 * @return Configurazione
	 * 
	 */
	@Override
	public CanaliConfigurazione getCanaliConfigurazione() throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.configDriver.getCanaliConfigurazione();
	}
	public CanaliConfigurazione getCanaliConfigurazione(boolean readNodi) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.configDriver.getCanaliConfigurazione(readNodi);
	}
	
	
	
	// *** Configurazione (Tracciamento) ***
	
	public boolean existsFaseTracciamentoDBRequestIn(boolean erogazioni, boolean fruizioni) throws DriverConfigurazioneException { 
		return this.configSearchDriver.existsFaseTracciamentoDBRequestIn(erogazioni, fruizioni);
	}
	public boolean existsFaseTracciamentoDBRequestOut(boolean erogazioni, boolean fruizioni) throws DriverConfigurazioneException { 
		return this.configSearchDriver.existsFaseTracciamentoDBRequestOut(erogazioni, fruizioni);
	}
	public boolean existsFaseTracciamentoDBResponseOut(boolean erogazioni, boolean fruizioni) throws DriverConfigurazioneException { 
		return this.configSearchDriver.existsFaseTracciamentoDBResponseOut(erogazioni, fruizioni);
	}
	
	
	
	// *** Configurazione ***
	
	/**
	 * Restituisce la configurazione generale della Porta di Dominio
	 * 
	 * @return Configurazione
	 * 
	 */
	@Override
	public Configurazione getConfigurazioneGenerale() throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.configDriver.getConfigurazioneGenerale();
	}

	public Object getConfigurazioneExtended(Configurazione config, String idExtendedConfiguration) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
		return this.configDriver.getConfigurazioneExtended(config, idExtendedConfiguration);
	}
	
	@Override
	public void createConfigurazione(Configurazione configurazione) throws DriverConfigurazioneException {
		this.configDriver.createConfigurazione(configurazione);
	}

	@Override
	public void updateConfigurazione(Configurazione configurazione) throws DriverConfigurazioneException {
		this.configDriver.updateConfigurazione(configurazione);
	}

	@Override
	public void deleteConfigurazione(Configurazione configurazione) throws DriverConfigurazioneException {
		this.configDriver.deleteConfigurazione(configurazione);
	}
	
	
	
	// *** Generic Properties ***	
		
	/**
	 * Restituisce le proprieta' generiche di una tipologia utilizzate dalla PdD
	 *
	 * @return proprieta' generiche
	 * 
	 */
	@Override
	public List<GenericProperties> getGenericProperties() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.genericPropertiesDriver.getGenericProperties();
	}
	
	/**
	 * Restituisce le proprieta' generiche utilizzate dalla PdD
	 *
	 * @return proprieta' generiche
	 * 
	 */
	@Override
	public List<GenericProperties> getGenericProperties(String tipologia) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.genericPropertiesDriver.getGenericProperties(tipologia);
	}
	
	@Override
	public GenericProperties getGenericProperties(String tipologia, String name) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.genericPropertiesDriver.getGenericProperties(tipologia, name);
	}
	
	/**
	 * Restituisce le proprieta' generiche utilizzate dalla PdD
	 *
	 * @return proprieta' generiche
	 * 
	 */
	public List<GenericProperties> getGenericProperties(List<String> tipologia, Integer idLista, ISearch ricerca, boolean throwNotFoundException) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.genericPropertiesDriver.getGenericProperties(tipologia, idLista, ricerca, throwNotFoundException);
	}

	public GenericProperties getGenericProperties(long idGenericProperties) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
		return this.genericPropertiesDriver.getGenericProperties(idGenericProperties);
	}

	/**
	 * Crea una proprieta' generica della PdD
	 * 
	 * @param genericProperties
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void createGenericProperties(GenericProperties genericProperties) throws DriverConfigurazioneException{
		this.genericPropertiesDriver.createGenericProperties(genericProperties);
	}

	/**
	 * Aggiorna le informazioni sulle proprieta' generiche della PdD
	 * 
	 * @param genericProperties
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void updateGenericProperties(GenericProperties genericProperties) throws DriverConfigurazioneException{
		this.genericPropertiesDriver.updateGenericProperties(genericProperties);
	}


	/**
	 * Elimina le informazioni sulle proprieta' generiche della PdD
	 * 
	 * @param genericProperties
	 * @throws DriverConfigurazioneException
	 */
	@Override
	public void deleteGenericProperties(GenericProperties genericProperties) throws DriverConfigurazioneException{
		this.genericPropertiesDriver.deleteGenericProperties(genericProperties);
	}

	
	
	
	// *** Plugins ***	
	
	@Override
	public RegistroPlugins getRegistroPlugins() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.getRegistroPlugins();
	}
	
	@Override
	public RegistroPlugin getRegistroPlugin(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.getRegistroPlugin(nome);
	}
	@Override
	public RegistroPlugin getDatiRegistroPlugin(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.getDatiRegistroPlugin(nome);
	}
	
	public RegistroPlugin getRegistroPlugin(Connection conParam, String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.getRegistroPlugin(conParam, nome);
	}
	public RegistroPlugin getDatiRegistroPlugin(Connection conParam, String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.getDatiRegistroPlugin(conParam, nome);
	}
		
	public RegistroPlugin getRegistroPluginFromPosizione(int posizione) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.getRegistroPluginFromPosizione(posizione);
	}
	public RegistroPlugin getDatiRegistroPluginFromPosizione(int posizione) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.getDatiRegistroPluginFromPosizione(posizione);
	}
		
	public boolean existsRegistroPlugin(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.existsRegistroPlugin(nome);
	}
	
	public int getMaxPosizioneRegistroPlugin() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.getMaxPosizioneRegistroPlugin();
	}
	
	public int getNumeroArchiviJarRegistroPlugin(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.getNumeroArchiviJarRegistroPlugin(nome);
	}
	
	@Override
	public void createRegistroPlugin(RegistroPlugin plugin) throws DriverConfigurazioneException{
		this.pluginsDriver.createRegistroPlugin(plugin);
	}
	
	@Override
	public void updateRegistroPlugin(RegistroPlugin plugin) throws DriverConfigurazioneException{
		this.pluginsDriver.updateRegistroPlugin(plugin);
	}
	
	@Override
	public void deleteRegistroPlugin(RegistroPlugin plugin) throws DriverConfigurazioneException{
		this.pluginsDriver.deleteRegistroPlugin(plugin);
	}
	
	@Override
	public void updateDatiRegistroPlugin(String nomePlugin, RegistroPlugin plugin) throws DriverConfigurazioneException{
		this.pluginsDriver.updateDatiRegistroPlugin(nomePlugin, plugin);
	}
	
	@Override
	public RegistroPluginArchivio getRegistroPluginArchivio(String nomePlugin, String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.getRegistroPluginArchivio(nomePlugin, nome);
	}
	
	public boolean existsRegistroPluginArchivio(String nomePlugin, String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.existsRegistroPluginArchivio(nomePlugin, nome);
	}
	
	public boolean existsRegistroPluginArchivio(String nomePlugin, PluginSorgenteArchivio tipoSorgente, String sorgente) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
		return this.pluginsDriver.existsRegistroPluginArchivio(nomePlugin, tipoSorgente, sorgente);
	}
	
	@Override
	public void createRegistroPluginArchivio(String nomePlugin, RegistroPluginArchivio plugin) throws DriverConfigurazioneException{
		this.pluginsDriver.createRegistroPluginArchivio(nomePlugin, plugin);
	}
	
	@Override
	public void updateRegistroPluginArchivio(String nomePlugin, RegistroPluginArchivio plugin) throws DriverConfigurazioneException{
		this.pluginsDriver.updateRegistroPluginArchivio(nomePlugin, plugin);
	}
	
	@Override
	public void deleteRegistroPluginArchivio(String nomePlugin, RegistroPluginArchivio plugin) throws DriverConfigurazioneException{
		this.pluginsDriver.deleteRegistroPluginArchivio(nomePlugin, plugin);
	}
		
	public List<RegistroPlugin> pluginsArchiviList(ISearch ricerca) throws DriverConfigurazioneException {
		return this.pluginsDriver.pluginsArchiviList(ricerca);
	}
	public List<RegistroPluginArchivio> pluginsArchiviJarList(String nome, ISearch ricerca) throws DriverConfigurazioneException {
		return this.pluginsDriver.pluginsArchiviJarList(nome, ricerca);
	}

	
	
	// *** Allarmi ***	
	
	public long countAllarmi(String tipologiaRicerca, Boolean enabled, StatoAllarme stato, Boolean acknowledged, String nomeAllarme,
			List<IDSoggetto> listSoggettiProprietariAbilitati, List<IDServizio> listIDServizioAbilitati,
			List<String> tipoSoggettiByProtocollo, List<String> tipoServiziByProtocollo, 
			IDSoggetto idSoggettoProprietario, List<IDServizio> listIDServizio) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.allarmiDriver.countAllarmi(tipologiaRicerca, enabled, stato, acknowledged, nomeAllarme,
				listSoggettiProprietariAbilitati, listIDServizioAbilitati,
				tipoSoggettiByProtocollo, tipoServiziByProtocollo, 
				idSoggettoProprietario, listIDServizio);
	}
	
	public List<Allarme> findAllAllarmi(String tipologiaRicerca, Boolean enabled, StatoAllarme stato, Boolean acknowledged, String nomeAllarme,
			List<IDSoggetto> listSoggettiProprietariAbilitati, List<IDServizio> listIDServizioAbilitati,
			List<String> tipoSoggettiByProtocollo, List<String> tipoServiziByProtocollo, 
			IDSoggetto idSoggettoProprietario, List<IDServizio> listIDServizio,
			Integer offset, Integer limit) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
		return this.allarmiDriver.findAllAllarmi(tipologiaRicerca, enabled, stato, acknowledged, nomeAllarme,
				listSoggettiProprietariAbilitati, listIDServizioAbilitati,
				tipoSoggettiByProtocollo, tipoServiziByProtocollo, 
				idSoggettoProprietario, listIDServizio,
				offset, limit);
	}
	
	
	
	
	// *** Reset ***	
	
	/**
	 * Reset delle tabelle del db gestito da questo driver
	 */
	@Override
	public void reset() throws DriverConfigurazioneException {
		this.utilsDriver.reset();
	}
	@Override
	public void reset(boolean resetConfigurazione) throws DriverConfigurazioneException{
		this.utilsDriver.reset(resetConfigurazione);
	}

	/**
	 * Reset delle tabelle del db govwayConsole gestito da questo driver
	 */
	public void resetCtrlstat() throws DriverConfigurazioneException {
		this.utilsDriver.resetCtrlstat();
	}

	/**
	 * Metodo che verica la connessione ad una risorsa.
	 * Se la connessione non e' presente, viene lanciata una eccezione che contiene il motivo della mancata connessione
	 * 
	 * @throws DriverConfigurazioneException eccezione che contiene il motivo della mancata connessione
	 */
	@Override
	public void isAlive() throws CoreException{
		this.utilsDriver.isAlive();
	}

	@Override
	public Openspcoop2 getImmagineCompletaConfigurazionePdD() throws DriverConfigurazioneException{

		Openspcoop2 openspcoop = new Openspcoop2();

		Configurazione conf = null;
		try{
			conf = this.getConfigurazioneGenerale();
		}catch(DriverConfigurazioneNotFound d){
			// ignore
		}
		if(conf!=null){
			try{
				conf.setAccessoRegistro(this.getAccessoRegistro());
			}catch(DriverConfigurazioneNotFound d){
				// ignore
			}
			try{
				conf.setAccessoConfigurazione(this.getAccessoConfigurazione());
			}catch(DriverConfigurazioneNotFound d){
				// ignore
			}
			try{
				conf.setAccessoDatiAutorizzazione(this.getAccessoDatiAutorizzazione());
			}catch(DriverConfigurazioneNotFound d){
				// ignore
			}
			conf.setRoutingTable(this.getRoutingTable());
			GestioneErrore compIntegrazione = null;
			try{
				compIntegrazione = this.getGestioneErroreComponenteIntegrazione();
			}catch(DriverConfigurazioneNotFound d){
				// ignore
			}
			GestioneErrore compCooperazione = null;
			try{
				compCooperazione = this.getGestioneErroreComponenteCooperazione();
			}catch(DriverConfigurazioneNotFound d){
				// ignore
			}
			if(compIntegrazione!=null && compCooperazione!=null)
			{
				ConfigurazioneGestioneErrore gee = new ConfigurazioneGestioneErrore();
				if(compIntegrazione!=null){
					gee.setComponenteIntegrazione(compIntegrazione);
				}
				if(compCooperazione!=null){
					gee.setComponenteCooperazione(compCooperazione);
				}
				conf.setGestioneErrore(gee);	
			}		
			// configurazione 
			openspcoop.setConfigurazione(conf);
		}


		// Soggetti
		List<Soggetto> soggetti = this.getAllSoggetti();
		while(!soggetti.isEmpty()){

			Soggetto soggetto = soggetti.remove(0);

			// elimino meta-informazioni
			while(soggetto.sizePortaDelegataList()>0){
				soggetto.removePortaDelegata(0);
			}
			while(soggetto.sizePortaApplicativaList()>0){
				soggetto.removePortaApplicativa(0);
			}
			while(soggetto.sizeServizioApplicativoList()>0){
				soggetto.removeServizioApplicativo(0);
			}

			// read porte delegate
			List<PortaDelegata> pd = this.getPorteDelegateBySoggetto(soggetto.getId());
			while(!pd.isEmpty()){
				soggetto.addPortaDelegata(pd.remove(0));
			}

			// read porte applicative
			List<PortaApplicativa> pa = this.getPorteApplicativeBySoggetto(soggetto.getId());
			while(!pa.isEmpty()){
				soggetto.addPortaApplicativa(pa.remove(0));
			}

			// read servizi applicativi
			List<ServizioApplicativo> sa = this.getServiziApplicativiBySoggetto(soggetto.getId());
			while(!sa.isEmpty()){
				soggetto.addServizioApplicativo(sa.remove(0));
			}

			openspcoop.addSoggetto(soggetto);
		}


		return openspcoop;
	}


}