OpenSPCoop2Properties.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.pdd.config;


import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.security.MessageDigest;
import java.sql.Connection;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;

import org.apache.commons.lang.StringUtils;
import org.openspcoop2.core.commons.CoreException;
import org.openspcoop2.core.commons.DBUtils;
import org.openspcoop2.core.commons.IExtendedInfo;
import org.openspcoop2.core.config.AccessoConfigurazionePdD;
import org.openspcoop2.core.config.constants.CostantiConfigurazione;
import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
import org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal;
import org.openspcoop2.core.constants.TransferLengthModes;
import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
import org.openspcoop2.core.id.IDSoggetto;
import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
import org.openspcoop2.message.AttachmentsProcessingMode;
import org.openspcoop2.message.ForwardConfig;
import org.openspcoop2.message.OpenSPCoop2MessageFactory;
import org.openspcoop2.message.utils.WWWAuthenticateErrorCode;
import org.openspcoop2.monitor.engine.statistic.StatisticsForceIndexConfig;
import org.openspcoop2.pdd.core.CostantiPdD;
import org.openspcoop2.pdd.core.autenticazione.WWWAuthenticateConfig;
import org.openspcoop2.pdd.core.autorizzazione.container.IAutorizzazioneSecurityContainer;
import org.openspcoop2.pdd.core.autorizzazione.pa.IAutorizzazionePortaApplicativa;
import org.openspcoop2.pdd.core.controllo_traffico.ConfigurazioneGatewayControlloTraffico;
import org.openspcoop2.pdd.core.controllo_traffico.INotify;
import org.openspcoop2.pdd.core.controllo_traffico.policy.driver.TipoGestorePolicy;
import org.openspcoop2.pdd.core.credenziali.IGestoreCredenziali;
import org.openspcoop2.pdd.core.credenziali.IGestoreCredenzialiIM;
import org.openspcoop2.pdd.core.dynamic.InformazioniIntegrazioneCodifica;
import org.openspcoop2.pdd.core.dynamic.InformazioniIntegrazioneSorgente;
import org.openspcoop2.pdd.core.handlers.ExitHandler;
import org.openspcoop2.pdd.core.handlers.InRequestHandler;
import org.openspcoop2.pdd.core.handlers.InRequestProtocolHandler;
import org.openspcoop2.pdd.core.handlers.InResponseHandler;
import org.openspcoop2.pdd.core.handlers.InitHandler;
import org.openspcoop2.pdd.core.handlers.IntegrationManagerRequestHandler;
import org.openspcoop2.pdd.core.handlers.IntegrationManagerResponseHandler;
import org.openspcoop2.pdd.core.handlers.OutRequestHandler;
import org.openspcoop2.pdd.core.handlers.OutResponseHandler;
import org.openspcoop2.pdd.core.handlers.PostOutRequestHandler;
import org.openspcoop2.pdd.core.handlers.PostOutResponseHandler;
import org.openspcoop2.pdd.core.handlers.PreInRequestHandler;
import org.openspcoop2.pdd.core.handlers.PreInResponseHandler;
import org.openspcoop2.pdd.core.handlers.notifier.INotifierCallback;
import org.openspcoop2.pdd.core.handlers.transazioni.ISalvataggioDiagnosticiManager;
import org.openspcoop2.pdd.core.handlers.transazioni.ISalvataggioTracceManager;
import org.openspcoop2.pdd.core.integrazione.IGestoreIntegrazionePA;
import org.openspcoop2.pdd.core.integrazione.IGestoreIntegrazionePD;
import org.openspcoop2.pdd.core.integrazione.UtilitiesTemplate;
import org.openspcoop2.pdd.core.node.INodeReceiver;
import org.openspcoop2.pdd.core.node.INodeSender;
import org.openspcoop2.pdd.core.threshold.IThreshold;
import org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione;
import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
import org.openspcoop2.pdd.logger.filetrace.FileTraceGovWayState;
import org.openspcoop2.pdd.logger.transazioni.ConfigurazioneTracciamento;
import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
import org.openspcoop2.pdd.mdb.Imbustamento;
import org.openspcoop2.pdd.mdb.ImbustamentoRisposte;
import org.openspcoop2.pdd.mdb.InoltroBuste;
import org.openspcoop2.pdd.mdb.InoltroRisposte;
import org.openspcoop2.pdd.mdb.Sbustamento;
import org.openspcoop2.pdd.mdb.SbustamentoRisposte;
import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
import org.openspcoop2.pdd.services.core.RicezioneBuste;
import org.openspcoop2.pdd.services.core.RicezioneContenutiApplicativi;
import org.openspcoop2.pdd.timers.TimerGestoreBusteNonRiscontrate;
import org.openspcoop2.pdd.timers.TimerGestoreMessaggi;
import org.openspcoop2.pdd.timers.TimerGestorePuliziaMessaggiAnomali;
import org.openspcoop2.pdd.timers.TimerGestoreRepositoryBuste;
import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
import org.openspcoop2.protocol.engine.constants.Costanti;
import org.openspcoop2.protocol.engine.driver.IFiltroDuplicati;
import org.openspcoop2.protocol.engine.driver.repository.GestoreRepositoryFactory;
import org.openspcoop2.protocol.engine.driver.repository.IGestoreRepository;
import org.openspcoop2.protocol.sdk.BypassMustUnderstandCheck;
import org.openspcoop2.protocol.sdk.IProtocolFactory;
import org.openspcoop2.protocol.sdk.ProtocolException;
import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
import org.openspcoop2.protocol.sdk.config.IProtocolConfiguration;
import org.openspcoop2.protocol.sdk.config.IProtocolManager;
import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
import org.openspcoop2.protocol.sdk.constants.FaultIntegrationGenericInfoMode;
import org.openspcoop2.protocol.sdk.constants.IDService;
import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
import org.openspcoop2.protocol.sdk.state.FunctionContextCustom;
import org.openspcoop2.protocol.sdk.state.FunctionContextsCustom;
import org.openspcoop2.protocol.sdk.state.RequestInfo;
import org.openspcoop2.protocol.utils.EsitiProperties;
import org.openspcoop2.security.message.MessageSecurityContext;
import org.openspcoop2.security.message.engine.MessageSecurityFactory;
import org.openspcoop2.utils.BooleanNullable;
import org.openspcoop2.utils.LoggerWrapperFactory;
import org.openspcoop2.utils.MapKey;
import org.openspcoop2.utils.NameValue;
import org.openspcoop2.utils.SemaphoreType;
import org.openspcoop2.utils.TipiDatabase;
import org.openspcoop2.utils.Utilities;
import org.openspcoop2.utils.UtilsException;
import org.openspcoop2.utils.VersionUtilities;
import org.openspcoop2.utils.cache.CacheType;
import org.openspcoop2.utils.certificate.KeystoreType;
import org.openspcoop2.utils.crypt.CryptConfig;
import org.openspcoop2.utils.date.DateEngineType;
import org.openspcoop2.utils.date.DateUtils;
import org.openspcoop2.utils.date.IDate;
import org.openspcoop2.utils.digest.IDigestReader;
import org.openspcoop2.utils.id.IUniqueIdentifierGenerator;
import org.openspcoop2.utils.io.ArchiveType;
import org.openspcoop2.utils.jdbc.IJDBCAdapter;
import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
import org.openspcoop2.utils.json.JsonSchemaValidatorConfig.ADDITIONAL;
import org.openspcoop2.utils.json.JsonValidatorAPI.ApiName;
import org.openspcoop2.utils.openapi.validator.OpenAPILibrary;
import org.openspcoop2.utils.resources.Charset;
import org.openspcoop2.utils.resources.FileSystemUtilities;
import org.openspcoop2.utils.resources.Loader;
import org.openspcoop2.utils.sql.ISQLQueryObject;
import org.openspcoop2.utils.transport.http.HttpConstants;
import org.openspcoop2.utils.transport.http.RFC2047Encoding;
import org.slf4j.Logger;

/**
 * Contiene un lettore del file di proprieta' di OpenSPCoop.
 *
 * @author Poli Andrea (apoli@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 */


public class OpenSPCoop2Properties {	

	/** Logger utilizzato per errori eventuali. */
	private Logger log = null;
	private void logError(String msg) {
		if(this.log!=null) {
			this.log.error(msg);
		}
	}
	private void logError(String msg, Exception e) {
		if(this.log!=null) {
			this.log.error(msg,e);
		}
	}
	private void logWarn(String msg) {
		if(this.log!=null) {
			this.log.warn(msg);
		}
	}
	private void logWarn(String msg, Exception e) {
		if(this.log!=null) {
			this.log.warn(msg,e);
		}
	}
	private void logInfo(String msg) {
		if(this.log!=null) {
			this.log.info(msg);
		}
	}
	private void logDebug(String msg) {
		if(this.log!=null) {
			this.log.debug(msg);
		}
	}
	
	private String getMessaggioProprietaNonImpostata(String pName, int defaultValue){
		return getMessaggioProprietaNonImpostata(pName, defaultValue+"");
	}
	private String getMessaggioProprietaNonImpostata(String pName, long defaultValue){
		return getMessaggioProprietaNonImpostata(pName, defaultValue+"");
	}
	private String getMessaggioProprietaNonImpostata(String pName, boolean defaultValue){
		return getMessaggioProprietaNonImpostata(pName, defaultValue+"");
	}
	private String getMessaggioProprietaNonImpostata(String pName, String defaultValue){
		return "Proprietà di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+defaultValue;
	}
	
	private String getMessaggioProprietaNonImpostata(String pName, Exception e, int defaultValue){
		return getMessaggioProprietaNonImpostata(pName, e, defaultValue+"");
	}
	private String getMessaggioProprietaNonImpostata(String pName, Exception e, long defaultValue){
		return getMessaggioProprietaNonImpostata(pName, e, defaultValue+"");
	}
	private String getMessaggioProprietaNonImpostata(String pName, Exception e, boolean defaultValue){
		return getMessaggioProprietaNonImpostata(pName, e, defaultValue+"");
	}
	private String getMessaggioProprietaNonImpostata(String pName, Exception e, String defaultValue){
		return "Proprietà di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+defaultValue+"; errore:"+e.getMessage();
	}
	
	private static final String HEADER_INTEGRAZIONE_SCONOSCIUTO = "L'header di integrazione indicato non esiste nelle classi registrate in GovWay";
	private static final String TIPO_SCONOSCIUTO = "Il tipo non esiste nelle classi registrate in GovWay";
	private String getMessaggioClasseSconosciuta(Exception e) {
		return "La classe non esiste: "+e.getMessage();
	}
	private static final String OGGETTO_NEW_INSTANCE_NON_CREATO = "Oggetto non creato dopo aver chiamato la newInstance";
	
	private static final String NON_DEFINITA = "non definita";
	
	private static final String VALORE_NON_CORRETTO_ABILITATO_DISABILITATO = "Valore non corretto (abilitato/disabilitato): ";
	
	private static final String PROPERTY_START_SUFFIX_ERRORE = ".*': ";

	private static final String PREFIX_JDBC_ADAPTER_NOT_EXISTS = "Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.jdbcAdapter'. \n L'adapter indicato non esiste [";
	
	private static final String PROPRIETA_NON_DEFINITA = "Proprietà non definita";
	
	private static final String ATTESO_UN_CARATTERE_TROVATI = "Atteso un carattere, trovati ";
	
	private String getPrefixFile(File f, boolean expectedDir) {
		return (expectedDir ? "Dir ":"")+"["+f.getAbsolutePath()+"] ";
	}
	private CoreException newCoreExceptionNotDir(File f, boolean expectedDir){
		return new CoreException(getPrefixFile(f, expectedDir)+"isn't dir");
	}
	private CoreException newCoreExceptionNotFile(File f, boolean expectedDir){
		return new CoreException(getPrefixFile(f, expectedDir)+"isn't file");
	}
	private CoreException newCoreExceptionCannotRead(File f, boolean expectedDir){
		return new CoreException(getPrefixFile(f, expectedDir)+"cannot read");
	}
	private CoreException newCoreExceptionCannotWrite(File f, boolean expectedDir){
		return new CoreException(getPrefixFile(f, expectedDir)+"cannot write");
	}
	/**private CoreException newCoreExceptionNotExists(File f, boolean expectedDir){
		return new CoreException(getPrefixFile(f, expectedDir)+"not exists");
	}*/
	

	
	/** Copia Statica */
	private static OpenSPCoop2Properties openspcoopProperties = null;




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

	/** Reader delle proprieta' impostate nel file 'govway.properties' */
	private OpenSPCoop2InstanceProperties reader;
	private PddProperties pddReader;





	/* ********  C O S T R U T T O R E  ******** */

	/**
	 * Viene chiamato in causa per istanziare il properties reader
	 *
	 * 
	 */
	public OpenSPCoop2Properties(Properties localProperties) throws CoreException{
		this(localProperties, "/govway.properties");
	}
	public OpenSPCoop2Properties(Properties localProperties, String path) throws CoreException{

		if(OpenSPCoop2Startup.initialize)
			this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
		else
			this.log = LoggerWrapperFactory.getLogger("govway.startup");

		/* ---- Lettura del cammino del file di configurazione ---- */
		Properties propertiesReader = new Properties();
		java.io.InputStream properties = null;
		try{ 
			properties = OpenSPCoop2Properties.class.getResourceAsStream(path);
			if(properties==null){
				File f = new File(path);
				if(f.exists()) {
					properties = new FileInputStream(f);
				}
				else {
					throw new CoreException("File '"+path+"' not found");
				}
			}
			propertiesReader.load(properties);
		}catch(Exception e) {
			this.logError("Riscontrato errore durante la lettura del file '"+path+"': \n\n"+e.getMessage(),e);
			throw new CoreException("OpenSPCoopProperties initialize error: "+e.getMessage(),e);
		}finally{
		    try{
		    	if(properties!=null)
		    		properties.close();
		    }catch(Exception er){
		    	// close
		    }
		}
		try {
			this.reader = new OpenSPCoop2InstanceProperties(propertiesReader, this.log, localProperties);
		}catch(Exception e) {
			throw new CoreException(e.getMessage(),e);
		}

	}

	/**
	 * Il Metodo si occupa di inizializzare il propertiesReader 
	 *
	 * 
	 */
	public static boolean initialize(Properties localProperties){
		try {
			OpenSPCoop2Properties.openspcoopProperties = new OpenSPCoop2Properties(localProperties);	
			return true;
		}
		catch(Exception e) {
			return false;
		}
	}
	public static boolean initialize(Properties localProperties, String path){
		try {
			OpenSPCoop2Properties.openspcoopProperties = new OpenSPCoop2Properties(localProperties, path);	
			return true;
		}
		catch(Exception e) {
			return false;
		}
	}

	/**
	 * Ritorna l'istanza di questa classe
	 *
	 * @return Istanza di OpenSPCoopProperties
	 * 
	 */
	public static OpenSPCoop2Properties getInstance(){
		return OpenSPCoop2Properties.openspcoopProperties;
	}


	public static void updatePddPropertiesReader(PddProperties pddProperties){
		OpenSPCoop2Properties.openspcoopProperties.pddReader = pddProperties;
	}












	/* ********  VALIDATORE FILE PROPERTY  ******** */

	/**
	 * Effettua una validazione delle proprieta' impostate nel file OpenSPCoop.properties.   
	 *
	 * @return true se la validazione ha successo, false altrimenti.
	 * 
	 */
	public boolean validaConfigurazione(java.lang.ClassLoader loader) {	
		try{  
			ClassNameProperties className = ClassNameProperties.getInstance();

			// root Directory
			if (getRootDirectory() == null)		
				return false;
			if( (new File(getRootDirectory())).exists() == false ){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.confDirectory'. \n La directory indicata non esiste ["+getRootDirectory()+"].");
				return false;
			}
			
			// Tipo server
			Boolean serverJ2EEtest = isServerJ2EE();
			if(serverJ2EEtest==null){
				return false;
			}
			
			// Attachment
			getAttachmentsProcessingMode();
			// warning, default false.
			if(this.isFileCacheEnable()){
				// Se abilitato, deve essere specificato il repository
				this.getAttachmentRepoDir();
			}
			// warning, default 1024
			this.getFileThreshold(); 		
			
			// Versione
			this.getVersione();
			this.getDetails();
			// openspcoop home
			this.getCheckOpenSPCoopHome();

			// Loader
			Loader loaderOpenSPCoop = null;
			if(loader!=null){
				loaderOpenSPCoop = Loader.getInstance(); // gia inizializzato nello startup
			}else{
				String loaderOP = this.getClassLoader();
				if(loaderOP!=null){
					try{
						Class<?> c = Class.forName(loaderOP);
						Constructor<?> constructor = c.getConstructor(java.lang.ClassLoader.class);
						java.lang.ClassLoader test = (java.lang.ClassLoader) constructor.newInstance(this.getClass().getClassLoader());
						test.toString();
						loaderOpenSPCoop = new Loader(loader);
					}catch(Exception e){
						this.logError("Riscontrato errore durante la lettura del class loader indicato nella proprieta' di openspcoop 'org.openspcoop2.pdd.classLoader': "+e.getMessage(),e);
						return false;
					}
				}else{
					loaderOpenSPCoop = Loader.getInstance();
				}
			}
			
			// Non posso inizializzarli durante la validazione poich' il ProtocolFactoryManager non e' ancora stato inizializzato
//			// EsitiProperties
/**			EsitiProperties.initialize(getRootDirectory(), this.log, loaderOpenSPCoop); */
			
			// Repository
			String tipoRepository = getRepositoryType();
			if(CostantiConfigurazione.REPOSITORY_FILE_SYSTEM.equals(tipoRepository)){
				if (getRepositoryDirectory() == null)	{						
					return false;
				}
				// Verra' creata se non esiste in openspcoop startup
/**				if( (new File(getRepositoryDirectory())).exists() == false ){
//					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.directory'. \n La directory indicata non esiste ["+getRepositoryDirectory()+"].");
//					return false;
//				}*/
			}else if(CostantiConfigurazione.REPOSITORY_DB.equals(tipoRepository)){
				if (getRepositoryJDBCAdapter() == null)	{						
					return false;
				}
				String jdbcAdapter = this.getRepositoryJDBCAdapter();
				if(this.getDatabaseType()!=null && TipiDatabase.DEFAULT.equals(jdbcAdapter)){
					try{
						IJDBCAdapter adapter = JDBCAdapterFactory.createJDBCAdapter(OpenSPCoop2Properties.openspcoopProperties.getDatabaseType());
						adapter.toString();					
					}catch(Exception e){
						this.logError(PREFIX_JDBC_ADAPTER_NOT_EXISTS+getRepositoryJDBCAdapter()+"]: "+e.getMessage(),e);
						return false;
					}
				}
				else{
					//	Ricerco connettore
					String adapterClass = className.getJDBCAdapter(jdbcAdapter);
					if(adapterClass == null){
						this.logError(PREFIX_JDBC_ADAPTER_NOT_EXISTS+getRepositoryJDBCAdapter()+"] nelle classi registrate in OpenSPCoop");
						return false;
					}
					try{
						IJDBCAdapter adapter = (IJDBCAdapter) loaderOpenSPCoop.newInstance(adapterClass);
						adapter.toString();
					}catch(Exception e){
						this.logError(PREFIX_JDBC_ADAPTER_NOT_EXISTS+getRepositoryJDBCAdapter()+"]: "+e.getMessage(),e);
						return false;
					}
				}
			}else{
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.tipo'. \n Il tipo indicato non e' un tipo valido ["+getRepositoryType()+"].");
				return false;
			}
			// warning
			this.isRepositoryOnFS();
			this.isCondivisioneConfigurazioneRegistroDB();

			// SoapBuffer
			if(this.useSoapMessageReader()) {
				this.getSoapMessageReaderBufferThresholdKb();
				this.useSoapMessageReaderHeaderOptimization();
			}
			
			this.useSoapMessagePassthrough();
			
			this.getSoapMessageSaajSaxParserPoolSize();
			// AlternativeContentTypeSoap12
			this.getAlternativeContentTypeSoap12();
			
			// Multipart
			this.useRestMultipartLazy();
			
			// EliminatoreMessaggi in Repository
			long intervalloEliminazione = getRepositoryIntervalloEliminazioneMessaggi();
			if(intervalloEliminazione<=0){
				if(intervalloEliminazione!=-1){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.timer'. \n Valore non valido ["+intervalloEliminazione+"].");			
				}
				return false;
			}
			long intervalloScadenza = getRepositoryIntervalloScadenzaMessaggi();
			if(intervalloScadenza<=0){
				if(intervalloScadenza!=-1){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.scadenzaMessaggio'. \n Valore non valido ["+intervalloScadenza+"].");			
				}
				return false;
			}
			this.isRepositoryBusteFiltraBusteScaduteRispettoOraRegistrazione();

			// EliminatoreCorrelazioniApplicative in Repository
			long intervalloScadenzaCorrelazioneApplicativa = getRepositoryIntervalloScadenzaCorrelazioneApplicativa();
			if(intervalloScadenzaCorrelazioneApplicativa<=0){
				if(intervalloScadenzaCorrelazioneApplicativa!=-1){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa'. \n Valore non valido ["+intervalloScadenzaCorrelazioneApplicativa+"].");			
				}
				return false;
			}
			this.getMaxLengthCorrelazioneApplicativa();
			this.isMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate();
			this.getMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate();
			this.isMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate();
			this.getMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate();
			this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione();
			this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata();
			this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore();
			this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore();
			this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore();
			this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore();
			this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca();
			this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca();
			
			// Msg gia Processati (Warning)
			this.getMsgGiaInProcessamentoAttesaAttiva();
			this.getMsgGiaInProcessamentoCheckInterval();
			this.isMsgGiaInProcessamentoUseLock();

			// Threshold per il Repository
			List<String> tipiThreshold = this.getRepositoryThresholdTypes();
			if(tipiThreshold!=null){
				// CheckInterval in Repository
				long intervalloCheck = this.getRepositoryThresholdCheckInterval();
				if(intervalloCheck<=0){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.threshold.checkInterval', valore non impostato/valido.");			
					return false;
				}
				for(int i=0; i<tipiThreshold.size();i++){
					if(this.getRepositoryThresholdParameters(tipiThreshold.get(i))==null)
						return false;
					//	Ricerco connettore
					String tipoClass = className.getThreshold(tipiThreshold.get(i));
					if(tipoClass == null){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.threshold.tipo'. \n La classe di Threshold indicata non esiste ["+tipiThreshold.get(i)+"] nelle classi registrate in OpenSPCoop");
						return false;
					}
					try{
						IThreshold t = (IThreshold) loaderOpenSPCoop.newInstance(tipoClass);
						t.toString();
					}catch(Exception e){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.threshold.tipo'. \n La classe di Threshold indicata non esiste ["+tipiThreshold.get(i)+"]: "+e.getMessage(),e);
						return false;
					}
				}
			}

			// Check validazioneSemantica: warning
			this.isValidazioneSemanticaRegistroServiziStartupXML();
			this.isValidazioneSemanticaConfigurazioneStartupXML();
			this.isValidazioneSemanticaRegistroServiziStartup();
			this.isValidazioneSemanticaConfigurazioneStartup();
			this.isValidazioneSemanticaRegistroServiziCheckURI();
			
			// Controllo risorse
			if( this.isAbilitatoControlloRisorseConfigurazione() ||
					this.isAbilitatoControlloValidazioneSemanticaConfigurazione() ||
					this.isAbilitatoControlloRisorseDB() ||
					this.isAbilitatoControlloRisorseJMS() ||
					this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati() || 
					this.isAbilitatoControlloRisorseRegistriServizi() ||
					this.isAbilitatoControlloValidazioneSemanticaRegistriServizi() ||
					this.isAbilitatoControlloRisorseTracciamentiPersonalizzati()){
				// CheckInterval 
				long intervalloCheck = this.getControlloRisorseCheckInterval();
				if(intervalloCheck<=0){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.risorse.checkInterval', valore non impostato/valido.");			
					return false;
				}
				// Warning
				this.isControlloRisorseRegistriRaggiungibilitaTotale();
				this.isControlloRisorseRegistrazioneEvento();
				if(this.isAbilitatoControlloRisorseDB()) {
					this.getNumeroIterazioniFalliteControlloRisorseDB();
					this.getIterazioniFalliteCheckIntervalControlloRisorseDB();
				}
				if(this.isAbilitatoControlloRisorseJMS()) {
					this.getNumeroIterazioniFalliteControlloRisorseJMS();
					this.getIterazioniFalliteCheckIntervalControlloRisorseJMS();
				}
				if(this.isAbilitatoControlloRisorseTracciamentiPersonalizzati()) {
					this.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati();
					this.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati();
				}
				if(this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati()) {
					this.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati();
					this.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati();
				}
				if(this.isAbilitatoControlloRisorseConfigurazione()) {
					this.getNumeroIterazioniFalliteControlloRisorseConfigurazione();
					this.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione();
				}
				if(this.isAbilitatoControlloRisorseRegistriServizi()) {
					this.getNumeroIterazioniFalliteControlloRisorseRegistriServizi();
					this.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi();
				}
			}


			// Tipo di Configurazione
			
			this.getConfigPreLoadingLocale();
			
			if (getTipoConfigurazionePDD() == null){		
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.config.tipo'. Proprieta' non impostata");
				return false;
			}
			if( (CostantiConfigurazione.CONFIGURAZIONE_XML.equalsIgnoreCase(getTipoConfigurazionePDD()) == false) &&
					(CostantiConfigurazione.CONFIGURAZIONE_DB.equalsIgnoreCase(getTipoConfigurazionePDD()) == false) ){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.config.tipo'. Tipo non Supportato");
				return false;
			}
			if( CostantiConfigurazione.CONFIGURAZIONE_DB.equalsIgnoreCase(getTipoConfigurazionePDD()) ){
				// Il tipo del DB e' obbligatorio.
				// Controllo che vi sia o
				// - come prefisso del datasource: tipoDatabase@datasource
				// - come tipo di database della porta di dominio.
				if(this.getPathConfigurazionePDD().indexOf("@")!=-1){
					// estrazione tipo database
					try{
						DBUtils.estraiTipoDatabaseFromLocation(this.getPathConfigurazionePDD());
					}catch(Exception e){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.config.location', mentre veniva analizzato il prefisso tipoDatabase@datasource: "+e.getMessage(),e);
						return false;
					}
				}else{
					if(this.getDatabaseType()==null){
						this.logError("La configurazione della porta di dominio di tipo ["+getTipoConfigurazionePDD()
								+"] richiede la definizione del tipo di database indicato o come prefisso della location (tipoDB@datasource) o attraverso la proprieta' 'org.openspcoop2.pdd.repository.tipoDatabase'");
					}
				}
			}


			// Location della configurazione
			if (getPathConfigurazionePDD() == null){		
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.config.location'. Proprieta' non impostata");
				return false;
			}
			if( CostantiConfigurazione.CONFIGURAZIONE_XML.equalsIgnoreCase(getTipoConfigurazionePDD()) ){

				String path = getPathConfigurazionePDD();
				if( (!path.startsWith("http://")) && (!path.startsWith("file://")) ){
					if( !(new File(path)).exists() ){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.config.location'. \n Il file indicato non esiste ["+path+"].");
						return false;
					}
				}else{
					// validazione url
					try{
						URL v  = new URL(path);
						v.toString();
					}catch(Exception e){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.config.location'. \n La url indicata non e' corretta ["+path+"].");
						return false;
					}
				}
			}
			else if( !CostantiConfigurazione.CONFIGURAZIONE_DB.equalsIgnoreCase(getTipoConfigurazionePDD())){		
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.config.tipo'. \n Tipo non supportato ["+getTipoConfigurazionePDD()+"].");
				return false;
			}

			// (warning)
			this.isConfigurazioneDinamica();
			this.isConfigurazioneCache_ConfigPrefill();
			this.isConfigurazioneCache_RegistryPrefill();
			this.isConfigurazioneCache_accessiSynchronized();
			this.isConfigurazioneCache_transactionContext_accessiSynchronized();
			
			this.getCacheTypeConfig();
			this.getCacheTypeRegistry();
			this.getCacheTypeAuthentication();
			this.getCacheTypeAuthorization();
			this.getCacheTypeResponseCaching();
			this.getCacheTypeToken();
			this.getCacheTypeAttributeAuthority();
			this.getCacheTypeKeystore();
			this.getCacheTypeLoadBalancer();
			this.getCacheTypeTrafficControl();
			this.getCacheTypeMessage();
			this.getCacheTypeRequestManager();
			
			this.isConfigurazioneCacheDebug();
			
			this.isConfigurazioneCacheRequestManagerUseCache();
			
			this.isConfigurazioneCacheRequestManagerExternalResourceSaveInCache();
			this.isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache();
			this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache();
			
			if(this.isConfigurazionePluginsEnabled()) {
				this.isConfigurazionePluginsDebug();
				this.getConfigurazionePluginsSeconds();
			}

			// DataSource
			if (getJNDIName_DataSource() == null){		
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.dataSource'. Proprieta' non impostata");
				return false;
			}
			if (getJNDIContext_DataSource() == null){		
				this.logError("Riscontrato errore durante la lettura della proprieta' del contesto JNDI per il datasource: 'org.openspcoop2.pdd.dataSource.property.*'. Proprieta' definite in maniera errata?");
				return false;
			}

			// Comunicazioni infrastrutturali
			if( this.getNodeReceiver()==null ){
				return false;
			}else{
				//	Ricerco connettore
				String tipoClass = className.getNodeReceiver(this.getNodeReceiver());
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.nodeReceiver'. \n Il node receiver indicato non esiste ["+this.getNodeReceiver()+"] nelle classi registrate in OpenSPCoop");
					return false;
				}
				try{
					INodeReceiver nodeReceiverTest = (INodeReceiver) loaderOpenSPCoop.newInstance(tipoClass);
					nodeReceiverTest.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.nodeReceiver'. \n Il node receiver indicato non esiste ["+this.getNodeReceiver()+"]: "+e.getMessage(),e);
					return false;
				}
			}
			// warning
			this.getNodeReceiverTimeout();
			this.getNodeReceiverTimeoutRicezioneContenutiApplicativi();
			this.getNodeReceiverTimeoutRicezioneBuste();
			this.getNodeReceiverCheckInterval();
			this.getNodeReceiverCheckDBInterval();
			this.singleConnection_NodeReceiver();

			if( this.getNodeSender()==null ){
				return false;
			}else{
				//	Ricerco connettore
				String tipoClass = className.getNodeSender(this.getNodeSender());
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.nodeSender'. \n Il node sender indicato non esiste ["+this.getNodeSender()+"] nelle classi registrate in OpenSPCoop");
					return false;
				}
				try{
					INodeSender nodeSenderTest = (INodeSender) loaderOpenSPCoop.newInstance(tipoClass);
					nodeSenderTest.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.nodeSender'. \n Il node sender indicato non esiste ["+this.getNodeSender()+"]: "+e.getMessage(),e);
					return false;
				}


				if(CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_DB.equals(this.getNodeSender())){
					if (getRepositoryJDBCAdapter() == null)	{	
						this.logError("Un JDBCAdapter deve essere definito in caso di NodeSender=db");
						return false;
					}
					//	Ricerco connettore
					String jdbcAdapter = this.getRepositoryJDBCAdapter();
					if(this.getDatabaseType()!=null && TipiDatabase.DEFAULT.equals(jdbcAdapter)){
						try{
							IJDBCAdapter adapter = JDBCAdapterFactory.createJDBCAdapter(OpenSPCoop2Properties.openspcoopProperties.getDatabaseType());
							adapter.toString();
						}catch(Exception e){
							this.logError(PREFIX_JDBC_ADAPTER_NOT_EXISTS+getRepositoryJDBCAdapter()+"]: "+e.getMessage(),e);
							return false;
						}
					}
					else{
						String adapterClass = className.getJDBCAdapter(jdbcAdapter);
						if(adapterClass == null){
							this.logError(PREFIX_JDBC_ADAPTER_NOT_EXISTS+getRepositoryJDBCAdapter()+"] nelle classi registrate in OpenSPCoop");
							return false;
						}
						try{
							IJDBCAdapter adapter = (IJDBCAdapter) loaderOpenSPCoop.newInstance(tipoClass);
							adapter.toString();
						}catch(Exception e){
							this.logError(PREFIX_JDBC_ADAPTER_NOT_EXISTS+getRepositoryJDBCAdapter()+"]: "+e.getMessage(),e);
							return false;
						}
					}
				}
			}

			
			// Servizi HTTP: warning
			isHttpDisableKeepAlive();
			isServiceRequestHttpMethodPatchEnabled();
			isServiceRequestHttpMethodLinkEnabled();
			isServiceRequestHttpMethodUnlinkEnabled();
			TransferLengthModes modeConsegna = this.getTransferLengthModes_consegnaContenutiApplicativi();
			if(TransferLengthModes.TRANSFER_ENCODING_CHUNKED.equals(modeConsegna)){
				this.getChunkLength_consegnaContenutiApplicativi();
			}
			TransferLengthModes modeInoltro = this.getTransferLengthModes_inoltroBuste();
			if(TransferLengthModes.TRANSFER_ENCODING_CHUNKED.equals(modeInoltro)){
				this.getChunkLength_inoltroBuste();
			}
			this.getTransferLengthModes_ricezioneBuste();
			this.getTransferLengthModes_ricezioneContenutiApplicativi();
			
			this.isFollowRedirects_consegnaContenutiApplicativi_soap();
			this.isFollowRedirects_consegnaContenutiApplicativi_rest();
			this.isFollowRedirects_inoltroBuste_soap();
			this.isFollowRedirects_inoltroBuste_rest();
			this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi();
			this.getFollowRedirectsMaxHop_inoltroBuste();
			this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi();
			this.isAcceptOnlyReturnCode_200_202_inoltroBuste();
			this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi();
			this.isAcceptOnlyReturnCode_307_inoltroBuste();
			
			this.checkSoapActionQuotedString_ricezioneContenutiApplicativi();
			this.checkSoapActionQuotedString_ricezioneBuste();
			
			this.isControlloContentTypeAbilitatoRicezioneContenutiApplicativi();
			this.isControlloContentTypeAbilitatoRicezioneBuste();
			this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap();
			this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest();
			this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap();
			this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest();
			this.isPrintInfoCertificate();
			
			if(this.isGestoreCredenzialiPortaDelegataEnabled()) {
				getGestoreCredenzialiPortaDelegataProperties();
			}
			if(this.isGestoreCredenzialiPortaApplicativaEnabled()) {
				getGestoreCredenzialiPortaApplicativaProperties();
			}
			
			this.getHSMConfig();
			this.isHSMConfigRequired();
			this.isHSMConfigUniqueProviderInstance();
			
			this.getOCSPConfig();
			this.isOCSPConfigRequired();
			this.isOCSPConfigLoadDefault();
			
			this.getBYOKConfig();
			this.isBYOKConfigRequired();
			
			this.getHttpUserAgent();
			this.getHttpServer();
			this.getHttpXPdDDetails();
			
			if(this.isEnabledEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi()){
				this.getCharsetEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi();
				this.getEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi();
			}
			if(this.isEnabledEncodingRFC2047HeaderValue_ricezioneBuste()){
				this.getCharsetEncodingRFC2047HeaderValue_ricezioneBuste();
				this.getEncodingRFC2047HeaderValue_ricezioneBuste();
			}
			if(this.isEnabledEncodingRFC2047HeaderValue_inoltroBuste()){
				this.getCharsetEncodingRFC2047HeaderValue_inoltroBuste();
				this.getEncodingRFC2047HeaderValue_inoltroBuste();
			}
			if(this.isEnabledEncodingRFC2047HeaderValue_consegnaContenutiApplicativi()){
				this.getCharsetEncodingRFC2047HeaderValue_consegnaContenutiApplicativi();
				this.getEncodingRFC2047HeaderValue_consegnaContenutiApplicativi();
			}
			
			this.isEnabledValidazioneRFC2047HeaderNameValue_ricezioneContenutiApplicativi();
			this.isEnabledValidazioneRFC2047HeaderNameValue_ricezioneBuste();
			this.isEnabledValidazioneRFC2047HeaderNameValue_inoltroBuste();
			this.isEnabledValidazioneRFC2047HeaderNameValue_consegnaContenutiApplicativi();
			
			this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi();
			this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi();
			this.getGestioneCORS_returnCode_ricezioneBuste();
			this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste();
			
			this. getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType();
			
			

			// ConnectionFactory
			if( CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(this.getNodeReceiver()) 
					|| CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(this.getNodeSender()) ){
				if (getJNDIName_ConnectionFactory() == null){		
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.queueConnectionFactory'. Proprieta' non impostata");
					return false;
				}
				if (getJNDIContext_ConnectionFactory() == null){		
					this.logError("Riscontrato errore durante la lettura della proprieta' del contesto JNDI del ConnectionFactory: 'org.openspcoop2.pdd.connectionFactory.property.*'. Proprieta' definite in maniera errata?");
					return false;
				}

				// Code Interne
				if(this.getJNDIQueueName( (CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(this.getNodeReceiver())),
						(CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(this.getNodeSender())))==null){
					// log stampato dentro il metodo
					return false;
				}
				if (getJNDIContext_CodeInterne() == null){		
					this.logError("Riscontrato errore durante la lettura della proprieta' del contesto JNDI delle code interne: 'org.openspcoop2.pdd.queue.property.*'. Proprieta' definite in maniera errata?");
					return false;
				}
				// warning
				this.getAcknowledgeModeSessioneConnectionFactory();

				// TransactionManager (Warning)
				this.getTransactionManager_AttesaAttiva();
				this.getTransactionManager_CheckDBInterval();
				this.getTransactionManager_CheckInterval();
				this.singleConnection_TransactionManager();
			}

			//	Timer EJB
			if(this.getJNDITimerEJBName()==null){
				// log stampato dentro il metodo
				return false;
			}
			if (getJNDIContext_TimerEJB() == null){		
				this.logError("Riscontrato errore durante la lettura della proprieta' del contesto JNDI delle code interne: 'org.openspcoop2.pdd.queue.property.*'. Proprieta' definite in maniera errata?");
				return false;
			}
			// warning
			this.getTimerEJBDeployTimeout();
			this.getTimerEJBDeployCheckInterval();
			this.isTimerAutoStart_StopTimer();
			
			this.isTimerGestoreRiscontriRicevuteAbilitato();
			this.isTimerGestoreRiscontriRicevuteAbilitatoLog();
			this.getTimerGestoreRiscontriRicevuteLimit();
			if(this.isTimerLockByDatabase()) {
				this.getTimerGestoreRiscontriRicevute_lockMaxLife();
				this.getTimerGestoreRiscontriRicevute_lockIdleTime();
			}
			this.getTimerGestoreRiscontriRicevute_getLockAttesaAttiva();
			this.getTimerGestoreRiscontriRicevute_getLockCheckInterval();
			
			this.isTimerGestoreMessaggiAbilitato();
			this.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata();
			this.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata();
			this.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata();
			this.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata();
			this.isTimerGestoreMessaggiAbilitatoOrderBy();
			this.isTimerGestoreMessaggiAbilitatoLog();
			this.getTimerGestoreMessaggiLimit();
			this.isTimerGestoreMessaggiVerificaConnessioniAttive();
			if(this.isTimerLockByDatabase()) {
				this.getTimerGestoreMessaggi_lockMaxLife();
				this.getTimerGestoreMessaggi_lockIdleTime();
			}
			this.getTimerGestoreMessaggi_getLockAttesaAttiva();
			this.getTimerGestoreMessaggi_getLockCheckInterval();
			
			this.isTimerGestorePuliziaMessaggiAnomaliAbilitato();
			this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy();
			this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog();
			this.getTimerGestorePuliziaMessaggiAnomaliLimit();
			if(this.isTimerLockByDatabase()) {
				this.getTimerGestorePuliziaMessaggiAnomali_lockMaxLife();
				this.getTimerGestorePuliziaMessaggiAnomali_lockIdleTime();
			}
			this.getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva();
			this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval();
			
			this.isTimerGestoreRepositoryBusteAbilitato();
			this.isTimerGestoreRepositoryBusteAbilitatoInitialState();
			this.isTimerGestoreRepositoryBusteAbilitatoOrderBy();
			this.isTimerGestoreRepositoryBusteAbilitatoLog();
			this.getTimerGestoreRepositoryBusteLimit();
			if(this.isTimerLockByDatabase()) {
				this.getTimerGestoreRepositoryBuste_lockMaxLife();
				this.getTimerGestoreRepositoryBuste_lockIdleTime();
			}
			this.getTimerGestoreRepositoryBuste_getLockAttesaAttiva();
			this.getTimerGestoreRepositoryBuste_getLockCheckInterval();
			
			this.isTimerConsegnaContenutiApplicativiAbilitato();
			this.isTimerConsegnaContenutiApplicativiSchedulingDebug();
			this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica();
			List<String> code = getTimerConsegnaContenutiApplicativiCode();
			if(code==null) {
				return false;
			}
			for (String coda : code) {
				ConfigurazioneCoda conf = getTimerConsegnaContenutiApplicativiConfigurazioneCoda(coda);
				if(conf==null) {
					return false;
				}
			}
			List<String> priorita = getTimerConsegnaContenutiApplicativiPriorita();
			if(priorita==null) {
				return false;
			}
			int sommaPercentuale = 0;
			for (int i = 0; i < priorita.size(); i++) {
				String prior = priorita.get(i);
				ConfigurazionePriorita conf = getTimerConsegnaContenutiApplicativiConfigurazionePriorita(prior);
				if(conf==null) {
					return false;
				}
				if(!conf.isNessunaPriorita()) {
					sommaPercentuale = sommaPercentuale + conf.getPercentuale();
				}
				if(i==(priorita.size()-1)) {
					if(!conf.isNessunaPriorita()) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.priorita.*': l'ultima priorità deve rappresentare 'nessuna priorita' e deve quindi avere un valore <=0 (trovato: "+conf.getPercentuale()+")");
						return false;
					}
				}
			}
			if(sommaPercentuale>100) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.priorita.*': la somma delle percentuali fornite non deve essere superiore a 100 (trovato: "+sommaPercentuale+")");
				return false;
			}
			this.isLoadBalancerDebug();
			if(this.isTimerLockByDatabase()) {
				this.getTimerConsegnaContenutiApplicativi_lockMaxLife();
				this.getTimerConsegnaContenutiApplicativi_lockIdleTime();
			}
			this.getTimerConsegnaContenutiApplicativi_presaInConsegnaMaxLife();
			this.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva();
			this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval();
			if(!isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager()){
				getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource();	
				getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSourceJndiContext();
				isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils();
			}
			if(!isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager()){
				getTimerConsegnaContenutiApplicativi_runtime_dataSource();	
				getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext();
				isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils();
			}
			if(!isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager()){
				getTimerConsegnaContenutiApplicativi_transazioni_dataSource();	
				getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext();
				isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils();
			}
				
			
			
			// Gestione Serializable DB (Warning)
			this.getGestioneSerializableDB_AttesaAttiva();
			this.getGestioneSerializableDB_CheckInterval();

			// GestioneErrore
			ProprietaErroreApplicativo paError = getProprietaGestioneErrorePD_engine(null,true);
			if( paError == null  ){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.erroreApplicativo'.");
				return false;
			}
			getLocaleSOAPFaultString();
			
			// Errori http
			getErroriHttpHeaderGovWayStatus();
			getErroriHttpHeaderGovWayType();
			getErroriHttpHeaderGovWayCode();
			
			// Errori soap
			this.isErroriSoapUseGovWayStatusAsFaultCode();
			this.isErroriSoapHttpHeaderGovWayCodeEnabled();
			
			// Errori			
			this.isErroriGovWayStatusEnabled();
			this.isErroriGovWayInstanceEnabled();
			this.isErroriGovWayForceSpecificDetails();
			this.isErroriGovWayFaultDetailsWithProblemRFC7807();
			
			// Problem RFC 7807
			this.isProblemRFC7807_enrichTitleAsGovWayType();
			this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode();
			this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim();
			this.getProblemRFC7807_transactionId_claim();
			this.getProblemRFC7807_code_claim();
			this.getProblemRFC7807_type_claim();

			// IdentitaPdD
			if( this.getIdentitaPortaDefault() == null  ){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.identificativoPorta'.");
				return false;
			}
			/**
			 * Controllo spostato sotto, in attesa che venga inizializzato il ProtocolFactoryManager
			Enumeration<String> protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
			while (protocolli.hasMoreElements()) {
				String protocollo = (String) protocolli.nextElement();
				getIdentitaPortaDefault(protocollo, null);
			}	
			*/		

			// Check tipi di default: urlBased, trasporto, soap
			List<String> headerDefault = new ArrayList<>();
			headerDefault.add(CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED);
			headerDefault.add(CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO);
			headerDefault.add(CostantiConfigurazione.HEADER_INTEGRAZIONE_SOAP);	
			if(!checkTipiIntegrazione(headerDefault.toArray(new String[1])))
				return false;
			
			// Integrazione tra Servizi Applicativi e GovWay
			if ( this.getTipoIntegrazionePD() == null ){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pd'. Almeno un tipo di integrazione e' obbligatorio.");
				return false;
			}else{
				String[] tipiIntegrazionePD = this.getTipoIntegrazionePD();

				// Check tipi registrati
				for(int i=0; i<tipiIntegrazionePD.length;i++){
					String tipoClass = className.getIntegrazionePortaDelegata(tipiIntegrazionePD[i]);
					if(tipoClass == null){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pd="+tipiIntegrazionePD[i]+
								"'"+"\n"+HEADER_INTEGRAZIONE_SCONOSCIUTO);
						return false;
					}
					try{
						IGestoreIntegrazionePD gestore = (IGestoreIntegrazionePD) loaderOpenSPCoop.newInstance(tipoClass);
						if(gestore==null){
							throw new CoreException(OGGETTO_NEW_INSTANCE_NON_CREATO);
						}
						gestore.toString();
					}catch(Exception e){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pd="+tipiIntegrazionePD[i]+"' (classe:"+tipoClass+"). \n Errore avvenuto: "+e.getMessage(),e);
						return false;
					}
				}

				if(checkTipiIntegrazione(tipiIntegrazionePD)==false)
					return false;
			}
			
			Properties integrazioneProtocolPD = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pd.");
			Enumeration<?> keys = integrazioneProtocolPD.keys();
			while (keys.hasMoreElements()) {
				String protocollo = (String) keys.nextElement();
				
				if(this.getTipoIntegrazionePD(protocollo)!=null){
					
					String[] tipiIntegrazionePDprotocollo = this.getTipoIntegrazionePD(protocollo);

					// Check tipi registrati
					for(int i=0; i<tipiIntegrazionePDprotocollo.length;i++){
						String tipoClass = className.getIntegrazionePortaDelegata(tipiIntegrazionePDprotocollo[i]);
						if(tipoClass == null){
							this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pd."+protocollo+"="+tipiIntegrazionePDprotocollo[i]+
									"'"+"\n"+HEADER_INTEGRAZIONE_SCONOSCIUTO);
							return false;
						}
						try{
							IGestoreIntegrazionePD gestore = (IGestoreIntegrazionePD) loaderOpenSPCoop.newInstance(tipoClass);
							if(gestore==null){
								throw new CoreException(OGGETTO_NEW_INSTANCE_NON_CREATO);
							}
							gestore.toString();
						}catch(Exception e){
							this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pd."+protocollo+"="+tipiIntegrazionePDprotocollo[i]+"' (classe:"+tipoClass+"). \n Errore avvenuto: "+e.getMessage(),e);
							return false;
						}
					}

					if(!checkTipiIntegrazione(tipiIntegrazionePDprotocollo))
						return false;
				}
			}

			// Integrazione tra GovWay e Servizi Applicativi
			if ( this.getTipoIntegrazionePA() == null ){
				String[] tipiIntegrazionePA = this.getTipoIntegrazionePA();

				// Check tipi registrati
				for(int i=0; i<tipiIntegrazionePA.length;i++){
					String tipoClass = className.getIntegrazionePortaApplicativa(tipiIntegrazionePA[i]);
					if(tipoClass == null){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pa="+tipiIntegrazionePA[i]+
								"'"+"\n"+HEADER_INTEGRAZIONE_SCONOSCIUTO);
						return false;
					}
					try{
						IGestoreIntegrazionePA gestore = (IGestoreIntegrazionePA) loaderOpenSPCoop.newInstance(tipoClass);
						if(gestore==null){
							throw new CoreException(OGGETTO_NEW_INSTANCE_NON_CREATO);
						}
						gestore.toString();
					}catch(Exception e){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pa="+tipiIntegrazionePA[i]+"' (classe:"+tipoClass+"). \n Errore avvenuto: "+e.getMessage(),e);
						return false;
					}
				}

				if(checkTipiIntegrazione(tipiIntegrazionePA)==false)
					return false;
			}
			
			Properties integrazioneProtocolPA = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pa.");
			keys = integrazioneProtocolPA.keys();
			while (keys.hasMoreElements()) {
				String protocollo = (String) keys.nextElement();
				
				if(this.getTipoIntegrazionePA(protocollo)!=null){
					
					String[] tipiIntegrazionePAprotocollo = this.getTipoIntegrazionePA(protocollo);

					// Check tipi registrati
					for(int i=0; i<tipiIntegrazionePAprotocollo.length;i++){
						String tipoClass = className.getIntegrazionePortaApplicativa(tipiIntegrazionePAprotocollo[i]);
						if(tipoClass == null){
							this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pa."+protocollo+"="+tipiIntegrazionePAprotocollo[i]+
									"'"+"\n"+HEADER_INTEGRAZIONE_SCONOSCIUTO);
							return false;
						}
						try{
							IGestoreIntegrazionePA gestore = (IGestoreIntegrazionePA) loaderOpenSPCoop.newInstance(tipoClass);
							if(gestore==null){
								throw new CoreException(OGGETTO_NEW_INSTANCE_NON_CREATO);
							}
							gestore.toString();
						}catch(Exception e){
							this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pa."+protocollo+"="+tipiIntegrazionePAprotocollo[i]+"' (classe:"+tipoClass+"). \n Errore avvenuto: "+e.getMessage(),e);
							return false;
						}
					}

					if(!checkTipiIntegrazione(tipiIntegrazionePAprotocollo))
						return false;
				}
			}
			
			// Integrazione Dynamic Info
			this.isIntegrazioneDynamicInfoEnabled();
			if(this.getIntegrazioneDynamicInfoType()==null) {
				return false;
			}
			if(this.getIntegrazioneDynamicInfoName()==null) {
				return false;
			}
			if(this.getIntegrazioneDynamicInfoEncodeType()==null) {
				return false;
			}
			this.isIntegrazioneDynamicInfoRequired();
			
			// Integrazione Response Dynamic Info
			this.isIntegrazioneResponseDynamicInfoEnabled();
			if(this.getIntegrazioneResponseDynamicInfoName()==null) {
				return false;
			}
			if(this.getIntegrazioneResponseDynamicInfoEncodeType()==null) {
				return false;
			}
			this.isIntegrazioneResponseDynamicInfoRequired();
			
			// Integrazione Template
			if(this.getIntegrazioneTemplateRequestPropertyTipo()==null) {
				return false;
			}
			if(this.getIntegrazioneTemplateRequestPropertyFile()==null) {
				return false;
			}
			if(this.getIntegrazioneTemplateResponsePropertyTipo()==null) {
				return false;
			}
			if(this.getIntegrazioneTemplateResponsePropertyFile()==null) {
				return false;
			}
			getIntegrazioneTemplatePortaDelegataRequestTipo();
			getIntegrazioneTemplatePortaDelegataRequestFile();
			getIntegrazioneTemplatePortaDelegataResponseTipo();
			getIntegrazioneTemplatePortaDelegataResponseFile();
			getIntegrazioneTemplatePortaApplicativaRequestTipo();
			getIntegrazioneTemplatePortaApplicativaRequestFile();
			getIntegrazioneTemplatePortaApplicativaResponseTipo();
			getIntegrazioneTemplatePortaApplicativaResponseFile();
			
			getIntegrazioneAutenticazionePortaDelegataRequestHeaders();
			getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap();
			getIntegrazioneAutenticazionePortaApplicativaRequestHeaders();
			getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap();
			if(this.getIntegrazioneAutenticazionePropertyHeaders()==null) {
				return false;
			}
			if(this.getIntegrazioneAutenticazionePropertyHeaderPrefix()==null) {
				return false;
			}			
			
			// Warning
			this.isIntegrazioneAsincroniConIdCollaborazioneEnabled();
			this.getNewOldMapping_backward_compatibility_trasparente_soggetto();
			this.getNewOldMapping_backward_compatibility_trasparente_servizio();
			this.getNewOldMapping_backward_compatibility_spcoop_soggetto();
			this.getNewOldMapping_backward_compatibility_spcoop_servizio();
			this.getNewOldMapping_backward_compatibility_sdi_soggetto();
			this.getNewOldMapping_backward_compatibility_sdi_servizio();
			this.getHeaderIntegrazioneSOAPPdDVersione();
			this.getHeaderIntegrazioneSOAPPdDDetails();
			this.deleteHeaderIntegrazioneRequestPD();
			this.deleteHeaderIntegrazioneResponsePD();
			this.processHeaderIntegrazionePDResponse(false);
			this.deleteHeaderIntegrazioneRequestPA();
			this.deleteHeaderIntegrazioneResponsePA();
			this.processHeaderIntegrazionePARequest(false);

			//	TipoAutorizzazioneBuste
			String tipoNonEsistente = "tipoNonEsistente";
			getAutorizzazioneLockPermits();
			getAutorizzazioneLockPermits(tipoNonEsistente);
			if( this.getTipoAutorizzazioneBuste()==null ){
				return false;
			}else{
				if(!CostantiConfigurazione.AUTORIZZAZIONE_NONE.equals(this.getTipoAutorizzazioneBuste())){
					//	Ricerco connettore
					String tipoClass = className.getAutorizzazionePortaApplicativa(this.getTipoAutorizzazioneBuste());
					if(tipoClass == null){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.autorizzazioneBuste'. \n L'autorizzazione delle buste indicata non esiste ["+this.getTipoAutorizzazioneBuste()+"] nelle classi registrate in OpenSPCoop");
						return false;
					}
					try{
						IAutorizzazionePortaApplicativa auth = (IAutorizzazionePortaApplicativa) loaderOpenSPCoop.newInstance(tipoClass);
						auth.toString();
					}catch(Exception e){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.autorizzazioneBuste'. \n L'autorizzazione delle buste indicata non esiste ["+this.getTipoAutorizzazioneBuste()+"]: "+e.getMessage(),e);
						return false;
					}
				}
			}
			isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta();
			
			//	TipoAutorizzazioneContenuti
			getAutorizzazioneContenutiLockPermits();
			getAutorizzazioneContenutiLockPermits(tipoNonEsistente);

			// ByPass
			// Controllo spostato sotto, in attesa che venga inizializzato il ProtocolFactoryManager
			/**protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
			while (protocolli.hasMoreElements()) {
				String protocollo = (String) protocolli.nextElement();
				getBypassFilterMustUnderstandProperties(protocollo);
			}*/
			
			// GestoreRepositoryBuste
			if( this.getGestoreRepositoryBuste() == null  ){
				return false;
			}else{
				//	Ricerco
				if(this.getDatabaseType()!=null){
					try{
						IGestoreRepository repository = GestoreRepositoryFactory.createRepositoryBuste(this.getDatabaseType());
						repository.toString();
					}catch(Exception e){
						this.logError("Riscontrato errore durante l'inizializzazione del gestore del repository buste associato dalla factory al tipo di database ["+this.getDatabaseType()+"]: "+e.getMessage(),e);
						return false;
					}
				}
				else{
					String tipoClass = className.getRepositoryBuste(this.getGestoreRepositoryBuste());
					if(tipoClass == null){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.repositoryBuste'. \n Il gestore del repository buste indicato non esiste ["+this.getGestoreRepositoryBuste()+"] nelle classi registrate in OpenSPCoop");
						return false;
					}
					try{
						IGestoreRepository repository = (IGestoreRepository) loaderOpenSPCoop.newInstance(tipoClass);
						repository.toString();
					}catch(Exception e){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.repositoryBuste'. \n Il gestore del repository buste indicato non esiste ["+this.getGestoreRepositoryBuste()+"]: "+e.getMessage(),e);
						return false;
					}
				}
			}

			// Filtro duplicati (warning)
			// Ricerco
			String tipoClassFiltroDuplicati = className.getFiltroDuplicati(this.getGestoreFiltroDuplicatiRepositoryBuste());
			if(tipoClassFiltroDuplicati == null){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.protocol.filtroDuplicati'. \n Il gestore filtro duplicati del repository buste indicato non esiste ["+this.getGestoreFiltroDuplicatiRepositoryBuste()+"] nelle classi registrate in OpenSPCoop");
				return false;
			}
			try{
				IFiltroDuplicati duplicati = (IFiltroDuplicati) loaderOpenSPCoop.newInstance(tipoClassFiltroDuplicati);
				duplicati.toString();
			}catch(Exception e){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.protocol.filtroDuplicati'. \n Il gestore filtro duplicati del repository buste indicato non esiste ["+this.getGestoreFiltroDuplicatiRepositoryBuste()+"]: "+e.getMessage(),e);
				return false;
			}
			
			// SQLQueryObject
			if(this.getDatabaseType()!=null){
				if ( ! TipiDatabase.isAMember(this.getDatabaseType())){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.tipoDatabase', tipo di database non gestito");
					return false;
				}
				// Ricerco
				String tipoClass = className.getSQLQueryObject(this.getDatabaseType());
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.tipoDatabase'. \n L'oggetto SQLQuery indicato non esiste ["+this.getDatabaseType()+"] nelle classi registrate in OpenSPCoop");
					return false;
				}
				try{
					ISQLQueryObject sqlQuery = (ISQLQueryObject) loaderOpenSPCoop.newInstance(tipoClass,TipiDatabase.DEFAULT);
					sqlQuery.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.tipoDatabase'. \n L'oggetto SQLQuery indicato non esiste ["+this.getDatabaseType()+"]: "+e.getMessage(),e);
					return false;
				}
			}

			// Connettore (Warning)
			if(this.isConnettoriUseLimitedInputStream()) {
				this.getLimitedInputStreamThresholdKb();
			}
			this.isConnettoriUseTimeoutInputStream();
			this.getConnectionTimeout_consegnaContenutiApplicativi();
			this.getConnectionTimeout_inoltroBuste();
			this.getReadConnectionTimeout_consegnaContenutiApplicativi();
			this.getReadConnectionTimeout_inoltroBuste();
			this.getConnectionLife_consegnaContenutiApplicativi();
			this.getConnectionLife_inoltroBuste();
			this.getReadConnectionTimeout_ricezioneContenutiApplicativi();
			this.getReadConnectionTimeout_ricezioneBuste();
			
			this.isConnettoriUseDiagnosticInputStream_inoltroBuste();
			this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi();
			this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi();
			this.isConnettoriUseDiagnosticInputStream_ricezioneBuste();
			this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream();
			
			// Connettore https
			this.getConnettoreHttps_secureRandomAlgo();
			this.isConnettoreHttps_useSecureRandom();
			
			// Connettore http (url https)
			if(this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste()) {
				this.getConnettoreHttp_urlHttps_repository_inoltroBuste();
			}
			if(this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi()) {
				this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi();
			}
			if(this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste() ||
					this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi()) {
				if(this.isConnettoreHttp_urlHttps_cacheEnabled()) {
					this.getConnettoreHttp_urlHttps_cacheSize();
				}
			}

			// Contatore esponenziale per consegna
			if(this.isRitardoConsegnaAbilitato()){
				if( this.getRitardoConsegnaEsponenziale() <= 0 ){
					return false;
				}else if(this.getRitardoConsegnaEsponenziale() > 0){
					try{
						this.isRitardoConsegnaEsponenzialeConMoltiplicazione();
					}catch(Exception e){
						return false;
					}
					if( this.getRitardoConsegnaEsponenzialeLimite() <= 0 ){
						return false;
					}
				}
			}

			// Cache per gestore Messaggi
			try{
				if(this.isAbilitataCacheGestoreMessaggi()){
					String algoritmo = this.getAlgoritmoCacheGestoreMessaggi();
					if(algoritmo!=null &&
							!CostantiConfigurazione.CACHE_LRU.equals(algoritmo) && 
							!CostantiConfigurazione.CACHE_MRU.equals(algoritmo)){
						this.logError("Algoritmo utilizzato con la cache (Gestore Messaggi) non conosciuto: "+algoritmo);
						throw new CoreException("Algoritmo Cache (Gestore Messaggi) non conosciuto");
					}
					this.getDimensioneCacheGestoreMessaggi();
					this.getItemIdleTimeCacheGestoreMessaggi();
					this.getItemLifeSecondCacheGestoreMessaggi();
				}
			}catch(Exception e){
				// Il motivo dell'errore viene loggato dentro i metodi
				return false;
			}

			// Gestione JMX
			this.isRisorseJMXAbilitate();
			this.getJNDIName_MBeanServer();
			this.getJNDIContext_MBeanServer();

			// DateManager
			if(this.getTipoDateManager()==null)
				return false;
			if(getTipoDateTimeFormat()==null) {
				return false;
			}
			String tipoDateManger = className.getDateManager(this.getTipoDateManager());
			if(tipoDateManger == null){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.date.tipo'. \n Il DateManager indicato non esiste ["+this.getTipoDateManager()+"] nelle classi registrate in OpenSPCoop");
				return false;
			}
			try{
				IDate date = (IDate) loaderOpenSPCoop.newInstance(tipoDateManger);
				date.toString();
			}catch(Exception e){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.date.tipo'. \n Il DateManager indicato non esiste ["+this.getTipoDateManager()+"]: "+e.getMessage(),e);
				return false;
			}
			if (this.getDateManagerProperties() == null){		
				this.logError("Riscontrato errore durante la lettura della proprieta' del DataManager: 'org.openspcoop2.pdd.date.property.*'. Proprieta' definite in maniera errata?");
				return false;
			}
			// Warning
			this.getTipoTempoBusta(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);

			// IntegrationManager
			if(this.isIntegrationManagerEnabled()) {
				this.isIntegrationManagerIdWithDate();
				this.getIntegrationManagerIdsLimit();
			}
			// IntegrationManager (Warning)
			this.integrationManager_readInformazioniTrasporto();
			this.integrationManager_isNomePortaDelegataUrlBased();
			if(this.isIntegrationManagerEnabled()) {
				if(!isIntegrationManager_runtime_useRuntimeManager() && !isIntegrationManager_runtime_useConsegnePreseInCaricoManager()){
					getIntegrationManager_runtime_dataSource();	
					getIntegrationManager_runtime_dataSourceJndiContext();
					isIntegrationManager_runtime_dataSource_useDBUtils();
				}
				if(!isIntegrationManager_transazioni_useTransactionManager() && !isIntegrationManager_transazioni_useConsegnePreseInCaricoManager()){
					getIntegrationManager_transazioni_dataSource();	
					getIntegrationManager_transazioni_dataSourceJndiContext();
					isIntegrationManager_transazioni_dataSource_useDBUtils();
				}
			}

			// Gestione Attachments (Warning)
			this.isDeleteInstructionTargetMachineXml();
			this.isTunnelSOAP_loadMailcap();
			this.getTunnelSOAPKeyWord_headerTrasporto();
			this.getTunnelSOAPKeyWordMimeType_headerTrasporto();
			this.getTunnelSOAPKeyWord_urlBased();
			this.getTunnelSOAPKeyWordMimeType_urlBased();

			// MustUnderstandHandler (warning)
			this.isBypassFilterMustUnderstandEnabledForAllHeaders();

			// Autenticazione
			this.getAutenticazioneLockPermits();
			this.getAutenticazioneLockPermits(tipoNonEsistente);
			this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed();
			if(this.getCryptConfigAutenticazioneApplicativi()==null) {
				return false;
			}
			if(this.getCryptConfigAutenticazioneSoggetti()==null) {
				return false;
			}
			
			this.isAutenticazioneBasicLogPassword();
			this.getRealmAutenticazioneBasicWWWAuthenticateConfig();
			
			this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig();
			
			this.isAutenticazioneHttpsPortaDelegataValidityCheck();
			if(this.getAutenticazioneHttpsPortaDelegataTruststorePath()!=null) {
				this.getAutenticazioneHttpsPortaDelegataTruststoreType();
				this.getAutenticazioneHttpsPortaDelegataTruststorePassword();
				this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs();
				this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy();
			}
			this.isAutenticazioneHttpsPortaApplicativaValidityCheck();
			if(this.getAutenticazioneHttpsPortaApplicativaTruststorePath()!=null) {
				this.getAutenticazioneHttpsPortaApplicativaTruststoreType();
				this.getAutenticazioneHttpsPortaApplicativaTruststorePassword();
				this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs();
				this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy();
			}
			this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari();
			this.getRealmAutenticazioneHttpsWWWAuthenticateConfig();
			
			this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari();
			TipoAutenticazionePrincipal [] tipiPrincipale = TipoAutenticazionePrincipal.values();
			for (TipoAutenticazionePrincipal tipoAutenticazionePrincipal : tipiPrincipale) {
				this.getRealmAutenticazionePrincipalWWWAuthenticateConfig(tipoAutenticazionePrincipal);	
			}
			
			this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari();
			
			// Gestori Credenziali PD
			String [] gestoriCredenzialiPD = this.getTipoGestoreCredenzialiPD();
			if(gestoriCredenzialiPD!=null){
				for(int i=0; i<gestoriCredenzialiPD.length;i++){
					//	Ricerco
					String tipoClass = className.getGestoreCredenziali(gestoriCredenzialiPD[i]);
					if(tipoClass == null){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.services.pd.gestoriCredenziali'. \n La classe del GestoreCredenziali indicata non esiste ["+gestoriCredenzialiPD[i]+"] nelle classi registrate in OpenSPCoop");
						return false;
					}
					try{
						IGestoreCredenziali g = (IGestoreCredenziali) loaderOpenSPCoop.newInstance(tipoClass);
						g.toString();
					}catch(Exception e){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.services.pd.gestoriCredenziali'. \n La classe del GestoreCredenziali indicata non esiste ["+gestoriCredenzialiPD[i]+"]: "+e.getMessage(),e);
						return false;
					}
				}
			}
			
			// Gestori Credenziali PA
			String [] gestoriCredenzialiPA = this.getTipoGestoreCredenzialiPA();
			if(gestoriCredenzialiPA!=null){
				for(int i=0; i<gestoriCredenzialiPA.length;i++){
					//	Ricerco
					String tipoClass = className.getGestoreCredenziali(gestoriCredenzialiPA[i]);
					if(tipoClass == null){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.services.pa.gestoriCredenziali'. \n La classe del GestoreCredenziali indicata non esiste ["+gestoriCredenzialiPA[i]+"] nelle classi registrate in OpenSPCoop");
						return false;
					}
					try{
						IGestoreCredenziali g = (IGestoreCredenziali) loaderOpenSPCoop.newInstance(tipoClass);
						g.toString();
					}catch(Exception e){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.services.pa.gestoriCredenziali'. \n La classe del GestoreCredenziali indicata non esiste ["+gestoriCredenzialiPA[i]+"]: "+e.getMessage(),e);
						return false;
					}
				}
			}
			
			// Gestori Credenziali IntegrationManager
			String [] gestoriCredenzialiIM = this.getTipoGestoreCredenzialiIM();
			if(gestoriCredenzialiIM!=null){
				for(int i=0; i<gestoriCredenzialiIM.length;i++){
					//	Ricerco
					String tipoClass = className.getGestoreCredenzialiIM(gestoriCredenzialiIM[i]);
					if(tipoClass == null){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.services.integrationManager.gestoriCredenziali'. \n La classe del GestoreCredenziali indicata non esiste ["+gestoriCredenzialiIM[i]+"] nelle classi registrate in OpenSPCoop");
						return false;
					}
					try{
						IGestoreCredenzialiIM g = (IGestoreCredenzialiIM) loaderOpenSPCoop.newInstance(tipoClass);
						g.toString();
					}catch(Exception e){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.services.integrationManager.gestoriCredenziali'. \n La classe del GestoreCredenziali indicata non esiste ["+gestoriCredenzialiIM[i]+"]: "+e.getMessage(),e);
						return false;
					}
				}
			}
			
			// warning Risposta Asincrona
			this.getTimeoutBustaRispostaAsincrona();
			this.getCheckIntervalBustaRispostaAsincrona();

			// Configurazione Cluster
			this.getClusterId(false);
			this.getClusterIdNumerico();
			if(this.isClusterDinamico()) {
				if(this.getClusterId(true)==null) {
					return false;
				}
				this.getClusterDinamicoRefreshSecondsInterval();
				this.getClusterHostname();
				if(this.getGroupId(false)==null) {
					return false;
				}
				if(this.getClusterDinamicoIdNumericoCifre(false)<0) {
					return false;
				}
				this.isUseHashClusterId();
			}
			if(this.isTimerLockByDatabase()) {
				this.isTimerLockByDatabaseNotifyLogEnabled();
			}
			this.getPddContextSerializer();
			
			// Warning
			this.isGenerazioneAttributiAsincroni(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
			this.isGenerazioneListaTrasmissioni(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
			this.isGenerazioneErroreProtocolloFiltroDuplicati(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
			this.isCheckFromRegistroFiltroDuplicatiAbilitato(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
			this.isCheckFromRegistroConfermaRicezioneAbilitato(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
			this.isCheckFromRegistroConsegnaInOrdineAbilitato(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
			this.isGestioneConsegnaInOrdine(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
			this.isGestioneElementoCollaborazione(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
			this.isGestioneRiscontri(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
			this.ignoraEccezioniNonGravi_Validazione();
			this.isForceSoapPrefixCompatibilitaOpenSPCoopV1();
			this.isReadQualifiedAttribute(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
			this.isValidazioneIDBustaCompleta(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);

			// Stateless
			if(this.getStatelessOneWay()==null)
				return false;
			if(this.getStatelessSincrono()==null)
				return false;
			if(this.getStatelessAsincroni()==null)
				return false;
			if(this.getStatelessRouting()==null)
				return false;

			// Warning
			this.isGestioneOnewayStateful_1_1();
			this.isRinegoziamentoConnessione();

			// Handlers
			this.isMergeHandlerBuiltInAndHandlerUser();
			
			// Handlers BuiltIn
			this.isPrintInfoHandlerBuiltIn();
			if(this.validateHandlersBuiltInEngine(className, loaderOpenSPCoop)==false) {
				return false;
			}
			
			// Handlers
			this.isPrintInfoHandler();
			if(this.validateHandlersEngine(className, loaderOpenSPCoop)==false) {
				return false;
			}
			
			// MessageSecurity
			this.isLoadApacheXMLDSig();
			this.isLoadBouncyCastle();
			this.getBouncyCastleSecureRandomAlgorithm();
			this.isUseBouncyCastleProviderForCertificate();
			this.isUseBouncyCastleProviderForMessageDigest();
			this.isUseBouncyCastleProviderForWss4jCryptoMerlin();
			this.getSecurityEgd();
			this.isGenerazioneActorDefault(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
			this.getActorDefault(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
			this.getPrefixWsuId();
			this.getWsuIdSecureRandomAlgorithm();
			this.getExternalPWCallbackPropertyFile();
			this.isAbilitataCacheMessageSecurityKeystore();
			this.getDimensioneCacheMessageSecurityKeystore();
			this.getItemLifeSecondCacheMessageSecurityKeystore();

			// Accesso registro servizi
			this.isReadObjectStatoBozza();
			
			// Tracce
			this.isTracciaturaFallita_BloccaCooperazioneInCorso();
			this.isTracciaturaFallita_BloccoServiziPdD();
			
			// Diagnostici
			this.isRegistrazioneDiagnosticaFile_intestazione_formatValues();
			this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD();
			this.isLoggerSaajDisabilitato();
			
			// Dump
			this.getDumpBufferImpl();
			this.isDumpAllAttachments();
			this.isDumpFallitoBloccaCooperazioneInCorso();
			this.isDumpFallitoBloccoServiziPdD();
			
			this.getDumpHeaderWhiteList();
			this.getDumpHeaderBlackList();
			
			this.getDumpHeaderErogazioniWhiteList();
			this.getDumpHeaderErogazioniBlackList();
			this.getDumpHeaderFruizioniWhiteList();
			this.getDumpHeaderFruizioniBlackList();
			
			this.getDumpHeaderErogazioniRichiestaIngressoWhiteList();
			this.getDumpHeaderErogazioniRichiestaIngressoBlackList();
			this.getDumpHeaderErogazioniRichiestaUscitaWhiteList();
			this.getDumpHeaderErogazioniRichiestaUscitaBlackList();
			this.getDumpHeaderErogazioniRispostaIngressoWhiteList();
			this.getDumpHeaderErogazioniRispostaIngressoBlackList();
			this.getDumpHeaderErogazioniRispostaUscitaWhiteList();
			this.getDumpHeaderErogazioniRispostaUscitaBlackList();
			
			this.getDumpHeaderFruizioniRichiestaIngressoWhiteList();
			this.getDumpHeaderFruizioniRichiestaIngressoBlackList();
			this.getDumpHeaderFruizioniRichiestaUscitaWhiteList();
			this.getDumpHeaderFruizioniRichiestaUscitaBlackList();
			this.getDumpHeaderFruizioniRispostaIngressoWhiteList();
			this.getDumpHeaderFruizioniRispostaIngressoBlackList();
			this.getDumpHeaderFruizioniRispostaUscitaWhiteList();
			this.getDumpHeaderFruizioniRispostaUscitaBlackList();
			
			this.isDumpEmitDiagnostic();
			
			// DumpBinario
			this.isDumpBinarioRegistrazioneDatabase();
			this.getDumpBinarioInMemoryThreshold();
			this.getDumpBinarioRepository();

			// DumpNotRealtime
			this.getDumpNonRealtimeInMemoryThreshold();
			this.getDumpNonRealtimeMode();
			if(this.isDumpNonRealtimeFileSystemMode()) {
				this.getDumpNonRealtimeRepository();
			}
			this.isDumpNonRealtimeThrowStreamingHandlerException();
			
			// Generatore di ID
			String tipoIDGenerator = this.getTipoIDManager();
			if(CostantiConfigurazione.NONE.equals(tipoIDGenerator)==false){
				String tipoIdManger = className.getUniqueIdentifier(tipoIDGenerator);
				if(tipoIdManger == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.idGenerator'. \n Il generatore di unique identifier indicato non esiste ["+this.getTipoIDManager()+"] nelle classi registrate in OpenSPCoop");
					return false;
				}
				useIDManagerWithThreadLocal();
				getIDManagerParameters();
				getIDManagerBufferSize();
				try{
					IUniqueIdentifierGenerator uniqueIdentifier = (IUniqueIdentifierGenerator) loaderOpenSPCoop.newInstance(tipoIdManger);
					uniqueIdentifier.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.idGenerator'. \n Il generatore di unique identifier non esiste ["+this.getTipoIDManager()+"]: "+e.getMessage(),e);
					return false;
				}
			}
			
			// InitOpenSPCoop2MessageFactory
			if ( this.getOpenspcoop2MessageFactory() != null ){
				String tipo = this.getOpenspcoop2MessageFactory();
				// Check tipi registrati
				String tipoClass = className.getOpenSPCoop2MessageFactory(tipo);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.messagefactory'=...,"+tipo+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					OpenSPCoop2MessageFactory test = (OpenSPCoop2MessageFactory) loaderOpenSPCoop.newInstance(tipoClass);
					test.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.messagefactory'=...,"+tipoClass+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				} 
			}
			
			// InitOpenSPCoop2MessageFactory
			if ( this.getMessageSecurityContext() != null ){
				String tipo = this.getMessageSecurityContext();
				// Check tipi registrati
				String tipoClass = className.getMessageSecurityContext(tipo);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.messageSecurity.context'=...,"+tipo+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					MessageSecurityContext test = (MessageSecurityContext) loaderOpenSPCoop.newInstance(tipoClass);
					test.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.messageSecurity.context'=...,"+tipoClass+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				} 
			}
			if ( this.getMessageSecurityDigestReader() != null ){
				String tipo = this.getMessageSecurityDigestReader();
				// Check tipi registrati
				String tipoClass = className.getMessageSecurityDigestReader(tipo);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.messageSecurity.digestReader'=...,"+tipo+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					IDigestReader test = (IDigestReader) loaderOpenSPCoop.newInstance(tipoClass);
					test.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.messageSecurity.digestReader'=...,"+tipoClass+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				} 
			}
			
			// test warning
			isPrintInfoFactory();
			isPrintInfoMessageSecurity();
			
			// FreeMemoryLog
			this.getFreeMemoryLog();
			
			// DefaultProtocol
			this.getDefaultProtocolName();
						
			// SoggettiVirtuali
			this.isSoggettiVirtualiEnabled();
			
			// Informazioni generazione errori
			this.isGenerazioneErroreProtocolloNonSupportato();
			this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled();
			this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled();
			this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled();
			this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled();
			this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled();
			this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled();
			
			// Informazioni generazione WSDL
			this.isGenerazioneWsdlPortaDelegataEnabled();
			this.isGenerazioneWsdlPortaApplicativaEnabled();
			this.isGenerazioneWsdlIntegrationManagerEnabled();
			
			// Check
			if(this.isCheckEnabled()) {
				if(this.isCheckHealthCheckApiRestEnabled() &&
					this.getCheckHealthCheckApiRestEndpoint()==null) {
					return false;
				}
				if(this.isCheckHealthCheckApiSoapEnabled() &&
					this.getCheckHealthCheckApiSoapEndpoint()==null) {
					return false;
				}
			}
			this.isCheckReadJMXResourcesEnabled();
			this.getCheckReadJMXResourcesUsername();
			this.getCheckReadJMXResourcesPassword();
			if(this.isProxyReadJMXResourcesEnabled()) {
				
				if(this.isProxyReadJMXResourcesAsyncProcessByTimer()) {
					this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass();
					this.isProxyReadJMXResourcesAsyncProcessByTimerDebug();
					this.getProxyReadJMXResourcesAsyncProcessByTimerSchema();
					this.getProxyReadJMXResourcesAsyncProcessByTimerHostname();
					this.getProxyReadJMXResourcesAsyncProcessByTimerPort();
					this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval();
					this.getProxyReadJMXResourcesAsyncProcessByTimerLimit();
					this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval();
					this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes();
				}
				
				this.getProxyReadJMXResourcesSchema();
				this.getProxyReadJMXResourcesPort();
				if(this.isProxyReadJMXResourcesHttpsEnabled()) {
					this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName();
					if(this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer()) {
						if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath()==null) {
							return false;
						}
						if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType()==null) {
							return false;
						}
						if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword()==null) {
							return false;
						}
					}
				}
				this.getProxyReadJMXResourcesUsername();
				this.getProxyReadJMXResourcesPassword();
				this.getProxyReadJMXResourcesConnectionTimeout();
				this.getProxyReadJMXResourcesReadTimeout();
			}
						
			// Datasource Wrapped
			this.isDSOp2UtilsEnabled();
			
			// Datasource getConnection
			this.isDataSourceGetConnectionCheckAutoCommitDisabled();
			if(this.isDataSourceGetConnectionCheckTransactionIsolationLevel()) {
				this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected();
			}
			
			// NotifierInputStreamEnabled
			if(this.isNotifierInputStreamEnabled()) {
				String notifierClass = null;
				try{
					notifierClass = this.getNotifierInputStreamCallback();
				}catch(Exception e){
					return false; // log registrato nel metodo
				}
				if(notifierClass!=null){
					String tipoClass = className.getNotifierCallback(notifierClass);
					if(tipoClass == null){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.notifierCallback'=...,"+notifierClass+
						"'"+"\n"+TIPO_SCONOSCIUTO);
						return false;
					}
					try{
						INotifierCallback test = (INotifierCallback) loaderOpenSPCoop.newInstance(tipoClass);
						test.toString();
					}catch(Exception e){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.notifierCallback'=...,"+tipoClass+
								"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
						return false;
					} 
				}
			}
			
			// PipedUnblockedVersion
			try{
				this.getPipedUnblockedStreamClassName();
			}catch(Exception e){
				return false; // log registrato nel metodo
			}
			
			// FormUrlEncodedFilter
			this.isFormUrlEncodedFilterEnabled();
			
			// semaphore
			this.getSemaphoreTimeoutMS();
			this.isSemaphoreDebug();
			this.getSemaphoreType();
			this.isSemaphoreFair();
			
			// JminixConsole
			this.getPortJminixConsole();
			
			// Custom Contexts
			this.isEnabledFunctionPD();
			this.isEnabledFunctionPDtoSOAP();
			this.isEnabledFunctionPA();
			this.getCustomContexts();
			
			// Custom Container
			if ( this.getRealContainerCustom() != null ){
				String tipo = this.getRealContainerCustom();
				// Check tipi registrati
				String tipoClass = className.getRealmContainerCustom(tipo);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.realmContainer.custom'="+tipo+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					IAutorizzazioneSecurityContainer test = (IAutorizzazioneSecurityContainer) loaderOpenSPCoop.newInstance(tipoClass);
					test.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.realmContainer.custom'="+tipoClass+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				} 
			}
			
			// govway_configurazioneSistema.log
			this.isConfigurazioneSistema_javaProperties_showPassword();
			
			// govway startup
			this.getStartup_richiesteIngressoTimeout_secondi();
			this.getStartup_richiesteIngressoCheck_ms();
			this.getStartup_lockMaxLife();
			this.getStartup_lockIdleTime();
			
			// ExtendedInfo (Configurazione)
			String extendedInfoConfigurazioneTest = null;
			try{
				extendedInfoConfigurazioneTest = this.getExtendedInfoConfigurazione();
			}catch(Exception e){
				return false; // log registrato nel metodo
			}
			if(extendedInfoConfigurazioneTest!=null){
				try{
					IExtendedInfo test = (IExtendedInfo) loaderOpenSPCoop.newInstance(extendedInfoConfigurazioneTest);
					test.toString();
				}catch(Exception e){
					this.logError("La classe ["+extendedInfoConfigurazioneTest+"], indicata nella proprieta' 'org.openspcoop2.pdd.config.extendedInfo.configurazione', non esiste: "+e.getMessage(),e);
					return false;
				} 
			}
			
			// ExtendedInfo (PortaDelegata)
			String extendedInfoPortaDelegataTest = null;
			try{
				extendedInfoPortaDelegataTest = this.getExtendedInfoPortaDelegata();
			}catch(Exception e){
				return false; // log registrato nel metodo
			}
			if(extendedInfoPortaDelegataTest!=null){
				try{
					IExtendedInfo test = (IExtendedInfo) loaderOpenSPCoop.newInstance(extendedInfoPortaDelegataTest);
					test.toString();
				}catch(Exception e){
					this.logError("La classe ["+extendedInfoPortaDelegataTest+"], indicata nella proprieta' 'org.openspcoop2.pdd.config.extendedInfo.portaDelegata', non esiste: "+e.getMessage(),e);
					return false;
				} 
			}
			
			// ExtendedInfo (PortaApplicativa)
			String extendedInfoPortaApplicativaTest = null;
			try{
				extendedInfoPortaApplicativaTest = this.getExtendedInfoPortaApplicativa();
			}catch(Exception e){
				return false; // log registrato nel metodo
			}
			if(extendedInfoPortaApplicativaTest!=null){
				try{
					IExtendedInfo test = (IExtendedInfo) loaderOpenSPCoop.newInstance(extendedInfoPortaApplicativaTest);
					test.toString();
				}catch(Exception e){
					this.logError("La classe ["+extendedInfoPortaApplicativaTest+"], indicata nella proprieta' 'org.openspcoop2.pdd.config.extendedInfo.portaApplicativa', non esiste: "+e.getMessage(),e);
					return false;
				} 
			}
			
			// ValidazioneContenutiApplicativi
			this.isValidazioneContenutiApplicativi_debug();
			this.isValidazioneContenutiApplicativi_bufferContentRead();
			this.isValidazioneContenutiApplicativi_rpcLiteral_xsiType_gestione();
			this.isValidazioneContenutiApplicativi_rpcLiteral_xsiType_ripulituraDopoValidazione();
			this.isValidazioneContenutiApplicativi_rpc_acceptRootElementUnqualified();
			this.isValidazioneContenutiApplicativi_checkSoapAction();
			this.getValidazioneContenutiApplicativi_json_policyAdditionalProperties();
			this.getValidazioneContenutiApplicativi_openApi_jsonValidator();
			this.getValidazioneContenutiApplicativi_openApi_library();
			this.isValidazioneContenutiApplicativi_openApi_validateAPISpec();
			this.isValidazioneContenutiApplicativi_openApi_validateRequestPath();
			this.isValidazioneContenutiApplicativi_openApi_validateRequestQuery();
			this.isValidazioneContenutiApplicativi_openApi_validateRequestUnexpectedQueryParam();
			this.isValidazioneContenutiApplicativi_openApi_validateRequestHeaders();
			this.isValidazioneContenutiApplicativi_openApi_validateRequestCookie();
			this.isValidazioneContenutiApplicativi_openApi_validateRequestBody();
			this.isValidazioneContenutiApplicativi_openApi_validateResponseHeaders();
			this.isValidazioneContenutiApplicativi_openApi_validateResponseBody();
			this.isValidazioneContenutiApplicativi_openApi_validateWildcardSubtypeAsJson();
			this.isValidazioneContenutiApplicativi_openApi_validateMultipartOptimization();
			this.isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_injectingAdditionalPropertiesFalse();
			this.isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_resolveFullyApiSpec();
			this.isValidazioneContenutiApplicativi_openApi_openapi4j_validateBase64Values();
			this.isValidazioneContenutiApplicativi_openApi_openapi4j_validateUriReferenceAsUrl();
			
			// XML
			this.isXmlFactoryDTDsEnabled();
			this.isXsltProcessAsDOMSource();
			
			// YAML
			this.getYamlSnakeLimits();
			
			// XPath Json Path
			this.isJsonPathCacheEnabled();
			this.isReadByPathBufferEnabled();
			
			// CachingResponse
			this.getCachingResponseDigestAlgorithm();
			this.getCachingResponseHeaderCacheKey();
			
			// Gestione Token
			this.isGestioneTokenDynamicDiscoveryDebug();
			this.isGestioneTokenIntrospectionDebug();
			this.isGestioneTokenUserInfoDebug();
			this.getGestioneTokenDynamicDiscoveryLockPermits();
			this.getGestioneTokenValidazioneJWTLockPermits();
			this.getGestioneTokenIntrospectionLockPermits();
			this.getGestioneTokenUserInfoLockPermits();
			this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken();
			this.isGestioneTokenDynamicDiscoveryUseCacheConfig();
			this.getGestioneTokenIatTimeCheckMilliseconds();
			this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds();
			this.isGestioneTokenExpTimeCheck();
			this.getGestioneTokenExpTimeCheckToleranceMilliseconds();
			this.isGestioneTokenSaveSourceTokenInfo();
			this.isGestioneTokenSaveTokenInfoValidationFailed();
			this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature();
			this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed();
			this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed();
			this.getGestioneTokenFormatDate();
			this.getGestioneTokenHeaderTrasportoJSON();
			this.getGestioneTokenHeaderTrasportoJWT();
			if(!this.checkTipiIntegrazioneGestioneToken()) {
				return false;
			}
			List<String> listCustomClaims = getCustomClaimsKeysGestioneTokenForward();
			if(listCustomClaims!=null && !listCustomClaims.isEmpty()) {
				for (String claim : listCustomClaims) {
					// in caso non siano presenti viene sollevata una eccezione
					this.getCustomClaimsNameGestioneTokenHeaderIntegrazione(claim);
					this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto(claim);
					this.getCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(claim);
					this.getCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(claim);
					this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson(claim);
					this.getCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(claim);
					this.getCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(claim);
				}
			}
			this.getGestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator();
			this.getGestioneTokenHeaderIntegrazioneTrasportoScopeSeparator();
			this.getGestioneTokenHeaderIntegrazioneTrasportoRoleSeparator();
			
			// Gestione RetrieveToken
			this.getGestioneRetrieveToken_debug();
			this.getGestioneRetrieveTokenLockPermits();
			if(!this.validateGestioneRetrieveToken_refreshTokenBeforeExpire()) {
				return false;
			}
			this.isGestioneRetrieveToken_refreshToken_grantType_clientCredentials();
			this.isGestioneRetrieveToken_refreshToken_grantType_usernamePassword();
			this.isGestioneRetrieveToken_refreshToken_grantType_rfc7523_x509();
			this.isGestioneRetrieveToken_refreshToken_grantType_rfc7523_clientSecret();
			this.isGestioneRetrieveToken_refreshToken_grantType_custom();
			this.isGestioneRetrieveToken_saveAsTokenInfo();
			this.isGestioneRetrieveToken_saveAsTokenInfo_excludeJwtSignature();
			this.isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest();
			this.isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest_date();
			this.isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_transazioniRegistrazioneInformazioniNormalizzate();
			this.isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_excludeJwtSignature();
			this.isGestioneRetrieveToken_saveTokenInfo_retrieveFailed();
			this.initGestioneRetrieveTokenCacheKey();
						
			// Gestione AttributeAuthority
			this.isGestioneAttributeAuthority_debug();
			this.getGestioneAttributeAuthorityLockPermits();
			this.isGestioneAttributeAuthority_saveSourceAttributeResponseInfo();
			this.isGestioneAttributeAuthority_transazioniRegistrazioneAttributiInformazioniNormalizzate();
			
			// Statistiche via jmx Console
			this.isStatisticheViaJmx();
			
			// Forward Proxy
			this.isForwardProxyEnable();
			this.getForwardProxyConfigurazioneDefault();
			this.getForwardProxyConfigurazioneTokenDefault();
			
			// Trasformazioni
			this.isTrasformazioni_readCharsetFromContentType();
			this.getTrasformazioni_backwardCompatibility();
			
			// Trasporto REST / SOAP
			
			this.getSOAPServicesUrlParametersForwardConfig();
			this.getSOAPServicesHeadersForwardConfig(true);
			this.getSOAPServicesHeadersForwardConfig(false);
			
			// Location
			this.isSOAPServices_inoltroBuste_proxyPassReverse();
			this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse();
			this.getSOAPServices_inoltroBuste_proxyPassReverse_headers();
			this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers();
			// SetCookie
			this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
			this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
			this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path();
			this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path();
			this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain();
			this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain();
			this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers();
			this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers();
			// useProtocolPrefix
			this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix();
			this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix();
			// securityHeaders
			if(this.isSOAPServices_inoltroBuste_response_securityHeaders()) {
				this.getSOAPServices_inoltroBuste_response_securityHeaders();
			}
			if(this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders()) {
				this.getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders();
			}
			
			this.getRESTServicesUrlParametersForwardConfig();
			this.getRESTServicesHeadersForwardConfig(true);
			this.getRESTServicesHeadersForwardConfig(false);
			
			// Location
			this.isRESTServices_inoltroBuste_proxyPassReverse();
			this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse();
			this.getRESTServices_inoltroBuste_proxyPassReverse_headers();
			this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers();
			// SetCookie
			this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
			this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
			this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path();
			this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path();
			this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain();
			this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain();
			this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers();
			this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers();
			// useProtocolPrefix
			this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix();
			this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix();
			// securityHeaders
			if(this.isRESTServices_inoltroBuste_response_securityHeaders()) {
				this.getRESTServices_inoltroBuste_response_securityHeaders();
			}
			if(this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders()) {
				this.getRESTServices_consegnaContenutiApplicativi_response_securityHeaders();
			}
								
			// Transazioni
			if(this.isTransazioniEnabled()) {
				this.isTransazioniDebug();
				if(!this.isTransazioniUsePddRuntimeDatasource()) {
					this.getTransazioniDatasource();
					this.getTransazioniDatasourceJndiContext();
					this.isTransazioniDatasourceUseDBUtils();
				}
				this.isTransazioniSaveTracceInUniqueTransaction();
				this.isTransazioniSaveDiagnosticiInUniqueTransaction();
				this.isTransazioniSaveDumpInUniqueTransaction();
				this.isTransazioniValorizzaDataIngressoConDataAccettazione();
				this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent();
				this.isTransazioniFaultPrettyPrint();
				
				this._isTransazioniFiltroDuplicatiSaveDateEnabled();
				if(this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled()) {
					this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection();
					this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex();
				}
				
				if(this.isTransazioniStatefulEnabled()) {
					this.isTransazioniStatefulDebug();
					this.getTransazioniStatefulTimerIntervalSeconds();
				}
				
				this.getTransazioniCredenzialiMittenteMaxLength();
				this.getTransazioniCredenzialiMittenteLifeSeconds();
				this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled();
				this.isTransazioniRegistrazioneTracceHeaderRawEnabled();
				this.isTransazioniRegistrazioneTracceDigestEnabled();
				this._getTransazioniRegistrazioneTracceManager(className, loaderOpenSPCoop);
				this._getTransazioniRegistrazioneDiagnosticiManager(className, loaderOpenSPCoop);
				this.isTransazioniRegistrazioneDumpHeadersCompactEnabled();
				
				this.isTransazioniHttpStatusAsEvent_inResponseCode();
				this.isTransazioniHttpStatusAsEvent_outResponseCode();
				this.isTransazioniTipoApiAsEvent();
				this.isTransazioniConnettoriMultipliAsEvent();
				this.isTransazioniUpdateUseDayInterval();
				
				if(this.isTransazioniRegistrazioneSlowLog()) {
					this.getTransazioniRegistrazioneSlowLogThresholdMs();
					this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails();
					this.isTransazioniRegistrazioneSlowLogRateLimitingDetails();
					this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails();
					this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails();
				}
				
				this.isTransazioniTracciamentoDBOutRequestThrowRequestException();
				this.isTransazioniTracciamentoDBOutResponseThrowRequestException();
				this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException();
				this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException();

				this.isTransazioniFileTraceEnabled();
				if(this.isTransazioniFileTraceDumpBinarioPDEnabled()) {
					this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled();
					this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled();
				}
				if(this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()) {
					this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled();
					this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled();
				}
				if(this.isTransazioniFileTraceDumpBinarioPAEnabled()) {
					this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled();
					this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled();
				}
				if(this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()) {
					this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled();
					this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled();
				}
				this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase();
				this.getTransazioniFileTraceConfig();
				
				this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit();
				this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog();
			}
			
			// Eventi
			if(this.isEventiEnabled()) {
				this.isEventiDebug();
				this.isEventiRegistrazioneStatoPorta();
				if(this.isEventiTimerEnabled()) {
					this.getEventiTimerIntervalSeconds();
					this.getEventiTimerIntervalConnectionTimeoutEveryXTimes();
					this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes();
					this.getEventiTimerIntervalReadTimeoutEveryXTimes();
				}
			}
			
			// FileSystemRecovery
			this.getFileSystemRecoveryRepository();
			this.isFileSystemRecoveryDebug();
			if(this.isFileSystemRecoveryTimerEnabled()) {
				this.getFileSystemRecoveryTimerIntervalSeconds();
				this.getFileSystemRecoveryMaxAttempts();
				this.isFileSystemRecoveryTimerEventEnabled();
				this.isFileSystemRecoveryTimerTransactionEnabled();
				this.getFileSystemRecoveryEventsProcessingFileAfterMs();
				this.getFileSystemRecoveryTransactionProcessingFileAfterMs();
			}
			
			// ControlloTraffico
			if(this.isControlloTrafficoEnabled()) {
				//this.initConfigurazioneControlloTraffico(loaderOpenSPCoop); invocato da OpenSPcoop2Startup
				TipoGestorePolicy tipo = this.getControlloTrafficoGestorePolicyTipo();
				if(TipoGestorePolicy.WS.equals(tipo)) {
					this.getControlloTrafficoGestorePolicyWSUrl();
				}
				else if(TipoGestorePolicy.IN_MEMORY.equals(tipo)) {
					@SuppressWarnings("unused")
					PolicyGroupByActiveThreadsType type = this.getControlloTrafficoGestorePolicyInMemoryType();
					
					this.isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodes_remaining_zeroValue();
					this.isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodes_limit_roundingDown();
					this.isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodes_limit_normalizedQuota();

					isControlloTrafficoGestorePolicyInMemoryDatabase_useTransaction();
					getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_AttesaAttiva();
					getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_CheckInterval();
					
					//case HAZELCAST:
					if(isHazelcastEngineEnabled()) {
						//case HAZELCAST_MAP:
						getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath();
						//case HAZELCAST_NEAR_CACHE:
						getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath();
						//case HAZELCAST_NEAR_CACHE_UNSAFE_SYNC_MAP:
						getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath();
						//case HAZELCAST_NEAR_CACHE_UNSAFE_ASYNC_MAP:
						getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath();
						// case HAZELCAST_REPLICATED_MAP
						getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath();
						//case HAZELCAST_LOCAL_CACHE:
						getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath();
						getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheTimerUpdate();

						getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId();
						getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig();
						isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy();
						
						getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath();
						getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath();
						getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath();
					}
					
					// case REDIS
					if(isRedisEngineEnabled()) {
						getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl();
						isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy();
						isControlloTrafficoGestorePolicyInMemoryRedis_throwExceptionIfRedisNotReady();
					}
					
					if(isHazelcastEngineEnabled() || isRedisEngineEnabled()) {
						isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock();
					}
					
				}
				this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository();
				
				// header limit
				this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit();
				this.getControlloTrafficoNumeroRichiesteHeaderLimit();
				this.getControlloTrafficoOccupazioneBandaHeaderLimit();
				this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit();
				this.getControlloTrafficoTempoMedioRispostaHeaderLimit();
				this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit();
				this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit();
				this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit();
				this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit();
				
				// header limit windows
				this.getControlloTrafficoNumeroRichiesteHeaderLimitWindows();
				this.getControlloTrafficoOccupazioneBandaHeaderLimitWindows();
				this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows();
				this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindows();
				this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows();
				this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows();
				this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows();
				this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows();
				
				// header remaining
				this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining();
				this.getControlloTrafficoNumeroRichiesteHeaderRemaining();
				this.getControlloTrafficoOccupazioneBandaHeaderRemaining();
				this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining();
				this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining();
				this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining();
				this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining();
				this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining();
				
				// header reset
				this.getControlloTrafficoNumeroRichiesteHeaderReset();
				this.getControlloTrafficoOccupazioneBandaHeaderReset();
				this.getControlloTrafficoTempoComplessivoRispostaHeaderReset();
				this.getControlloTrafficoTempoMedioRispostaHeaderReset();
				this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset();
				this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset();
				this.getControlloTrafficoNumeroFaultApplicativiHeaderReset();
				this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset();
				
				this.getControlloTrafficoRetryAfterHeader();
				this.getControlloTrafficoRetryAfterHeader_randomBackoff();
			}
			
			// Allarmi
			if(this.isAllarmiEnabled()) {
				this.isAllarmiDebug();
			}
			
			// Service Unavailable
			this.getServiceUnavailableRetryAfterSeconds_pd();
			this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd();
			this.getServiceUnavailableRetryAfterSeconds_pa();
			this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa();
			if(this.isEnabledServiceUnavailableRetryAfter_pd_suspend()) {
				this.getServiceUnavailableRetryAfterSeconds_pd_suspend();
				this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_suspend();
			}
			if(this.isEnabledServiceUnavailableRetryAfter_pa_suspend()) {
				this.getServiceUnavailableRetryAfterSeconds_pa_suspend();
				this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_suspend();
			}
			if(this.isEnabledServiceUnavailableRetryAfter_pd_connectionFailed()) {
				this.getServiceUnavailableRetryAfterSeconds_pd_connectionFailed();
				this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_connectionFailed();
			}
			if(this.isEnabledServiceUnavailableRetryAfter_pa_connectionFailed()) {
				this.getServiceUnavailableRetryAfterSeconds_pa_connectionFailed();
				this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_connectionFailed();
			}
			this.isServiceUnavailable_ReadTimedOut("");
			
			// Statistiche
			if(this.isStatisticheGenerazioneEnabled()) {
				if(!this.isStatisticheUsePddRuntimeDatasource() &&
						!this.isStatisticheUseTransazioniDatasource()) {
					this.getStatisticheDatasource();
					this.getStatisticheDatasourceJndiContext();
					this.isStatisticheDatasourceUseDBUtils();
				}
				this.isStatisticheGenerazioneUseUnionForLatency();
				if(this.isStatisticheGenerazioneCustomEnabled()) {
					this.isStatisticheGenerazioneCustomSdkEnabled();
				}
				if(this.isStatisticheGenerazioneBaseOrariaEnabled()) {
					this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra();
				}
				if(this.isStatisticheGenerazioneBaseGiornalieraEnabled()) {
					this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno();
				}
				if(this.isStatisticheGenerazioneBaseSettimanaleEnabled()) {
					this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana();
				}
				if(this.isStatisticheGenerazioneBaseMensileEnabled()) {
					this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese();
				}
				this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie();
				this.getStatisticheGenerazioneTradeOffMs();
				this.getStatisticheOrarieGenerazioneTimerIntervalSeconds();
				this.getStatisticheGiornaliereGenerazioneTimerIntervalSeconds();
				this.getStatisticheSettimanaliGenerazioneTimerIntervalSeconds();
				this.getStatisticheMensiliGenerazioneTimerIntervalSeconds();
				this.getStatisticheGenerazioneTimerLockMaxLife();
				this.getStatisticheGenerazioneTimerLockIdleTime();
				this.getStatisticheGenerazioneTimerLockAttesaAttiva();
				this.getStatisticheGenerazioneTimerLockCheckInterval();
				this.getStatisticheGenerazioneExternalForceIndexRepository();
			}
			
			if(this.isGestoreChiaviPDNDEnabled()) {
				isGestoreChiaviPDNDDebug();
				isGestoreChiaviPDNDEventiAdd();
				isGestoreChiaviPDNDEventiUpdate();
				isGestoreChiaviPDNDEventiDelete();
				getGestoreChiaviPDNDRemoteStoreName();
				getGestoreChiaviPDNDkeysMaxLifeMinutes();
				getGestoreChiaviPDNDkeysPath();
				getGestoreChiaviPDNDeventsKeysPath();
				getGestoreChiaviPDNDeventsKeysParameterLastEventId();
				getGestoreChiaviPDNDeventsKeysParameterLimit();
				getGestoreChiaviPDNDeventsKeysLimit();
				getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi();
				getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi();
				getGestoreChiaviPDNDTimerLockMaxLife();
				getGestoreChiaviPDNDTimerLockIdleTime();
				getGestoreChiaviPDNDTimerLockAttesaAttiva();
				getGestoreChiaviPDNDTimerLockCheckInterval();
				getGestoreChiaviPDNDclientsPath();
				getGestoreChiaviPDNDclientsOrganizationJsonPath();
				getGestoreChiaviPDNDorganizationsPath();
				
				isGestoreChiaviPDNDclientInfoEnabled();
				getGestoreChiaviPDNDclientInfoMaxLifeMinutes();
				isGestoreChiaviPDNDclientsErrorAbortTransaction();
				isGestoreChiaviPDNDorganizationsErrorAbortTransaction();
				isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation();
				isGestoreChiaviPDNDclientsTraceJsonResponse();
				isGestoreChiaviPDNDorganizationsTraceJsonResponse();
				isGestoreChiaviPDNDorganizationsTraceName();
			}
			
			return true;

		}catch(java.lang.Exception e) {
			this.logError("Riscontrato errore durante la validazione lettura della proprieta' di openspcoop: "+e.getMessage(),e);
			return false;
		}
	}
	
	public boolean validaConfigurazioneDopoInizializzazioneProtocolManager(java.lang.ClassLoader loader) {	
		try{  
			
			if(loader!=null) {
				// nop
			}
			
			// IdentitaPdD
			Enumeration<String> protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
			while (protocolli.hasMoreElements()) {
				String protocollo = protocolli.nextElement();
				getIdentitaPortaDefault(protocollo, null);
			}	
			
			// ByPass
			protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
			while (protocolli.hasMoreElements()) {
				String protocollo = protocolli.nextElement();
				getBypassFilterMustUnderstandProperties(protocollo);
			}
			
			return true;
			
		}catch(java.lang.Exception e) {
			this.logError("Riscontrato errore durante la validazione lettura della proprieta' di openspcoop: "+e.getMessage(),e);
			return false;
		}
	}

	private boolean validateHandlersBuiltInEngine(ClassNameProperties className, Loader loaderOpenSPCoop) {
		// InitHandlerBuiltIn
		if ( this.getInitHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getInitHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getInitHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.init'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					InitHandler handler = (InitHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.init'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		
		// ExitHandlerBuiltIn
		if ( this.getExitHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getExitHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getExitHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.exit'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					ExitHandler handler = (ExitHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.exit'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		
		// PreInRequestHandlerBuiltIn
		if ( this.getPreInRequestHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getPreInRequestHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getPreInRequestHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.pre-in-request'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					PreInRequestHandler handler = (PreInRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.pre-in-request'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// InRequestHandlerBuiltIn
		if ( this.getInRequestHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getInRequestHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getInRequestHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.in-request'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					InRequestHandler handler = (InRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.in-request'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// InRequestProtocolHandlerBuiltIn
		if ( this.getInRequestProtocolHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getInRequestProtocolHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getInRequestProtocolHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.in-protocol-request'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					InRequestProtocolHandler handler = (InRequestProtocolHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.in-protocol-request'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// OutRequestHandlerBuiltIn
		if ( this.getOutRequestHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getOutRequestHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getOutRequestHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.out-request'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					OutRequestHandler handler = (OutRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.out-request'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// PostOutRequestHandlerBuiltIn
		if ( this.getPostOutRequestHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getPostOutRequestHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getPostOutRequestHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.post-out-request'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					PostOutRequestHandler handler = (PostOutRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.post-out-request'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// PreInResponseHandlerBuiltIn
		if ( this.getPreInResponseHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getPreInResponseHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getPreInResponseHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.pre-in-response'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					PreInResponseHandler handler = (PreInResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.pre-in-response'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// InResponseHandlerBuiltIn
		if ( this.getInResponseHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getInResponseHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getInResponseHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.in-response'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					InResponseHandler handler = (InResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.in-response'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// OutResponseHandlerBuiltIn
		if ( this.getOutResponseHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getOutResponseHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getOutResponseHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.out-response'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					OutResponseHandler handler = (OutResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.out-response'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// PostOutResponseHandlerBuiltIn
		if ( this.getPostOutResponseHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getPostOutResponseHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getPostOutResponseHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.post-out-response'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					PostOutResponseHandler handler = (PostOutResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.post-out-response'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// IntegrationManagerRequestHandlerBuiltIn
		if ( this.getIntegrationManagerRequestHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getIntegrationManagerRequestHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getIntegrationManagerRequestHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.built-in.request'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					IntegrationManagerRequestHandler handler = (IntegrationManagerRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.built-in.request'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// IntegrationManagerResponseHandlerBuiltIn
		if ( this.getIntegrationManagerResponseHandlerBuiltIn() != null ){
			String[] tipiHandlerBuiltIn = this.getIntegrationManagerResponseHandlerBuiltIn();
			// Check tipi registrati
			for(int i=0; i<tipiHandlerBuiltIn.length;i++){
				String tipoClass = className.getIntegrationManagerResponseHandlerBuiltIn(tipiHandlerBuiltIn[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.built-in.response'=...,"+tipiHandlerBuiltIn[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					IntegrationManagerResponseHandler handler = (IntegrationManagerResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.built-in.response'=...,"+tipiHandlerBuiltIn[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		return true;
	}
	
	
	private boolean validateHandlersEngine(ClassNameProperties className, Loader loaderOpenSPCoop) {
		// InitHandler
		if ( this.getInitHandler() != null ){
			String[] tipiHandler = this.getInitHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getInitHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.init'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					InitHandler handler = (InitHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.init'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		
		// ExitHandler
		if ( this.getExitHandler() != null ){
			String[] tipiHandler = this.getExitHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getExitHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.exit'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					ExitHandler handler = (ExitHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.exit'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		
		// PreInRequestHandler
		if ( this.getPreInRequestHandler() != null ){
			String[] tipiHandler = this.getPreInRequestHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getPreInRequestHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.pre-in-request'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					PreInRequestHandler handler = (PreInRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.pre-in-request'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// InRequestHandler
		if ( this.getInRequestHandler() != null ){
			String[] tipiHandler = this.getInRequestHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getInRequestHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.in-request'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					InRequestHandler handler = (InRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.in-request'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// InRequestProtocolHandler
		if ( this.getInRequestProtocolHandler() != null ){
			String[] tipiHandler = this.getInRequestProtocolHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getInRequestProtocolHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.in-protocol-request'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					InRequestProtocolHandler handler = (InRequestProtocolHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.in-protocol-request'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// OutRequestHandler
		if ( this.getOutRequestHandler() != null ){
			String[] tipiHandler = this.getOutRequestHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getOutRequestHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.out-request'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					OutRequestHandler handler = (OutRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.out-request'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// PostOutRequestHandler
		if ( this.getPostOutRequestHandler() != null ){
			String[] tipiHandler = this.getPostOutRequestHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getPostOutRequestHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.post-out-request'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					PostOutRequestHandler handler = (PostOutRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.post-out-request'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// PreInResponseHandler
		if ( this.getPreInResponseHandler() != null ){
			String[] tipiHandler = this.getPreInResponseHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getPreInResponseHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.pre-in-response'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					PreInResponseHandler handler = (PreInResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.pre-in-response'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// InResponseHandler
		if ( this.getInResponseHandler() != null ){
			String[] tipiHandler = this.getInResponseHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getInResponseHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.in-response'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					InResponseHandler handler = (InResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.in-response'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// OutResponseHandler
		if ( this.getOutResponseHandler() != null ){
			String[] tipiHandler = this.getOutResponseHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getOutResponseHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.out-response'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					OutResponseHandler handler = (OutResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.out-response'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// PostOutResponseHandler
		if ( this.getPostOutResponseHandler() != null ){
			String[] tipiHandler = this.getPostOutResponseHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getPostOutResponseHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.post-out-response'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					PostOutResponseHandler handler = (PostOutResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.post-out-response'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// IntegrationManagerRequestHandler
		if ( this.getIntegrationManagerRequestHandler() != null ){
			String[] tipiHandler = this.getIntegrationManagerRequestHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getIntegrationManagerRequestHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.request'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					IntegrationManagerRequestHandler handler = (IntegrationManagerRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.request'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		// IntegrationManagerResponseHandler
		if ( this.getIntegrationManagerResponseHandler() != null ){
			String[] tipiHandler = this.getIntegrationManagerResponseHandler();
			// Check tipi registrati
			for(int i=0; i<tipiHandler.length;i++){
				String tipoClass = className.getIntegrationManagerResponseHandler(tipiHandler[i]);
				if(tipoClass == null){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.response'=...,"+tipiHandler[i]+
					"'"+"\n"+TIPO_SCONOSCIUTO);
					return false;
				}
				try{
					IntegrationManagerResponseHandler handler = (IntegrationManagerResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
					handler.toString();
				}catch(Exception e){
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.response'=...,"+tipiHandler[i]+
							"'"+"\n"+getMessaggioClasseSconosciuta(e),e);
					return false;
				}
			}
		}
		return true;
	}


	public List<String> getKeywordsIntegrazioneGestioneToken(){
		List<String> keywords = new ArrayList<>();
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PROCESS_TIME);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ISSUER);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SUBJECT);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_USERNAME);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_AUDIENCE);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_CLIENT_ID);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ISSUED_AT);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_EXPIRED);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_NBF);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ROLES);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SCOPES);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FULL_NAME);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FIRST_NAME);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_MIDDLE_NAME);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FAMILY_NAME);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_EMAIL);
		return keywords;
	}

	private boolean checkTipiIntegrazioneGestioneToken(){
		
		Map<?,?> prop = this.getKeyValueGestioneTokenHeaderIntegrazioneTrasporto();
		if ( prop == null ){
			this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.keyword.*'.");
			return false;
		}
		
		Map<String, Boolean> propSetPDtrasporto = null;
		try {
			propSetPDtrasporto = this.getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto();
		}catch(Exception e) {
			this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled.*'.");
			return false;
		}
		
		Map<String, Boolean> propSetPDjson = null;
		try {
			propSetPDjson = this.getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson();
		}catch(Exception e) {
			this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled.*'.");
			return false;
		}
		
		Map<String, Boolean> propSetPAtrasporto = null;
		try {
			propSetPAtrasporto = this.getKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto();
		}catch(Exception e) {
			this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled.*'.");
			return false;
		}
		
		Map<String, Boolean> propSetPAjson = null;
		try {
			propSetPAjson = this.getKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson();
		}catch(Exception e) {
			this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled.*'.");
			return false;
		}
		
		List<String> keywords = this.getKeywordsIntegrazioneGestioneToken();
		for (String keyword : keywords) {
			if( prop.get(keyword) == null){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.keyword."+
						keyword+"'.");
				return false;
			}
			if( !propSetPDtrasporto.containsKey(keyword)){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled."+
						keyword+"'.");
				return false;
			}
			if( !propSetPDjson.containsKey(keyword)){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled."+
						keyword+"'.");
				return false;
			}
			if( !propSetPAtrasporto.containsKey(keyword)){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled."+
						keyword+"'.");
				return false;
			}
			if( !propSetPAjson.containsKey(keyword)){
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled."+
						keyword+"'.");
				return false;
			}
		}
				

		return true;
	}

	public List<MapKey<String>> getKeywordsIntegrazione(){
		return getKeywordsIntegrazioneEngine(false);
	}
	private List<MapKey<String>> getKeywordsIntegrazioneEngine(boolean all){
		List<MapKey<String>> keywords = new ArrayList<>();
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_MITTENTE);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_MITTENTE);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_DESTINATARIO);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_DESTINATARIO);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_SERVIZIO);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_SERVIZIO);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_VERSIONE_SERVIZIO);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_AZIONE);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_ID_MESSAGGIO);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_RIFERIMENTO_MESSAGGIO);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_COLLABORAZIONE);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_ID_APPLICATIVO);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_SERVIZIO_APPLICATIVO);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_MITTENTE_TOKEN);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_MITTENTE_TOKEN);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_SERVIZIO_APPLICATIVO_TOKEN);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_ID_TRANSAZIONE);
		keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_PROTOCOL_INFO);
		if(all) {
			keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_INFO);
			keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_USER_AGENT);
		}
		return keywords;
	}

	private boolean checkTipiIntegrazione(String[] tipiIntegrazione){
		// Check KeyWord per tipi 'trasporto' e 'urlBased' e 'soap'
		for(int i=0; i<tipiIntegrazione.length;i++){
			if(CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO.equals(tipiIntegrazione[i]) ||
					CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED.equals(tipiIntegrazione[i]) ||
							CostantiConfigurazione.HEADER_INTEGRAZIONE_SOAP.equals(tipiIntegrazione[i]) ){
				
				Map<MapKey<String>,String> propGovWay = null;
				Map<MapKey<String>,String> propOpenSPCoop2 = null;
				Map<MapKey<String>,String> propOpenSPCoop1 = null;
				Map<MapKey<String>, Boolean> propSetRequestPD = null;
				Map<MapKey<String>, Boolean> propSetResponsePD = null;
				Map<MapKey<String>, Boolean> propReadPD = null;
				Map<MapKey<String>, Boolean> propSetRequestPA = null;
				Map<MapKey<String>, Boolean> propSetResponsePA = null;
				Map<MapKey<String>, Boolean> propReadPA = null;
				String tipo = "";
				if(CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO.equals(tipiIntegrazione[i])){
					if ( this.getKeyValue_HeaderIntegrazioneTrasporto() == null ){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.keyword.*'.");
						return false;
					}
					propGovWay = this.getKeyValue_HeaderIntegrazioneTrasporto();
					propOpenSPCoop2 = this.getKeyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2();
					propOpenSPCoop1 = this.getKeyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1();
					try {
						propSetRequestPD = this.getKeyPDSetEnabled_HeaderIntegrazioneTrasporto(true);
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.pd.set.request.enabled.*'.");
						return false;
					}
					try {
						propSetResponsePD = this.getKeyPDSetEnabled_HeaderIntegrazioneTrasporto(false);
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.pd.set.response.enabled.*'.");
						return false;
					}
					try {
						propReadPD = this.getKeyPDReadEnabled_HeaderIntegrazioneTrasporto();
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.pd.read.enabled.*'.");
						return false;
					}
					try {
						propSetRequestPA = this.getKeyPASetEnabled_HeaderIntegrazioneTrasporto(true);
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.pa.set.request.enabled.*'.");
						return false;
					}
					try {
						propSetResponsePA = this.getKeyPASetEnabled_HeaderIntegrazioneTrasporto(false);
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.pa.set.response.enabled.*'.");
						return false;
					}
					try {
						propReadPA = this.getKeyPAReadEnabled_HeaderIntegrazioneTrasporto();
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.pa.read.enabled.*'.");
						return false;
					}
					tipo=CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO;
				}else if(CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED.equals(tipiIntegrazione[i])){
					if ( this.getKeyValue_HeaderIntegrazioneUrlBased() == null ){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.urlBased.keyword.*'.");
						return false;
					}
					propGovWay = this.getKeyValue_HeaderIntegrazioneUrlBased();
					propOpenSPCoop2 = this.getKeyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2();
					propOpenSPCoop1 = this.getKeyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1();
					try {
						propSetRequestPD = this.getKeyPDSetEnabled_HeaderIntegrazioneUrlBased();
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.urlBased.pd.set.enabled.*'.");
						return false;
					}
					try {
						propReadPD = this.getKeyPDReadEnabled_HeaderIntegrazioneUrlBased();
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.urlBased.pd.read.enabled.*'.");
						return false;
					}
					try {
						propSetRequestPA = this.getKeyPASetEnabled_HeaderIntegrazioneUrlBased();
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.urlBased.pa.set.enabled.*'.");
						return false;
					}
					try {
						propReadPA = this.getKeyPAReadEnabled_HeaderIntegrazioneUrlBased();
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.urlBased.pa.read.enabled.*'.");
						return false;
					}
					tipo=CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED;
				}else if(CostantiConfigurazione.HEADER_INTEGRAZIONE_SOAP.equals(tipiIntegrazione[i])){
					if ( this.getKeyValue_HeaderIntegrazioneSoap() == null ){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.keyword.*'.");
						return false;
					}
					propGovWay = this.getKeyValue_HeaderIntegrazioneSoap();
					propOpenSPCoop2 = this.getKeyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2();
					propOpenSPCoop1 = this.getKeyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1();
					try {
						propSetRequestPD = this.getKeyPDSetEnabled_HeaderIntegrazioneSoap(true);
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pd.set.request.enabled.*'.");
						return false;
					}
					try {
						propSetResponsePD = this.getKeyPDSetEnabled_HeaderIntegrazioneSoap(false);
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pd.set.response.enabled.*'.");
						return false;
					}
					try {
						propReadPD = this.getKeyPDReadEnabled_HeaderIntegrazioneSoap();
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pd.read.enabled.*'.");
						return false;
					}
					try {
						propSetRequestPA = this.getKeyPASetEnabled_HeaderIntegrazioneSoap(true);
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pa.set.request.enabled.*'.");
						return false;
					}
					try {
						propSetResponsePA = this.getKeyPASetEnabled_HeaderIntegrazioneSoap(false);
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pa.set.response.enabled.*'.");
						return false;
					}
					try {
						propReadPA = this.getKeyPAReadEnabled_HeaderIntegrazioneSoap();
					}catch(Exception e) {
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pa.read.enabled.*'.");
						return false;
					}
					tipo=CostantiConfigurazione.HEADER_INTEGRAZIONE_SOAP;
				}
				
				if(propSetRequestPD==null) {
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pd.set.request.enabled.*'. Set is null");
					return false;
				}
				
				List<MapKey<String>> keywords = this.getKeywordsIntegrazione();
				for (MapKey<String> mapkey : keywords) {
					
					if(CostantiPdD.HEADER_INTEGRAZIONE_PROTOCOL_INFO.equals(mapkey)) {
						continue; // gestito sotto come caso eccezionale
					}
					
					if( propGovWay.get(mapkey) == null){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".keyword."+
								mapkey+"'.");
						return false;
					}
					if( propOpenSPCoop2.get(mapkey) == null){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop2."+tipo+".keyword."+
								mapkey+"'.");
						return false;
					}
					if( propOpenSPCoop1.get(mapkey) == null){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop1."+tipo+".keyword."+
								mapkey.toString()+"'.");
						return false;
					}
					if(CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED.equals(tipiIntegrazione[i])){
						if( !propSetRequestPD.containsKey(mapkey)){
							this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.enabled."+
									mapkey+"'.");
							return false;
						}
					}
					else {
						if( !propSetRequestPD.containsKey(mapkey)){
							this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.request.enabled."+
									mapkey+"'.");
							return false;
						}
						if( propSetResponsePD==null || !propSetResponsePD.containsKey(mapkey)){
							this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.response.enabled."+
									mapkey+"'.");
							return false;
						}
					}
					if( !propReadPD.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.read.enabled."+
								mapkey+"'.");
						return false;
					}
					if(CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED.equals(tipiIntegrazione[i])){
						if( !propSetRequestPA.containsKey(mapkey)){
							this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.enabled."+
									mapkey+"'.");
							return false;
						}
					}
					else {
						if( !propSetRequestPA.containsKey(mapkey)){
							this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.request.enabled."+
									mapkey+"'.");
							return false;
						}
						if( !propSetResponsePA.containsKey(mapkey)){
							this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.response.enabled."+
									mapkey+"'.");
							return false;
						}
					}
					if( !propReadPA.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.read.enabled."+
								mapkey+"'.");
						return false;
					}
				}
				
				MapKey<String> mapkey = CostantiPdD.HEADER_INTEGRAZIONE_INFO;
				if(CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED.equals(tipiIntegrazione[i])){
					if( !propSetRequestPD.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.enabled."+
								mapkey+"'.");
						return false;
					}
					if( !propSetRequestPA.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.enabled."+
								mapkey+"'.");
						return false;
					}
				}
				else {
					if( !propSetRequestPD.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.request.enabled."+
								mapkey+"'.");
						return false;
					}
					if( propSetResponsePD==null || !propSetResponsePD.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.response.enabled."+
								mapkey+"'.");
						return false;
					}
					if( !propSetRequestPA.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.request.enabled."+
								mapkey+"'.");
						return false;
					}
					if( !propSetResponsePA.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.response.enabled."+
								mapkey+"'.");
						return false;
					}
				}
				
				if(CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO.equals(tipo)) {
					mapkey = CostantiPdD.HEADER_INTEGRAZIONE_USER_AGENT;
					if( !propSetRequestPD.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.request.enabled."+
								mapkey+"'.");
						return false;
					}
					if( propSetResponsePD==null || !propSetResponsePD.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.response.enabled."+
								mapkey+"'.");
						return false;
					}
					if( !propSetRequestPA.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.request.enabled."+
								mapkey+"'.");
						return false;
					}
					if( !propSetResponsePA.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.response.enabled."+
								mapkey+"'.");
						return false;
					}
				}
				
				mapkey = CostantiPdD.HEADER_INTEGRAZIONE_PROTOCOL_INFO;
				if(CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED.equals(tipiIntegrazione[i])){
					if( !propSetRequestPD.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.enabled."+
								mapkey+"'.");
						return false;
					}
					if( !propSetRequestPA.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.enabled."+
								mapkey+"'.");
						return false;
					}
				}
				else {
					if( !propSetRequestPD.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.request.enabled."+
								mapkey+"'.");
						return false;
					}
					if( propSetResponsePD==null || !propSetResponsePD.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.response.enabled."+
								mapkey+"'.");
						return false;
					}
					if( !propSetRequestPA.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.request.enabled."+
								mapkey+"'.");
						return false;
					}
					if( !propSetResponsePA.containsKey(mapkey)){
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.response.enabled."+
								mapkey+"'.");
						return false;
					}
				}
				
			}
			
			
			if(CostantiConfigurazione.HEADER_INTEGRAZIONE_SOAP.equals(tipiIntegrazione[i])){
				if ( this.getHeaderSoapNameIntegrazione() == null ){
					return false;
				}
				if ( this.getHeaderSoapNameIntegrazione_backwardCompatibility_openspcoop2() == null ){
					return false;
				}
				if ( this.getHeaderSoapNameIntegrazione_backwardCompatibility_openspcoop1() == null ){
					return false;
				}
				
				if ( this.getHeaderSoapActorIntegrazione() == null ){
					return false;
				}
				if ( this.getHeaderSoapActorIntegrazione_backwardCompatibility_openspcoop2() == null ){
					return false;
				}
				if ( this.getHeaderSoapActorIntegrazione_backwardCompatibility_openspcoop1() == null ){
					return false;
				}
				
				if ( this.getHeaderSoapPrefixIntegrazione() == null ){
					return false;
				}
				if ( this.getHeaderSoapPrefixIntegrazione_backwardCompatibility_openspcoop2() == null ){
					return false;
				}
				if ( this.getHeaderSoapPrefixIntegrazione_backwardCompatibility_openspcoop1() == null ){
					return false;
				}
				
				if ( this.getHeaderSoapExtProtocolInfoNomeElementoIntegrazione() == null ){
					return false;
				}
				if ( this.getHeaderSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2() == null ){
					return false;
				}
				if ( this.getHeaderSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1() == null ){
					return false;
				}
				
				if ( this.getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione() == null ){
					return false;
				}
				if ( this.getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2() == null ){
					return false;
				}
				if ( this.getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1() == null ){
					return false;
				}
			}
			
		}
		return true;
	}














	/* ********  CONF DIRECTORY  ******** */

	/**
	 * Restituisce la directory di configurazione di OpenSPCoop.
	 *
	 * @return la directory di configurazione di OpenSPCoop.
	 * 
	 */
	private String rootDirectory = null;
	public String getRootDirectory() {	
		if(this.rootDirectory==null){
			try{ 
				String root = null;
				root = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.confDirectory");

				if(root==null)
					throw new CoreException(NON_DEFINITA);

				root = root.trim();

				if(!root.endsWith(File.separator))
					root = root + File.separator;

				this.rootDirectory = root;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop, 'org.openspcoop2.pdd.confDirectory': "+e.getMessage(),e);
				this.rootDirectory = null;
			}    
		}

		return this.rootDirectory;
	}

	/**
	 * Restituisce L'indicazione se il server è un server J2EE o WEB
	 *
	 * @return indicazione se il server è un server J2EE o WEB
	 * 
	 */
	private Boolean serverJ2EE = null;
	public Boolean isServerJ2EE() {	
		if(this.serverJ2EE==null){
			try{ 
				String server = null;
				server = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.server");

				if(server==null)
					throw new CoreException(NON_DEFINITA);

				server = server.trim();

				if(CostantiConfigurazione.SERVER_J2EE.equalsIgnoreCase(server)){
					this.serverJ2EE = true;
				}else if(CostantiConfigurazione.SERVER_WEB.equalsIgnoreCase(server)){
					this.serverJ2EE = false;
				}else{
					throw new CoreException("Valore ["+server+"] non conosciuto");
				}

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop, 'org.openspcoop2.pdd.server': "+e.getMessage(),e);
				this.serverJ2EE = null;
			}    
		}

		return this.serverJ2EE;
	}

	private Boolean getClassLoaderRead = null;
	private String getClassLoader = null;
	public String getClassLoader(){

		if(this.getClassLoaderRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.classLoader"); 

				if (value != null){
					value = value.trim();
					this.getClassLoader = value;
				}

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.classLoader' non impostata, errore:"+e.getMessage(),e);
			}
			this.getClassLoaderRead = true;
		}

		return this.getClassLoader;
	}

	private String productName = null;
	public String getProductName() {	
		if(this.productName==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.productName");
				if(v!=null){
					v = v.trim();
					this.productName = v;
				}else{
					this.productName = CostantiPdD.OPENSPCOOP2_PRODUCT;
				}
			}catch(java.lang.Exception e) {
				this.productName = CostantiPdD.OPENSPCOOP2_PRODUCT;
			}    
		}
		return this.productName;
	}
	
	private String versione = null;
	public String getVersione() {	
		if(this.versione==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.versione");
				if(v!=null){
					v = v.trim();
					this.versione = v;
				}else{
					this.versione = getVersionePdD(null);
				}
			}catch(java.lang.Exception e) {
				this.versione = CostantiPdD.OPENSPCOOP2_PRODUCT_VERSION;
			}    
		}
		return this.versione;
	}
	public static String getVersionePdD(OpenSPCoop2Properties properties) {
		String versione = CostantiPdD.OPENSPCOOP2_PRODUCT_VERSION;
		if(properties!=null){
			versione = properties.getPddDetailsForServices();
		}
		
		try {
			String version = VersionUtilities.readVersion();
			if(version!=null && !StringUtils.isEmpty(version)) {
				versione = version;
			}
		}catch(Exception e) {
			// ignore
		}
		
		String buildVersion = null;
		try {
			buildVersion = VersionUtilities.readBuildVersion();
		}catch(Exception e) {
			// ignore
		}
		if(buildVersion!=null) {
			versione = versione + " (build "+buildVersion+")";
		}
		return versione;
	}
	
	private String details = null;
	public String getDetails() {	
		if(this.details==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.details");
				if(v!=null){
					v = v.trim();
					this.details = v;
				}else{
					this.details = CostantiPdD.OPENSPCOOP2_DETAILS;
				}
			}catch(java.lang.Exception e) {
				this.details = CostantiPdD.OPENSPCOOP2_DETAILS;
			}    
		}
		return this.details;
	}
	
	private String getPddDetailsForLog = null;
	public String getPddDetailsForLog() {	
		if(this.getPddDetailsForLog==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.log.details");
				if(v!=null){
					v = v.trim();
					this.getPddDetailsForLog = v;
				}else{
					this.getPddDetailsForLog = getDefaultLogVersionDetails();
				}
			}catch(java.lang.Exception e) {
				this.getPddDetailsForLog = getDefaultLogVersionDetails();
			}    
		}
		return this.getPddDetailsForLog;
	}
	
	private String getDefaultLogVersionDetails() {
		String d = this.getDetails();
		if(d!=null && !"".equals(d))
			return this.getVersione()+" ("+d+")";
		else
			return this.getVersione();
	}

	private String getPddDetailsForServices = null;
	public String getPddDetailsForServices() {	
		if(this.getPddDetailsForServices==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.details");
				if(v!=null){
					v = v.trim();
					this.getPddDetailsForServices = v;
				}else{
					this.getPddDetailsForServices = this.getVersione();
				}
			}catch(java.lang.Exception e) {
				this.getPddDetailsForServices = this.getVersione();
			}    
		}
		return this.getPddDetailsForServices;
	}
	
	private StatoFunzionalitaConWarning getCheckOpenSPCoopHome = null;
	public StatoFunzionalitaConWarning getCheckOpenSPCoopHome() {	
		if(this.getCheckOpenSPCoopHome==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.checkHomeProperty");
				if(v!=null){
					v = v.trim();
					this.getCheckOpenSPCoopHome = (StatoFunzionalitaConWarning) StatoFunzionalitaConWarning.toEnumConstantFromString(v);
					if(this.getCheckOpenSPCoopHome==null){
						throw new CoreException("Valore inatteso: "+v);
					}
				}else{
					this.getCheckOpenSPCoopHome = StatoFunzionalitaConWarning.DISABILITATO;
				}
			}catch(java.lang.Exception e) {
				e.printStackTrace(System.out);
				this.getCheckOpenSPCoopHome = StatoFunzionalitaConWarning.DISABILITATO;
			}    
		}
		return this.getCheckOpenSPCoopHome;
	}
	
	public void checkOpenSPCoopHome() throws CoreException{
		if(!StatoFunzionalitaConWarning.DISABILITATO.equals(this.getCheckOpenSPCoopHome())){
			Exception e = null;
			boolean foundSystem = false;
			try{
				String dir = System.getProperty(CostantiPdD.OPENSPCOOP2_LOCAL_HOME);
				if(dir==null || "".equals(dir)){
					throw new CoreException("Variabile java ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non trovata");
				}
				foundSystem = true;
				File fDir = new File(dir);
				if(!fDir.exists()){
					throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile java ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non esiste");
				}
				if(!fDir.isDirectory()){
					throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile java ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non è una directory");
				}
				if(!fDir.canRead()){
					throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile java ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non è accessibile in lettura");
				}
			}catch(Exception eTh){
				e = eTh;
			}
			try{
				// NOTA: nel caricamento la variabile di sistema vince sulla variabile java
				String dir = System.getenv(CostantiPdD.OPENSPCOOP2_LOCAL_HOME);
				if(dir==null || "".equals(dir)){
					if(!foundSystem){
						throw new CoreException("Ne variabile java ne variabile di sistema ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] trovata");
					}
				}
				else{
					File fDir = new File(dir);
					if(!fDir.exists()){
						throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile di sistema ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non esiste");
					}
					if(!fDir.isDirectory()){
						throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile di sistema ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non è una directory");
					}
					if(!fDir.canRead()){
						throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile di sistema ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non è accessibile in lettura");
					}
					// trovata.
					// annullo una eventuale eccezione di sistema
					e = null;
				}
			}catch(Exception eTh){
				if(e==null)
					e = eTh;
				else{
					e = new Exception(e.getMessage()+" - "+eTh.getMessage(),eTh);
				}
			}
			if(e!=null){
				throw new CoreException(e.getMessage(),e);
			}
		}
	}
	
	




	/* ********  CONFIGURAZIONE DI OPENSPCOOP  ******** */

	/**
	 * Restituisce la location della configurazione della porta di dominio di OpenSPCoop,
	 *
	 * @return il path del file di configurazione della porta di dominio in caso di ricerca con successo, null altrimenti.
	 * 
	 */
	private String pathConfigurazionePDD = null;
	public String getPathConfigurazionePDD() {	
		if(this.pathConfigurazionePDD==null){
			try{  
				String indirizzo = this.reader.getValue("org.openspcoop2.pdd.config.location"); 
				if(indirizzo==null)
					throw new CoreException(NON_DEFINITA);

				indirizzo = indirizzo.trim();

				if(CostantiConfigurazione.CONFIGURAZIONE_XML.equalsIgnoreCase(getTipoConfigurazionePDD())){

					if( (!indirizzo.startsWith("http://")) && (!indirizzo.startsWith("file://")) ){
						if(!indirizzo.startsWith("${")){
							String root = getRootDirectory();
							indirizzo = root+indirizzo;
						}
						while (indirizzo.indexOf("${")!=-1){
							int indexStart = indirizzo.indexOf("${");
							int indexEnd = indirizzo.indexOf("}");
							if(indexEnd==-1){
								throw new CoreException("errore durante l'interpretazione del path ["+indirizzo+"]: ${ utilizzato senza la rispettiva chiusura }");
							}
							String nameSystemProperty = indirizzo.substring(indexStart+"${".length(),indexEnd);
							String valueSystemProperty = System.getProperty(nameSystemProperty);
							if(valueSystemProperty==null){
								throw new CoreException("errore durante l'interpretazione del path ["+indirizzo+"]: variabile di sistema ${"+nameSystemProperty+"} non esistente");
							}
							indirizzo = indirizzo.replace("${"+nameSystemProperty+"}", valueSystemProperty);
						}
					}

				}

				this.pathConfigurazionePDD = indirizzo;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.config.location': "+e.getMessage(),e);
				this.pathConfigurazionePDD = null;
			}
		}

		return this.pathConfigurazionePDD;
	} 

	private List<byte[]> configPreLoadingLocale = null;
	private Boolean configPreLoadingLocaleRead = null;
	public List<byte[]> getConfigPreLoadingLocale() {	
		if(this.configPreLoadingLocaleRead==null){
			try{ 
				String resourceTmp = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.config.preLoading.locale");
				if(resourceTmp!=null){
					resourceTmp = resourceTmp.trim();
					
					List<String> lResources = new ArrayList<>();
					if(resourceTmp.contains(",")) {
						String [] tmp = resourceTmp.split(",");
						for (int i = 0; i < tmp.length; i++) {
							String r = tmp[i];
							if(r!=null) {
								r = r.trim();
								if(!"".equals(r)) {
									lResources.add(r);
								}
							}
						}
					}
					else {
						lResources.add(resourceTmp);
					}
					
					this.configPreLoadingLocale = new ArrayList<>();
					
					for (String resource : lResources) {
						File f = new File(resource);
						if(f.exists()) {
							this.configPreLoadingLocale.add(FileSystemUtilities.readBytesFromFile(f));
						}
						else {
							if(!resource.startsWith("/")) {
								resource = "/" + resource;
							}
							InputStream is = OpenSPCoop2Properties.class.getResourceAsStream(resource);
							if(is!=null) {
								try {
									this.configPreLoadingLocale.add(Utilities.getAsByteArray(is));
								}finally {
									try {
										is.close();
									}catch(Exception eClose) {
										// close
									}
								}
							}
						}	
					}
					
				}

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.config.preLoading.locale': "+e.getMessage(),e);
				this.tipoConfigurazionePDD = null;
			}  
			
			this.configPreLoadingLocaleRead = true;
		}

		return this.configPreLoadingLocale;
	}
	
	/**
	 * Restituisce il tipo di configurazione della porta di dominio di OpenSPCoop.
	 *
	 * @return il tipo di configurazione della porta di dominio, null altrimenti.
	 * 
	 */
	private String tipoConfigurazionePDD = null;
	public String getTipoConfigurazionePDD() {	
		if(this.tipoConfigurazionePDD==null){
			try{ 
				String tipo = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.config.tipo");
				if(tipo==null)
					throw new CoreException(NON_DEFINITA);
				tipo = tipo.trim();

				this.tipoConfigurazionePDD = tipo;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.config.tipo': "+e.getMessage(),e);
				this.tipoConfigurazionePDD = null;
			}    
		}

		return this.tipoConfigurazionePDD;
	}

	/**
	 * Restituisce l'indicazione Se si desidera condividere i due database config e regserv
	 *
	 * @return l'indicazione Se si desidera condividere i due database config e regserv
	 * 
	 */
	private Boolean isCondivisioneConfigurazioneRegistroDB = null;
	public boolean isCondivisioneConfigurazioneRegistroDB() {	
		if(this.isCondivisioneConfigurazioneRegistroDB==null){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.config.db.condivisioneDBRegserv");
				if(value==null)
					this.isCondivisioneConfigurazioneRegistroDB = false;
				else{
					this.isCondivisioneConfigurazioneRegistroDB = Boolean.parseBoolean(value);
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.config.db.condivisioneDBRegserv' (Viene utilizzato il default:false): "+e.getMessage(),e);
				this.isCondivisioneConfigurazioneRegistroDB = false;
			}    
		}

		return this.isCondivisioneConfigurazioneRegistroDB;
	}

	/**
	 * Restituisce le proprieta' da utilizzare con il contesto JNDI di lookup, se impostate.
	 *
	 * @return proprieta' da utilizzare con il contesto JNDI di lookup.
	 * 
	 */
	private java.util.Properties jndiContext_Configurazione = null;
	public java.util.Properties getJNDIContext_Configurazione() {	
		if(this.jndiContext_Configurazione==null){
			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.config.property.");
				this.jndiContext_Configurazione = prop;

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle propriete' JNDI per la configurazione di openspcoop 'org.openspcoop2.pdd.config.property.*': "+e.getMessage(),e);
				this.jndiContext_Configurazione = null;
			}    
		}

		return this.jndiContext_Configurazione;
	}

	
	private AccessoConfigurazionePdD accessoConfigurazionePdD = null;
	public AccessoConfigurazionePdD getAccessoConfigurazionePdD() throws OpenSPCoop2ConfigurationException{ 
		if(this.accessoConfigurazionePdD==null){
			try{  
				AccessoConfigurazionePdD conf = new AccessoConfigurazionePdD();
				conf.setTipo(this.getTipoConfigurazionePDD());
				if(CostantiConfigurazione.CONFIGURAZIONE_DB.equalsIgnoreCase(this.getTipoConfigurazionePDD())){	
					String tipoDatabase = null;
					String location = null;
					if(this.getPathConfigurazionePDD().indexOf("@")!=-1){
						// estrazione tipo database
						tipoDatabase = DBUtils.estraiTipoDatabaseFromLocation(this.getPathConfigurazionePDD());
						location = this.getPathConfigurazionePDD().substring(this.getPathConfigurazionePDD().indexOf("@")+1);
					}else{
						tipoDatabase = this.getDatabaseType();
						location =this.getPathConfigurazionePDD();
					}
					conf.setLocation(location);
					conf.setTipoDatabase(tipoDatabase);
				}else{
					conf.setLocation(this.getPathConfigurazionePDD());
				}
				conf.setContext(this.getJNDIContext_Configurazione());
				conf.setCondivisioneDatabasePddRegistro(this.isCondivisioneConfigurazioneRegistroDB());
				
				this.accessoConfigurazionePdD = conf;
			}catch(java.lang.Exception e) {
				throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della modalita' di accesso alla configurazione della PdD OpenSPCoop",e);
			}
		}

		return this.accessoConfigurazionePdD;
	}

	/**
	 * Restituisce l'indicazione se la configurazione di GovWay
	 * e' letta una sola volta (statica) o letta ai refresh della sorgente (dinamica) 
	 *
	 * @return Restituisce indicazione se la configurazione e' statica (false) o dinamica (true)
	 * 
	 */
	private Boolean isConfigurazioneDinamica_value = null;
	public boolean isConfigurazioneDinamica(){
		if(this.isConfigurazioneDinamica_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.config.refresh"); 

				if(value!=null){
					value = value.trim();
					this.isConfigurazioneDinamica_value = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.config.refresh' non impostata, viene utilizzato il default=true");
					this.isConfigurazioneDinamica_value = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.config.refresh' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isConfigurazioneDinamica_value = true;
			}
		}

		return this.isConfigurazioneDinamica_value;
	}
	
	private Boolean isConfigurazioneCache_ConfigPrefill_value = null;
	public boolean isConfigurazioneCache_ConfigPrefill(){
		if(this.isConfigurazioneCache_ConfigPrefill_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cache.config.prefill"); 

				if(value!=null){
					value = value.trim();
					this.isConfigurazioneCache_ConfigPrefill_value = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.cache.config.prefill' non impostata, viene utilizzato il default=false");
					this.isConfigurazioneCache_ConfigPrefill_value = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.cache.config.prefill' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isConfigurazioneCache_ConfigPrefill_value = false;
			}
		}

		return this.isConfigurazioneCache_ConfigPrefill_value;
	}
	
	private Boolean isConfigurazioneCache_RegistryPrefill_value = null;
	public boolean isConfigurazioneCache_RegistryPrefill(){
		if(this.isConfigurazioneCache_RegistryPrefill_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cache.registry.prefill"); 

				if(value!=null){
					value = value.trim();
					this.isConfigurazioneCache_RegistryPrefill_value = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.cache.registry.prefill' non impostata, viene utilizzato il default=false");
					this.isConfigurazioneCache_RegistryPrefill_value = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.cache.registry.prefill' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isConfigurazioneCache_RegistryPrefill_value = false;
			}
		}

		return this.isConfigurazioneCache_RegistryPrefill_value;
	}
	
	private Boolean isConfigurazioneCache_accessiSynchronized = null;
	public boolean isConfigurazioneCache_accessiSynchronized(){
		if(this.isConfigurazioneCache_accessiSynchronized==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cache.get.synchronized"); 

				if(value!=null){
					value = value.trim();
					this.isConfigurazioneCache_accessiSynchronized = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.cache.get.synchronized' non impostata, viene utilizzato il default=false");
					this.isConfigurazioneCache_accessiSynchronized = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.cache.get.synchronized' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isConfigurazioneCache_accessiSynchronized = false;
			}
		}

		return this.isConfigurazioneCache_accessiSynchronized;
	}
	
	private Boolean isConfigurazioneCache_transactionContext_accessiSynchronized = null;
	public boolean isConfigurazioneCache_transactionContext_accessiSynchronized(){
		if(this.isConfigurazioneCache_transactionContext_accessiSynchronized==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cache.transactionContext.synchronized"); 

				if(value!=null){
					value = value.trim();
					this.isConfigurazioneCache_transactionContext_accessiSynchronized = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.cache.transactionContext.synchronized' non impostata, viene utilizzato il default=true");
					this.isConfigurazioneCache_transactionContext_accessiSynchronized = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.cache.transactionContext.synchronized' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isConfigurazioneCache_transactionContext_accessiSynchronized = true;
			}
		}

		return this.isConfigurazioneCache_transactionContext_accessiSynchronized;
	}

	private CacheType readCacheTypeConfig = null;
	public CacheType getCacheTypeConfig() {
		if(this.readCacheTypeConfig==null) {
			this.readCacheTypeConfig = readCacheType("org.openspcoop2.pdd.cache.impl.config");
		}
		return this.readCacheTypeConfig;
	}
	
	private CacheType readCacheTypeRegistry = null;
	public CacheType getCacheTypeRegistry() {
		if(this.readCacheTypeRegistry==null) {
			this.readCacheTypeRegistry = readCacheType("org.openspcoop2.pdd.cache.impl.registry");
		}
		return this.readCacheTypeRegistry;
	}
	
	private CacheType readCacheTypeAuthentication = null;
	public CacheType getCacheTypeAuthentication() {
		if(this.readCacheTypeAuthentication==null) {
			this.readCacheTypeAuthentication = readCacheType("org.openspcoop2.pdd.cache.impl.authentication");
		}
		return this.readCacheTypeAuthentication;
	}
	
	private CacheType readCacheTypeAuthorization = null;
	public CacheType getCacheTypeAuthorization() {
		if(this.readCacheTypeAuthorization==null) {
			this.readCacheTypeAuthorization = readCacheType("org.openspcoop2.pdd.cache.impl.authorization");
		}
		return this.readCacheTypeAuthorization;
	}
	
	private CacheType readCacheTypeResponseCaching = null;
	public CacheType getCacheTypeResponseCaching() {
		if(this.readCacheTypeResponseCaching==null) {
			this.readCacheTypeResponseCaching = readCacheType("org.openspcoop2.pdd.cache.impl.responseCaching");
		}
		return this.readCacheTypeResponseCaching;
	}

	private CacheType readCacheTypeToken = null;
	public CacheType getCacheTypeToken() {
		if(this.readCacheTypeToken==null) {
			this.readCacheTypeToken = readCacheType("org.openspcoop2.pdd.cache.impl.token");
		}
		return this.readCacheTypeToken;
	}
	
	private CacheType readCacheTypeAttributeAuthority = null;
	public CacheType getCacheTypeAttributeAuthority() {
		if(this.readCacheTypeAttributeAuthority==null) {
			this.readCacheTypeAttributeAuthority = readCacheType("org.openspcoop2.pdd.cache.impl.attributeAuthority");
		}
		return this.readCacheTypeAttributeAuthority;
	}
	
	private CacheType readCacheTypeKeystore = null;
	public CacheType getCacheTypeKeystore() {
		if(this.readCacheTypeKeystore==null) {
			this.readCacheTypeKeystore = readCacheType("org.openspcoop2.pdd.cache.impl.keystore");
		}
		return this.readCacheTypeKeystore;
	}
	
	private CacheType readCacheTypeLoadBalancer = null;
	public CacheType getCacheTypeLoadBalancer() {
		if(this.readCacheTypeLoadBalancer==null) {
			this.readCacheTypeLoadBalancer = readCacheType("org.openspcoop2.pdd.cache.impl.loadBalancer");
		}
		return this.readCacheTypeLoadBalancer;
	}
	
	private CacheType readCacheTypeTrafficControl = null;
	public CacheType getCacheTypeTrafficControl() {
		if(this.readCacheTypeTrafficControl==null) {
			this.readCacheTypeTrafficControl = readCacheType("org.openspcoop2.pdd.cache.impl.trafficControl");
		}
		return this.readCacheTypeTrafficControl;
	}
	
	private CacheType readCacheTypeMessage = null;
	public CacheType getCacheTypeMessage() {
		if(this.readCacheTypeMessage==null) {
			this.readCacheTypeMessage = readCacheType("org.openspcoop2.pdd.cache.impl.message");
		}
		return this.readCacheTypeMessage;
	}
	
	private CacheType readCacheTypeRequestManager = null;
	public CacheType getCacheTypeRequestManager() {
		if(this.readCacheTypeRequestManager==null) {
			this.readCacheTypeRequestManager = readCacheType("org.openspcoop2.pdd.cache.impl.requestManager");
		}
		return this.readCacheTypeRequestManager;
	}
	
	
	public CacheType readCacheType(String pName){
		try{  
			String value = this.reader.getValueConvertEnvProperties(pName); 

			if(value!=null){
				value = value.trim();
				return CacheType.valueOf(value);
			}else{
				this.logWarn(getMessaggioProprietaNonImpostata(pName,CacheType.JCS.toString()));
				return CacheType.JCS;
			}

		}catch(java.lang.Exception e) {
			this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CacheType.JCS.toString()),e);
			return CacheType.JCS;
		}
	}

	private Boolean isConfigurazioneCacheDebug = null;
	public boolean isConfigurazioneCacheDebug(){
		if(this.isConfigurazioneCacheDebug==null){
			String pName = "org.openspcoop2.pdd.cache.debug";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isConfigurazioneCacheDebug = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isConfigurazioneCacheDebug = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isConfigurazioneCacheDebug = false;
			}
		}

		return this.isConfigurazioneCacheDebug;
	}
	
	private Boolean isConfigurazioneCacheRequestManagerUseCache = null;
	public boolean isConfigurazioneCacheRequestManagerUseCache(){
		if(this.isConfigurazioneCacheRequestManagerUseCache==null){
			String pName = "org.openspcoop2.pdd.cache.impl.requestManager.useCache";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isConfigurazioneCacheRequestManagerUseCache = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isConfigurazioneCacheRequestManagerUseCache = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isConfigurazioneCacheRequestManagerUseCache = true;
			}
		}

		return this.isConfigurazioneCacheRequestManagerUseCache;
	}
	
	private Boolean isConfigurazioneCacheRequestManagerExternalResourceSaveInCache = null;
	public boolean isConfigurazioneCacheRequestManagerExternalResourceSaveInCache() {	
		if(this.isConfigurazioneCacheRequestManagerExternalResourceSaveInCache==null){
			String pName = "org.openspcoop2.pdd.cache.impl.requestManager.externalResource.saveInCache";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isConfigurazioneCacheRequestManagerExternalResourceSaveInCache = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isConfigurazioneCacheRequestManagerExternalResourceSaveInCache = false;
			}    
		}

		return this.isConfigurazioneCacheRequestManagerExternalResourceSaveInCache;
	}
	
	private Boolean isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache = null;
	public boolean isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache() {	
		if(this.isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache==null){
			String pName = "org.openspcoop2.pdd.cache.impl.requestManager.ocspResponse.saveInCache";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache = false;
			}    
		}

		return this.isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache;
	}
	
	private Boolean isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache = null;
	public boolean isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache() {	
		if(this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache==null){
			String pName = "org.openspcoop2.pdd.cache.impl.requestManager.remoteStore.saveInCache";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache = false;
			}    
		}

		return this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache;
	}


	
	
	/* ********  CONFIGURAZIONE PLUGINS  ******** */
	
	private Boolean isConfigurazionePluginsEnabled = null;
	public boolean isConfigurazionePluginsEnabled(){
		
		String pName = "org.openspcoop2.pdd.config.plugins.enabled";
		if(this.isConfigurazionePluginsEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isConfigurazionePluginsEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isConfigurazionePluginsEnabled = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isConfigurazionePluginsEnabled = true;
			}
		}

		return this.isConfigurazionePluginsEnabled;
	}
	
	private Boolean isConfigurazionePluginsDebug = null;
	public boolean isConfigurazionePluginsDebug(){
		
		String pName = "org.openspcoop2.pdd.config.plugins.debug";
		if(this.isConfigurazionePluginsDebug==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isConfigurazionePluginsDebug = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isConfigurazionePluginsDebug = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isConfigurazionePluginsDebug = true;
			}
		}

		return this.isConfigurazionePluginsDebug;
	}
	
	private Integer getConfigurazionePluginsSeconds = null;
	public int getConfigurazionePluginsSeconds(){
		
		String pName = "org.openspcoop2.pdd.config.plugins.seconds";
		if(this.getConfigurazionePluginsSeconds==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.getConfigurazionePluginsSeconds = Integer.parseInt(value);
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=300");
					this.getConfigurazionePluginsSeconds = 300;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=300, errore:"+e.getMessage(),e);
				this.getConfigurazionePluginsSeconds = 300;
			}
		}

		return this.getConfigurazionePluginsSeconds;
	}






	/* ********  DATASOURCE DI OPENSPCOOP  ******** */

	/**
	 * Restituisce il Nome JNDI del DataSource utilizzato da OpenSPCoop.
	 *
	 * @return il Nome JNDI del DataSource utilizzato da OpenSPCoop.
	 * 
	 */
	private String jndiNameDatasource = null;
	public String getJNDIName_DataSource() {	
		if(this.jndiNameDatasource==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dataSource");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();

				this.jndiNameDatasource = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.dataSource': "+e.getMessage(),e);
				this.jndiNameDatasource = null;
			}    
		}

		return this.jndiNameDatasource;
	}

	/**
	 * Restituisce le proprieta' da utilizzare con il contesto JNDI di lookup, se impostate.
	 *
	 * @return proprieta' da utilizzare con il contesto JNDI di lookup.
	 * 
	 */
	private java.util.Properties jndiContextDatasource = null;
	public java.util.Properties getJNDIContext_DataSource() {
		if(this.jndiContextDatasource == null){
			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.dataSource.property.");
				this.jndiContextDatasource = prop;

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle propriete' JNDI per il datasource di openspcoop 'org.openspcoop2.pdd.dataSource.property.*': "+e.getMessage(),e);
				this.jndiContextDatasource = null;
			}   
		}

		return this.jndiContextDatasource;
	}











	/* ********  CONNECTION FACTORY DI OPENSPCOOP  ******** */

	/**
	 * Restituisce il Nome JNDI del ConnectionFactory utilizzato da OpenSPCoop.
	 *
	 * @return il Nome JNDI del ConnectionFactory utilizzato da OpenSPCoop.
	 * 
	 */
	private String jndiNameConnectionFactory = null;
	public String getJNDIName_ConnectionFactory() {	
		if(this.jndiNameConnectionFactory==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.queueConnectionFactory");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();

				this.jndiNameConnectionFactory = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.queueConnectionFactory': "+e.getMessage(),e);
				this.jndiNameConnectionFactory = null;
			}    
		}

		return this.jndiNameConnectionFactory;
	}

	/**
	 * Restituisce le proprieta' da utilizzare con il contesto JNDI di lookup, se impostate.
	 *
	 * @return proprieta' da utilizzare con il contesto JNDI di lookup.
	 * 
	 */
	private java.util.Properties jndiContextConnectionFactory = null;
	public java.util.Properties getJNDIContext_ConnectionFactory() {
		if(this.jndiContextConnectionFactory==null){
			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.connectionFactory.property.");
				this.jndiContextConnectionFactory = prop;

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle propriete' JNDI del ConnectionFactory di openspcoop 'org.openspcoop2.pdd.connectionFactory.property.*': "+e.getMessage(),e);
				this.jndiContextConnectionFactory = null;
			}    
		}

		return this.jndiContextConnectionFactory;
	}

	/**
	 * Restituisce acknowledgeMode della Sessione utilizzata da OpenSPCoop.
	 *
	 * @return acknowledgeMode della Sessione utilizzata da OpenSPCoop.
	 * 
	 */
	private int acknowledgeModeSessioneConnectionFactory = -1;
	public int getAcknowledgeModeSessioneConnectionFactory() {	
		if(this.acknowledgeModeSessioneConnectionFactory==-1){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.queueConnectionFactory.session.AcknowledgeMode");

				if(name!=null){
					name = name.trim();
					if(CostantiConfigurazione.AUTO_ACKNOWLEDGE.equals(name))
						this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.AUTO_ACKNOWLEDGE;
					else if(CostantiConfigurazione.CLIENT_ACKNOWLEDGE.equals(name))
						this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.CLIENT_ACKNOWLEDGE;
					else if(CostantiConfigurazione.DUPS_OK_ACKNOWLEDGE.equals(name))
						this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.DUPS_OK_ACKNOWLEDGE;
					else
						throw new CoreException("Tipo di acknowledgeModeSessione non conosciuto (viene utilizzato il default:AUTO_ACKNOWLEDGE)");
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.queueConnectionFactory.session.AcknowledgeMode' non impostata, viene utilizzato il default=AUTO_ACKNOWLEDGE");
					this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.AUTO_ACKNOWLEDGE; // Default
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.queueConnectionFactory.session.AcknowledgeMode' non impostata, viene utilizzato il default=AUTO_ACKNOWLEDGE, errore:"+e.getMessage(),e);
				this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.AUTO_ACKNOWLEDGE; // Default
			}    
		}

		return this.acknowledgeModeSessioneConnectionFactory;
	}








	/* ********  CODE JMS DI OPENSPCOOP  ******** */

	public java.util.Map<String,String> getJNDIQueueName(boolean receiverJMSActive,boolean senderJMSActive){
		java.util.Map<String,String> table = new java.util.HashMap<>();
		try{ 
			boolean ricezioneContenutiApplicativi = !receiverJMSActive;
			boolean ricezioneBuste = !receiverJMSActive;
			boolean consegnaContenutiApplicativi = !senderJMSActive;
			boolean inoltroBuste = !senderJMSActive;
			boolean inoltroRisposte = !senderJMSActive;
			boolean imbustamento = !senderJMSActive;
			boolean imbustamentoRisposte = !senderJMSActive;
			boolean sbustamento=!senderJMSActive;
			boolean sbustamentoRisposte=!senderJMSActive;
			java.util.Enumeration<?> en = this.reader.propertyNames();
			for (; en.hasMoreElements() ;) {
				String property = (String) en.nextElement();
				if(property.startsWith("org.openspcoop2.pdd.queue.")){
					String key = (property.substring("org.openspcoop2.pdd.queue.".length()));
					if(key != null)
						key = key.trim();
					String value = this.reader.getValueConvertEnvProperties(property);
					if(value!=null)
						value = value.trim();
					if(receiverJMSActive){
						if("ricezioneContenutiApplicativi".equals(key) && value!=null){
							table.put(RicezioneContenutiApplicativi.ID_MODULO, value);
							ricezioneContenutiApplicativi = true;
						}else if("ricezioneBuste".equals(key) && value!=null){
							table.put(RicezioneBuste.ID_MODULO, value);
							ricezioneBuste = true;
						}
					}
					if(senderJMSActive){
						if("inoltroBuste".equals(key) && value!=null){
							table.put(InoltroBuste.ID_MODULO, value);
							inoltroBuste = true;
						}else if("inoltroRisposte".equals(key) && value!=null){
							table.put(InoltroRisposte.ID_MODULO, value);
							inoltroRisposte = true;
						}else if("consegnaContenutiApplicativi".equals(key) && value!=null){
							table.put(ConsegnaContenutiApplicativi.ID_MODULO, value);
							consegnaContenutiApplicativi = true;
						}else if("imbustamento".equals(key) && value!=null){
							table.put(Imbustamento.ID_MODULO, value);
							imbustamento = true;
						}else if("imbustamentoRisposte".equals(key) && value!=null){
							table.put(ImbustamentoRisposte.ID_MODULO, value);
							imbustamentoRisposte = true;
						}else if("sbustamento".equals(key) && value!=null){
							table.put(Sbustamento.ID_MODULO, value);
							sbustamento = true;
						}else if("sbustamentoRisposte".equals(key) && value!=null){
							table.put(SbustamentoRisposte.ID_MODULO, value);
							sbustamentoRisposte = true;
						}
					}
				}
			}


			if(ricezioneContenutiApplicativi==false){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.ricezioneContenutiApplicativi non definita");
				return null;
			}
			if(ricezioneBuste==false){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.ricezioneBuste non definita");
				return null;
			}
			if(consegnaContenutiApplicativi==false){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.consegnaContenutiApplicativi non definita");
				return null;
			}
			if(inoltroBuste==false){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.inoltroBuste non definita");
				return null;
			}
			if(inoltroRisposte==false){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.inoltroRisposte non definita");
				return null;
			}
			if(imbustamento==false){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.imbustamento non definita");
				return null;
			}if(imbustamentoRisposte==false){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.imbustamentoRisposte non definita");
				return null;
			}else if(sbustamentoRisposte==false){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.sbustamentoRisposte non definita");
				return null;
			}
			if(sbustamento==false){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.sbustamento non definita");
				return null;
			}
			return table;

		}catch(java.lang.Exception e) {
			this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop 'org.openspcoop2.pdd.queue.property.*': "+e.getMessage(),e);
			return null;
		}    
	}

	/**
	 * Restituisce le proprieta' da utilizzare nel contesto JNDI di lookup per localizzare le code.
	 *
	 * @return proprieta' da utilizzare con il contesto JNDI di lookup per localizzare le code.
	 * 
	 */
	private java.util.Properties jndiContext_CodeInterne = null;
	public java.util.Properties getJNDIContext_CodeInterne() {	
		if(this.jndiContext_CodeInterne==null){
			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.queue.property.");
				this.jndiContext_CodeInterne = prop;

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle propriete' JNDI delle code di openspcoop 'org.openspcoop2.pdd.queue.property.*': "+e.getMessage(),e);
				this.jndiContext_CodeInterne = null;
			}    
		}

		return this.jndiContext_CodeInterne;
	}














	/* ********  Timer EJB DI OPENSPCOOP  ******** */

	public java.util.Map<String,String> getJNDITimerEJBName(){
		java.util.Map<String,String> table = new java.util.HashMap<>();
		try{ 
			boolean gestoreBusteNonRiscontrate = false;
			boolean gestoreMessaggi = false;
			boolean gestorePuliziaMessaggiAnomali = false;
			boolean gestoreRepositoryBuste = false;
			java.util.Enumeration<?> en = this.reader.propertyNames();
			for (; en.hasMoreElements() ;) {
				String property = (String) en.nextElement();
				if(property.startsWith("org.openspcoop2.pdd.timer.")){
					String key = (property.substring("org.openspcoop2.pdd.timer.".length()));
					if(key != null)
						key = key.trim();
					String value = this.reader.getValueConvertEnvProperties(property);
					if(value!=null)
						value = value.trim();
					if("gestoreBusteNonRiscontrate".equals(key) && value!=null){
						table.put(TimerGestoreBusteNonRiscontrate.ID_MODULO, value);
						gestoreBusteNonRiscontrate = true;
					}else if("gestoreMessaggi".equals(key) && value!=null){
						table.put(TimerGestoreMessaggi.ID_MODULO, value);
						gestoreMessaggi = true;
					}else if("gestorePuliziaMessaggiAnomali".equals(key) && value!=null){
						table.put(TimerGestorePuliziaMessaggiAnomali.ID_MODULO, value);
						gestorePuliziaMessaggiAnomali = true;
					}else if("gestoreRepositoryBuste".equals(key) && value!=null){
						table.put(TimerGestoreRepositoryBuste.ID_MODULO, value);
						gestoreRepositoryBuste = true;
					}
				}
			}


			if(gestoreBusteNonRiscontrate==false && this.isTimerGestoreRiscontriRicevuteAbilitato()){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI dei timer openspcoop: timer org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate non definito");
				return null;
			}
			if(gestoreMessaggi==false && this.isTimerGestoreMessaggiAbilitato()){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI dei timer openspcoop: timer org.openspcoop2.pdd.timer.gestoreMessaggi non definito");
				return null;
			}
			if(gestorePuliziaMessaggiAnomali==false && this.isTimerGestorePuliziaMessaggiAnomaliAbilitato()){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI dei timer openspcoop: timer org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali non definito");
				return null;
			}
			if(gestoreRepositoryBuste==false && this.isTimerGestoreRepositoryBusteAbilitato()){
				this.logError("Riscontrato errore durante la lettura dei nomi JNDI dei timer openspcoop: timer org.openspcoop2.pdd.timer.gestoreRepositoryBuste  non definito");
				return null;
			}
			return table;

		}catch(java.lang.Exception e) {
			this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop 'org.openspcoop2.pdd.queue.property.*': "+e.getMessage(),e);
			return null;
		}    
	}

	/**
	 * Restituisce le proprieta' da utilizzare nel contesto JNDI di lookup per localizzare i timer.
	 *
	 * @return proprieta' da utilizzare con il contesto JNDI di lookup per localizzare i timer.
	 * 
	 */
	private java.util.Properties jndiContext_TimerEJB = null;
	public java.util.Properties getJNDIContext_TimerEJB() {	
		if(this.jndiContext_TimerEJB==null){
			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.timer.property.");
				this.jndiContext_TimerEJB = prop;

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle propriete' JNDI dei timer di openspcoop 'org.openspcoop2.pdd.timer.property.*': "+e.getMessage(),e);
				this.jndiContext_TimerEJB = null;
			}    
		}

		return this.jndiContext_TimerEJB;
	}
	
	private Boolean isTimerAutoStart_StopTimer = null;
	public boolean isTimerAutoStart_StopTimer(){
		if(this.isTimerAutoStart_StopTimer==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.autoStart.stop"); 

				if(value!=null){
					value = value.trim();
					this.isTimerAutoStart_StopTimer = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.autoStart.stop' non impostata, viene utilizzato il default=true");
					this.isTimerAutoStart_StopTimer = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.autoStart.stop', viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTimerAutoStart_StopTimer = true;
			}
		}

		return this.isTimerAutoStart_StopTimer;
	}
	
	
	

	
	// GestoreRiscontriRicevute
	
	/**
	 * Restituisce l'indicazione se avviare il timer
	 *
	 * @return Restituisce indicazione se avviare il timer
	 * 
	 */
	private Boolean isTimerGestoreRiscontriRicevuteAbilitato = null;
	public boolean isTimerGestoreRiscontriRicevuteAbilitato(){
		if(this.isTimerGestoreRiscontriRicevuteAbilitato==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.enable"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreRiscontriRicevuteAbilitato = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.enable' non impostata, viene utilizzato il default=true");
					this.isTimerGestoreRiscontriRicevuteAbilitato = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.enable', viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTimerGestoreRiscontriRicevuteAbilitato = true;
			}
		}

		return this.isTimerGestoreRiscontriRicevuteAbilitato;
	}
	
	/**
	 * Restituisce l'indicazione se registrare su log le queries
	 *
	 * @return Restituisce indicazione se registrare su log le queries
	 * 
	 */
	private Boolean isTimerGestoreRiscontriRicevuteAbilitatoLog = null;
	public boolean isTimerGestoreRiscontriRicevuteAbilitatoLog(){
		if(this.isTimerGestoreRiscontriRicevuteAbilitatoLog==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.logQuery"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreRiscontriRicevuteAbilitatoLog = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.logQuery' non impostata, viene utilizzato il default=false");
					this.isTimerGestoreRiscontriRicevuteAbilitatoLog = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.logQuery', viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isTimerGestoreRiscontriRicevuteAbilitatoLog = false;
			}
		}

		return this.isTimerGestoreRiscontriRicevuteAbilitatoLog;
	}
	
	/**
	 * Restituisce l'indicazione sul numero di messaggi alla volta processati
	 *
	 * @return Restituisce indicazione sul numero di messaggi alla volta processati
	 * 
	 */
	private Integer getTimerGestoreRiscontriRicevuteLimit = null;
	public int getTimerGestoreRiscontriRicevuteLimit(){
		if(this.getTimerGestoreRiscontriRicevuteLimit==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.query.limit"); 

				if(value!=null){
					value = value.trim();
					this.getTimerGestoreRiscontriRicevuteLimit = Integer.parseInt(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.query.limit' non impostata, viene utilizzato il default="+CostantiPdD.LIMIT_MESSAGGI_GESTORI);
					this.getTimerGestoreRiscontriRicevuteLimit = CostantiPdD.LIMIT_MESSAGGI_GESTORI;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.query.limit', viene utilizzato il default="+CostantiPdD.LIMIT_MESSAGGI_GESTORI+", errore:"+e.getMessage(),e);
				this.getTimerGestoreRiscontriRicevuteLimit = CostantiPdD.LIMIT_MESSAGGI_GESTORI;
			}
		}

		return this.getTimerGestoreRiscontriRicevuteLimit;
	}
	
	private Integer getTimerGestoreRiscontriRicevute_lockMaxLife = null;
	public int getTimerGestoreRiscontriRicevute_lockMaxLife() {	
		if(this.getTimerGestoreRiscontriRicevute_lockMaxLife==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.maxLife");

				if(name!=null){
					name = name.trim();
					this.getTimerGestoreRiscontriRicevute_lockMaxLife = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
					this.getTimerGestoreRiscontriRicevute_lockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE+", errore:"+e.getMessage(),e);
				this.getTimerGestoreRiscontriRicevute_lockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
			}  
			if(this.getTimerGestoreRiscontriRicevute_lockMaxLife!=null && this.getTimerGestoreRiscontriRicevute_lockMaxLife>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getTimerGestoreRiscontriRicevute_lockMaxLife = this.getTimerGestoreRiscontriRicevute_lockMaxLife *1000;
			}
		}

		return this.getTimerGestoreRiscontriRicevute_lockMaxLife;
	}
	
	private Integer getTimerGestoreRiscontriRicevute_lockIdleTime = null;
	public int getTimerGestoreRiscontriRicevute_lockIdleTime() {	
		if(this.getTimerGestoreRiscontriRicevute_lockIdleTime==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.idleTime");

				if(name!=null){
					name = name.trim();
					this.getTimerGestoreRiscontriRicevute_lockIdleTime = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
					this.getTimerGestoreRiscontriRicevute_lockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME+", errore:"+e.getMessage(),e);
				this.getTimerGestoreRiscontriRicevute_lockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
			} 
			if(this.getTimerGestoreRiscontriRicevute_lockIdleTime!=null && this.getTimerGestoreRiscontriRicevute_lockIdleTime>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getTimerGestoreRiscontriRicevute_lockIdleTime = this.getTimerGestoreRiscontriRicevute_lockIdleTime *1000;
			}
		}

		return this.getTimerGestoreRiscontriRicevute_lockIdleTime;
	}
	
	private Long getTimerGestoreRiscontriRicevute_getLockAttesaAttiva = null;
	public long getTimerGestoreRiscontriRicevute_getLockAttesaAttiva() {	
		if(this.getTimerGestoreRiscontriRicevute_getLockAttesaAttiva==null){
			String pName = "org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.attesaAttiva";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					long time = java.lang.Long.parseLong(name);
					this.getTimerGestoreRiscontriRicevute_getLockAttesaAttiva = time*1000;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
					this.getTimerGestoreRiscontriRicevute_getLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.getTimerGestoreRiscontriRicevute_getLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
			}    
		}

		return this.getTimerGestoreRiscontriRicevute_getLockAttesaAttiva;
	}

	private Integer getTimerGestoreRiscontriRicevute_getLockCheckInterval = null;
	public int getTimerGestoreRiscontriRicevute_getLockCheckInterval() {	
		if(this.getTimerGestoreRiscontriRicevute_getLockCheckInterval==null){
			String pName = "org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.check";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.getTimerGestoreRiscontriRicevute_getLockCheckInterval = time;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
					this.getTimerGestoreRiscontriRicevute_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.getTimerGestoreRiscontriRicevute_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
			}  
		}

		return this.getTimerGestoreRiscontriRicevute_getLockCheckInterval;
	}
	
	
	
	
	// GestoreMessaggi
	
	/**
	 * Restituisce l'indicazione se avviare il timer
	 *
	 * @return Restituisce indicazione se avviare il timer
	 * 
	 */
	private Boolean isTimerGestoreMessaggiAbilitato = null;
	public boolean isTimerGestoreMessaggiAbilitato(){
		if(this.isTimerGestoreMessaggiAbilitato==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.enable"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreMessaggiAbilitato = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.enable' non impostata, viene utilizzato il default=true");
					this.isTimerGestoreMessaggiAbilitato = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.enable', viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTimerGestoreMessaggiAbilitato = true;
			}
		}

		return this.isTimerGestoreMessaggiAbilitato;
	}
	
	private Boolean isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata = null;
	public boolean isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata(){
		if(this.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiEliminati.enable"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiEliminati.enable' non impostata, viene utilizzato il default=true");
					this.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiEliminati.enable', viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata = true;
			}
		}

		return this.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata;
	}
	
	private Boolean isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata = null;
	public boolean isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata(){
		if(this.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiScaduti.enable"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiScaduti.enable' non impostata, viene utilizzato il default=true");
					this.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiScaduti.enable', viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata = true;
			}
		}

		return this.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata;
	}
	
	private Boolean isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata = null;
	public boolean isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata(){
		if(this.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiNonGestiti.enable"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiNonGestiti.enable' non impostata, viene utilizzato il default=true");
					this.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiNonGestiti.enable', viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata = true;
			}
		}

		return this.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata;
	}
	
	private Boolean isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata = null;
	public boolean isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata(){
		if(this.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaCorrelazioneApplicativa.enable"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaCorrelazioneApplicativa.enable' non impostata, viene utilizzato il default=true");
					this.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaCorrelazioneApplicativa.enable', viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata = true;
			}
		}

		return this.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata;
	}
	
	/**
	 * Restituisce l'indicazione se usare l'order by nelle queries
	 *
	 * @return Restituisce indicazione se usare l'order by nelle queries
	 * 
	 */
	private Boolean isTimerGestoreMessaggiAbilitatoOrderBy = null;
	public boolean isTimerGestoreMessaggiAbilitatoOrderBy(){
		if(this.isTimerGestoreMessaggiAbilitatoOrderBy==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.orderBy"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreMessaggiAbilitatoOrderBy = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.orderBy' non impostata, viene utilizzato il default=false");
					this.isTimerGestoreMessaggiAbilitatoOrderBy = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.orderBy', viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isTimerGestoreMessaggiAbilitatoOrderBy = false;
			}
		}

		return this.isTimerGestoreMessaggiAbilitatoOrderBy;
	}
	
	/**
	 * Restituisce l'indicazione se registrare su log le queries
	 *
	 * @return Restituisce indicazione se registrare su log le queries
	 * 
	 */
	private Boolean isTimerGestoreMessaggiAbilitatoLog = null;
	public boolean isTimerGestoreMessaggiAbilitatoLog(){
		if(this.isTimerGestoreMessaggiAbilitatoLog==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.logQuery"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreMessaggiAbilitatoLog = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.logQuery' non impostata, viene utilizzato il default=false");
					this.isTimerGestoreMessaggiAbilitatoLog = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.logQuery', viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isTimerGestoreMessaggiAbilitatoLog = false;
			}
		}

		return this.isTimerGestoreMessaggiAbilitatoLog;
	}
	
	/**
	 * Restituisce l'indicazione sul numero di messaggi alla volta processati
	 *
	 * @return Restituisce indicazione sul numero di messaggi alla volta processati
	 * 
	 */
	private Integer getTimerGestoreMessaggiLimit = null;
	public int getTimerGestoreMessaggiLimit(){
		if(this.getTimerGestoreMessaggiLimit==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.query.limit"); 

				if(value!=null){
					value = value.trim();
					this.getTimerGestoreMessaggiLimit = Integer.parseInt(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.query.limit' non impostata, viene utilizzato il default="+CostantiPdD.LIMIT_MESSAGGI_GESTORI);
					this.getTimerGestoreMessaggiLimit = CostantiPdD.LIMIT_MESSAGGI_GESTORI;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.query.limit', viene utilizzato il default="+CostantiPdD.LIMIT_MESSAGGI_GESTORI+", errore:"+e.getMessage(),e);
				this.getTimerGestoreMessaggiLimit = CostantiPdD.LIMIT_MESSAGGI_GESTORI;
			}
		}

		return this.getTimerGestoreMessaggiLimit;
	}
	
	/**
	 * Restituisce l'indicazione se devono essere verificate anche le connessioni rimaste attive
	 *
	 * @return Restituisce indicazione se devono essere verificate anche le connessioni rimaste attive
	 * 
	 */
	private Boolean isTimerGestoreMessaggiVerificaConnessioniAttive = null;
	public boolean isTimerGestoreMessaggiVerificaConnessioniAttive(){
		if(this.isTimerGestoreMessaggiVerificaConnessioniAttive==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.verificaConnessioniAttive"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreMessaggiVerificaConnessioniAttive = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.verificaConnessioniAttive' non impostata, viene utilizzato il default=false");
					this.isTimerGestoreMessaggiVerificaConnessioniAttive = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.verificaConnessioniAttive', viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isTimerGestoreMessaggiVerificaConnessioniAttive = false;
			}
		}

		return this.isTimerGestoreMessaggiVerificaConnessioniAttive;
	}
		
	private Integer getTimerGestoreMessaggi_lockMaxLife = null;
	public int getTimerGestoreMessaggi_lockMaxLife() {	
		if(this.getTimerGestoreMessaggi_lockMaxLife==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.lock.maxLife");

				if(name!=null){
					name = name.trim();
					this.getTimerGestoreMessaggi_lockMaxLife = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
					this.getTimerGestoreMessaggi_lockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE+", errore:"+e.getMessage(),e);
				this.getTimerGestoreMessaggi_lockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
			}
			if(this.getTimerGestoreMessaggi_lockMaxLife!=null && this.getTimerGestoreMessaggi_lockMaxLife>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getTimerGestoreMessaggi_lockMaxLife = this.getTimerGestoreMessaggi_lockMaxLife *1000;
			}
		}

		return this.getTimerGestoreMessaggi_lockMaxLife;
	}
	
	private Integer getTimerGestoreMessaggi_lockIdleTime = null;
	public int getTimerGestoreMessaggi_lockIdleTime() {	
		if(this.getTimerGestoreMessaggi_lockIdleTime==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.lock.idleTime");

				if(name!=null){
					name = name.trim();
					this.getTimerGestoreMessaggi_lockIdleTime = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
					this.getTimerGestoreMessaggi_lockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME+", errore:"+e.getMessage(),e);
				this.getTimerGestoreMessaggi_lockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
			}
			if(this.getTimerGestoreMessaggi_lockIdleTime!=null && this.getTimerGestoreMessaggi_lockIdleTime>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getTimerGestoreMessaggi_lockIdleTime = this.getTimerGestoreMessaggi_lockIdleTime *1000;
			}
		}

		return this.getTimerGestoreMessaggi_lockIdleTime;
	}
	
	private Long getTimerGestoreMessaggi_getLockAttesaAttiva = null;
	public long getTimerGestoreMessaggi_getLockAttesaAttiva() {	
		if(this.getTimerGestoreMessaggi_getLockAttesaAttiva==null){
			String pName = "org.openspcoop2.pdd.timer.gestoreMessaggi.lock.attesaAttiva";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					long time = java.lang.Long.parseLong(name);
					this.getTimerGestoreMessaggi_getLockAttesaAttiva = time*1000;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
					this.getTimerGestoreMessaggi_getLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.getTimerGestoreMessaggi_getLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
			}    
		}

		return this.getTimerGestoreMessaggi_getLockAttesaAttiva;
	}

	private Integer getTimerGestoreMessaggi_getLockCheckInterval = null;
	public int getTimerGestoreMessaggi_getLockCheckInterval() {	
		if(this.getTimerGestoreMessaggi_getLockCheckInterval==null){
			String pName = "org.openspcoop2.pdd.timer.gestoreMessaggi.lock.check";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.getTimerGestoreMessaggi_getLockCheckInterval = time;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
					this.getTimerGestoreMessaggi_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.getTimerGestoreMessaggi_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
			}  
		}

		return this.getTimerGestoreMessaggi_getLockCheckInterval;
	}
	
	
	
	
	// GestorePuliziaMessaggiAnomali
	
	/**
	 * Restituisce l'indicazione se avviare il timer
	 *
	 * @return Restituisce indicazione se avviare il timer
	 * 
	 */
	private Boolean isTimerGestorePuliziaMessaggiAnomaliAbilitato = null;
	public boolean isTimerGestorePuliziaMessaggiAnomaliAbilitato(){
		if(this.isTimerGestorePuliziaMessaggiAnomaliAbilitato==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.enable"); 
				if(value!=null){
					value = value.trim();
					this.isTimerGestorePuliziaMessaggiAnomaliAbilitato = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.enable' non impostata, viene utilizzato il default=true");
					this.isTimerGestorePuliziaMessaggiAnomaliAbilitato = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.enable', viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTimerGestorePuliziaMessaggiAnomaliAbilitato = true;
			}
		}

		return this.isTimerGestorePuliziaMessaggiAnomaliAbilitato;
	}
	
	/**
	 * Restituisce l'indicazione se usare l'order by nelle queries
	 *
	 * @return Restituisce indicazione se usare l'order by nelle queries
	 * 
	 */
	private Boolean isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy = null;
	public boolean isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy(){
		if(this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.orderBy"); 
				if(value!=null){
					value = value.trim();
					this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.orderBy' non impostata, viene utilizzato il default=false");
					this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.orderBy', viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy = false;
			}
		}

		return this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy;
	}
	
	/**
	 * Restituisce l'indicazione se registrare su log le queries
	 *
	 * @return Restituisce indicazione se registrare su log le queries
	 * 
	 */
	private Boolean isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog = null;
	public boolean isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog(){
		if(this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.logQuery"); 
				if(value!=null){
					value = value.trim();
					this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.logQuery' non impostata, viene utilizzato il default=false");
					this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.logQuery', viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog = false;
			}
		}

		return this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog;
	}

	/**
	 * Restituisce l'indicazione sul numero di messaggi alla volta processati
	 *
	 * @return Restituisce indicazione sul numero di messaggi alla volta processati
	 * 
	 */
	private Integer getTimerGestorePuliziaMessaggiAnomaliLimit = null;
	public int getTimerGestorePuliziaMessaggiAnomaliLimit(){
		if(this.getTimerGestorePuliziaMessaggiAnomaliLimit==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.query.limit"); 

				if(value!=null){
					value = value.trim();
					this.getTimerGestorePuliziaMessaggiAnomaliLimit = Integer.parseInt(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.query.limit' non impostata, viene utilizzato il default="+CostantiPdD.LIMIT_MESSAGGI_GESTORI);
					this.getTimerGestorePuliziaMessaggiAnomaliLimit = CostantiPdD.LIMIT_MESSAGGI_GESTORI;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.query.limit', viene utilizzato il default="+CostantiPdD.LIMIT_MESSAGGI_GESTORI+", errore:"+e.getMessage(),e);
				this.getTimerGestorePuliziaMessaggiAnomaliLimit = CostantiPdD.LIMIT_MESSAGGI_GESTORI;
			}
		}

		return this.getTimerGestorePuliziaMessaggiAnomaliLimit;
	}
	
	private Integer getTimerGestorePuliziaMessaggiAnomali_lockMaxLife = null;
	public int getTimerGestorePuliziaMessaggiAnomali_lockMaxLife() {	
		if(this.getTimerGestorePuliziaMessaggiAnomali_lockMaxLife==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.maxLife");

				if(name!=null){
					name = name.trim();
					this.getTimerGestorePuliziaMessaggiAnomali_lockMaxLife = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
					this.getTimerGestorePuliziaMessaggiAnomali_lockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE+", errore:"+e.getMessage(),e);
				this.getTimerGestorePuliziaMessaggiAnomali_lockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
			}  
			if(this.getTimerGestorePuliziaMessaggiAnomali_lockMaxLife!=null && this.getTimerGestorePuliziaMessaggiAnomali_lockMaxLife>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getTimerGestorePuliziaMessaggiAnomali_lockMaxLife = this.getTimerGestorePuliziaMessaggiAnomali_lockMaxLife *1000;
			}
		}

		return this.getTimerGestorePuliziaMessaggiAnomali_lockMaxLife;
	}
	
	private Integer getTimerGestorePuliziaMessaggiAnomali_lockIdleTime = null;
	public int getTimerGestorePuliziaMessaggiAnomali_lockIdleTime() {	
		if(this.getTimerGestorePuliziaMessaggiAnomali_lockIdleTime==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.idleTime");

				if(name!=null){
					name = name.trim();
					this.getTimerGestorePuliziaMessaggiAnomali_lockIdleTime = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
					this.getTimerGestorePuliziaMessaggiAnomali_lockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME+", errore:"+e.getMessage(),e);
				this.getTimerGestorePuliziaMessaggiAnomali_lockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
			} 
			if(this.getTimerGestorePuliziaMessaggiAnomali_lockIdleTime!=null && this.getTimerGestorePuliziaMessaggiAnomali_lockIdleTime>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getTimerGestorePuliziaMessaggiAnomali_lockIdleTime = this.getTimerGestorePuliziaMessaggiAnomali_lockIdleTime *1000;
			}
		}

		return this.getTimerGestorePuliziaMessaggiAnomali_lockIdleTime;
	}
	
	private Long getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva = null;
	public long getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva() {	
		if(this.getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva==null){
			String pName = "org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.attesaAttiva";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					long time = java.lang.Long.parseLong(name);
					this.getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva = time*1000;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
					this.getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
			}    
		}

		return this.getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva;
	}

	private Integer getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval = null;
	public int getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval() {	
		if(this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval==null){
			String pName = "org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.check";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval = time;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
					this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
			}  
		}

		return this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval;
	}
	
	
	
	// GestoreBuste
	
	/**
	 * Restituisce l'indicazione se avviare il timer
	 *
	 * @return Restituisce indicazione se avviare il timer
	 * 
	 */
	private Boolean isTimerGestoreRepositoryBusteAbilitato = null;
	public boolean isTimerGestoreRepositoryBusteAbilitato(){
		if(this.isTimerGestoreRepositoryBusteAbilitato==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.enable"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreRepositoryBusteAbilitato = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.enable' non impostata, viene utilizzato il default=true");
					this.isTimerGestoreRepositoryBusteAbilitato = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.enable', viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTimerGestoreRepositoryBusteAbilitato = true;
			}
		}

		return this.isTimerGestoreRepositoryBusteAbilitato;
	}
	private Boolean isTimerGestoreRepositoryBusteAbilitatoInitialState = null;
	public boolean isTimerGestoreRepositoryBusteAbilitatoInitialState(){
		if(this.isTimerGestoreRepositoryBusteAbilitatoInitialState==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.statoIniziale.enable"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreRepositoryBusteAbilitatoInitialState = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.statoIniziale.enable' non impostata, viene utilizzato il default=true");
					this.isTimerGestoreRepositoryBusteAbilitatoInitialState = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.statoIniziale.enable', viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTimerGestoreRepositoryBusteAbilitatoInitialState = true;
			}
		}

		return this.isTimerGestoreRepositoryBusteAbilitatoInitialState;
	}

	/**
	 * Restituisce l'indicazione se usare l'order by nelle queries
	 *
	 * @return Restituisce indicazione se usare l'order by nelle queries
	 * 
	 */
	private Boolean isTimerGestoreRepositoryBusteAbilitatoOrderBy = null;
	public boolean isTimerGestoreRepositoryBusteAbilitatoOrderBy(){
		if(this.isTimerGestoreRepositoryBusteAbilitatoOrderBy==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.orderBy"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreRepositoryBusteAbilitatoOrderBy = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.orderBy' non impostata, viene utilizzato il default=false");
					this.isTimerGestoreRepositoryBusteAbilitatoOrderBy = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.orderBy', viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isTimerGestoreRepositoryBusteAbilitatoOrderBy = false;
			}
		}

		return this.isTimerGestoreRepositoryBusteAbilitatoOrderBy;
	}
	
	/**
	 * Restituisce l'indicazione se registrare su log le queries
	 *
	 * @return Restituisce indicazione se registrare su log le queries
	 * 
	 */
	private Boolean isTimerGestoreRepositoryBusteAbilitatoLog = null;
	public boolean isTimerGestoreRepositoryBusteAbilitatoLog(){
		if(this.isTimerGestoreRepositoryBusteAbilitatoLog==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.logQuery"); 

				if(value!=null){
					value = value.trim();
					this.isTimerGestoreRepositoryBusteAbilitatoLog = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.logQuery' non impostata, viene utilizzato il default=false");
					this.isTimerGestoreRepositoryBusteAbilitatoLog = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.logQuery', viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isTimerGestoreRepositoryBusteAbilitatoLog = false;
			}
		}

		return this.isTimerGestoreRepositoryBusteAbilitatoLog;
	}
	
	/**
	 * Restituisce l'indicazione sul numero di messaggi alla volta processati
	 *
	 * @return Restituisce indicazione sul numero di messaggi alla volta processati
	 * 
	 */
	private Integer getTimerGestoreRepositoryBusteLimit = null;
	public int getTimerGestoreRepositoryBusteLimit(){
		if(this.getTimerGestoreRepositoryBusteLimit==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.query.limit"); 

				if(value!=null){
					value = value.trim();
					this.getTimerGestoreRepositoryBusteLimit = Integer.parseInt(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.query.limit' non impostata, viene utilizzato il default="+CostantiPdD.LIMIT_MESSAGGI_GESTORI);
					this.getTimerGestoreRepositoryBusteLimit = CostantiPdD.LIMIT_MESSAGGI_GESTORI;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.query.limit', viene utilizzato il default="+CostantiPdD.LIMIT_MESSAGGI_GESTORI+", errore:"+e.getMessage(),e);
				this.getTimerGestoreRepositoryBusteLimit = CostantiPdD.LIMIT_MESSAGGI_GESTORI;
			}
		}

		return this.getTimerGestoreRepositoryBusteLimit;
	}
	
	private Integer getTimerGestoreRepositoryBuste_lockMaxLife = null;
	public int getTimerGestoreRepositoryBuste_lockMaxLife() {	
		if(this.getTimerGestoreRepositoryBuste_lockMaxLife==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.maxLife");

				if(name!=null){
					name = name.trim();
					this.getTimerGestoreRepositoryBuste_lockMaxLife = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
					this.getTimerGestoreRepositoryBuste_lockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE+", errore:"+e.getMessage(),e);
				this.getTimerGestoreRepositoryBuste_lockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
			}
			if(this.getTimerGestoreRepositoryBuste_lockMaxLife!=null && this.getTimerGestoreRepositoryBuste_lockMaxLife>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getTimerGestoreRepositoryBuste_lockMaxLife = this.getTimerGestoreRepositoryBuste_lockMaxLife *1000;
			}
		}

		return this.getTimerGestoreRepositoryBuste_lockMaxLife;
	}
	
	private Integer getTimerGestoreRepositoryBuste_lockIdleTime = null;
	public int getTimerGestoreRepositoryBuste_lockIdleTime() {	
		if(this.getTimerGestoreRepositoryBuste_lockIdleTime==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.idleTime");

				if(name!=null){
					name = name.trim();
					this.getTimerGestoreRepositoryBuste_lockIdleTime = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
					this.getTimerGestoreRepositoryBuste_lockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME+", errore:"+e.getMessage(),e);
				this.getTimerGestoreRepositoryBuste_lockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
			}
			if(this.getTimerGestoreRepositoryBuste_lockIdleTime!=null && this.getTimerGestoreRepositoryBuste_lockIdleTime>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getTimerGestoreRepositoryBuste_lockIdleTime = this.getTimerGestoreRepositoryBuste_lockIdleTime *1000;
			}
		}

		return this.getTimerGestoreRepositoryBuste_lockIdleTime;
	}

	private Long getTimerGestoreRepositoryBuste_getLockAttesaAttiva = null;
	public long getTimerGestoreRepositoryBuste_getLockAttesaAttiva() {	
		if(this.getTimerGestoreRepositoryBuste_getLockAttesaAttiva==null){
			String pName = "org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.attesaAttiva";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					long time = java.lang.Long.parseLong(name);
					this.getTimerGestoreRepositoryBuste_getLockAttesaAttiva = time*1000;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
					this.getTimerGestoreRepositoryBuste_getLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.getTimerGestoreRepositoryBuste_getLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
			}    
		}

		return this.getTimerGestoreRepositoryBuste_getLockAttesaAttiva;
	}

	private Integer getTimerGestoreRepositoryBuste_getLockCheckInterval = null;
	public int getTimerGestoreRepositoryBuste_getLockCheckInterval() {	
		if(this.getTimerGestoreRepositoryBuste_getLockCheckInterval==null){
			String pName = "org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.check";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.getTimerGestoreRepositoryBuste_getLockCheckInterval = time;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
					this.getTimerGestoreRepositoryBuste_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.getTimerGestoreRepositoryBuste_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
			}  
		}

		return this.getTimerGestoreRepositoryBuste_getLockCheckInterval;
	}
	


	
	
	// Gestore ConsegnaContenutiApplicativi
	
	/**
	 * Restituisce l'indicazione se avviare il timer
	 *
	 * @return Restituisce indicazione se avviare il timer
	 * 
	 */
	private Boolean isTimerConsegnaContenutiApplicativiAbilitato = null;
	public boolean isTimerConsegnaContenutiApplicativiAbilitato(){
		
		if(this.isTimerConsegnaContenutiApplicativiAbilitato==null){
			if(this.isServerJ2EE()){
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.enable' disabilitata poiche' il prodotto e' configurato in modalita' server j2ee");
				this.isTimerConsegnaContenutiApplicativiAbilitato = false;
			}
			else{			
				try{  
					String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.enable"); 
					if(value!=null){
						value = value.trim();
						this.isTimerConsegnaContenutiApplicativiAbilitato = Boolean.parseBoolean(value);
					}else{
						this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.enable' non impostata, viene utilizzato il default=true");
						this.isTimerConsegnaContenutiApplicativiAbilitato = true;
					}
	
				}catch(java.lang.Exception e) {
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.enable', viene utilizzato il default=true, errore:"+e.getMessage(),e);
					this.isTimerConsegnaContenutiApplicativiAbilitato = true;
				}
			}

		}
		
		return this.isTimerConsegnaContenutiApplicativiAbilitato;
	}
	
	private Boolean isTimerConsegnaContenutiApplicativiSchedulingDebug = null;
	public boolean isTimerConsegnaContenutiApplicativiSchedulingDebug(){
		
		String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.scheduling.debug";
		if(this.isTimerConsegnaContenutiApplicativiSchedulingDebug==null){
			if(this.isServerJ2EE()){
				this.logWarn("Proprieta' di openspcoop '"+pName+"' disabilitata poiche' il prodotto e' configurato in modalita' server j2ee");
				this.isTimerConsegnaContenutiApplicativiSchedulingDebug = false;
			}
			else{			
				try{  
					String value = this.reader.getValueConvertEnvProperties(pName); 
					if(value!=null){
						value = value.trim();
						this.isTimerConsegnaContenutiApplicativiSchedulingDebug = Boolean.parseBoolean(value);
					}else{
						this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
						this.isTimerConsegnaContenutiApplicativiSchedulingDebug = true;
					}
	
				}catch(java.lang.Exception e) {
					this.logWarn("Proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true, errore:"+e.getMessage(),e);
					this.isTimerConsegnaContenutiApplicativiSchedulingDebug = true;
				}
			}

		}
		
		return this.isTimerConsegnaContenutiApplicativiSchedulingDebug;
	}
	
	private Boolean isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = null;
	public boolean isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica(){
		
		String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.scheduling.checkEliminazioneLogica";
		if(this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica==null){
			if(this.isServerJ2EE()){
				this.logWarn("Proprieta' di openspcoop '"+pName+"' disabilitata poiche' il prodotto e' configurato in modalita' server j2ee");
				this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = false;
			}
			else{			
				try{  
					String value = this.reader.getValueConvertEnvProperties(pName); 
					if(value!=null){
						value = value.trim();
						this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = Boolean.parseBoolean(value);
					}else{
						this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
						this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = true;
					}
	
				}catch(java.lang.Exception e) {
					this.logWarn("Proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true, errore:"+e.getMessage(),e);
					this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = true;
				}
			}

		}
		
		return this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica;
	}
	
	private List<String> getTimerConsegnaContenutiApplicativiCode = null;
	private boolean getTimerConsegnaContenutiApplicativiCodeRead = false;
	public List<String> getTimerConsegnaContenutiApplicativiCode() {	
		if(this.getTimerConsegnaContenutiApplicativiCodeRead == false){
			try{ 

				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.code");
				if(name==null){
					this.getTimerConsegnaContenutiApplicativiCode = null;
				}else{
					String [] r = name.trim().split(",");
					List<String> l = new ArrayList<>();
					for(int i=0; i<r.length; i++){
						r[i] = r[i].trim();
						l.add(r[i]);
					}
					
					if(!l.isEmpty()) {
						this.getTimerConsegnaContenutiApplicativiCode = new ArrayList<>();
						this.getTimerConsegnaContenutiApplicativiCode.addAll(l);
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.code': "+e.getMessage(),e);
				this.getTimerConsegnaContenutiApplicativiCode = null;
			}  
			this.getTimerConsegnaContenutiApplicativiCodeRead = true;
		}

		return this.getTimerConsegnaContenutiApplicativiCode;
	}
	
	private HashMap<String, ConfigurazioneCoda> getTimerConsegnaContenutiApplicativiConfigurazioneCoda = new HashMap<String, ConfigurazioneCoda>();
	public ConfigurazioneCoda getTimerConsegnaContenutiApplicativiConfigurazioneCoda(String nome) {
		
		ConfigurazioneCoda conf = this.getTimerConsegnaContenutiApplicativiConfigurazioneCoda.get(nome);
		if(conf!=null) {
			return conf;
		}
		
		String prefix = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.coda."+nome+".";
		try{ 
			Properties p = this.reader.readPropertiesConvertEnvProperties(prefix);
			if(p==null || p.isEmpty()) {
				throw new CoreException("Configurazione non presente");
			}
			
			ConfigurazioneCoda confCoda = new ConfigurazioneCoda(nome, p);
			this.getTimerConsegnaContenutiApplicativiConfigurazioneCoda.put(nome, confCoda);
			return confCoda;
			
		}catch(java.lang.Exception e) {
			this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+prefix+"*': "+e.getMessage(),e);
			return null;
		}  

	}
	
	private List<String> getTimerConsegnaContenutiApplicativiPriorita = null;
	private boolean getTimerConsegnaContenutiApplicativiPrioritaRead = false;
	public List<String> getTimerConsegnaContenutiApplicativiPriorita() {	
		if(this.getTimerConsegnaContenutiApplicativiPrioritaRead == false){
			try{ 

				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.priorita");
				if(name==null){
					this.getTimerConsegnaContenutiApplicativiPriorita = null;
				}else{
					String [] r = name.trim().split(",");
					List<String> l = new ArrayList<>();
					for(int i=0; i<r.length; i++){
						r[i] = r[i].trim();
						l.add(r[i]);
					}
					
					if(!l.isEmpty()) {
						this.getTimerConsegnaContenutiApplicativiPriorita = new ArrayList<>();
						this.getTimerConsegnaContenutiApplicativiPriorita.addAll(l);
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.priorita': "+e.getMessage(),e);
				this.getTimerConsegnaContenutiApplicativiPriorita = null;
			}  
			this.getTimerConsegnaContenutiApplicativiPrioritaRead = true;
		}

		return this.getTimerConsegnaContenutiApplicativiPriorita;
	}
	
	private HashMap<String, ConfigurazionePriorita> getTimerConsegnaContenutiApplicativiConfigurazionePriorita = new HashMap<String, ConfigurazionePriorita>();
	public ConfigurazionePriorita getTimerConsegnaContenutiApplicativiConfigurazionePriorita(String nome) {
		
		ConfigurazionePriorita conf = this.getTimerConsegnaContenutiApplicativiConfigurazionePriorita.get(nome);
		if(conf!=null) {
			return conf;
		}
		
		String prefix = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.priorita."+nome+".";
		try{ 
			Properties p = this.reader.readPropertiesConvertEnvProperties(prefix);
			if(p==null || p.isEmpty()) {
				throw new CoreException("Configurazione non presente");
			}
			
			ConfigurazionePriorita confPriorita = new ConfigurazionePriorita(nome, p);
			this.getTimerConsegnaContenutiApplicativiConfigurazionePriorita.put(nome, confPriorita);
			return confPriorita;
			
		}catch(java.lang.Exception e) {
			this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+prefix+"*': "+e.getMessage(),e);
			return null;
		}  

	}
	
	private Boolean isLoadBalancerDebug = null;
	public boolean isLoadBalancerDebug(){
		if(this.isLoadBalancerDebug==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.loadBalancer.debug"); 
				if(value!=null){
					value = value.trim();
					this.isLoadBalancerDebug = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.loadBalancer.debug' non impostata, viene utilizzato il default=false");
					this.isLoadBalancerDebug = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.loadBalancer.debug', viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isLoadBalancerDebug = false;
			}
		}

		return this.isLoadBalancerDebug;
	}
	
	private Integer getTimerConsegnaContenutiApplicativi_lockMaxLife = null;
	public int getTimerConsegnaContenutiApplicativi_lockMaxLife() {	
		if(this.getTimerConsegnaContenutiApplicativi_lockMaxLife==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.maxLife");

				if(name!=null){
					name = name.trim();
					this.getTimerConsegnaContenutiApplicativi_lockMaxLife = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
					this.getTimerConsegnaContenutiApplicativi_lockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE+", errore:"+e.getMessage(),e);
				this.getTimerConsegnaContenutiApplicativi_lockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
			}  
			if(this.getTimerConsegnaContenutiApplicativi_lockMaxLife!=null && this.getTimerConsegnaContenutiApplicativi_lockMaxLife>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getTimerConsegnaContenutiApplicativi_lockMaxLife = this.getTimerConsegnaContenutiApplicativi_lockMaxLife *1000;
			}
		}

		return this.getTimerConsegnaContenutiApplicativi_lockMaxLife;
	}
	
	private Integer getTimerConsegnaContenutiApplicativi_lockIdleTime = null;
	public int getTimerConsegnaContenutiApplicativi_lockIdleTime() {	
		if(this.getTimerConsegnaContenutiApplicativi_lockIdleTime==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.idleTime");

				if(name!=null){
					name = name.trim();
					this.getTimerConsegnaContenutiApplicativi_lockIdleTime = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
					this.getTimerConsegnaContenutiApplicativi_lockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME+", errore:"+e.getMessage(),e);
				this.getTimerConsegnaContenutiApplicativi_lockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
			} 
			if(this.getTimerConsegnaContenutiApplicativi_lockIdleTime!=null && this.getTimerConsegnaContenutiApplicativi_lockIdleTime>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getTimerConsegnaContenutiApplicativi_lockIdleTime = this.getTimerConsegnaContenutiApplicativi_lockIdleTime *1000;
			}
		}

		return this.getTimerConsegnaContenutiApplicativi_lockIdleTime;
	}
	
	private Integer getTimerConsegnaContenutiApplicativi_presaInConsegnaMaxLife = null;
	public int getTimerConsegnaContenutiApplicativi_presaInConsegnaMaxLife() {	
		if(this.getTimerConsegnaContenutiApplicativi_presaInConsegnaMaxLife==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.presaInConsegna.maxLife");

				if(name!=null){
					name = name.trim();
					this.getTimerConsegnaContenutiApplicativi_presaInConsegnaMaxLife = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.presaInConsegna.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_RICONSEGNA_CONTENUTI_APPLICATIVI_PRESA_IN_CONSEGNA_MAX_LIFE);
					this.getTimerConsegnaContenutiApplicativi_presaInConsegnaMaxLife = CostantiPdD.TIMER_RICONSEGNA_CONTENUTI_APPLICATIVI_PRESA_IN_CONSEGNA_MAX_LIFE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.presaInConsegna.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_RICONSEGNA_CONTENUTI_APPLICATIVI_PRESA_IN_CONSEGNA_MAX_LIFE+", errore:"+e.getMessage(),e);
				this.getTimerConsegnaContenutiApplicativi_presaInConsegnaMaxLife = CostantiPdD.TIMER_RICONSEGNA_CONTENUTI_APPLICATIVI_PRESA_IN_CONSEGNA_MAX_LIFE;
			}  
			if(this.getTimerConsegnaContenutiApplicativi_presaInConsegnaMaxLife!=null && this.getTimerConsegnaContenutiApplicativi_presaInConsegnaMaxLife>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getTimerConsegnaContenutiApplicativi_presaInConsegnaMaxLife = this.getTimerConsegnaContenutiApplicativi_presaInConsegnaMaxLife *1000;
			}
		}

		return this.getTimerConsegnaContenutiApplicativi_presaInConsegnaMaxLife;
	}
	
	private Long getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva = null;
	public long getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva() {	
		if(this.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.attesaAttiva";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					long time = java.lang.Long.parseLong(name);
					this.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva = time*1000;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
					this.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
			}    
		}

		return this.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva;
	}

	private Integer getTimerConsegnaContenutiApplicativi_getLockCheckInterval = null;
	public int getTimerConsegnaContenutiApplicativi_getLockCheckInterval() {	
		if(this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.check";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval = time;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
					this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
			}  
		}

		return this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval;
	}

	
	// *** Smistatore ***
	
	private Boolean isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager = null;
	public boolean isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager() {	
		if(this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.smistatore.runtime.useRuntimeManager";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager = true;
			}    
		}

		return this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager;
	}
	
	private String getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource = null;
	public String getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource() throws CoreException {	
		if(this.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.smistatore.runtime.dataSource";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource;
	}
	
	private Properties getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSourceJndiContext = null;
	public Properties getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSourceJndiContext() throws CoreException {	
		if(this.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSourceJndiContext==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.smistatore.runtime.dataSource.property.";
			try{ 
				this.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSourceJndiContext;
	}
	
	private Boolean isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils = null;
	public boolean isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils() {	
		if(this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.smistatore.runtime.datasource.useDSUtils";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils = true;
			}    
		}

		return this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils;
	}
	
	
	
	// *** Consegne, gestione runtime ***
	
	private Boolean isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager = null;
	public boolean isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager() {	
		if(this.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.runtime.useRuntimeManager";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager = true;
			}    
		}

		return this.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager;
	}
	
	private String getTimerConsegnaContenutiApplicativi_runtime_dataSource = null;
	public String getTimerConsegnaContenutiApplicativi_runtime_dataSource() throws CoreException {	
		if(this.getTimerConsegnaContenutiApplicativi_runtime_dataSource==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.runtime.dataSource";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getTimerConsegnaContenutiApplicativi_runtime_dataSource = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTimerConsegnaContenutiApplicativi_runtime_dataSource;
	}
	
	private Properties getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext = null;
	public Properties getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext() throws CoreException {	
		if(this.getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.runtime.dataSource.property.";
			try{ 
				this.getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext;
	}
	
	private Boolean isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils = null;
	public boolean isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils() {	
		if(this.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.runtime.datasource.useDSUtils";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils = true;
			}    
		}

		return this.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils;
	}
	
	
	// *** Consegne, gestione tracce ***
	
	private Boolean isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager = null;
	public boolean isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager() {	
		if(this.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.transazioni.useTransactionManager";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager = true;
			}    
		}

		return this.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager;
	}
	
	private String getTimerConsegnaContenutiApplicativi_transazioni_dataSource = null;
	public String getTimerConsegnaContenutiApplicativi_transazioni_dataSource() throws CoreException {	
		if(this.getTimerConsegnaContenutiApplicativi_transazioni_dataSource==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.transazioni.dataSource";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getTimerConsegnaContenutiApplicativi_transazioni_dataSource = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTimerConsegnaContenutiApplicativi_transazioni_dataSource;
	}
	
	private Properties getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext = null;
	public Properties getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext() throws CoreException {	
		if(this.getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.transazioni.dataSource.property.";
			try{ 
				this.getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext;
	}
	
	private Boolean isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils = null;
	public boolean isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils() {	
		if(this.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils==null){
			String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.transazioni.datasource.useDSUtils";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils = true;
			}    
		}

		return this.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils;
	}
	

	/* ********  REPOSITORY DI OPENSPCOOP  ******** */

	/**
	 * Restituisce il tipo di repository utilizzato da OpenSPCoop 
	 *
	 * @return Restituisce il tipo di repository utilizzato da OpenSPCoop 
	 * 
	 */
	private String repositoryType = null;
	public String getRepositoryType() {	
		if(this.repositoryType==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.tipo");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.repositoryType = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.tipo': "+e.getMessage(),e);
				this.repositoryType = null;
			}    
		}

		return this.repositoryType;
	}

	/**
	 * Restituisce il tipo di database utilizzato da OpenSPCoop 
	 *
	 * @return Restituisce il tipo di database utilizzato da OpenSPCoop 
	 * 
	 */
	private String databaseType = null;
	public String getDatabaseType() {	
		if(this.databaseType==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.tipoDatabase");
				if(name!=null)
					name = name.trim();
				this.databaseType = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.tipoDatabase': "+e.getMessage(),e);
				this.databaseType = null;
			}    
		}

		return this.databaseType;
	}

	/**
	 * Restituisce true se il tipo di repository utilizzato da OpenSPCoop  e' fs
	 *
	 * @return Restituisce true se il tipo di repository utilizzato da OpenSPCoop  e' su file system
	 * 
	 */
	private Boolean isRepositoryOnFS_value = null;
	public boolean isRepositoryOnFS() {	

		if(this.isRepositoryOnFS_value==null){
			// DEFAULT is true!

			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.tipo");

				if(name!=null){
					name = name.trim();
					if(CostantiConfigurazione.REPOSITORY_DB.equals(name)){
						this.isRepositoryOnFS_value = false;
					}else{
						this.isRepositoryOnFS_value = true;
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.tipo' non impostata, viene utilizzato il default=true");
					this.isRepositoryOnFS_value = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.tipo' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isRepositoryOnFS_value = true;
			}    
		}

		return this.isRepositoryOnFS_value;
	}

	/**
	 * Restituisce la working directory utilizzata da OpenSPCoop 
	 *
	 * @return Restituisce la working directory utilizzata da OpenSPCoop.
	 * 
	 */
	private String repositoryDirectory = null;
	public String getRepositoryDirectory() {
		if(this.repositoryDirectory==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.directory");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.repositoryDirectory = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.directory': "+e.getMessage(),e);
				this.repositoryDirectory = null;
			}  
		}

		return this.repositoryDirectory;
	}

	/**
	 * Restituisce il JDBC Adapter utilizzato da OpenSPCoop 
	 *
	 * @return Restituisce il JDBC Adapter utilizzato da OpenSPCoop.
	 * 
	 */
	private String repositoryJDBCAdapter = null;
	public String getRepositoryJDBCAdapter() {	
		if(this.repositoryJDBCAdapter==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.jdbcAdapter");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.repositoryJDBCAdapter = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.jdbcAdapter': "+e.getMessage(),e);
				this.repositoryJDBCAdapter = null;
			}    
		}

		return this.repositoryJDBCAdapter;
	}


	private Boolean forceIndex = null;
	public boolean isForceIndex() {	

		if(this.forceIndex==null){
			// DEFAULT is false

			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.forceIndex");

				if(name!=null){
					name = name.trim();
					this.forceIndex = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.forceIndex' non impostata, viene utilizzato il default=false");
					this.forceIndex = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.forceIndex' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.forceIndex = false;
			}    
		}

		return this.forceIndex;
	}
	
	

	private AttachmentsProcessingMode attachmentsProcessingMode = null;
	public AttachmentsProcessingMode getAttachmentsProcessingMode() {	
		if(this.attachmentsProcessingMode==null){
			if(this.isFileCacheEnable()){
				try{ 
					this.attachmentsProcessingMode=AttachmentsProcessingMode.getFileCacheProcessingMode(getAttachmentRepoDir(), getFileThreshold());
				} catch(java.lang.Exception e) {
					this.logError("Riscontrato errore durante l'identificazione della modalità di processing degli attachments: "+e.getMessage(),e);
					this.attachmentsProcessingMode=AttachmentsProcessingMode.getMemoryCacheProcessingMode();
				} 
			}else{
				this.attachmentsProcessingMode=AttachmentsProcessingMode.getMemoryCacheProcessingMode();
			}
		}

		return this.attachmentsProcessingMode;
	}

	private Boolean isFileCacheEnable = null;
	private boolean isFileCacheEnable() {	
		if(this.isFileCacheEnable==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.attachment.fileCacheEnable");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.fileCacheEnable' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isFileCacheEnable = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.fileCacheEnable': "+e.getMessage(),e);
				this.isFileCacheEnable = false;
			}    
		}

		return this.isFileCacheEnable;
	}


	private String attachmentRepoDir = null;
	private String getAttachmentRepoDir() {	

		if(this.attachmentRepoDir==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.attachment.repositoryDir");

				if(name!=null){
					name = name.trim();
					this.attachmentRepoDir = name;
				}else{
					// Se fileCacheEnable == false allora puo' essere null; 
					if(!isFileCacheEnable())
						return null;
					throw new CoreException(NON_DEFINITA);
				}

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.repositoryDir': "+e.getMessage(),e);
				this.attachmentRepoDir = null;
			}    
		}

		return this.attachmentRepoDir;
	}
	
	private String fileThreshold = null;
	private String getFileThreshold() {	

		if(this.fileThreshold==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.attachment.fileThreshold");

				if(name!=null){
					name = name.trim();
					this.fileThreshold = name;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.fileThreshold' non impostata, viene utilizzato il default=1024");
					this.fileThreshold = "1024";
				}

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.fileThreshold': "+e.getMessage(),e);
				this.fileThreshold = "1024";
			}    
		}

		return this.fileThreshold;
	}
	
	private String filePrefix = null;
	public String getFilePrefix() {	

		if(this.filePrefix==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.attachment.filePrefix");

				if(name!=null){
					name = name.trim();
					this.filePrefix = name;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.filePrefix' non impostata, viene utilizzato il default="+CostantiPdD.OPENSPCOOP2);
					this.filePrefix = CostantiPdD.OPENSPCOOP2;
				}

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.filePrefix': "+e.getMessage(),e);
				this.filePrefix = CostantiPdD.OPENSPCOOP2;
			}    
		}

		return this.filePrefix;
	}
	
	private String fileSuffix = null;
	public String getFileSuffix() {	

		if(this.fileSuffix==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.attachment.fileSuffix");

				if(name!=null){
					name = name.trim();
					this.fileSuffix = name;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.fileSuffix' non impostata, viene utilizzato il default=.att");
					this.fileSuffix = ".att";
				}

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.fileSuffix': "+e.getMessage(),e);
				this.fileSuffix = ".att";
			}    
		}

		return this.fileSuffix;
	}
	
	private int deleteInterval = 0;
	public int getDeleteInterval() {	

		if(this.deleteInterval==0){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.attachment.deleteInterval");

				if(name!=null){
					name = name.trim();
					this.deleteInterval = Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.deleteInterval' non impostata, viene utilizzato il default=300");
					this.deleteInterval = 300;
				}

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.deleteInterval': "+e.getMessage(),e);
				this.deleteInterval = 300;
			}    
		}

		return this.deleteInterval;
	}

	/**
	 * Restituisce l'intervallo di pulizia del repository di OpenSPCoop 
	 *
	 * @return Restituisce l'intervallo di pulizia del repository di OpenSPCoo
	 * 
	 */
	private Long repositoryIntervalloEliminazioneMessaggi = null;
	public long getRepositoryIntervalloEliminazioneMessaggi() {	
		if(this.repositoryIntervalloEliminazioneMessaggi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.timer");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.repositoryIntervalloEliminazioneMessaggi = java.lang.Long.parseLong(name);
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.timer': "+e.getMessage(),e);
				this.repositoryIntervalloEliminazioneMessaggi = -1L;
			}   
		}

		return this.repositoryIntervalloEliminazioneMessaggi;
	}

	/**
	 * Restituisce l'intervallo di tempo che definisce un msg scaduto nel repository di OpenSPCoop 
	 *
	 * @return Restituisce l'intervallo di tempo che definisce un msg scaduto nel repository di OpenSPCoo
	 * 
	 */
	private Long repositoryIntervalloScadenzaMessaggi = null;
	public long getRepositoryIntervalloScadenzaMessaggi() {	
		if(this.repositoryIntervalloScadenzaMessaggi == null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaMessaggio");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.repositoryIntervalloScadenzaMessaggi = java.lang.Long.parseLong(name);
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaMessaggio': "+e.getMessage(),e);
				this.repositoryIntervalloScadenzaMessaggi = -1L;
			}    
		}

		return this.repositoryIntervalloScadenzaMessaggi;
	}
	
	private Boolean useSoapMessageReader = null;
	public boolean useSoapMessageReader() {	
		if(this.useSoapMessageReader==null){
			String pName = "org.openspcoop2.pdd.soapMessage.reader";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.useSoapMessageReader = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.useSoapMessageReader = true;
			}    
		}

		return this.useSoapMessageReader;
	}
	
	private Integer soapMessageReaderBufferThresholdKb = null;
	public int getSoapMessageReaderBufferThresholdKb() {	

		if(this.soapMessageReaderBufferThresholdKb==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soapMessage.reader.bufferThreshold");

				if(name!=null){
					name = name.trim();
					this.soapMessageReaderBufferThresholdKb = Integer.valueOf(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soapMessage.reader.bufferThreshold' non impostata, viene utilizzato il default=10");
					this.soapMessageReaderBufferThresholdKb = 10;
				}

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soapMessage.reader.bufferThreshold': "+e.getMessage(),e);
				this.soapMessageReaderBufferThresholdKb = 10;
			}    
		}

		return this.soapMessageReaderBufferThresholdKb;
	}
	
	private Boolean useSoapMessageReaderHeaderOptimization = null;
	public boolean useSoapMessageReaderHeaderOptimization() {	
		if(this.useSoapMessageReaderHeaderOptimization==null){
			String pName = "org.openspcoop2.pdd.soapMessage.reader.headerOptimization";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.useSoapMessageReaderHeaderOptimization = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.useSoapMessageReaderHeaderOptimization = true;
			}    
		}

		return this.useSoapMessageReaderHeaderOptimization;
	}
	
	private Boolean useSoapMessagePassthrough = null;
	public boolean useSoapMessagePassthrough() {	
		if(this.useSoapMessagePassthrough==null){
			String pName = "org.openspcoop2.pdd.soapMessage.passthrough";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.useSoapMessagePassthrough = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.useSoapMessagePassthrough = true;
			}    
		}

		return this.useSoapMessagePassthrough;
	}
	
	private Integer soapMessageSaajSaxParserPoolSize = null;
	public int getSoapMessageSaajSaxParserPoolSize() {	

		if(this.soapMessageSaajSaxParserPoolSize==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soapMessage.saaj.saxParserPoolSize");

				if(name!=null){
					name = name.trim();
					this.soapMessageSaajSaxParserPoolSize = Integer.valueOf(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soapMessage.saaj.saxParserPoolSize' non impostata, viene utilizzato il default=200");
					this.soapMessageSaajSaxParserPoolSize = 200;
				}

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soapMessage.saaj.saxParserPoolSize': "+e.getMessage(),e);
				this.soapMessageSaajSaxParserPoolSize = 200;
			}    
		}

		return this.soapMessageSaajSaxParserPoolSize;
	}
	
	private List<String> alternativeContentTypeSoap12 = null;
	private boolean alternativeContentTypeSoap12Read = false;
	public List<String> getAlternativeContentTypeSoap12() {	
		if(!this.alternativeContentTypeSoap12Read){
			String pName = "org.openspcoop2.pdd.soapMessage.v12.alternativeContentTypes";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.alternativeContentTypeSoap12 = null;
				}else{
					String [] r = name.trim().split(",");
					List<String> l = new ArrayList<>();
					for(int i=0; i<r.length; i++){
						r[i] = r[i].trim();
						l.add(r[i]);
					}
					
					if(!l.isEmpty()) {
						this.alternativeContentTypeSoap12 = new ArrayList<>();
						this.alternativeContentTypeSoap12.addAll(l);
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+": "+e.getMessage(),e);
				this.alternativeContentTypeSoap12 = null;
			}  
			this.alternativeContentTypeSoap12Read = true;
		}

		return this.alternativeContentTypeSoap12;
	}
	
	
	private Boolean useRestMultipartLazy = null;
	public boolean useRestMultipartLazy() {	
		if(this.useRestMultipartLazy==null){
			String pName = "org.openspcoop2.pdd.restMessage.multipart.lazy";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.useRestMultipartLazy = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.useRestMultipartLazy = true;
			}    
		}

		return this.useRestMultipartLazy;
	}
	
	
	
	/**
	 * Restituisce L'indicazione se filtrare le buste rispetto alla scadenza della busta
	 *
	 * @return indicazione se filtrare le buste rispetto alla scadenza della busta
	 * 
	 */
	private Boolean repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione = null;
	public boolean isRepositoryBusteFiltraBusteScaduteRispettoOraRegistrazione() {	
		if(this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione==null){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaMessaggio.filtraBusteScaduteRispettoOraRegistrazione");
				if(value==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaMessaggio.filtraBusteScaduteRispettoOraRegistrazione' non definita (Viene utilizzato il default:true)");
					this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione = true;
				}else{
					this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione = Boolean.parseBoolean(value);
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaMessaggio.filtraBusteScaduteRispettoOraRegistrazione' (Viene utilizzato il default:true): "+e.getMessage(),e);
				this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione = true;
			}    
		}

		return this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione;
	}

	/**
	 * Restituisce l'intervallo di tempo che definisce una correlazione scaduta nel repository di OpenSPCoop 
	 *
	 * @return Restituisce l'intervallo di tempo che definisce una correlazione scaduta nel repository di OpenSPCoo
	 * 
	 */
	private Long repositoryIntervalloScadenzaCorrelazioneApplicativa = null;
	public long getRepositoryIntervalloScadenzaCorrelazioneApplicativa() {	
		if(this.repositoryIntervalloScadenzaCorrelazioneApplicativa == null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa");
				if(name==null){
					/** throw new CoreException(NON_DEFINITA); */
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa' non definita, viene usato il valore impostato nella proprieta 'org.openspcoop2.pdd.repository.scadenzaMessaggio'");
					this.repositoryIntervalloScadenzaCorrelazioneApplicativa = getRepositoryIntervalloScadenzaMessaggi();
				}
				else{
					name = name.trim();
					this.repositoryIntervalloScadenzaCorrelazioneApplicativa = java.lang.Long.parseLong(name);
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa': "+e.getMessage(),e);
				this.repositoryIntervalloScadenzaCorrelazioneApplicativa = -1L;
			}    
		}
		
		return this.repositoryIntervalloScadenzaCorrelazioneApplicativa;
	}
	
	private Integer maxLengthCorrelazioneApplicativa = null;
	public int getMaxLengthCorrelazioneApplicativa() {	
		if(this.maxLengthCorrelazioneApplicativa == null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLength");
				if(name==null){
					/** throw new CoreException(NON_DEFINITA); */
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLength' non definita, viene usato il valore di default: 255");
					this.maxLengthCorrelazioneApplicativa = 255;
				}
				else{
					name = name.trim();
					this.maxLengthCorrelazioneApplicativa = java.lang.Integer.parseInt(name);
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLength': "+e.getMessage(),e);
				this.maxLengthCorrelazioneApplicativa = 255;
			}    
		}
		
		return this.maxLengthCorrelazioneApplicativa;
	}
	
	private Boolean maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateActive = null;
	public boolean isMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate() {	
		if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateActive == null){
			String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLengthExceeded.identificazioneFallita.blocca.truncate";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					/** throw new CoreException(NON_DEFINITA); */
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non definita, viene usato il valore di default: false");
					this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateActive = false;
				}
				else{
					name = name.trim();
					this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateActive = java.lang.Boolean.parseBoolean(name);
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage()+". Viene usato il valore di default: false",e);
				this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateActive = false;
			}    
		}
		
		return this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateActive;
	}
	
	private Integer maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate = null;
	private Boolean maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateRead = null;
	public Integer getMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate() {	
		if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateRead == null){
			String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLengthExceeded.identificazioneFallita.blocca.truncate.length";
			try{ 
				String name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null && StringUtils.isNotEmpty(name.trim())){
					name = name.trim();
					this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate = java.lang.Integer.parseInt(name);
					if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate<=0) {
						throw new CoreException("Deve essere fornito un valore maggiore di 0");
					}
					if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate>=getMaxLengthCorrelazioneApplicativa()) {
						throw new CoreException("Deve essere fornito un valore minore di "+getMaxLengthCorrelazioneApplicativa());
					}
				}
				else {
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non definita, viene usato il valore di default: 245");
					this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate = 245;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate = null;
			}  
			
			this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateRead = true;
		}
		
		return this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate;
	}
	
	private Boolean maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateActive = null;
	public boolean isMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate() {	
		if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateActive == null){
			String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLengthExceeded.identificazioneFallita.accetta.truncate";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					/** throw new CoreException(NON_DEFINITA); */
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non definita, viene usato il valore di default: false");
					this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateActive = false;
				}
				else{
					name = name.trim();
					this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateActive = java.lang.Boolean.parseBoolean(name);
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage()+". Viene usato il valore di default: false",e);
				this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateActive = false;
			}    
		}
		
		return this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateActive;
	}
	
	private Integer maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate = null;
	private Boolean maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateRead = null;
	public Integer getMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate() {	
		if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateRead == null){
			String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLengthExceeded.identificazioneFallita.accetta.truncate.length";
			try{ 
				String name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null && StringUtils.isNotEmpty(name.trim())){
					name = name.trim();
					this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate = java.lang.Integer.parseInt(name);
					if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate<=0) {
						throw new CoreException("Deve essere fornito un valore maggiore di 0");
					}
					if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate>=getMaxLengthCorrelazioneApplicativa()) {
						throw new CoreException("Deve essere fornito un valore minore di "+getMaxLengthCorrelazioneApplicativa());
					}
				}
				else {
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non definita, viene usato il valore di default: 245");
					this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate = 245;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate = null;
			}  
			
			this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateRead = true;
		}
		
		return this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate;
	}

	
	private Boolean isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione = null;
	public boolean isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione() {	
		
		if(this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione");
				
				if(name!=null){
					name = name.trim();
					this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione' non impostata, viene utilizzato il default=true");
					this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione = true;
				}
	
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione = true;
			}    
		}
		
		return this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione;
	}
	
	private Boolean isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata = null;
	public boolean isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata() {	
		
		if(this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione.soloCorrelazioniSenzaScadenza");
				
				if(name!=null){
					name = name.trim();
					this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione.soloCorrelazioniSenzaScadenza' non impostata, viene utilizzato il default=false");
					this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata = false;
				}
	
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione.soloCorrelazioniSenzaScadenza' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata = false;
			}    
		}
		
		return this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata;
	}
	

	private Boolean isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore = null;
	public boolean isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore() {	
		
		String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.richiesta.identificativoEstrattoIsNull.consideraErrore";
		if(this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				
				if(name!=null){
					name = name.trim();
					this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore = true;
				}
	
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true));
				this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore = true;
			}    
		}
		
		return this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore;
	}
	
	private Boolean isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore = null;
	public boolean isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore() {	
		
		String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.risposta.identificativoEstrattoIsNull.consideraErrore";
		if(this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				
				if(name!=null){
					name = name.trim();
					this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore = true;
				}
	
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true));
				this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore = true;
			}    
		}
		
		return this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore;
	}
	
	private Boolean isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore = null;
	public boolean isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore() {	
		
		String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.richiesta.identificativoEstrattoIsEmpty.consideraErrore";
		if(this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				
				if(name!=null){
					name = name.trim();
					this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore = true;
				}
	
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true));
				this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore = true;
			}    
		}
		
		return this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore;
	}
	
	private Boolean isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore = null;
	public boolean isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore() {	
		
		String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.risposta.identificativoEstrattoIsEmpty.consideraErrore";
		if(this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				
				if(name!=null){
					name = name.trim();
					this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore = true;
				}
	
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true));
				this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore = true;
			}    
		}
		
		return this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore;
	}
	
	
	private Boolean isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca = null;
	public boolean isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca() {	
		
		String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.richiesta.regolaCorrelazioneNonTrovata.blocca";
		if(this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				
				if(name!=null){
					name = name.trim();
					this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca = false;
				}
	
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false));
				this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca = false;
			}    
		}
		
		return this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca;
	}
	
	private Boolean isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca = null;
	public boolean isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca() {	
		
		String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.risposta.regolaCorrelazioneNonTrovata.blocca";
		if(this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				
				if(name!=null){
					name = name.trim();
					this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca = false;
				}
	
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false));
				this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca = false;
			}    
		}
		
		return this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca;
	}
	

	/**
	 * Restituisce l'intervallo in millisecondi di attesa attiva per messaggi gia in processamento
	 * 
	 * @return Restituisce l'intervallo in millisecondi di attesa attiva per messaggi gia in processamento
	 *  * 
	 */
	private Long msgGiaInProcessamentoAttesaAttiva = null;
	public long getMsgGiaInProcessamentoAttesaAttiva() {	
		if(this.msgGiaInProcessamentoAttesaAttiva==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.messaggioInProcessamento.attesaAttiva");

				if(name!=null){
					name = name.trim();
					long time = java.lang.Long.parseLong(name);
					this.msgGiaInProcessamentoAttesaAttiva = time*1000;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.messaggioInProcessamento.attesaAttiva' non impostato, viene utilizzato il default="+CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_ATTESA_ATTIVA);
					this.msgGiaInProcessamentoAttesaAttiva = CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_ATTESA_ATTIVA;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.messaggioInProcessamento.attesaAttiva' non impostato, viene utilizzato il default="+CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.msgGiaInProcessamentoAttesaAttiva = CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_ATTESA_ATTIVA;
			}    
		}

		return this.msgGiaInProcessamentoAttesaAttiva;
	}

	/**
	 * Restituisce l'intervallo maggiore per frequenza di check nell'attesa attiva effettuata dal TransactionManager, in millisecondi
	 * 
	 * @return Restituisce Intervallo maggiore per frequenza di check nell'attesa attiva effettuata dal TransactionManager, in millisecondi
	 * 
	 */
	private Integer msgGiaInProcessamentoCheckInterval = null;
	public int getMsgGiaInProcessamentoCheckInterval() {	
		String pName = "org.openspcoop2.pdd.repository.messaggioInProcessamento.check";
		if(this.msgGiaInProcessamentoCheckInterval==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.msgGiaInProcessamentoCheckInterval = time;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_CHECK_INTERVAL);
					this.msgGiaInProcessamentoCheckInterval = CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.msgGiaInProcessamentoCheckInterval = CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_CHECK_INTERVAL;
			}  
		}

		return this.msgGiaInProcessamentoCheckInterval;
	}
	
	private Boolean msgGiaInProcessamentoUseLock = null;
	public boolean isMsgGiaInProcessamentoUseLock() {	
		if(this.msgGiaInProcessamentoUseLock==null){
			String pName = "org.openspcoop2.pdd.repository.messaggioInProcessamento.useLock";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					this.msgGiaInProcessamentoUseLock = Boolean.valueOf(name);
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+false);
					this.msgGiaInProcessamentoUseLock = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+false+", errore:"+e.getMessage(),e);
				this.msgGiaInProcessamentoUseLock = false;
			}  
		}

		return this.msgGiaInProcessamentoUseLock;
	}

	/**
	 * Restituisce l'IThreshold utilizzato da OpenSPCoop 
	 *
	 * @return Restituisce l'IThreshold utilizzato da OpenSPCoop.
	 * 
	 */
	private List<String> repositoryThresholdTypes = null;
	private boolean repositoryThresholdTypesRead = false;
	public List<String> getRepositoryThresholdTypes() {	
		if(!this.repositoryThresholdTypesRead){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.threshold.tipi");
				if(name==null){
					this.repositoryThresholdTypes = null;
				}else{
					String [] r = name.trim().split(",");
					List<String> l = new ArrayList<>();
					for(int i=0; i<r.length; i++){
						r[i] = r[i].trim();
						l.add(r[i]);
					}
					
					if(!l.isEmpty()) {
						this.repositoryThresholdTypes = new ArrayList<>();
						this.repositoryThresholdTypes.addAll(l);
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.threshold.tipi': "+e.getMessage(),e);
				this.repositoryThresholdTypes = null;
			}  
			this.repositoryThresholdTypesRead = true;
		}

		return this.repositoryThresholdTypes;
	}
	/**
	 * Restituisce la soglia utilizzata dall'IThreshold utilizzato da OpenSPCoop 
	 *
	 * @return Restituisce la soglia utilizzata dall'IThreshold utilizzato da OpenSPCoop.
	 * 
	 */
	private Properties repositoryThresholdParameters = null;
	private boolean repositoryThresholdParametersRead = false;
	public Properties getRepositoryThresholdParameters(String tipoThreshould) {	
		if(!this.repositoryThresholdParametersRead){
			try{ 
				this.repositoryThresholdParameters = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.repository.threshold."+tipoThreshould+".");
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.threshold."+tipoThreshould+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
				this.repositoryThresholdParameters = null;
			}  
			this.repositoryThresholdParametersRead = true; 
		}

		return this.repositoryThresholdParameters;
	}

	/**
	 * Restituisce l'intervallo per il timer di Threshold
	 *
	 * @return Restituisce l'intervallo per il timer di Threshold
	 * 
	 */
	private Long repositoryThresholdCheckInterval = null;
	public long getRepositoryThresholdCheckInterval() {	
		if(this.repositoryThresholdCheckInterval == null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.threshold.checkInterval");
				if(name!=null){
					name = name.trim();
					this.repositoryThresholdCheckInterval = java.lang.Long.parseLong(name);
				}else{
					this.repositoryThresholdCheckInterval = 0L;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.threshold.checkInterval': "+e.getMessage(),e);
				this.repositoryThresholdCheckInterval = -1L;
			}    
		}

		return this.repositoryThresholdCheckInterval;
	}

	/**
	 * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione xml
	 *   
	 * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione xml
	 * 
	 */
	private Boolean isValidazioneSemanticaConfigurazioneStartupXML = null;
	public boolean isValidazioneSemanticaConfigurazioneStartupXML(){

		if(this.isValidazioneSemanticaConfigurazioneStartupXML==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.startup.config.xml.validazioneSemantica"); 

				if (value != null){
					value = value.trim();
					if(CostantiConfigurazione.ABILITATO.equals(value)){
						this.isValidazioneSemanticaConfigurazioneStartupXML = true;
					}else if(CostantiConfigurazione.DISABILITATO.equals(value)){
						this.isValidazioneSemanticaConfigurazioneStartupXML = false;
					}
					else{
						throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.config.xml.validazioneSemantica' non impostata, viene utilizzato il default=true");
					this.isValidazioneSemanticaConfigurazioneStartupXML = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.config.xml.validazioneSemantica' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isValidazioneSemanticaConfigurazioneStartupXML = true;
			}
		}

		return this.isValidazioneSemanticaConfigurazioneStartupXML;
	}
	/**
	 * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione
	 *   
	 * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione
	 * 
	 */
	private Boolean isValidazioneSemanticaConfigurazioneStartup = null;
	public boolean isValidazioneSemanticaConfigurazioneStartup(){

		if(this.isValidazioneSemanticaConfigurazioneStartup==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.startup.config.validazioneSemantica"); 

				if (value != null){
					value = value.trim();
					if(CostantiConfigurazione.ABILITATO.equals(value)){
						this.isValidazioneSemanticaConfigurazioneStartup = true;
					}else if(CostantiConfigurazione.DISABILITATO.equals(value)){
						this.isValidazioneSemanticaConfigurazioneStartup = false;
					}
					else{
						throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.config.validazioneSemantica' non impostata, viene utilizzato il default=false");
					this.isValidazioneSemanticaConfigurazioneStartup = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.config.validazioneSemantica' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isValidazioneSemanticaConfigurazioneStartup = false;
			}
		}

		return this.isValidazioneSemanticaConfigurazioneStartup;
	}
	/**
	 * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della registro servizi xml
	 *   
	 * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della registro servizi xml
	 * 
	 */
	private Boolean isValidazioneSemanticaRegistroServiziStartupXML = null;
	public boolean isValidazioneSemanticaRegistroServiziStartupXML(){

		if(this.isValidazioneSemanticaRegistroServiziStartupXML==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.startup.registri.xml.validazioneSemantica"); 

				if (value != null){
					value = value.trim();
					if(CostantiConfigurazione.ABILITATO.equals(value)){
						this.isValidazioneSemanticaRegistroServiziStartupXML = true;
					}else if(CostantiConfigurazione.DISABILITATO.equals(value)){
						this.isValidazioneSemanticaRegistroServiziStartupXML = false;
					}
					else{
						throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.registri.xml.validazioneSemantica' non impostata, viene utilizzato il default=true");
					this.isValidazioneSemanticaRegistroServiziStartupXML = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.registri.xml.validazioneSemantica' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isValidazioneSemanticaRegistroServiziStartupXML = true;
			}
		}

		return this.isValidazioneSemanticaRegistroServiziStartupXML;
	}
	/**
	 * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della registro servizi
	 *   
	 * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della registro servizi
	 * 
	 */
	private Boolean isValidazioneSemanticaRegistroServiziStartup = null;
	public boolean isValidazioneSemanticaRegistroServiziStartup(){

		if(this.isValidazioneSemanticaRegistroServiziStartup==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.startup.registri.validazioneSemantica"); 

				if (value != null){
					value = value.trim();
					if(CostantiConfigurazione.ABILITATO.equals(value)){
						this.isValidazioneSemanticaRegistroServiziStartup = true;
					}else if(CostantiConfigurazione.DISABILITATO.equals(value)){
						this.isValidazioneSemanticaRegistroServiziStartup = false;
					}
					else{
						throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.registri.validazioneSemantica' non impostata, viene utilizzato il default=false");
					this.isValidazioneSemanticaRegistroServiziStartup = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.registri.validazioneSemantica' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isValidazioneSemanticaRegistroServiziStartup = false;
			}
		}

		return this.isValidazioneSemanticaRegistroServiziStartup;
	}
	/**
	 * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione
	 *   
	 * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione
	 * 
	 */
	private Boolean isValidazioneSemanticaRegistroServiziCheckURI = null;
	public boolean isValidazioneSemanticaRegistroServiziCheckURI(){

		if(this.isValidazioneSemanticaRegistroServiziCheckURI==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.startup.registri.validazioneSemantica.checkURI"); 

				if (value != null){
					value = value.trim();
					if(CostantiConfigurazione.ABILITATO.equals(value)){
						this.isValidazioneSemanticaRegistroServiziCheckURI = true;
					}else if(CostantiConfigurazione.DISABILITATO.equals(value)){
						this.isValidazioneSemanticaRegistroServiziCheckURI = false;
					}
					else{
						throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.registri.validazioneSemantica.checkURI' non impostata, viene utilizzato il default=false");
					this.isValidazioneSemanticaRegistroServiziCheckURI = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.registri.validazioneSemantica.checkURI' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isValidazioneSemanticaRegistroServiziCheckURI = false;
			}
		}

		return this.isValidazioneSemanticaRegistroServiziCheckURI;
	}
	

	private static final String RISORSE_DB = "db";
	private static final String RISORSE_JMS = "jms";
	private static final String RISORSE_TRACCIAMENTO = "tracciamento";
	private static final String RISORSE_MSGDIAGNOSTICI = "msgdiagnostici";
	private static final String RISORSE_CONFIGURAZIONE = "configurazione";
	private static final String RISORSE_CONFIGURAZIONE_VALIDAZIONE_SEMANTICA = "configurazione.validazioneSemantica";
	private static final String RISORSE_REGISTRI = "registri";
	private static final String RISORSE_REGISTRI_VALIDAZIONE_SEMANTICA = "registri.validazioneSemantica";
	
	private static final String RISORSE_PROPERTY_NAME_CHECK = "org.openspcoop2.pdd.risorse.check.";

	private Boolean isAbilitatoControlloRisorseDB = null;
	public boolean isAbilitatoControlloRisorseDB() {	
		if(this.isAbilitatoControlloRisorseDB==null){
			this.isAbilitatoControlloRisorseDB = isAbilitatoControlloRisorse(RISORSE_DB);
		}
		return this.isAbilitatoControlloRisorseDB;
	}
	private Boolean isAbilitatoControlloRisorseJMS = null;
	public boolean isAbilitatoControlloRisorseJMS() {	
		if(this.isAbilitatoControlloRisorseJMS==null){
			this.isAbilitatoControlloRisorseJMS = isAbilitatoControlloRisorse(RISORSE_JMS);
		}
		return this.isAbilitatoControlloRisorseJMS;
	}
	private Boolean isAbilitatoControlloRisorseTracciamentiPersonalizzati = null;
	public boolean isAbilitatoControlloRisorseTracciamentiPersonalizzati() {	
		if(this.isAbilitatoControlloRisorseTracciamentiPersonalizzati==null){
			this.isAbilitatoControlloRisorseTracciamentiPersonalizzati = isAbilitatoControlloRisorse(RISORSE_TRACCIAMENTO);
		}
		return this.isAbilitatoControlloRisorseTracciamentiPersonalizzati;
	}
	private Boolean isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati = null;
	public boolean isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati() {	
		if(this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati==null){
			this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati = isAbilitatoControlloRisorse(RISORSE_MSGDIAGNOSTICI);
		}
		return this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati;
	}
	private Boolean isAbilitatoControlloRisorseConfigurazione = null;
	public boolean isAbilitatoControlloRisorseConfigurazione() {	
		if(this.isAbilitatoControlloRisorseConfigurazione==null){
			this.isAbilitatoControlloRisorseConfigurazione = isAbilitatoControlloRisorse(RISORSE_CONFIGURAZIONE);
		}
		return this.isAbilitatoControlloRisorseConfigurazione;
	}
	private Boolean isAbilitatoControlloValidazioneSemanticaConfigurazione = null;
	public boolean isAbilitatoControlloValidazioneSemanticaConfigurazione() {	
		if(this.isAbilitatoControlloValidazioneSemanticaConfigurazione==null){
			this.isAbilitatoControlloValidazioneSemanticaConfigurazione = isAbilitatoControlloRisorse(RISORSE_CONFIGURAZIONE_VALIDAZIONE_SEMANTICA);
		}
		return this.isAbilitatoControlloValidazioneSemanticaConfigurazione;
	}
	private Boolean isAbilitatoControlloRisorseRegistriServizi = null;
	public boolean isAbilitatoControlloRisorseRegistriServizi() {	
		if(this.isAbilitatoControlloRisorseRegistriServizi==null){
			this.isAbilitatoControlloRisorseRegistriServizi = isAbilitatoControlloRisorse(RISORSE_REGISTRI);
		}
		return this.isAbilitatoControlloRisorseRegistriServizi;
	}
	private Boolean isAbilitatoControlloValidazioneSemanticaRegistriServizi = null;
	public boolean isAbilitatoControlloValidazioneSemanticaRegistriServizi() {	
		if(this.isAbilitatoControlloValidazioneSemanticaRegistriServizi==null){
			this.isAbilitatoControlloValidazioneSemanticaRegistriServizi = isAbilitatoControlloRisorse(RISORSE_REGISTRI_VALIDAZIONE_SEMANTICA);
		}
		return this.isAbilitatoControlloValidazioneSemanticaRegistriServizi;
	}
	private boolean isAbilitatoControlloRisorse(String tipo) {	
		try{  
			String value = this.reader.getValueConvertEnvProperties(RISORSE_PROPERTY_NAME_CHECK+tipo); 
			if(value==null){
				this.logWarn(getMessaggioProprietaNonImpostata(RISORSE_PROPERTY_NAME_CHECK+tipo, false));
				return false;
			}
			return CostantiConfigurazione.ABILITATO.equals(value);
		}catch(java.lang.Exception e) {
			this.logWarn(getMessaggioProprietaNonImpostata(RISORSE_PROPERTY_NAME_CHECK+tipo, e, false));
			return false;
		}
	}
	private Boolean isControlloRisorseRegistriRaggiungibilitaTotale = null;
	public boolean isControlloRisorseRegistriRaggiungibilitaTotale() {	
		if(this.isControlloRisorseRegistriRaggiungibilitaTotale==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.risorse.check.registri.tipo"); 
				if(value==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.check.registri.tipo' non impostata, viene utilizzato il default=false");
					this.isControlloRisorseRegistriRaggiungibilitaTotale = false;
				}
				else
					this.isControlloRisorseRegistriRaggiungibilitaTotale = "singolo".equals(value);
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.check.registri.tipo' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isControlloRisorseRegistriRaggiungibilitaTotale = false;
			}
		}

		return this.isControlloRisorseRegistriRaggiungibilitaTotale;
	}
	
	
	private Integer getNumeroIterazioniFalliteControlloRisorseDB = null;
	public int getNumeroIterazioniFalliteControlloRisorseDB() {	
		if(this.getNumeroIterazioniFalliteControlloRisorseDB==null){
			this.getNumeroIterazioniFalliteControlloRisorseDB = getNumeroIterazioniFalliteControlloRisorse(RISORSE_DB);
		}
		return this.getNumeroIterazioniFalliteControlloRisorseDB;
	}
	private Integer getNumeroIterazioniFalliteControlloRisorseJMS = null;
	public int getNumeroIterazioniFalliteControlloRisorseJMS() {	
		if(this.getNumeroIterazioniFalliteControlloRisorseJMS==null){
			this.getNumeroIterazioniFalliteControlloRisorseJMS = getNumeroIterazioniFalliteControlloRisorse(RISORSE_JMS);
		}
		return this.getNumeroIterazioniFalliteControlloRisorseJMS;
	}
	private Integer getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati = null;
	public int getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati() {	
		if(this.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati==null){
			this.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati = getNumeroIterazioniFalliteControlloRisorse(RISORSE_TRACCIAMENTO);
		}
		return this.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati;
	}
	private Integer getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati = null;
	public int getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati() {	
		if(this.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati==null){
			this.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati = getNumeroIterazioniFalliteControlloRisorse(RISORSE_MSGDIAGNOSTICI);
		}
		return this.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati;
	}
	private Integer getNumeroIterazioniFalliteControlloRisorseConfigurazione = null;
	public int getNumeroIterazioniFalliteControlloRisorseConfigurazione() {	
		if(this.getNumeroIterazioniFalliteControlloRisorseConfigurazione==null){
			this.getNumeroIterazioniFalliteControlloRisorseConfigurazione = getNumeroIterazioniFalliteControlloRisorse(RISORSE_CONFIGURAZIONE);
		}
		return this.getNumeroIterazioniFalliteControlloRisorseConfigurazione;
	}
	private Integer getNumeroIterazioniFalliteControlloRisorseRegistriServizi = null;
	public int getNumeroIterazioniFalliteControlloRisorseRegistriServizi() {	
		if(this.getNumeroIterazioniFalliteControlloRisorseRegistriServizi==null){
			this.getNumeroIterazioniFalliteControlloRisorseRegistriServizi = getNumeroIterazioniFalliteControlloRisorse(RISORSE_REGISTRI);
		}
		return this.getNumeroIterazioniFalliteControlloRisorseRegistriServizi;
	}
	private int getNumeroIterazioniFalliteControlloRisorse(String tipo) {	
		try{  
			String value = this.reader.getValueConvertEnvProperties(RISORSE_PROPERTY_NAME_CHECK+tipo+".iterazioni"); 
			if(value==null){
				this.logWarn("Proprieta' di openspcoop '"+RISORSE_PROPERTY_NAME_CHECK+""+tipo+".iterazioni' non impostata, viene utilizzato il default=1");
				return 1;
			}
			return Integer.parseInt(value);
		}catch(java.lang.Exception e) {
			this.logWarn("Proprieta' di openspcoop '"+RISORSE_PROPERTY_NAME_CHECK+""+tipo+"' non impostata, viene utilizzato il default=1, errore:"+e.getMessage(),e);
			return 1;
		}
	}
	
	private Integer getIterazioniFalliteCheckIntervalControlloRisorseDB = null;
	public int getIterazioniFalliteCheckIntervalControlloRisorseDB() {	
		if(this.getIterazioniFalliteCheckIntervalControlloRisorseDB==null){
			this.getIterazioniFalliteCheckIntervalControlloRisorseDB = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_DB);
		}
		return this.getIterazioniFalliteCheckIntervalControlloRisorseDB;
	}
	private Integer getIterazioniFalliteCheckIntervalControlloRisorseJMS = null;
	public int getIterazioniFalliteCheckIntervalControlloRisorseJMS() {	
		if(this.getIterazioniFalliteCheckIntervalControlloRisorseJMS==null){
			this.getIterazioniFalliteCheckIntervalControlloRisorseJMS = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_JMS);
		}
		return this.getIterazioniFalliteCheckIntervalControlloRisorseJMS;
	}
	private Integer getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati = null;
	public int getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati() {	
		if(this.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati==null){
			this.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_TRACCIAMENTO);
		}
		return this.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati;
	}
	private Integer getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati = null;
	public int getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati() {	
		if(this.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati==null){
			this.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_MSGDIAGNOSTICI);
		}
		return this.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati;
	}
	private Integer getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione = null;
	public int getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione() {	
		if(this.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione==null){
			this.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_CONFIGURAZIONE);
		}
		return this.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione;
	}
	private Integer getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi = null;
	public int getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi() {	
		if(this.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi==null){
			this.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_REGISTRI);
		}
		return this.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi;
	}
	private int getIterazioniFalliteCheckIntervalControlloRisorse(String tipo) {	
		try{  
			String value = this.reader.getValueConvertEnvProperties(RISORSE_PROPERTY_NAME_CHECK+tipo+".checkInterval"); 
			if(value==null){
				this.logWarn("Proprieta' di openspcoop '"+RISORSE_PROPERTY_NAME_CHECK+""+tipo+".checkInterval' non impostata, viene utilizzato il default=500");
				return 500;
			}
			return Integer.parseInt(value);
		}catch(java.lang.Exception e) {
			this.logWarn("Proprieta' di openspcoop '"+RISORSE_PROPERTY_NAME_CHECK+""+tipo+".checkInterval' non impostata, viene utilizzato il default=500, errore:"+e.getMessage(),e);
			return 500;
		}
	}
	
	/**
	 * Restituisce l'intervallo per il timer di Threshold
	 *
	 * @return Restituisce l'intervallo per il timer di Threshold
	 * 
	 */
	private Long controlloRisorseCheckInterval = null;
	public long getControlloRisorseCheckInterval() {	
		if(this.controlloRisorseCheckInterval==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.risorse.checkInterval");
				if(name!=null){
					name = name.trim();
					this.controlloRisorseCheckInterval = java.lang.Long.parseLong(name);
				}else{
					this.controlloRisorseCheckInterval = 0L;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.checkInterval': "+e.getMessage(),e);
				this.controlloRisorseCheckInterval = -1L;
			}    
		}

		return this.controlloRisorseCheckInterval;
	}

	private Boolean isControlloRisorseRegistrazioneEvento = null;
	public boolean isControlloRisorseRegistrazioneEvento() {	
		if(this.isControlloRisorseRegistrazioneEvento==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.risorse.registraEvento");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.registraEvento' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isControlloRisorseRegistrazioneEvento = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.registraEvento', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isControlloRisorseRegistrazioneEvento = true;
			}    
		}

		return this.isControlloRisorseRegistrazioneEvento;
	}






	/* ******** ERRORE APPLICATIVO  ******** */

	/**
	 * Restituisce le proprieta' di default utilizzate dalla porta di dominio per invocazioni di porte delegate che generano errori
	 *
	 * @return Restituisce le proprieta' di default utilizzate dalla porta di dominio per invocazioni di porte delegate che generano errori
	 * 
	 */
	private ProprietaErroreApplicativo proprietaGestioneErrorePD = null;
	public ProprietaErroreApplicativo getProprietaGestioneErrorePD(IProtocolManager protocolManager){
		return getProprietaGestioneErrorePD_engine(protocolManager,false);
	}
	private ProprietaErroreApplicativo getProprietaGestioneErrorePD_engine(IProtocolManager protocolManager,boolean testPerValidazione){
		if(this.proprietaGestioneErrorePD==null){
			String fault = null;
			try{  
				fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.fault"); 
				if(fault==null)
					throw new CoreException(NON_DEFINITA);
				fault = fault.trim();		
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.fault': "+e.getMessage(),e);
				return null;
			}

			String faultCodeIntegrationNamespace = null;
			try{  
				faultCodeIntegrationNamespace = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultCode.integrationNamespace"); 
				if(faultCodeIntegrationNamespace!=null) {
					faultCodeIntegrationNamespace = faultCodeIntegrationNamespace.trim();
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultCode.integrationNamespace': "+e.getMessage(),e);
			}
			
			String faultCodeProtocolNamespace = null;
			try{  
				faultCodeProtocolNamespace = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultCode.protocolNamespace"); 
				if(faultCodeProtocolNamespace!=null) {
					faultCodeProtocolNamespace = faultCodeProtocolNamespace.trim();
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultCode.protocolNamespace': "+e.getMessage(),e);
			}
			
			String faultActor = null;
			try{  
				faultActor = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultActor"); 
				if(faultActor==null)
					throw new CoreException(NON_DEFINITA);
				faultActor = faultActor.trim();		
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultActor': "+e.getMessage(),e);
				return null;
			}

			String faultGeneric = null;
			try{  
				faultGeneric = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.genericFaultCode"); 
				if(faultGeneric==null)
					throw new CoreException(NON_DEFINITA);
				faultGeneric = faultGeneric.trim();		
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.genericFaultCode': "+e.getMessage(),e);
				return null;
			}

			String faultPrefix = null;
			try{  
				faultPrefix = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.prefixFaultCode"); 
				if(faultPrefix!=null)
					faultPrefix = faultPrefix.trim();		
			}catch(java.lang.Exception e) {
				// proprieta' che puo' non essere definita (default GOVWAY-)
			}

			ProprietaErroreApplicativo gestione = new ProprietaErroreApplicativo();
			if(CostantiConfigurazione.ERRORE_APPLICATIVO_XML.equals(fault))
				gestione.setFaultAsXML(true);
			else
				gestione.setFaultAsXML(false); // default: ERRORE_APPLICATIVO_SOAP
			gestione.setDefaultFaultCodeIntegrationNamespace(faultCodeIntegrationNamespace);
			gestione.setDefaultFaultCodeProtocolNamespace(faultCodeProtocolNamespace);
			gestione.setFaultActor(faultActor);
			if(CostantiConfigurazione.ABILITATO.equals(faultGeneric))
				gestione.setFaultAsGenericCode(true);
			else
				gestione.setFaultAsGenericCode(false); // default: false
			gestione.setFaultPrefixCode(faultPrefix);

			gestione.setInsertAsDetails(this.isErroreApplicativoIntoDetails());
			
			gestione.setAggiungiDetailErroreApplicativo_SoapFaultApplicativo(this.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo());
			
			gestione.setAggiungiDetailErroreApplicativo_SoapFaultPdD(this.isAggiungiDetailErroreApplicativo_SoapFaultPdD());

			this.proprietaGestioneErrorePD = gestione;
		}

		ProprietaErroreApplicativo pNew = new ProprietaErroreApplicativo();
		pNew.setDominio(this.proprietaGestioneErrorePD.getDominio());
		pNew.setDefaultFaultCodeIntegrationNamespace(this.proprietaGestioneErrorePD.getDefaultFaultCodeIntegrationNamespace());
		pNew.setDefaultFaultCodeProtocolNamespace(this.proprietaGestioneErrorePD.getDefaultFaultCodeProtocolNamespace());
		pNew.setFaultActor(this.proprietaGestioneErrorePD.getFaultActor());
		pNew.setFaultAsGenericCode(this.proprietaGestioneErrorePD.isFaultAsGenericCode());
		pNew.setFaultAsXML(this.proprietaGestioneErrorePD.isFaultAsXML());
		pNew.setFaultPrefixCode(this.proprietaGestioneErrorePD.getFaultPrefixCode());
		pNew.setIdModulo(this.proprietaGestioneErrorePD.getIdModulo());
		pNew.setInsertAsDetails(this.proprietaGestioneErrorePD.isInsertAsDetails());
		pNew.setAggiungiDetailErroreApplicativo_SoapFaultApplicativo(this.proprietaGestioneErrorePD.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo());
		pNew.setAggiungiDetailErroreApplicativo_SoapFaultPdD(this.proprietaGestioneErrorePD.isAggiungiDetailErroreApplicativo_SoapFaultPdD());
		if(protocolManager!=null){
			FaultIntegrationGenericInfoMode sf = protocolManager.getModalitaGenerazioneInformazioniGeneriche_DetailsFaultIntegrazione();
			if(FaultIntegrationGenericInfoMode.SERVIZIO_APPLICATIVO.equals(sf)){
				pNew.setInformazioniGenericheDetailsOpenSPCoop(null);
			}
			else if(FaultIntegrationGenericInfoMode.ABILITATO.equals(sf)){
				pNew.setInformazioniGenericheDetailsOpenSPCoop(true);
			} 
			else if(FaultIntegrationGenericInfoMode.DISABILITATO.equals(sf)){
				pNew.setInformazioniGenericheDetailsOpenSPCoop(false);
			} 
			
			BooleanNullable enrichNullable = protocolManager.isAggiungiDetailErroreApplicativo_FaultApplicativo();
			if(enrichNullable!=null && enrichNullable.getValue()!=null){
				pNew.setAggiungiDetailErroreApplicativo_SoapFaultApplicativo(enrichNullable.getValue());
			}
			
			enrichNullable = protocolManager.isAggiungiDetailErroreApplicativo_FaultPdD();
			if(enrichNullable!=null && enrichNullable.getValue()!=null){
				pNew.setAggiungiDetailErroreApplicativo_SoapFaultPdD(enrichNullable.getValue());
			}
			
		}else{
			pNew.setInformazioniGenericheDetailsOpenSPCoop(null); // default
		}
		return pNew;
	}


	private Locale localeSOAPFaultString = null;
	private Boolean localeSOAPFaultStringRead = null;
	public Locale getLocaleSOAPFaultString(){
		if(this.localeSOAPFaultStringRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultString.language"); 
				if (value != null){
					value = value.trim();
					
					String language = value;
					
					String country = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultString.country"); 
					if(country!=null) {
						country = country.trim();
					}
					
					String variant = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultString.variant"); 
					if(variant!=null) {
						variant = variant.trim();
					}
					
					this.localeSOAPFaultString = new Locale(language, country, variant);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultString.language' non impostata, viene utilizzato il default="+Locale.getDefault());
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultString.language' non impostata, viene utilizzato il default="+Locale.getDefault()+", errore:"+e.getMessage(),e);
			}
			this.localeSOAPFaultStringRead = true;
		}

		return this.localeSOAPFaultString;
	}
	

	/**
	 * Indicazione se l'errore applicativo deve essere inserito in un details.
	 *   
	 * @return Indicazione se l'errore applicativo deve essere inserito in un details.
	 * 
	 */
	private Boolean isErroreApplicativoIntoDetails = null;
	public boolean isErroreApplicativoIntoDetails(){
		if(this.isErroreApplicativoIntoDetails==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.fault.details"); 

				if (value != null){
					value = value.trim();
					this.isErroreApplicativoIntoDetails = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.fault.details' non impostata, viene utilizzato il default=true");
					this.isErroreApplicativoIntoDetails = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.fault.details' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isErroreApplicativoIntoDetails = true;
			}
		}

		return this.isErroreApplicativoIntoDetails;
	}
	
	
	/**
	 * Indicazione se aggiungere un detail contenente descrizione dell'errore nel SoapFaultApplicativo originale
	 * 
	 * @return Indicazione se aggiungere un detail contenente descrizione dell'errore nel SoapFaultApplicativo originale
	 */
	private Boolean isAggiungiDetailErroreApplicativo_SoapFaultApplicativo = null;
	public boolean isAggiungiDetailErroreApplicativo_SoapFaultApplicativo(){
		if(this.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultApplicativo.enrichDetails"); 

				if (value != null){
					value = value.trim();
					this.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultApplicativo.enrichDetails' non impostata, viene utilizzato il default=true");
					this.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultApplicativo.enrichDetails' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo = true;
			}
		}

		return this.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo;
	}
	
	
	/**
	 * Indicazione se aggiungere un detail contenente descrizione dell'errore nel SoapFaultPdD originale
	 * 
	 * @return Indicazione se aggiungere un detail contenente descrizione dell'errore nel SoapFaultPdD originale
	 */
	private Boolean isAggiungiDetailErroreApplicativo_SoapFaultPdD = null;
	public boolean isAggiungiDetailErroreApplicativo_SoapFaultPdD(){
		if(this.isAggiungiDetailErroreApplicativo_SoapFaultPdD==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultPdD.enrichDetails"); 

				if (value != null){
					value = value.trim();
					this.isAggiungiDetailErroreApplicativo_SoapFaultPdD = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultPdD.enrichDetails' non impostata, viene utilizzato il default=true");
					this.isAggiungiDetailErroreApplicativo_SoapFaultPdD = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultPdD.enrichDetails' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isAggiungiDetailErroreApplicativo_SoapFaultPdD = true;
			}
		}

		return this.isAggiungiDetailErroreApplicativo_SoapFaultPdD;
	}
	
	
	
	private String getErroriHttpHeaderGovWayStatus = null;
	public String getErroriHttpHeaderGovWayStatus(){
		
		String pName = "org.openspcoop2.pdd.errori.http.govwayStatus";
		if(this.getErroriHttpHeaderGovWayStatus==null){
			try{  
				String name = this.reader.getValueConvertEnvProperties(pName); 
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getErroriHttpHeaderGovWayStatus = name;

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,org.openspcoop2.protocol.basic.Costanti._internal_getHTTP_HEADER_GOVWAY_ERROR_STATUS()),e);
				this.getErroriHttpHeaderGovWayStatus = org.openspcoop2.protocol.basic.Costanti._internal_getHTTP_HEADER_GOVWAY_ERROR_STATUS();
			}
		}

		return this.getErroriHttpHeaderGovWayStatus;
	}
	
	private String getErroriHttpHeaderGovWayType = null;
	public String getErroriHttpHeaderGovWayType(){
		
		String pName = "org.openspcoop2.pdd.errori.http.govwayType";
		if(this.getErroriHttpHeaderGovWayType==null){
			try{  
				String name = this.reader.getValueConvertEnvProperties(pName); 
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getErroriHttpHeaderGovWayType = name;

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,org.openspcoop2.protocol.basic.Costanti._internal_getHTTP_HEADER_GOVWAY_ERROR_TYPE()),e);
				this.getErroriHttpHeaderGovWayType = org.openspcoop2.protocol.basic.Costanti._internal_getHTTP_HEADER_GOVWAY_ERROR_TYPE();
			}
		}

		return this.getErroriHttpHeaderGovWayType;
	}
	
	private String getErroriHttpHeaderGovWayCode = null;
	public String getErroriHttpHeaderGovWayCode(){
		
		String pName = "org.openspcoop2.pdd.errori.http.govwayCode";
		if(this.getErroriHttpHeaderGovWayCode==null){
			try{  
				String name = this.reader.getValueConvertEnvProperties(pName); 
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getErroriHttpHeaderGovWayCode = name;

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,org.openspcoop2.protocol.basic.Costanti._internal_getHTTP_HEADER_GOVWAY_ERROR_CODE()),e);
				this.getErroriHttpHeaderGovWayCode = org.openspcoop2.protocol.basic.Costanti._internal_getHTTP_HEADER_GOVWAY_ERROR_CODE();
			}
		}

		return this.getErroriHttpHeaderGovWayCode;
	}
	
	
	
	private Boolean isErroriSoapUseGovWayStatusAsFaultCode = null;
	public boolean isErroriSoapUseGovWayStatusAsFaultCode(){
		if(this.isErroriSoapUseGovWayStatusAsFaultCode==null){
			String pName = "org.openspcoop2.pdd.errori.soap.useGovWayStatusAsFaultCode";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isErroriSoapUseGovWayStatusAsFaultCode = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isErroriSoapUseGovWayStatusAsFaultCode = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isErroriSoapUseGovWayStatusAsFaultCode = false;
			}
		}

		return this.isErroriSoapUseGovWayStatusAsFaultCode;
	}
	
	private Boolean isErroriSoapHttpHeaderGovWayCodeEnabled = null;
	public boolean isErroriSoapHttpHeaderGovWayCodeEnabled(){
		if(this.isErroriSoapHttpHeaderGovWayCodeEnabled==null){
			String pName = "org.openspcoop2.pdd.errori.soap.HttpHeaderGovWayCode.enabled";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isErroriSoapHttpHeaderGovWayCodeEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isErroriSoapHttpHeaderGovWayCodeEnabled = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isErroriSoapHttpHeaderGovWayCodeEnabled = false;
			}
		}

		return this.isErroriSoapHttpHeaderGovWayCodeEnabled;
	}
	
	private Boolean isErroriGovWayStatusEnabled = null;
	public boolean isErroriGovWayStatusEnabled(){
		if(this.isErroriGovWayStatusEnabled==null){
			String pName = "org.openspcoop2.pdd.errori.status";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isErroriGovWayStatusEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isErroriGovWayStatusEnabled = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isErroriGovWayStatusEnabled = false;
			}
		}

		return this.isErroriGovWayStatusEnabled;
	}
	
	private Boolean isErroriGovWayInstanceEnabled = null;
	public boolean isErroriGovWayInstanceEnabled(){
		if(this.isErroriGovWayInstanceEnabled==null){
			String pName = "org.openspcoop2.pdd.errori.instance";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isErroriGovWayInstanceEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isErroriGovWayInstanceEnabled = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isErroriGovWayInstanceEnabled = false;
			}
		}

		return this.isErroriGovWayInstanceEnabled;
	}
	
	private Boolean isErroriGovWayForceSpecificDetails = null;
	public boolean isErroriGovWayForceSpecificDetails(){
		if(this.isErroriGovWayForceSpecificDetails==null){
			String pName = "org.openspcoop2.pdd.errori.forceSpecificDetails";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isErroriGovWayForceSpecificDetails = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isErroriGovWayForceSpecificDetails = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isErroriGovWayForceSpecificDetails = false;
			}
		}

		return this.isErroriGovWayForceSpecificDetails;
	}
	
	private Boolean isErroriGovWayFaultDetailsWithProblemRFC7807 = null;
	public boolean isErroriGovWayFaultDetailsWithProblemRFC7807(){
		if(this.isErroriGovWayFaultDetailsWithProblemRFC7807==null){
			String pName = "org.openspcoop2.pdd.errori.faultDetailsWithProblemRFC7807";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isErroriGovWayFaultDetailsWithProblemRFC7807 = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isErroriGovWayFaultDetailsWithProblemRFC7807 = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isErroriGovWayFaultDetailsWithProblemRFC7807 = false;
			}
		}

		return this.isErroriGovWayFaultDetailsWithProblemRFC7807;
	}
	
	
	
	
	private Boolean isProblemRFC7807_enrichTitleAsGovWayType = null;
	public boolean isProblemRFC7807_enrichTitleAsGovWayType(){
		if(this.isProblemRFC7807_enrichTitleAsGovWayType==null){
			String pName = "org.openspcoop2.pdd.problemRFC7807.enrichTitleAsGovWayType";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isProblemRFC7807_enrichTitleAsGovWayType = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isProblemRFC7807_enrichTitleAsGovWayType = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isProblemRFC7807_enrichTitleAsGovWayType = true;
			}
		}

		return this.isProblemRFC7807_enrichTitleAsGovWayType;
	}
	
	
	private Boolean isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode = null;
	public boolean isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode(){
		if(this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode==null){
			String pName = "org.openspcoop2.pdd.problemRFC7807.enrichTitleAsGovWayType.camelCaseDecode";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode = false;
			}
		}

		return this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode;
	}
	
	
	private Boolean isProblemRFC7807_enrichTitleAsGovWayType_customClaim = null;
	public boolean isProblemRFC7807_enrichTitleAsGovWayType_customClaim(){
		if(this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim==null){
			String pName = "org.openspcoop2.pdd.problemRFC7807.enrichTitleAsGovWayType.customClaim";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim = false;
			}
		}

		return this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim;
	}
	

	private String getProblemRFC7807_transactionId_claim = null;
	public String getProblemRFC7807_transactionId_claim(){
		
		String pName = "org.openspcoop2.pdd.problemRFC7807.transactionId.claim";
		if(this.getProblemRFC7807_transactionId_claim==null){
			try{  
				String fault = this.reader.getValueConvertEnvProperties(pName); 
				if(fault==null)
					throw new CoreException(NON_DEFINITA);
				fault = fault.trim();
				this.getProblemRFC7807_transactionId_claim = fault;

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,org.openspcoop2.protocol.basic.Costanti._internal_getPROBLEM_RFC7807_GOVWAY_TRANSACTION_ID()),e);
				this.getProblemRFC7807_transactionId_claim = org.openspcoop2.protocol.basic.Costanti._internal_getPROBLEM_RFC7807_GOVWAY_TRANSACTION_ID();
			}
		}

		return this.getProblemRFC7807_transactionId_claim;
	}
	
	private String getProblemRFC7807_code_claim = null;
	public String getProblemRFC7807_code_claim(){
		
		String pName = "org.openspcoop2.pdd.problemRFC7807.code.claim";
		if(this.getProblemRFC7807_code_claim==null){
			try{  
				String fault = this.reader.getValueConvertEnvProperties(pName); 
				if(fault==null)
					throw new CoreException(NON_DEFINITA);
				fault = fault.trim();
				this.getProblemRFC7807_code_claim = fault;

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,org.openspcoop2.protocol.basic.Costanti._internal_getPROBLEM_RFC7807_GOVWAY_CODE()),e);
				this.getProblemRFC7807_code_claim = org.openspcoop2.protocol.basic.Costanti._internal_getPROBLEM_RFC7807_GOVWAY_CODE();
			}
		}

		return this.getProblemRFC7807_code_claim;
	}
	
	private String getProblemRFC7807_type_claim = null;
	public String getProblemRFC7807_type_claim(){
		
		String pName = "org.openspcoop2.pdd.problemRFC7807.type.claim";
		if(this.getProblemRFC7807_type_claim==null){
			try{  
				String fault = this.reader.getValueConvertEnvProperties(pName); 
				if(fault==null)
					throw new CoreException(NON_DEFINITA);
				fault = fault.trim();
				this.getProblemRFC7807_type_claim = fault;

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,org.openspcoop2.protocol.basic.Costanti._internal_getPROBLEM_RFC7807_GOVWAY_TYPE()),e);
				this.getProblemRFC7807_type_claim = org.openspcoop2.protocol.basic.Costanti._internal_getPROBLEM_RFC7807_GOVWAY_TYPE();
			}
		}

		return this.getProblemRFC7807_type_claim;
	}





	/* ******** PORTA DI DOMINIO  ******** */

	/**
	 * Restituisce il nome di default dell'identificativo porta utilizzato dalla porta di dominio
	 *
	 * @return Restituisce il nome di default dell'identificativo porta utilizzato dalla porta di dominio
	 * 
	 */
	private String identificativoPortaDefault = null;
	private String getIdentificativoPortaDefault(){
		if(this.identificativoPortaDefault==null){
			try{  
				String fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.identificativoPorta.dominio"); 
				if(fault==null)
					throw new CoreException(NON_DEFINITA);
				fault = fault.trim();
				this.identificativoPortaDefault = fault;

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.identificativoPorta.dominio': "+e.getMessage(),e);
				this.identificativoPortaDefault = null;
			}
		}

		return this.identificativoPortaDefault;
	}
	/**
	 * Restituisce il nome di default della porta utilizzato dalla porta di dominio
	 *
	 * @return Restituisce il nome di default della porta utilizzato dalla porta di dominio
	 * 
	 */
	private String nomePortaDefault = null;
	private String getNomePortaDefault(){
		if(this.nomePortaDefault==null){
			try{  
				String fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.identificativoPorta.nome"); 
				if(fault==null)
					throw new CoreException(NON_DEFINITA);
				fault = fault.trim();
				this.nomePortaDefault = fault;

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.identificativoPorta.nome': "+e.getMessage(),e);
				this.nomePortaDefault = null;
			}
		}

		return this.nomePortaDefault;
	}


	/**
	 * Restituisce il nome di default della porta utilizzato dalla porta di dominio
	 *
	 * @return Restituisce il nome di default della porta utilizzato dalla porta di dominio
	 * 
	 */
	private String tipoPortaDefault = null;
	private String getTipoPortaDefault(){
		if(this.tipoPortaDefault==null){
			try{  
				String fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.identificativoPorta.tipo"); 
				if(fault==null)
					throw new CoreException(NON_DEFINITA);
				fault = fault.trim();
				this.tipoPortaDefault = fault;

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.identificativoPorta.tipo': "+e.getMessage(),e);
				this.tipoPortaDefault = null;
			}
		}
		return this.tipoPortaDefault;
	}

	/**
	 * Restituisce l'identita di default della porta utilizzato dalla porta di dominio
	 *
	 * @return Restituisce l'identita di default della porta utilizzato dalla porta di dominio
	 * 
	 */
	private IDSoggetto identitaPortaDefault = null;
	private IDSoggetto getIdentitaPortaDefault(){
		if(this.identitaPortaDefault==null){
			String pdd = getIdentificativoPortaDefault();
			String nome = getNomePortaDefault();
			String tipo = getTipoPortaDefault();
			if(tipo==null || nome==null || pdd==null)
				this.identitaPortaDefault = null;
			else	
				this.identitaPortaDefault = new IDSoggetto(tipo,nome,pdd);
		}

		if(this.identitaPortaDefault!=null){
			IDSoggetto idNew = new IDSoggetto();
			idNew.setCodicePorta(this.identitaPortaDefault.getCodicePorta());
			idNew.setNome(this.identitaPortaDefault.getNome());
			idNew.setTipo(this.identitaPortaDefault.getTipo());
			return idNew;
		}
		else{
			return null;
		}
	}


	// protocol mapping
	
	private Map<String,String> identificativoPortaDefault_mappingProtocol = new HashMap<>();
	private String _getIdentificativoPortaDefault(String protocol){
		
		if(protocol==null){
			return getIdentificativoPortaDefault();
		}
		
		if(this.identificativoPortaDefault_mappingProtocol.containsKey(protocol)==false){
			
			try{  
				
				String fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd."+protocol+".identificativoPorta.dominio"); 
				if(fault==null){
					fault = this.getIdentificativoPortaDefault();
				}else{
					fault = fault.trim();
				}
				this.identificativoPortaDefault_mappingProtocol.put(protocol, fault);

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd."+protocol+".identificativoPorta.dominio': "+e.getMessage(),e);
				return this.getIdentificativoPortaDefault();
			}
		}

		return this.identificativoPortaDefault_mappingProtocol.get(protocol);
	}

	private Map<String,String> nomePortaDefault_mappingProtocol = new HashMap<>();
	private String _getNomePortaDefault(String protocol){
		
		if(protocol==null){
			return getNomePortaDefault();
		}
		
		if(this.nomePortaDefault_mappingProtocol.containsKey(protocol)==false){
			
			try{  
				
				String nome = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd."+protocol+".identificativoPorta.nome"); 
				if(nome==null){
					nome = this.getNomePortaDefault();
				}else{
					nome = nome.trim();
				}
				this.nomePortaDefault_mappingProtocol.put(protocol, nome);

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd."+protocol+".identificativoPorta.nome': "+e.getMessage(),e);
				return this.getNomePortaDefault();
			}
		}

		return this.nomePortaDefault_mappingProtocol.get(protocol);
	}
	
	private Map<String,String> tipoPortaDefault_mappingProtocol = new HashMap<>();
	private String _getTipoPortaDefault(String protocol){
		
		if(protocol==null){
			return getTipoPortaDefault();
		}
		
		if(this.tipoPortaDefault_mappingProtocol.containsKey(protocol)==false){
			
			try{  
				
				String tipo = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd."+protocol+".identificativoPorta.tipo"); 
				if(tipo==null){
					tipo = this.getTipoPortaDefault();
				}else{
					tipo = tipo.trim();
				}
				this.tipoPortaDefault_mappingProtocol.put(protocol, tipo);

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd."+protocol+".identificativoPorta.tipo': "+e.getMessage(),e);
				return this.getTipoPortaDefault();
			}
		}

		return this.tipoPortaDefault_mappingProtocol.get(protocol);
	}

	public IDSoggetto getIdentitaPortaDefaultWithoutProtocol(){
		return getIdentitaPortaDefault();
	}
	
	private Map<String,IDSoggetto> identitaPortaDefault_mappingProtocol = new HashMap<String, IDSoggetto>();
	public IDSoggetto getIdentitaPortaDefault(String protocol, RequestInfo requestInfo){
		
		if(requestInfo!=null && requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getDominioDefault()!=null) {
			IDSoggetto identitaPortaDefault = requestInfo.getRequestConfig().getDominioDefault();
			
			IDSoggetto idNew = new IDSoggetto();
			idNew.setCodicePorta(identitaPortaDefault.getCodicePorta());
			idNew.setNome(identitaPortaDefault.getNome());
			idNew.setTipo(identitaPortaDefault.getTipo());
			return idNew;
		}
		
		if(protocol==null){
			return getIdentitaPortaDefault();
		}
		
		if(this.identitaPortaDefault_mappingProtocol.containsKey(protocol)==false){
			String pdd = _getIdentificativoPortaDefault(protocol);
			String nome = _getNomePortaDefault(protocol);
			String tipo = _getTipoPortaDefault(protocol);
			if(tipo!=null && nome!=null && pdd!=null){
				IDSoggetto identitaPortaDefault = new IDSoggetto(tipo,nome,pdd);
				this.identitaPortaDefault_mappingProtocol.put(protocol, identitaPortaDefault);
			}
		}
		
		IDSoggetto identitaPortaDefault = this.identitaPortaDefault_mappingProtocol.get(protocol);
		
		if(identitaPortaDefault!=null){
			
			if(requestInfo!=null && requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getDominioDefault()==null) {
				requestInfo.getRequestConfig().setDominioDefault(identitaPortaDefault);
			}
			
			IDSoggetto idNew = new IDSoggetto();
			idNew.setCodicePorta(identitaPortaDefault.getCodicePorta());
			idNew.setNome(identitaPortaDefault.getNome());
			idNew.setTipo(identitaPortaDefault.getTipo());
			return idNew;
		}
		else{
			return null;
		}
	}
	public String getIdentificativoPortaDefault(String protocol, RequestInfo requestInfo){
		IDSoggetto identitaPortaDefault = getIdentitaPortaDefault(protocol, requestInfo);
		if(identitaPortaDefault!=null) {
			return identitaPortaDefault.getCodicePorta();
		}
		return null;
	}






	/************ AUTORIZZAZIONE *******************/

	private Boolean getAutorizzazioneLockPermitsRead = null;
	private Integer getAutorizzazioneLockPermits = null;
	public Integer getAutorizzazioneLockPermits() {

		String pName = "org.openspcoop2.pdd.core.autorizzazione.lock.permits";
		if(this.getAutorizzazioneLockPermitsRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					int permits = Integer.parseInt(value); 
					if(permits>1) {
						// altrimenti è un normale semaphore binario
						this.getAutorizzazioneLockPermits = permits;
					}
				}
				
				
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			
			this.getAutorizzazioneLockPermitsRead = true;
		}

		return this.getAutorizzazioneLockPermits;
	}
	
	private Map<String, Integer> getTipoAutorizzazioneLockPermits = null;
	public Integer getAutorizzazioneLockPermits(String tipoAutorizzazione) { 

		String pName = "org.openspcoop2.pdd.core.autorizzazione.lock.permits.";
		if(this.getTipoAutorizzazioneLockPermits==null){
			
			this.getTipoAutorizzazioneLockPermits = new HashMap<>();
			
			try{  
				Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
				if(p!=null && !p.isEmpty()) {
					for (Object oKey : p.keySet()) {
						if(oKey!=null) {
							String key = (String) oKey;
							String value = p.getProperty(key);
							if(value!=null) {
								int permits = Integer.parseInt(value);
								if(permits>1) {
									// altrimenti è un normale semaphore binario
									this.getTipoAutorizzazioneLockPermits.put(key, permits);
								}
							}
						}
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			
		}

		return this.getTipoAutorizzazioneLockPermits.get(tipoAutorizzazione);
	}
	
	/**
	 * Restituisce il tipo di autorizzazione delle buste effettuato dalla porta di dominio
	 *
	 * @return Restituisce il tipo di autorizzazione delle buste effettuato dalla porta di dominio
	 * 
	 */
	private String tipoAutorizzazioneBuste = null;
	public String getTipoAutorizzazioneBuste(){
		if(this.tipoAutorizzazioneBuste==null){
			try{  
				String autorizzazione = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.autorizzazioneBuste.tipo");
				if(autorizzazione==null)
					throw new CoreException(NON_DEFINITA);
				autorizzazione = autorizzazione.trim();
				this.tipoAutorizzazioneBuste = autorizzazione;

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.autorizzazioneBuste.tipo': "+e.getMessage(),e);
				this.tipoAutorizzazioneBuste = null;
			}
		}

		return this.tipoAutorizzazioneBuste;
	}
	
	
	private Boolean isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta = null;
	public boolean isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta() {	
		if(this.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta==null){
			String pName = "org.openspcoop2.pdd.autorizzazioneBusta.autenticazioneOpzionale.soggettoFruitoreProfiloInteroperabilitaDifferenteServizio.bloccaRichiesta";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta = true;
			}    
		}

		return this.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta;
	}

	



	
	/************ AUTORIZZAZIONE CONTENUTI *******************/

	private Boolean getAutorizzazioneContenutiLockPermitsRead = null;
	private Integer getAutorizzazioneContenutiLockPermits = null;
	public Integer getAutorizzazioneContenutiLockPermits() {

		String pName = "org.openspcoop2.pdd.core.autorizzazioneContenuti.lock.permits";
		if(this.getAutorizzazioneContenutiLockPermitsRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					int permits = Integer.parseInt(value); 
					if(permits>1) {
						// altrimenti è un normale semaphore binario
						this.getAutorizzazioneContenutiLockPermits = permits;
					}
				}
				
				
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			
			this.getAutorizzazioneContenutiLockPermitsRead = true;
		}

		return this.getAutorizzazioneContenutiLockPermits;
	}
	
	private Map<String, Integer> getTipoAutorizzazioneContenutiLockPermits = null;
	public Integer getAutorizzazioneContenutiLockPermits(String tipoAutorizzazioneContenuti) { 

		String pName = "org.openspcoop2.pdd.core.autorizzazioneContenuti.lock.permits.";
		if(this.getTipoAutorizzazioneContenutiLockPermits==null){
			
			this.getTipoAutorizzazioneContenutiLockPermits = new HashMap<>();
			
			try{  
				Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
				if(p!=null && !p.isEmpty()) {
					for (Object oKey : p.keySet()) {
						if(oKey!=null) {
							String key = (String) oKey;
							String value = p.getProperty(key);
							if(value!=null) {
								int permits = Integer.parseInt(value);
								if(permits>1) {
									// altrimenti è un normale semaphore binario
									this.getTipoAutorizzazioneContenutiLockPermits.put(key, permits);
								}
							}
						}
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			
		}

		return this.getTipoAutorizzazioneContenutiLockPermits.get(tipoAutorizzazioneContenuti);
	}
	
	
	
	



	/* ********  Bypass Filtri  ******** */

	/**
	 * Restituisce le proprieta' che localizzano gli header element su cui deve essere applicato il filtro bypass.
	 *
	 * @return proprieta' che localizzano gli header element su cui deve essere applicato il filtro bypass.
	 * 
	 */
	private Map<String,List<NameValue>> mapGetBypassFilterMustUnderstandProperties = null;
	public List<NameValue> getBypassFilterMustUnderstandProperties(String protocol) {
		if(this.mapGetBypassFilterMustUnderstandProperties==null){
			initBypassFilterMustUnderstandProperties();
		}
		return this.mapGetBypassFilterMustUnderstandProperties.get(protocol);
	}
	private void initBypassFilterMustUnderstandProperties(){
		if(this.mapGetBypassFilterMustUnderstandProperties==null){
			
			this.mapGetBypassFilterMustUnderstandProperties = new HashMap<String, List<NameValue>>();
			
			List<NameValue> resultList = new ArrayList<NameValue>();
			try{ 
				java.util.Properties tmpP = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.");
				if(tmpP!=null && tmpP.size()>0){
					Enumeration<Object> keys = tmpP.keys();
					while (keys.hasMoreElements()) {
						Object object = (Object) keys.nextElement();
						if(object instanceof String){
							String key = (String) object;
							String localName = key;
							String namespace = tmpP.getProperty(key);
							if(key.contains("!")){
								// serve a fornire più proprietà con stesso localName e namespace differente
								// tramite la formula 
								// org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.nomeHeader=http://prova
								// org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.nomeHeader!1=http://prova2
								// org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.nomeHeader!2=http://prova3
								localName = key.split("!")[0];
							}
							NameValue nameValue = new NameValue();
							nameValue.setName(localName);
							nameValue.setValue(namespace);
							resultList.add(nameValue);
						}
					}
				}
				
				
				// aggiungo i bypass specifici dei protocolli
				Enumeration<String> protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
				while (protocolli.hasMoreElements()) {
					String protocollo = (String) protocolli.nextElement();
					IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactories().get(protocollo);
					IProtocolConfiguration pc = pf.createProtocolConfiguration();
					List<BypassMustUnderstandCheck> list = pc.getBypassMustUnderstandCheck();
					
					List<NameValue> resultListForProtocol = new ArrayList<NameValue>();
					if(resultList!=null && resultList.size()>0){
						resultListForProtocol.addAll(resultList);
					}
					
					if(list!=null && list.size()>0){
						for (Iterator<?> iterator = list.iterator(); iterator.hasNext();) {
							BypassMustUnderstandCheck bypassMustUnderstandCheck = (BypassMustUnderstandCheck) iterator.next();
							
							NameValue nameValue = new NameValue();
							nameValue.setName(bypassMustUnderstandCheck.getElementName());
							nameValue.setValue(bypassMustUnderstandCheck.getNamespace());
							resultListForProtocol.add(nameValue);
							
						}
					}
					
					for (NameValue nameValue : resultListForProtocol) {
						this.logDebug("["+protocollo+"] ["+nameValue.getName()+"]=["+nameValue.getValue()+"]");
					}
					
					this.mapGetBypassFilterMustUnderstandProperties.put(protocollo, resultListForProtocol);
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle propriete' 'org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.*': "+e.getMessage(),e);
				this.mapGetBypassFilterMustUnderstandProperties = null;
			}    
			
		}

	}

	/**
	 * Restituisce l'indicazione se il BypassFilterMustUnderstand e' abilitato per tutti gli header
	 *
	 * @return Restituisce l'indicazione se il BypassFilterMustUnderstand e' abilitato per tutti gli header
	 * 
	 */
	private Boolean isBypassFilterMustUnderstandEnabledForAllHeaders = null;
	public boolean isBypassFilterMustUnderstandEnabledForAllHeaders(){
		if(this.isBypassFilterMustUnderstandEnabledForAllHeaders==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.BypassMustUnderstandHandler.allHeaders"); 

				if(value!=null){
					value = value.trim();
					this.isBypassFilterMustUnderstandEnabledForAllHeaders = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.BypassMustUnderstandHandler.allHeaders' non impostata, viene utilizzato il default=false");
					this.isBypassFilterMustUnderstandEnabledForAllHeaders = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.BypassMustUnderstandHandler.allHeaders' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isBypassFilterMustUnderstandEnabledForAllHeaders = false;
			}
		}

		return this.isBypassFilterMustUnderstandEnabledForAllHeaders;
	}





	
	
	/* ------------- ContentType ---------------------*/
	
	private Boolean isControlloContentTypeAbilitatoRicezioneContenutiApplicativi= null;
	public boolean isControlloContentTypeAbilitatoRicezioneContenutiApplicativi(){
		if(this.isControlloContentTypeAbilitatoRicezioneContenutiApplicativi==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.contentType.checkEnabled"); 

				if(value!=null){
					value = value.trim();
					this.isControlloContentTypeAbilitatoRicezioneContenutiApplicativi = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.contentType.checkEnabled' non impostata, viene utilizzato il default=true");
					this.isControlloContentTypeAbilitatoRicezioneContenutiApplicativi = true;
				}

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.contentType.checkEnabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isControlloContentTypeAbilitatoRicezioneContenutiApplicativi = true;
			}
		}
		return this.isControlloContentTypeAbilitatoRicezioneContenutiApplicativi;
	}

	private Boolean isControlloContentTypeAbilitatoRicezioneBuste= null;
	public boolean isControlloContentTypeAbilitatoRicezioneBuste(){
		if(this.isControlloContentTypeAbilitatoRicezioneBuste==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.contentType.checkEnabled"); 

				if(value!=null){
					value = value.trim();
					this.isControlloContentTypeAbilitatoRicezioneBuste = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.contentType.checkEnabled' non impostata, viene utilizzato il default=true");
					this.isControlloContentTypeAbilitatoRicezioneBuste = true;
				}

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.contentType.checkEnabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isControlloContentTypeAbilitatoRicezioneBuste = true;
			}
		}
		return this.isControlloContentTypeAbilitatoRicezioneBuste;
	}
	
	private Boolean isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap= null;
	private List<String> listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = null;
	public boolean isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap(){
		if(this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap==null){
			String pName = "org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.soap.charsetExpected";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					if("*".equals(value)) {
						this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = false;
					}
					else {
						List<String> l = new ArrayList<>();
						if(value.contains(",")) {
							String [] tmp = value.split(",");
							if(tmp!=null && tmp.length>0) {
								for (String s : tmp) {
									if(s!=null && !"".equals(s)) {
										l.add(s);
									}
								}
							}
						}
						else {
							l.add(value);
						}
						if(!l.isEmpty()) {
							this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = true;
							this.listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = l;
						}
						else {
							this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = false;
						}
					}
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = false;
				}

			}catch(java.lang.Exception e) {
				this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = false;
			}
		}
		return this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap;
	}
	public List<String> getControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap(){
		if(isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap()) {
			return this.listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap;
		}
		return null;
	}
	
	private Boolean isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest= null;
	private List<String> listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = null;
	public boolean isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest(){
		if(this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest==null){
			String pName = "org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.rest.charsetExpected";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					if("*".equals(value)) {
						this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = false;
					}
					else {
						List<String> l = new ArrayList<>();
						if(value.contains(",")) {
							String [] tmp = value.split(",");
							if(tmp!=null && tmp.length>0) {
								for (String s : tmp) {
									if(s!=null && !"".equals(s)) {
										l.add(s);
									}
								}
							}
						}
						else {
							l.add(value);
						}
						if(!l.isEmpty()) {
							this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = true;
							this.listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = l;
						}
						else {
							this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = false;
						}
					}
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = false;
				}

			}catch(java.lang.Exception e) {
				this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = false;
			}
		}
		return this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest;
	}
	public List<String> getControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest(){
		if(isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest()) {
			return this.listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest;
		}
		return null;
	}
	
	private Boolean isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap= null;
	private List<String> listControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = null;
	public boolean isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap(){
		if(this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap==null){
			String pName = "org.openspcoop2.pdd.services.ricezioneBuste.soap.charsetExpected";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					if("*".equals(value)) {
						this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = false;
					}
					else {
						List<String> l = new ArrayList<>();
						if(value.contains(",")) {
							String [] tmp = value.split(",");
							if(tmp!=null && tmp.length>0) {
								for (String s : tmp) {
									if(s!=null && !"".equals(s)) {
										l.add(s);
									}
								}
							}
						}
						else {
							l.add(value);
						}
						if(!l.isEmpty()) {
							this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = true;
							this.listControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = l;
						}
						else {
							this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = false;
						}
					}
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = false;
				}

			}catch(java.lang.Exception e) {
				this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = false;
			}
		}
		return this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap;
	}
	public List<String> getControlloCharsetContentTypeAbilitatoRicezioneBusteSoap(){
		if(isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap()) {
			return this.listControlloCharsetContentTypeAbilitatoRicezioneBusteSoap;
		}
		return null;
	}
	
	private Boolean isControlloCharsetContentTypeAbilitatoRicezioneBusteRest= null;
	private List<String> listControlloCharsetContentTypeAbilitatoRicezioneBusteRest = null;
	public boolean isControlloCharsetContentTypeAbilitatoRicezioneBusteRest(){
		if(this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest==null){
			String pName = "org.openspcoop2.pdd.services.ricezioneBuste.rest.charsetExpected";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					if("*".equals(value)) {
						this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = false;
					}
					else {
						List<String> l = new ArrayList<>();
						if(value.contains(",")) {
							String [] tmp = value.split(",");
							if(tmp!=null && tmp.length>0) {
								for (String s : tmp) {
									if(s!=null && !"".equals(s)) {
										l.add(s);
									}
								}
							}
						}
						else {
							l.add(value);
						}
						if(!l.isEmpty()) {
							this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = true;
							this.listControlloCharsetContentTypeAbilitatoRicezioneBusteRest = l;
						}
						else {
							this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = false;
						}
					}
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = false;
				}

			}catch(java.lang.Exception e) {
				this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = false;
			}
		}
		return this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest;
	}
	public List<String> getControlloCharsetContentTypeAbilitatoRicezioneBusteRest(){
		if(isControlloCharsetContentTypeAbilitatoRicezioneBusteRest()) {
			return this.listControlloCharsetContentTypeAbilitatoRicezioneBusteRest;
		}
		return null;
	}
	
	private Boolean isPrintInfoCertificate= null;
	public boolean isPrintInfoCertificate(){
		if(this.isPrintInfoCertificate==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.certificate.printInfo"); 

				if(value!=null){
					value = value.trim();
					this.isPrintInfoCertificate = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.certificate.printInfo' non impostata, viene utilizzato il default=false");
					this.isPrintInfoCertificate = false;
				}

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.certificate.printInfo' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isPrintInfoCertificate = false;
			}
		}
		return this.isPrintInfoCertificate;
	}
	
	
	/* ------------- Gestore Credenziali (Porta Delegata) ---------------------*/

	public static final String prefixGestoreCredenzialiPortaDelegataProperties = "org.openspcoop2.pdd.services.pd.gestoreCredenziali.";
	
	private Boolean isGestoreCredenzialiPortaDelegataEnabled= null;
	public boolean isGestoreCredenzialiPortaDelegataEnabled(){
		String pName = prefixGestoreCredenzialiPortaDelegataProperties+"enabled";
        if(this.isGestoreCredenzialiPortaDelegataEnabled==null){
                try{  
                        String value = this.reader.getValueConvertEnvProperties(pName); 

                        if(value!=null){
                                value = value.trim();
                                this.isGestoreCredenzialiPortaDelegataEnabled = Boolean.parseBoolean(value);
                        }else{
                                this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
                                this.isGestoreCredenzialiPortaDelegataEnabled = false;
                        }

                }catch(java.lang.Exception e) {
                        this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
                        this.isGestoreCredenzialiPortaDelegataEnabled = false;
                }
        }
        return this.isGestoreCredenzialiPortaDelegataEnabled;
	}

	
	private Properties getGestoreCredenzialiPortaDelegataProperties = null;
	public Properties getGestoreCredenzialiPortaDelegataProperties() {
		if(this.getGestoreCredenzialiPortaDelegataProperties==null){
			try{  
				this.getGestoreCredenzialiPortaDelegataProperties=this.reader.readProperties(prefixGestoreCredenzialiPortaDelegataProperties);
				if(this.getGestoreCredenzialiPortaDelegataProperties==null) {
					this.getGestoreCredenzialiPortaDelegataProperties=new Properties();
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+prefixGestoreCredenzialiPortaDelegataProperties+"*' non impostate correttamente, errore:"+e.getMessage(),e);
				this.getGestoreCredenzialiPortaDelegataProperties = null;
			}
		}
		return this.getGestoreCredenzialiPortaDelegataProperties;
	}

	
	
	/* ------------- Gestore Credenziali (Porta Applicativa) ---------------------*/

	public static final String prefixGestoreCredenzialiPortaApplicativaProperties = "org.openspcoop2.pdd.services.pa.gestoreCredenziali.";
	
	private Boolean isGestoreCredenzialiPortaApplicativaEnabled= null;
	public boolean isGestoreCredenzialiPortaApplicativaEnabled(){
		String pName = prefixGestoreCredenzialiPortaApplicativaProperties+"enabled";
        if(this.isGestoreCredenzialiPortaApplicativaEnabled==null){
                try{  
                        String value = this.reader.getValueConvertEnvProperties(pName); 

                        if(value!=null){
                                value = value.trim();
                                this.isGestoreCredenzialiPortaApplicativaEnabled = Boolean.parseBoolean(value);
                        }else{
                                this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
                                this.isGestoreCredenzialiPortaApplicativaEnabled = false;
                        }

                }catch(java.lang.Exception e) {
                        this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
                        this.isGestoreCredenzialiPortaApplicativaEnabled = false;
                }
        }
        return this.isGestoreCredenzialiPortaApplicativaEnabled;
	}

	
	private Properties getGestoreCredenzialiPortaApplicativaProperties = null;
	public Properties getGestoreCredenzialiPortaApplicativaProperties() {
		if(this.getGestoreCredenzialiPortaApplicativaProperties==null){
			try{  
				this.getGestoreCredenzialiPortaApplicativaProperties=this.reader.readProperties(prefixGestoreCredenzialiPortaApplicativaProperties);
				if(this.getGestoreCredenzialiPortaApplicativaProperties==null) {
					this.getGestoreCredenzialiPortaApplicativaProperties=new Properties();
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+prefixGestoreCredenzialiPortaApplicativaProperties+"*' non impostate correttamente, errore:"+e.getMessage(),e);
				this.getGestoreCredenzialiPortaApplicativaProperties = null;
			}
		}
		return this.getGestoreCredenzialiPortaApplicativaProperties;
	}
	

	
	/* ********  HSM  ******** */
	
	private String getHSMConfig = null;
	public String getHSMConfig(){
		if(this.getHSMConfig==null){
			String pName = "org.openspcoop2.pdd.hsm.config";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					if(!"".equals(value)) {
						this.getHSMConfig = value;
					}
				}

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verrà abilitato l'engine HSM errore:"+e.getMessage(),e);
				this.getHSMConfig = null;
			}
		}
		return this.getHSMConfig;
	}
	
	private Boolean isHSMConfigRequired= null;
	public boolean isHSMConfigRequired(){
		if(this.isHSMConfigRequired==null){
			String pName = "org.openspcoop2.pdd.hsm.required";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isHSMConfigRequired = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isHSMConfigRequired = false;
				}

			}catch(java.lang.Exception e) {
				this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isHSMConfigRequired = false;
			}
		}
		return this.isHSMConfigRequired;
	}
	
	private Boolean isHSMConfigUniqueProviderInstance= null;
	public boolean isHSMConfigUniqueProviderInstance(){
		if(this.isHSMConfigUniqueProviderInstance==null){
			String pName = "org.openspcoop2.pdd.hsm.uniqueProviderInstance";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isHSMConfigUniqueProviderInstance = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isHSMConfigUniqueProviderInstance = true;
				}

			}catch(java.lang.Exception e) {
				this.logError(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isHSMConfigUniqueProviderInstance = true;
			}
		}
		return this.isHSMConfigUniqueProviderInstance;
	}
	

	
	
	/* ********  OCSP  ******** */
	
	private String getOCSPConfig = null;
	public String getOCSPConfig(){
		if(this.getOCSPConfig==null){
			String pName = "org.openspcoop2.pdd.ocsp.config";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					if(!"".equals(value)) {
						this.getOCSPConfig = value;
					}
				}

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verrà abilitato l'engine OCSP errore:"+e.getMessage(),e);
				this.getOCSPConfig = null;
			}
		}
		return this.getOCSPConfig;
	}
	
	private Boolean isOCSPConfigRequired= null;
	public boolean isOCSPConfigRequired(){
		if(this.isOCSPConfigRequired==null){
			String pName = "org.openspcoop2.pdd.ocsp.required";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isOCSPConfigRequired = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isOCSPConfigRequired = false;
				}

			}catch(java.lang.Exception e) {
				this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isOCSPConfigRequired = false;
			}
		}
		return this.isOCSPConfigRequired;
	}
	
	private Boolean isOCSPConfigLoadDefault= null;
	public boolean isOCSPConfigLoadDefault(){
		if(this.isOCSPConfigLoadDefault==null){
			String pName = "org.openspcoop2.pdd.ocsp.loadDefault";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isOCSPConfigLoadDefault = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isOCSPConfigLoadDefault = true;
				}

			}catch(java.lang.Exception e) {
				this.logError(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isOCSPConfigLoadDefault = true;
			}
		}
		return this.isOCSPConfigLoadDefault;
	}
	
	
	
	
	
	/* ********  BYOK  ******** */
	
	private String getBYOKConfig = null;
	public String getBYOKConfig(){
		if(this.getBYOKConfig==null){
			String pName = "org.openspcoop2.pdd.byok.config";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					if(!"".equals(value)) {
						this.getBYOKConfig = value;
					}
				}

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verrà abilitato l'engine BYOK errore:"+e.getMessage(),e);
				this.getBYOKConfig = null;
			}
		}
		return this.getBYOKConfig;
	}
	
	private Boolean isBYOKConfigRequired= null;
	public boolean isBYOKConfigRequired(){
		if(this.isBYOKConfigRequired==null){
			String pName = "org.openspcoop2.pdd.byok.required";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isBYOKConfigRequired = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isBYOKConfigRequired = false;
				}

			}catch(java.lang.Exception e) {
				this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isBYOKConfigRequired = false;
			}
		}
		return this.isBYOKConfigRequired;
	}
	
	
	
	

	/* ********  NODE RECEIVER  ******** */


	/**
	 * Restituisce il Timeout di attesa di una risposta applicativa
	 *
	 * @return Restituisce il Timeout di attesa di una risposta applicativa
	 * 
	 */
	private Long nodeReceiverTimeout = null;
	public long getNodeReceiverTimeout() {	
		if(this.nodeReceiverTimeout == null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.timeout");
				if(name!=null){
					name = name.trim();
					this.nodeReceiverTimeout = java.lang.Long.parseLong(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.timeout' non impostata, viene utilizzato il default="+CostantiPdD.NODE_RECEIVER_ATTESA_ATTIVA);
					this.nodeReceiverTimeout = CostantiPdD.NODE_RECEIVER_ATTESA_ATTIVA;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.timeout' non impostata, viene utilizzato il default="+CostantiPdD.NODE_RECEIVER_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.nodeReceiverTimeout = CostantiPdD.NODE_RECEIVER_ATTESA_ATTIVA;
			}    
		}

		return this.nodeReceiverTimeout;
	} 
	/**
	 * Restituisce il Timeout di attesa di una risposta applicativa
	 *
	 * @return Restituisce il Timeout di attesa di una risposta applicativa
	 * 
	 */
	private Long nodeReceiverTimeoutRicezioneContenutiApplicativi = null;
	public long getNodeReceiverTimeoutRicezioneContenutiApplicativi() {	
		if(this.nodeReceiverTimeoutRicezioneContenutiApplicativi == null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.ricezioneContenutiApplicativi.timeout");
				if(name!=null){
					name = name.trim();
					this.nodeReceiverTimeoutRicezioneContenutiApplicativi = java.lang.Long.parseLong(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.ricezioneContenutiApplicativi.timeout' non impostata, viene utilizzato il default="+this.getNodeReceiverTimeout());
					this.nodeReceiverTimeoutRicezioneContenutiApplicativi = this.getNodeReceiverTimeout();
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.ricezioneContenutiApplicativi.timeout' non impostata, viene utilizzato il default="+this.getNodeReceiverTimeout()+", errore:"+e.getMessage(),e);
				this.nodeReceiverTimeoutRicezioneContenutiApplicativi = this.getNodeReceiverTimeout();
			}    
		}

		return this.nodeReceiverTimeoutRicezioneContenutiApplicativi;
	} 
	/**
	 * Restituisce il Timeout di attesa di una busta
	 *
	 * @return Restituisce il Timeout di attesa di una busta
	 * 
	 */
	private Long nodeReceiverTimeoutRicezioneBuste = null;
	public long getNodeReceiverTimeoutRicezioneBuste() {	
		if(this.nodeReceiverTimeoutRicezioneBuste == null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.ricezioneBuste.timeout");

				if(name!=null){
					name = name.trim();
					this.nodeReceiverTimeoutRicezioneBuste = java.lang.Long.parseLong(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.ricezioneBuste.timeout' non impostata, viene utilizzato il default="+this.getNodeReceiverTimeout());
					this.nodeReceiverTimeoutRicezioneBuste = this.getNodeReceiverTimeout();
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.ricezioneBuste.timeout' non impostata, viene utilizzato il default="+this.getNodeReceiverTimeout()+", errore:"+e.getMessage(),e);
				this.nodeReceiverTimeoutRicezioneBuste = this.getNodeReceiverTimeout();
			}    
		}

		return this.nodeReceiverTimeoutRicezioneBuste;
	} 
	/**
	 * Restituisce la Frequenza di check sulla coda RicezioneBuste/RicezioneContenutiApplicativi
	 *
	 * @return Restituisce la Frequenza di check sulla coda RicezioneBuste/RicezioneContenutiApplicativi
	 * 
	 */
	private Integer nodeReceiverCheckInterval = null;
	public int getNodeReceiverCheckInterval() {	
		if(this.nodeReceiverCheckInterval==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.check");
				if(name!=null){
					name = name.trim();
					this.nodeReceiverCheckInterval = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.check' non impostata, viene utilizzato il default="+CostantiPdD.NODE_RECEIVER_CHECK_INTERVAL);
					this.nodeReceiverCheckInterval = CostantiPdD.NODE_RECEIVER_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.check' non impostata, viene utilizzato il default="+CostantiPdD.NODE_RECEIVER_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.nodeReceiverCheckInterval = CostantiPdD.NODE_RECEIVER_CHECK_INTERVAL;
			}    
		}

		return this.nodeReceiverCheckInterval;
	}

	/**
	 * Restituisce l'intervallo di check su DB effettuata dal TransactionManager, in caso di cache attiva
	 * 
	 * @return Restituisce intervallo di check su DB effettuata dal TransactionManager, in caso di cache attiva
	 * 
	 */
	private Integer nodeReceiverCheckDBInterval = null;
	public int getNodeReceiverCheckDBInterval() {	
		if(this.nodeReceiverCheckDBInterval==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.checkDB");

				if(name!=null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.nodeReceiverCheckDBInterval = time;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.checkDB' non impostata, viene utilizzato il default="+CostantiPdD.NODE_RECEIVER_CHECK_DB_INTERVAL);
					this.nodeReceiverCheckDBInterval = CostantiPdD.NODE_RECEIVER_CHECK_DB_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.checkDB' non impostata, viene utilizzato il default="+CostantiPdD.NODE_RECEIVER_CHECK_DB_INTERVAL+", errore:"+e.getMessage(),e);
				this.nodeReceiverCheckDBInterval = CostantiPdD.NODE_RECEIVER_CHECK_DB_INTERVAL;
			}  
		}

		return this.nodeReceiverCheckDBInterval;
	}

	/**
	 * Restituisce il nodeReceiver da utilizzare per le comunicazioni infrastrutturali 
	 * 
	 * @return  il nodeReceiver da utilizzare per le comunicazioni infrastrutturali 
	 */
	private String nodeReceiver = null;
	public String getNodeReceiver() {
		if(this.nodeReceiver==null){
			try{ 
				this.nodeReceiver = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver");
				if(this.nodeReceiver==null)
					throw new CoreException(NON_DEFINITA);
				this.nodeReceiver = this.nodeReceiver.trim();

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver': "+e.getMessage(),e);
				this.nodeReceiver = null;
			}    
		}

		return this.nodeReceiver;
	}

	/**
	 * Restituisce l'indicazione se il NodeReceiver deve essere utilizzato in single connection
	 *
	 * @return Restituisce l'indicazione se il NodeReceiver deve essere utilizzato in single connection
	 * 
	 */
	private Boolean singleConnection_nodeReceiver_value = null;
	public boolean singleConnection_NodeReceiver(){

		if(this.singleConnection_nodeReceiver_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.singleConnection"); 

				if(value!=null){
					value = value.trim();
					this.singleConnection_nodeReceiver_value = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.singleConnection' non impostata, viene utilizzato il default=false");
					this.singleConnection_nodeReceiver_value = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.singleConnection' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.singleConnection_nodeReceiver_value = false;
			}
		}

		return this.singleConnection_nodeReceiver_value;

	}




	/* ********  NODE SENDER  ******** */

	/**
	 * Restituisce il nodeSender da utilizzare per le comunicazioni infrastrutturali 
	 * 
	 * @return  il nodeSender da utilizzare per le comunicazioni infrastrutturali 
	 */
	private String nodeSender = null;
	public String getNodeSender() {
		if(this.nodeSender==null){
			try{ 
				this.nodeSender = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeSender");
				if(this.nodeSender==null)
					throw new CoreException(NON_DEFINITA);
				this.nodeSender = this.nodeSender.trim();

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.nodeSender': "+e.getMessage(),e);
				this.nodeSender = null;
			}    
		}

		return this.nodeSender;
	}








	/* ********  EJB  ******** */

	/**
	 * Restituisce il Timeout di attesa per i deploy dei timer
	 *
	 * @return Restituisce il Timeout di attesa per i deploy dei timer
	 * 
	 */
	private Long timerEJBDeployTimeout = null;
	public long getTimerEJBDeployTimeout() {	
		if(this.timerEJBDeployTimeout==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.timeout");

				if(name!=null){
					name = name.trim();
					this.timerEJBDeployTimeout = java.lang.Long.parseLong(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.timeout' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_EJB_ATTESA_ATTIVA);
					this.timerEJBDeployTimeout = CostantiPdD.TIMER_EJB_ATTESA_ATTIVA;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.timeout' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_EJB_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.timerEJBDeployTimeout = CostantiPdD.TIMER_EJB_ATTESA_ATTIVA;
			}    
		}

		return this.timerEJBDeployTimeout;
	} 
	/**
	 * Restituisce la Frequenza di check per il deploy dei timer
	 *
	 * @return Restituisce la Frequenza di check per il deploy dei timer
	 * 
	 */
	private Integer timerEJBDeployCheckInterval = null;
	public int getTimerEJBDeployCheckInterval() {	
		if(this.timerEJBDeployCheckInterval==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.check");

				if(name!=null){
					name = name.trim();
					this.timerEJBDeployCheckInterval = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.check' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_EJB_CHECK_INTERVAL);
					this.timerEJBDeployCheckInterval = CostantiPdD.TIMER_EJB_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.check' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_EJB_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.timerEJBDeployCheckInterval = CostantiPdD.TIMER_EJB_CHECK_INTERVAL;
			}  
		}

		return this.timerEJBDeployCheckInterval;
	}








	/* ********  TRANSACTION MANAGER  ******** */

	/**
	 * Restituisce l'intervallo in millisecondi di attesa attiva effettuato dal Transaction Manager (Default 2 minuti)
	 * 
	 * @return Restituisce l'intervallo in millisecondi di attesa attiva effettuato dal Transaction Manager (Default 2 minuti)
	 *  * 
	 */
	private Long transactionManager_AttesaAttiva = null;
	public long getTransactionManager_AttesaAttiva() {	
		if(this.transactionManager_AttesaAttiva==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.TransactionManager.attesaAttiva");

				if(name!=null){
					name = name.trim();
					long time = java.lang.Long.parseLong(name);
					this.transactionManager_AttesaAttiva = time*1000;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.attesaAttiva' non impostata, viene utilizzato il default="+CostantiPdD.TRANSACTION_MANAGER_ATTESA_ATTIVA);
					this.transactionManager_AttesaAttiva = CostantiPdD.TRANSACTION_MANAGER_ATTESA_ATTIVA;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.attesaAttiva' non impostata, viene utilizzato il default="+CostantiPdD.TRANSACTION_MANAGER_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.transactionManager_AttesaAttiva = CostantiPdD.TRANSACTION_MANAGER_ATTESA_ATTIVA;
			}    
		}

		return this.transactionManager_AttesaAttiva;
	}

	/**
	 * Restituisce l'intervallo maggiore per frequenza di check nell'attesa attiva effettuata dal TransactionManager, in millisecondi
	 * 
	 * @return Restituisce Intervallo maggiore per frequenza di check nell'attesa attiva effettuata dal TransactionManager, in millisecondi
	 * 
	 */
	private Integer transactionManager_CheckInterval = null;
	public int getTransactionManager_CheckInterval() {	
		if(this.transactionManager_CheckInterval==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.TransactionManager.check");

				if(name!=null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.transactionManager_CheckInterval = time;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.check' non impostata, viene utilizzato il default="+CostantiPdD.TRANSACTION_MANAGER_CHECK_INTERVAL);
					this.transactionManager_CheckInterval = CostantiPdD.TRANSACTION_MANAGER_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.check' non impostata, viene utilizzato il default="+CostantiPdD.TRANSACTION_MANAGER_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.transactionManager_CheckInterval = CostantiPdD.TRANSACTION_MANAGER_CHECK_INTERVAL;
			}  
		}

		return this.transactionManager_CheckInterval;
	}

	/**
	 * Restituisce l'intervallo di check su DB effettuata dal TransactionManager, in caso di cache attiva
	 * 
	 * @return Restituisce intervallo di check su DB effettuata dal TransactionManager, in caso di cache attiva
	 * 
	 */
	private Integer transactionManager_CheckDBInterval = null;
	public int getTransactionManager_CheckDBInterval() {	
		if(this.transactionManager_CheckDBInterval==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.TransactionManager.checkDB");

				if(name!=null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.transactionManager_CheckDBInterval = time;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.checkDB' non impostata, viene utilizzato il default="+CostantiPdD.TRANSACTION_MANAGER_CHECK_DB_INTERVAL);
					this.transactionManager_CheckDBInterval = CostantiPdD.TRANSACTION_MANAGER_CHECK_DB_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.checkDB' non impostata, viene utilizzato il default="+CostantiPdD.TRANSACTION_MANAGER_CHECK_DB_INTERVAL+", errore:"+e.getMessage(),e);
				this.transactionManager_CheckDBInterval = CostantiPdD.TRANSACTION_MANAGER_CHECK_DB_INTERVAL;
			}  
		}

		return this.transactionManager_CheckDBInterval;
	}


	/**
	 * Restituisce l'indicazione se il TransactionManager deve essere utilizzato in single connection
	 *
	 * @return Restituisce l'indicazione se il TransactionManager deve essere utilizzato in single connection
	 * 
	 */
	private Boolean singleConnection_TransactionManager_value = null;
	public boolean singleConnection_TransactionManager(){

		if(this.singleConnection_TransactionManager_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.TransactionManager.singleConnection"); 

				if(value!=null){
					value = value.trim();
					this.singleConnection_TransactionManager_value = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.singleConnection' non impostata, viene utilizzato il default=false");
					this.singleConnection_TransactionManager_value = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.singleConnection' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.singleConnection_TransactionManager_value = false;
			}
		}

		return this.singleConnection_TransactionManager_value;

	}






	/* ********  SERIALIZABLE  ******** */

	/**
	 * Restituisce l'intervallo di Attesa attiva di default effettuata per la gestione del livello serializable nel DB, in millisecondi 
	 * 
	 * @return Restituisce l'intervallo di Attesa attiva di default effettuata per la gestione del livello serializable nel DB, in millisecondi 
	 * 
	 */
	private Long gestioneSerializableDB_AttesaAttiva = null;
	public long getGestioneSerializableDB_AttesaAttiva() {	
		if(this.gestioneSerializableDB_AttesaAttiva==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.jdbc.serializable.attesaAttiva");
				if (name != null) {
					name = name.trim();
					long time = java.lang.Long.parseLong(name);
					this.gestioneSerializableDB_AttesaAttiva = time*1000;
				} else {
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jdbc.serializable.attesaAttiva' non impostata, viene utilizzato il default="+Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA);
					this.gestioneSerializableDB_AttesaAttiva =  Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jdbc.serializable.attesaAttiva' non impostata, viene utilizzato il default="+Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.gestioneSerializableDB_AttesaAttiva = Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA;
			}   
		}

		return this.gestioneSerializableDB_AttesaAttiva;
	}

	/**
	 * Restituisce l'intervallo maggiore per frequenza di check nell'attesa attiva effettuata per la gestione del livello serializable nel DB, in millisecondi
	 * 
	 * @return Restituisce Intervallo maggiore per frequenza di check nell'attesa attiva effettuata per la gestione del livello serializable nel DB, in millisecondi
	 */
	private Integer gestioneSerializableDB_CheckInterval = null;
	public int getGestioneSerializableDB_CheckInterval() {	
		if(this.gestioneSerializableDB_CheckInterval==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.jdbc.serializable.check");
				if (name != null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.gestioneSerializableDB_CheckInterval = time;
				} else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jdbc.serializable.check' non impostata, viene utilizzato il default="+Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL);
					this.gestioneSerializableDB_CheckInterval = Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jdbc.serializable.check' non impostata, viene utilizzato il default="+Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.gestioneSerializableDB_CheckInterval = Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL;
			}    
		}

		return this.gestioneSerializableDB_CheckInterval;
	}








	/* ********  LIBRERIA PROTOCOL  ******** */

	/**
	 * Restituisce il tipo di gestione del RepositoryBuste
	 * 
	 * @return Restituisce il tipo di gestione  del RepositoryBuste
	 */
	private String gestoreRepositoryBuste = null;
	public String getGestoreRepositoryBuste() {
		if(this.gestoreRepositoryBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.repository.gestore");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				
				if(CostantiConfigurazione.REPOSITORY_BUSTE_AUTO_BYTEWISE.equals(name)){
					if(this.getDatabaseType()!=null){
						name = GestoreRepositoryFactory.getTipoRepositoryBuste(this.getDatabaseType());
					}
					else{
						this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.protocol.repository.gestore': il valore '"+
								CostantiConfigurazione.REPOSITORY_BUSTE_AUTO_BYTEWISE+"' deve essere utilizzato in combinazione con la definizione del tipo di database del repository. Viene impostato come gestore il tipo di default: "+
								CostantiConfigurazione.REPOSITORY_BUSTE_DEFAULT);
						name = CostantiConfigurazione.REPOSITORY_BUSTE_DEFAULT;
					}
				}
				
				this.gestoreRepositoryBuste = name;
			
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.protocol.repository.gestore': "+e.getMessage(),e);
				this.gestoreRepositoryBuste = null;
			}    
		}

		return this.gestoreRepositoryBuste;
	}

	/**
	 * Restituisce il tipo di filtro duplicati utilizzato dal RepositoryBuste
	 * 
	 * @return Restituisce il tipo di filtro duplicati utilizzato dal RepositoryBuste
	 */
	private String gestoreFiltroDuplicatiRepositoryBuste = null;
	public String getGestoreFiltroDuplicatiRepositoryBuste() {
		if(this.gestoreFiltroDuplicatiRepositoryBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.filtroDuplicati");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.filtroDuplicati' non impostata, viene utilizzato il default="+CostantiConfigurazione.FILTRO_DUPLICATI_OPENSPCOOP);
					this.gestoreFiltroDuplicatiRepositoryBuste = CostantiConfigurazione.FILTRO_DUPLICATI_OPENSPCOOP;
				}else{
					name = name.trim();
					this.gestoreFiltroDuplicatiRepositoryBuste = name;
				}
			
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.filtroDuplicati' non impostata, viene utilizzato il default="+CostantiConfigurazione.FILTRO_DUPLICATI_OPENSPCOOP+", errore:"+e.getMessage(),e);
				this.gestoreFiltroDuplicatiRepositoryBuste = CostantiConfigurazione.FILTRO_DUPLICATI_OPENSPCOOP;
			}    
		}

		return this.gestoreFiltroDuplicatiRepositoryBuste;
	}

	/**
	 * Restituisce la Generazione attributi 'tipo' e 'servizioCorrelato' nell'elemento 'ProfiloCollaborazione' della richiesta asincrona simmetrica 
	 * e della ricevuta alla richiesta asincrona asimmetrica
	 *   
	 * @return Restituisce la Generazione attributi 'tipo' e 'servizioCorrelato' nell'elemento 'ProfiloCollaborazione' della richiesta asincrona simmetrica 
	 *         e della ricevuta alla richiesta asincrona asimmetrica
	 * 
	 */
	private Boolean isGenerazioneAttributiAsincroni = null;
	public boolean isGenerazioneAttributiAsincroni(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getBusta_AsincroniAttributiCorrelatiEnable(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else 
					return false;
			}
		}

		if(this.isGenerazioneAttributiAsincroni==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.asincroni.attributiCorrelati.enable"); 

				if (value != null){
					value = value.trim();
					this.isGenerazioneAttributiAsincroni = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.asincroni.attributiCorrelati.enable' non impostata, viene utilizzato il default=true");
					this.isGenerazioneAttributiAsincroni = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.asincroni.attributiCorrelati.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isGenerazioneAttributiAsincroni = true;
			}
		}

		return this.isGenerazioneAttributiAsincroni;
	}

	

	/**
	 * Indicazione se ritenere una busta malformata se la validazione ha rilevato eccezioni di livello non gravi
	 *   
	 * @return Indicazione se ritenere una busta malformata se la validazione ha rilevato eccezioni di livello non gravi
	 * 
	 */
	private Boolean ignoraEccezioniNonGravi_Validazione = null;
	public boolean ignoraEccezioniNonGravi_Validazione(){
		if(this.ignoraEccezioniNonGravi_Validazione==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.validazione.ignoraEccezioniNonGravi"); 

				if (value != null){
					value = value.trim();
					this.ignoraEccezioniNonGravi_Validazione = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.validazione.ignoraEccezioniNonGravi' non impostata, viene utilizzato il default=false");
					this.ignoraEccezioniNonGravi_Validazione = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.validazione.ignoraEccezioniNonGravi' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.ignoraEccezioniNonGravi_Validazione = false;
			}
		}

		return this.ignoraEccezioniNonGravi_Validazione;
	}
	
	/**
	 * Indicazione se forzare la generazione del prefix 'soap' per i fault spcoop (compatibilita' con OpenSPCoop v1).
	 *   
	 * @return Indicazione se forzare la generazione del prefix 'soap' per i fault spcoop (compatibilita' con OpenSPCoop v1).
	 * 
	 */
	private Boolean forceSoapPrefixCompatibilitaOpenSPCoopV1 = null;
	public boolean isForceSoapPrefixCompatibilitaOpenSPCoopV1(){
		if(this.forceSoapPrefixCompatibilitaOpenSPCoopV1==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.spcoop.backwardCompatibility.forceSoapPrefix"); 

				if (value != null){
					value = value.trim();
					this.forceSoapPrefixCompatibilitaOpenSPCoopV1 = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.spcoop.backwardCompatibility.forceSoapPrefix' non impostata, viene utilizzato il default=true");
					this.forceSoapPrefixCompatibilitaOpenSPCoopV1 = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.spcoop.backwardCompatibility.forceSoapPrefix' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.forceSoapPrefixCompatibilitaOpenSPCoopV1 = true;
			}
		}

		return this.forceSoapPrefixCompatibilitaOpenSPCoopV1;
	}
	

	/**
	 * Indicazione se generare la lista Trasmissione
	 *   
	 * @return Indicazione se generare la lista Trasmissione
	 * 
	 */
	private Boolean isGenerazioneListaTrasmissioni = null;
	public boolean isGenerazioneListaTrasmissioni(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){			
			String tipo = this.pddReader.getBusta_TrasmissioneEnable(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
					return false;
			}
		}

		if(this.isGenerazioneListaTrasmissioni==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.trasmissione.enable"); 

				if (value != null){
					value = value.trim();
					this.isGenerazioneListaTrasmissioni = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.trasmissione.enable' non impostata, viene utilizzato il default=true");
					this.isGenerazioneListaTrasmissioni = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.trasmissione.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isGenerazioneListaTrasmissioni = true;
			}
		}

		return this.isGenerazioneListaTrasmissioni;
	}

	/**
	 * Indicazione se generare un msg di Protocollo errore in caso di filtro duplicati anche per il profilo oneway
	 *   
	 * @return Indicazione se generare un msg di Protocollo errore in caso di filtro duplicati  anche per il profilo oneway
	 * 
	 */
	private Boolean isGenerazioneErroreFiltroDuplicati = null;
	public boolean isGenerazioneErroreProtocolloFiltroDuplicati(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getBusta_FiltroduplicatiGenerazioneBustaErrore(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
					return false;
			}
		}

		if(this.isGenerazioneErroreFiltroDuplicati==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.filtroduplicati.generazioneErrore"); 

				if (value != null){
					value = value.trim();
					this.isGenerazioneErroreFiltroDuplicati = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.filtroduplicati.generazioneErrore' non impostata, viene utilizzato il default=false");
					this.isGenerazioneErroreFiltroDuplicati = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.filtroduplicati.generazioneErrore' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isGenerazioneErroreFiltroDuplicati = false;
			}
		}

		return this.isGenerazioneErroreFiltroDuplicati;
	}

	/**
	 * Indicazione se leggere dal registro se abilitato il filtro duplicati
	 *   
	 * @return Indicazione se leggere dal registro se abilitato il filtro duplicati
	 * 
	 */
	private Boolean isCheckFromRegistroFiltroDuplicatiAbilitato = null;
	public boolean isCheckFromRegistroFiltroDuplicatiAbilitato(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getValidazione_FiltroDuplicatiLetturaRegistro(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
					return false;
			}
		}

		if(this.isCheckFromRegistroFiltroDuplicatiAbilitato==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.filtroDuplicati.letturaRegistro"); 

				if (value != null){
					value = value.trim();
					this.isCheckFromRegistroFiltroDuplicatiAbilitato = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.filtroDuplicati.letturaRegistro' non impostata, viene utilizzato il default=true");
					this.isCheckFromRegistroFiltroDuplicatiAbilitato = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.filtroDuplicati.letturaRegistro' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isCheckFromRegistroFiltroDuplicatiAbilitato = true;
			}
		}

		return this.isCheckFromRegistroFiltroDuplicatiAbilitato;
	}

	/**
	 * Indicazione se leggere dal registro se abilitato la gestione dei riscontri
	 *   
	 * @return Indicazione se leggere dal registro se abilitato la gestione dei riscontri
	 * 
	 */
	private Boolean isCheckFromRegistroConfermaRicezioneAbilitato = null;
	public boolean isCheckFromRegistroConfermaRicezioneAbilitato(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getValidazione_ConfermaRicezioneLetturaRegistro(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
					return false;
			}
		}

		if(this.isCheckFromRegistroConfermaRicezioneAbilitato==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.confermaRicezione.letturaRegistro"); 

				if (value != null){
					value = value.trim();
					this.isCheckFromRegistroConfermaRicezioneAbilitato = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.confermaRicezione.letturaRegistro' non impostata, viene utilizzato il default=true");
					this.isCheckFromRegistroConfermaRicezioneAbilitato = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.confermaRicezione.letturaRegistro' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isCheckFromRegistroConfermaRicezioneAbilitato = true;
			}
		}

		return this.isCheckFromRegistroConfermaRicezioneAbilitato;
	}

	/**
	 * Indicazione se leggere dal registro se abilitato la consegna in ordine
	 *   
	 * @return Indicazione se leggere dal registro se abilitato la gestione dei riscontri
	 * 
	 */
	private Boolean isCheckFromRegistroConsegnaInOrdineAbilitato = null;
	public boolean isCheckFromRegistroConsegnaInOrdineAbilitato(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getValidazione_ConsegnaInOrdineLetturaRegistro(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
					return false;
			}
		}

		if(this.isCheckFromRegistroConsegnaInOrdineAbilitato==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.consegnaInOrdine.letturaRegistro"); 

				if (value != null){
					value = value.trim();
					this.isCheckFromRegistroConsegnaInOrdineAbilitato = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.consegnaInOrdine.letturaRegistro' non impostata, viene utilizzato il default=true");
					this.isCheckFromRegistroConsegnaInOrdineAbilitato = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.consegnaInOrdine.letturaRegistro' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isCheckFromRegistroConsegnaInOrdineAbilitato = true;
			}
		}

		return this.isCheckFromRegistroConsegnaInOrdineAbilitato;
	}

	/**
	 * Indicazione se l'elemento collaborazione deve essere gestito
	 *   
	 * @return Indicazione se l'elemento collaborazione deve essere gestito
	 * 
	 */
	private Boolean isGestioneElementoCollaborazione = null;
	public boolean isGestioneElementoCollaborazione(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getBusta_CollaborazioneEnable(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else 
					return false;
			}
		}

		if(this.isGestioneElementoCollaborazione==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.collaborazione.enable"); 

				if (value != null){
					value = value.trim();
					this.isGestioneElementoCollaborazione = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.collaborazione.enable' non impostata, viene utilizzato il default=true");
					this.isGestioneElementoCollaborazione = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.collaborazione.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isGestioneElementoCollaborazione = true;
			}
		}

		return this.isGestioneElementoCollaborazione;
	}
	
	private Boolean isGestioneElementoIdRiferimentoRichiesta = null;
	public boolean isGestioneElementoIdRiferimentoRichiesta(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getBusta_IdRiferimentoRichiestaEnable(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else 
					return false;
			}
		}

		if(this.isGestioneElementoIdRiferimentoRichiesta==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.idRiferimentoRichiesta.enable"); 

				if (value != null){
					value = value.trim();
					this.isGestioneElementoIdRiferimentoRichiesta = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.idRiferimentoRichiesta.enable' non impostata, viene utilizzato il default=true");
					this.isGestioneElementoIdRiferimentoRichiesta = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.idRiferimentoRichiesta.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isGestioneElementoIdRiferimentoRichiesta = true;
			}
		}

		return this.isGestioneElementoIdRiferimentoRichiesta;
	}

	/**
	 * Indicazione se la funzionalita' di consegna in ordine deve essere gestita
	 *   
	 * @return Indicazione se la funzionalita' di consegna in ordine deve essere gestita
	 * 
	 */
	private Boolean isGestioneConsegnaInOrdine = null;
	public boolean isGestioneConsegnaInOrdine(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getBusta_ConsegnaInOrdineEnable(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else 
					return false;
			}
		}

		if(this.isGestioneConsegnaInOrdine==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.consegnaInOrdine.enable"); 

				if (value != null){
					value = value.trim();
					this.isGestioneConsegnaInOrdine = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.consegnaInOrdine.enable' non impostata, viene utilizzato il default=true");
					this.isGestioneConsegnaInOrdine = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.consegnaInOrdine.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isGestioneConsegnaInOrdine = true;
			}
		}

		return this.isGestioneConsegnaInOrdine;
	}

	/**
	 * Indicazione se la funzionalita' dei riscontri deve essere gestita
	 *   
	 * @return Indicazione se la funzionalita' dei riscontri deve essere gestita
	 * 
	 */
	private Boolean isGestioneRiscontri = null;
	public boolean isGestioneRiscontri(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getBusta_RiscontriEnable(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
					return false;
			}
		}

		if(this.isGestioneRiscontri==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.riscontri.enable"); 

				if (value != null){
					value = value.trim();
					this.isGestioneRiscontri = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.riscontri.enable' non impostata, viene utilizzato il default=true");
					this.isGestioneRiscontri = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.riscontri.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isGestioneRiscontri = true;
			}
		}

		return this.isGestioneRiscontri;
	}
    
   

	
	/**
	 * Validazione buste che possiedono attributi qualificati (default:false)
	 * Lo schema della busta non permette attributi qualificati (attributeFormDefault="unqualified")
	 * Se non si abilita la validazione 'rigida' (tramite schema xsd) e si abilita la seguente opzione, e' possibile far accettare/processare
	 * alla porta di dominio anche buste che contengono attributi qualificati.
	 *   
	 * @return Indicazione se ritornare solo SoapFault o busteSPCoop in caso di buste con struttura malformata.
	 * 
	 */
	private Boolean isReadQualifiedAttribute = null;
	public boolean isReadQualifiedAttribute(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getValidazione_readQualifiedAttribute(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
					return false;
			}
		}

		if(this.isReadQualifiedAttribute==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.validazione.readQualifiedAttribute"); 

				if (value != null){
					value = value.trim();
					this.isReadQualifiedAttribute = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.validazione.readQualifiedAttribute' non impostata, viene utilizzato il default=false");
					this.isReadQualifiedAttribute = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.validazione.readQualifiedAttribute' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isReadQualifiedAttribute = false;
			}
		}

		return this.isReadQualifiedAttribute;
	}

	
	/**
	 * Validazione buste che possiedono attributi qualificati (default:false)
	 * Lo schema della busta non permette attributi qualificati (attributeFormDefault="unqualified")
	 * Se non si abilita la validazione 'rigida' (tramite schema xsd) e si abilita la seguente opzione, e' possibile far accettare/processare
	 * alla porta di dominio anche buste che contengono attributi qualificati.
	 *   
	 * @return Indicazione se ritornare solo SoapFault o busteSPCoop in caso di buste con struttura malformata.
	 * 
	 */
	private Boolean isValidazioneIDBustaCompleta = null;
	public boolean isValidazioneIDBustaCompleta(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getValidazione_ValidazioneIDBustaCompleta(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
					return false;
			}
		}

		if(this.isValidazioneIDBustaCompleta==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.validazione.idbusta.validazioneCompleta"); 

				if (value != null){
					value = value.trim();
					this.isValidazioneIDBustaCompleta = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.validazione.idbusta.validazioneCompleta' non impostata, viene utilizzato il default=true");
					this.isValidazioneIDBustaCompleta = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.validazione.idbusta.validazioneCompleta' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isValidazioneIDBustaCompleta = true;
			}
		}

		return this.isValidazioneIDBustaCompleta;
	}
	
	public ProprietaManifestAttachments getProprietaManifestAttachments(String implementazionePdDSoggetto){
		ProprietaManifestAttachments properties = new ProprietaManifestAttachments();
		properties.setReadQualifiedAttribute(this.isReadQualifiedAttribute(implementazionePdDSoggetto));
		return properties;
	}


	/**
	 * Restituisce l'eventuale location del file govway.pdd.properties
	 * 
	 * @return Restituisce la location del file govway.pdd.properties
	 */
	private String filePddProperties = null;
	private boolean filePddPropertiesLetto = false;
	public String getLocationPddProperties() {
		if(this.filePddPropertiesLetto==false){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.pddProperties");
				if(name!=null){
					name = name.trim();
					this.filePddProperties = name;
				}
				this.filePddPropertiesLetto= true;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.protocol.pddProperties': "+e.getMessage(),e);
				this.filePddProperties = null;
			}    			
		}

		return this.filePddProperties;
	}






	/* ********  INTEGRAZIONE  ******** */

	/**
	 * Restituisce l'elenco dei tipi di integrazione da gestire lato PortaDelegata
	 * 
	 * @return  Restituisce l'elenco dei tipi di integrazione da gestire lato PortaDelegata
	 */
	private String[] tipoIntegrazionePD = null;
	private boolean tipoIntegrazionePDRead = false;
	public String[] getTipoIntegrazionePD() {
		if(this.tipoIntegrazionePDRead == false){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pd"); 
				if(value==null)
					throw new CoreException(NON_DEFINITA);
				value = value.trim();
				String [] r = value.split(",");
				this.tipoIntegrazionePD = r;

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.tipo.pd': "+e.getMessage(),e);
				this.tipoIntegrazionePD = null;
			}
			this.tipoIntegrazionePDRead = true;
		}

		return this.tipoIntegrazionePD;
	}
	/**
	 * Restituisce l'elenco dei tipi di integrazione da gestire lato PortaApplicativa
	 * 
	 * @return  Restituisce l'elenco dei tipi di integrazione da gestire lato PortaApplicativa
	 */
	private String[] tipoIntegrazionePA = null;
	private boolean tipoIntegrazionePARead = false;
	public String[] getTipoIntegrazionePA() {
		if(this.tipoIntegrazionePARead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pa");
				if(value==null)
					throw new CoreException(NON_DEFINITA);
				value = value.trim();
				String [] r = value.split(",");
				this.tipoIntegrazionePA = r;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di integrazione tra porta di dominio e servizio applicativo 'org.openspcoop2.pdd.integrazione.tipo.pa': "+e.getMessage(),e);
				this.tipoIntegrazionePA = null;
			}   
			this.tipoIntegrazionePARead = true;
		}

		return this.tipoIntegrazionePA;
	}
	
	/**
	 * Restituisce l'elenco dei tipi di integrazione da gestire lato PortaDelegata specifici per protocollo
	 * 
	 * @return  Restituisce l'elenco dei tipi di integrazione da gestire lato PortaDelegata specifici per protocollo
	 */
	private Map<String, String[]> tipoIntegrazionePD_perProtocollo = new HashMap<String, String[]>();
	private Map<String, Boolean> tipoIntegrazionePD_perProtocollo_notExists = new HashMap<String, Boolean>();
	public String[] getTipoIntegrazionePD(String protocollo) {
		
		if( 
			(this.tipoIntegrazionePD_perProtocollo.containsKey(protocollo)==false) 
			&&
			(this.tipoIntegrazionePD_perProtocollo_notExists.containsKey(protocollo)==false) 
		){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pd."+protocollo); 
				if(value==null){
					this.tipoIntegrazionePD_perProtocollo_notExists.put(protocollo, false);
				}
				else{
					value = value.trim();
					String [] r = value.split(",");
					this.tipoIntegrazionePD_perProtocollo.put(protocollo, r);
				}

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.tipo.pd."+protocollo+"': "+e.getMessage(),e);
			}
		}

		if(this.tipoIntegrazionePD_perProtocollo.containsKey(protocollo)){
			return this.tipoIntegrazionePD_perProtocollo.get(protocollo);
		}else{
			return null;
		}
	}
	
	/**
	 * Restituisce l'elenco dei tipi di integrazione da gestire lato PortaApplicativa specifici per protocollo
	 * 
	 * @return  Restituisce l'elenco dei tipi di integrazione da gestire lato PortaApplicativa specifici per protocollo
	 */
	private Map<String, String[]> tipoIntegrazionePA_perProtocollo = new HashMap<String, String[]>();
	private Map<String, Boolean> tipoIntegrazionePA_perProtocollo_notExists = new HashMap<String, Boolean>();
	public String[] getTipoIntegrazionePA(String protocollo) {
		
		if( 
			(this.tipoIntegrazionePA_perProtocollo.containsKey(protocollo)==false) 
			&&
			(this.tipoIntegrazionePA_perProtocollo_notExists.containsKey(protocollo)==false) 
		){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pa."+protocollo); 
				if(value==null){
					this.tipoIntegrazionePA_perProtocollo_notExists.put(protocollo, false);
				}
				else{
					value = value.trim();
					String [] r = value.split(",");
					this.tipoIntegrazionePA_perProtocollo.put(protocollo, r);
				}

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.tipo.pa."+protocollo+"': "+e.getMessage(),e);
			}
		}

		if(this.tipoIntegrazionePA_perProtocollo.containsKey(protocollo)){
			return this.tipoIntegrazionePA_perProtocollo.get(protocollo);
		}else{
			return null;
		}
	}
	

	/**
	 * Compatibilita integrazione asincroni con versioni precedenti a 1.4
	 * L'indicazione dell'id per la correlazione asincrona poteva essere fornita, 
	 * oltre che tramite il riferimentoMessaggio, anche tramite l'elemento idCollaborazione.
	 * Tale funzionalita' e' disabilitata per default dalla versione 1.4
	 * Se si desidera riabilitarla e' possibile agire sulla proprieta': org.openspcoop2.pdd.integrazione.asincroni.idCollaborazione.enabled
	 * Questo metodo restituisce l'indicazione se tale proprieta' e' abilitata.
	 *  
	 * @return Restituisce l'indicazione se la proprieta' org.openspcoop2.pdd.integrazione.asincroni.idCollaborazione.enabled e' abilitata.
	 * 
	 */
	private Boolean isIntegrazioneAsincroniConIdCollaborazioneEnabled = null;
	public boolean isIntegrazioneAsincroniConIdCollaborazioneEnabled(){
		if(this.isIntegrazioneAsincroniConIdCollaborazioneEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.asincroni.idCollaborazione.enabled"); 

				if (value != null){
					value = value.trim();
					this.isIntegrazioneAsincroniConIdCollaborazioneEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.asincroni.idCollaborazione.enabled' non impostata, viene utilizzato il default=false");
					this.isIntegrazioneAsincroniConIdCollaborazioneEnabled = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.asincroni.idCollaborazione.enabled' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isIntegrazioneAsincroniConIdCollaborazioneEnabled = false;
			}
		}

		return this.isIntegrazioneAsincroniConIdCollaborazioneEnabled;
	}
	
	private Map<String, String> newOldMapping_backward_compatibility_trasparente_soggetto = null;
	public Map<String, String> getNewOldMapping_backward_compatibility_trasparente_soggetto() {	
		if(this.newOldMapping_backward_compatibility_trasparente_soggetto==null){
			String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.trasparente.soggetto.tipo.";
			try{ 
				Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
				this.newOldMapping_backward_compatibility_trasparente_soggetto=new HashMap<>();
				if(p!=null && !p.isEmpty()) {
					for (Object oKey : p.keySet()) {
						if(oKey!=null && oKey instanceof String) {
							String key = (String) oKey;
							String old = p.getProperty(key);
							this.newOldMapping_backward_compatibility_trasparente_soggetto.put(key, old);
						}
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
				this.newOldMapping_backward_compatibility_trasparente_soggetto = null;
			}    
		}

		return this.newOldMapping_backward_compatibility_trasparente_soggetto;
	}
	private Map<String, String> newOldMapping_backward_compatibility_trasparente_servizio = null;
	public Map<String, String> getNewOldMapping_backward_compatibility_trasparente_servizio() {	
		if(this.newOldMapping_backward_compatibility_trasparente_servizio==null){
			String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.trasparente.servizio.tipo.";
			try{ 
				Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
				this.newOldMapping_backward_compatibility_trasparente_servizio=new HashMap<>();
				if(p!=null && !p.isEmpty()) {
					for (Object oKey : p.keySet()) {
						if(oKey!=null && oKey instanceof String) {
							String key = (String) oKey;
							String old = p.getProperty(key);
							this.newOldMapping_backward_compatibility_trasparente_servizio.put(key, old);
						}
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
				this.newOldMapping_backward_compatibility_trasparente_servizio = null;
			}    
		}

		return this.newOldMapping_backward_compatibility_trasparente_servizio;
	}

	private Map<String, String> newOldMapping_backward_compatibility_spcoop_soggetto = null;
	public Map<String, String> getNewOldMapping_backward_compatibility_spcoop_soggetto() {	
		if(this.newOldMapping_backward_compatibility_spcoop_soggetto==null){
			String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.spcoop.soggetto.tipo.";
			try{ 
				Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
				this.newOldMapping_backward_compatibility_spcoop_soggetto=new HashMap<>();
				if(p!=null && !p.isEmpty()) {
					for (Object oKey : p.keySet()) {
						if(oKey!=null && oKey instanceof String) {
							String key = (String) oKey;
							String old = p.getProperty(key);
							this.newOldMapping_backward_compatibility_spcoop_soggetto.put(key, old);
						}
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
				this.newOldMapping_backward_compatibility_spcoop_soggetto = null;
			}    
		}

		return this.newOldMapping_backward_compatibility_spcoop_soggetto;
	}
	private Map<String, String> newOldMapping_backward_compatibility_spcoop_servizio = null;
	public Map<String, String> getNewOldMapping_backward_compatibility_spcoop_servizio() {	
		if(this.newOldMapping_backward_compatibility_spcoop_servizio==null){
			String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.spcoop.servizio.tipo.";
			try{ 
				Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
				this.newOldMapping_backward_compatibility_spcoop_servizio=new HashMap<>();
				if(p!=null && !p.isEmpty()) {
					for (Object oKey : p.keySet()) {
						if(oKey!=null && oKey instanceof String) {
							String key = (String) oKey;
							String old = p.getProperty(key);
							this.newOldMapping_backward_compatibility_spcoop_servizio.put(key, old);
						}
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
				this.newOldMapping_backward_compatibility_spcoop_servizio = null;
			}    
		}

		return this.newOldMapping_backward_compatibility_spcoop_servizio;
	}
	
	private Map<String, String> newOldMapping_backward_compatibility_sdi_soggetto = null;
	public Map<String, String> getNewOldMapping_backward_compatibility_sdi_soggetto() {	
		if(this.newOldMapping_backward_compatibility_sdi_soggetto==null){
			String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.sdi.soggetto.tipo.";
			try{ 
				Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
				this.newOldMapping_backward_compatibility_sdi_soggetto=new HashMap<>();
				if(p!=null && !p.isEmpty()) {
					for (Object oKey : p.keySet()) {
						if(oKey!=null && oKey instanceof String) {
							String key = (String) oKey;
							String old = p.getProperty(key);
							this.newOldMapping_backward_compatibility_sdi_soggetto.put(key, old);
						}
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
				this.newOldMapping_backward_compatibility_sdi_soggetto = null;
			}    
		}

		return this.newOldMapping_backward_compatibility_sdi_soggetto;
	}
	private Map<String, String> newOldMapping_backward_compatibility_sdi_servizio = null;
	public Map<String, String> getNewOldMapping_backward_compatibility_sdi_servizio() {	
		if(this.newOldMapping_backward_compatibility_sdi_servizio==null){
			String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.sdi.servizio.tipo.";
			try{ 
				Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
				this.newOldMapping_backward_compatibility_sdi_servizio=new HashMap<>();
				if(p!=null && !p.isEmpty()) {
					for (Object oKey : p.keySet()) {
						if(oKey!=null && oKey instanceof String) {
							String key = (String) oKey;
							String old = p.getProperty(key);
							this.newOldMapping_backward_compatibility_sdi_servizio.put(key, old);
						}
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
				this.newOldMapping_backward_compatibility_sdi_servizio = null;
			}    
		}

		return this.newOldMapping_backward_compatibility_sdi_servizio;
	}
	
	


	private <T> Map<MapKey<String>, T> _convertMapToCostantiIntegrazione(Map<String, T> map) throws CoreException{
		List<MapKey<String>> keywordsIntegrazione = getKeywordsIntegrazioneEngine(true);
		Map<MapKey<String>, T> newMap = new HashMap<MapKey<String>, T>();
		for (String key : map.keySet()) {
			boolean find = false;
			for (MapKey<String> mapKey : keywordsIntegrazione) {
				if(key.equals(mapKey.getValue())){
					newMap.put(mapKey, map.get(key));
					find = true;
				}
			}
			if(!find) {
				throw new CoreException("Chiave '"+key+"' sconosciuta, non risulta essere una keyword di integrazione");
			}
		}
		return newMap;
	}
	
	/**
	 * Restituisce le proprieta' che identificano gli header di integrazione in caso di 'trasporto' 
	 *
	 * @return Restituisce le proprieta' che identificano gli header di integrazione in caso di 'trasporto'
	 *  
	 */
	private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneTrasporto = null;
	public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneTrasporto() {	
		if(this.keyValue_HeaderIntegrazioneTrasporto==null){

			try{ 

				this.keyValue_HeaderIntegrazioneTrasporto = _convertMapToCostantiIntegrazione(this.reader.readPropertiesAsHashMapConvertEnvProperties("org.openspcoop2.pdd.integrazione.trasporto.keyword."));
			
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.trasporto.keyword.*': "+e.getMessage(),e);
				this.keyValue_HeaderIntegrazioneTrasporto = null;
			}    
		}

		return this.keyValue_HeaderIntegrazioneTrasporto;
	}
	
	private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2 = null;
	public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2() {	
		if(this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2==null){

			try{ 

				this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2 = 
						_convertMapToCostantiIntegrazione(
								this.reader.readPropertiesAsHashMapConvertEnvProperties("org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop2.trasporto.keyword."));
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop2.trasporto.keyword.*': "+e.getMessage(),e);
				this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2 = null;
			}    
		}

		return this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2;
	}
	
	private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1 = null;
	public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1() {	
		if(this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1==null){

			try{ 

				this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1 =  
						_convertMapToCostantiIntegrazione(
								this.reader.readPropertiesAsHashMapConvertEnvProperties("org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop1.trasporto.keyword."));
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop1.trasporto.keyword.*': "+e.getMessage(),e);
				this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1 = null;
			}    
		}

		return this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1;
	}
	
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_setPD_request = null;
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_setPD_response = null;
	public Map<MapKey<String>, Boolean> getKeyPDSetEnabled_HeaderIntegrazioneTrasporto(boolean request) throws CoreException {	
				
		if( (request && this.keyValue_HeaderIntegrazioneTrasporto_setPD_request==null)
			||
			(!request && this.keyValue_HeaderIntegrazioneTrasporto_setPD_response==null)
			){

			String pName = "org.openspcoop2.pdd.integrazione.trasporto.pd.set.request.enabled.";
			if(!request) {
				pName = "org.openspcoop2.pdd.integrazione.trasporto.pd.set.response.enabled.";
			}
			
			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties(pName);
				Map<String, Boolean> _tmp = new HashMap<String, Boolean>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = (Object) it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						try {
							boolean b = Boolean.parseBoolean(value);
							_tmp.put(key, b);
						}catch(Exception e) {
							throw new CoreException("Rilevato errore durante il parsing della property '"+pName+"."+key+"' (atteso: true/false): "+e.getMessage(),e);
						}
					}
				}
				if(request) {
					this.keyValue_HeaderIntegrazioneTrasporto_setPD_request = _convertMapToCostantiIntegrazione(_tmp);
				}
				else {
					this.keyValue_HeaderIntegrazioneTrasporto_setPD_response = _convertMapToCostantiIntegrazione(_tmp);
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		if(request) {
			return this.keyValue_HeaderIntegrazioneTrasporto_setPD_request;
		}
		else {
			return this.keyValue_HeaderIntegrazioneTrasporto_setPD_response;
		}
	}
	
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_readPD = null;
	public Map<MapKey<String>, Boolean> getKeyPDReadEnabled_HeaderIntegrazioneTrasporto() throws CoreException {	
		if(this.keyValue_HeaderIntegrazioneTrasporto_readPD==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.trasporto.pd.read.enabled.");
				Map<String, Boolean> _tmp = new HashMap<String, Boolean>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = (Object) it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						try {
							boolean b = Boolean.parseBoolean(value);
							_tmp.put(key, b);
						}catch(Exception e) {
							throw new CoreException("Rilevato errore durante il parsing della property 'org.openspcoop2.pdd.integrazione.trasporto.pd.read.enabled."+key+"' (atteso: true/false): "+e.getMessage(),e);
						}
					}
				}
				this.keyValue_HeaderIntegrazioneTrasporto_readPD = _convertMapToCostantiIntegrazione(_tmp);
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.trasporto.pd.read.enabled.*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.keyValue_HeaderIntegrazioneTrasporto_readPD;
	}
	
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_setPA_request = null;
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_setPA_response = null;
	public Map<MapKey<String>, Boolean> getKeyPASetEnabled_HeaderIntegrazioneTrasporto(boolean request) throws CoreException {
				
		if( (request && this.keyValue_HeaderIntegrazioneTrasporto_setPA_request==null)
				||
				(!request && this.keyValue_HeaderIntegrazioneTrasporto_setPA_response==null)
				){

			String pName = "org.openspcoop2.pdd.integrazione.trasporto.pa.set.request.enabled.";
			if(!request) {
				pName = "org.openspcoop2.pdd.integrazione.trasporto.pa.set.response.enabled.";
			}
			
			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties(pName);
				Map<String, Boolean> _tmp = new HashMap<String, Boolean>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = (Object) it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						try {
							boolean b = Boolean.parseBoolean(value);
							//if(request) {
							//	_tmp.put(key, b);
							//}
							//else {
							_tmp.put(key, b);
							//}
						}catch(Exception e) {
							throw new CoreException("Rilevato errore durante il parsing della property '"+pName+"."+key+"' (atteso: true/false): "+e.getMessage(),e);
						}
					}
				}
				if(request) {
					this.keyValue_HeaderIntegrazioneTrasporto_setPA_request = _convertMapToCostantiIntegrazione(_tmp);
				}
				else {
					this.keyValue_HeaderIntegrazioneTrasporto_setPA_response = _convertMapToCostantiIntegrazione(_tmp);
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		if(request) {
			return this.keyValue_HeaderIntegrazioneTrasporto_setPA_request;
		}
		else {
			return this.keyValue_HeaderIntegrazioneTrasporto_setPA_response;
		}
	}
	
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_readPA = null;
	public Map<MapKey<String>, Boolean> getKeyPAReadEnabled_HeaderIntegrazioneTrasporto() throws CoreException {	
		if(this.keyValue_HeaderIntegrazioneTrasporto_readPA==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.trasporto.pa.read.enabled.");
				Map<String, Boolean> _tmp = new HashMap<String, Boolean>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = (Object) it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						try {
							boolean b = Boolean.parseBoolean(value);
							_tmp.put(key, b);
						}catch(Exception e) {
							throw new CoreException("Rilevato errore durante il parsing della property 'org.openspcoop2.pdd.integrazione.trasporto.pa.read.enabled."+key+"' (atteso: true/false): "+e.getMessage(),e);
						}
					}
				}
				this.keyValue_HeaderIntegrazioneTrasporto_readPA = _convertMapToCostantiIntegrazione(_tmp);
								
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.trasporto.pa.read.enabled.*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.keyValue_HeaderIntegrazioneTrasporto_readPA;
	}
	
	/**
	 * Restituisce le proprieta' che identificano gli header di integrazione in caso di 'urlBased'.
	 *
	 * @return Restituisce le proprieta' che identificano gli header di integrazione in caso di 'urlBased'.
	 *  
	 */
	private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneUrlBased = null;
	public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneUrlBased() {	
		if(this.keyValue_HeaderIntegrazioneUrlBased==null){

			try{ 

				this.keyValue_HeaderIntegrazioneUrlBased = 
						_convertMapToCostantiIntegrazione(
								this.reader.readPropertiesAsHashMapConvertEnvProperties("org.openspcoop2.pdd.integrazione.urlBased.keyword."));
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.urlBased.keyword.*': "+e.getMessage(),e);
				this.keyValue_HeaderIntegrazioneUrlBased = null;
			}    
		}

		return this.keyValue_HeaderIntegrazioneUrlBased;
	}
	
	private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2 = null;
	public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2() {	
		if(this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2==null){

			try{ 

				this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2 =  
						_convertMapToCostantiIntegrazione(
								this.reader.readPropertiesAsHashMapConvertEnvProperties("org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop2.urlBased.keyword."));
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop2.urlBased.keyword.*': "+e.getMessage(),e);
				this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2 = null;
			}    
		}

		return this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2;
	}
	
	private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1 = null;
	public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1() {	
		if(this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1==null){

			try{ 

				this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1 =  
						_convertMapToCostantiIntegrazione(
								this.reader.readPropertiesAsHashMapConvertEnvProperties("org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop1.urlBased.keyword."));
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop1.urlBased.keyword.*': "+e.getMessage(),e);
				this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1 = null;
			}    
		}

		return this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1;
	}
	
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneUrlBased_setPD = null;
	public Map<MapKey<String>, Boolean> getKeyPDSetEnabled_HeaderIntegrazioneUrlBased() throws CoreException {	
		if(this.keyValue_HeaderIntegrazioneUrlBased_setPD==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.urlBased.pd.set.request.enabled.");
				Map<String, Boolean> _tmp = new HashMap<String, Boolean>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = (Object) it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						try {
							boolean b = Boolean.parseBoolean(value);
							_tmp.put(key, b);
						}catch(Exception e) {
							throw new CoreException("Rilevato errore durante il parsing della property 'org.openspcoop2.pdd.integrazione.urlBased.pd.set.request.enabled."+key+"' (atteso: true/false): "+e.getMessage(),e);
						}
					}
				}
				this.keyValue_HeaderIntegrazioneUrlBased_setPD = _convertMapToCostantiIntegrazione(_tmp);
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.urlBased.pd.set.request.enabled*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.keyValue_HeaderIntegrazioneUrlBased_setPD;
	}
	
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneUrlBased_readPD = null;
	public Map<MapKey<String>, Boolean> getKeyPDReadEnabled_HeaderIntegrazioneUrlBased() throws CoreException {	
		if(this.keyValue_HeaderIntegrazioneUrlBased_readPD==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.urlBased.pd.read.enabled.");
				Map<String, Boolean> _tmp = new HashMap<String, Boolean>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = (Object) it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						try {
							boolean b = Boolean.parseBoolean(value);
							_tmp.put(key, b);
						}catch(Exception e) {
							throw new CoreException("Rilevato errore durante il parsing della property 'org.openspcoop2.pdd.integrazione.urlBased.pd.read.enabled."+key+"' (atteso: true/false): "+e.getMessage(),e);
						}
					}
				}
				this.keyValue_HeaderIntegrazioneUrlBased_readPD = _convertMapToCostantiIntegrazione(_tmp);
								
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.urlBased.pd.read.enabled.*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.keyValue_HeaderIntegrazioneUrlBased_readPD;
	}
	
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneUrlBased_setPA = null;
	public Map<MapKey<String>, Boolean> getKeyPASetEnabled_HeaderIntegrazioneUrlBased() throws CoreException {	
		if(this.keyValue_HeaderIntegrazioneUrlBased_setPA==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.urlBased.pa.set.request.enabled.");
				Map<String, Boolean> _tmp = new HashMap<String, Boolean>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = (Object) it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						try {
							boolean b = Boolean.parseBoolean(value);
							_tmp.put(key, b);
						}catch(Exception e) {
							throw new CoreException("Rilevato errore durante il parsing della property 'org.openspcoop2.pdd.integrazione.urlBased.pa.set.request.enabled."+key+"' (atteso: true/false): "+e.getMessage(),e);
						}
					}
				}
				this.keyValue_HeaderIntegrazioneUrlBased_setPA = _convertMapToCostantiIntegrazione(_tmp);
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.urlBased.pa.set.request.enabled*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.keyValue_HeaderIntegrazioneUrlBased_setPA;
	}
	
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneUrlBased_readPA = null;
	public Map<MapKey<String>, Boolean> getKeyPAReadEnabled_HeaderIntegrazioneUrlBased() throws CoreException {	
		if(this.keyValue_HeaderIntegrazioneUrlBased_readPA==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.urlBased.pa.read.enabled.");
				Map<String, Boolean> _tmp = new HashMap<String, Boolean>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = (Object) it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						try {
							boolean b = Boolean.parseBoolean(value);
							_tmp.put(key, b);
						}catch(Exception e) {
							throw new CoreException("Rilevato errore durante il parsing della property 'org.openspcoop2.pdd.integrazione.urlBased.pa.read.enabled."+key+"' (atteso: true/false): "+e.getMessage(),e);
						}
					}
				}
				this.keyValue_HeaderIntegrazioneUrlBased_readPA = _convertMapToCostantiIntegrazione(_tmp);
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.urlBased.pa.read.enabled.*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.keyValue_HeaderIntegrazioneUrlBased_readPA;
	}
	
	/**
	 * Restituisce le proprieta' che identificano gli header di integrazione in caso di 'soap'.
	 *
	 * @return Restituisce le proprieta' che identificano gli header di integrazione in caso di 'soap'.
	 *  
	 */
	private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneSoap = null;
	public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneSoap() {	
		if(this.keyValue_HeaderIntegrazioneSoap==null){

			try{ 

				this.keyValue_HeaderIntegrazioneSoap =  
						_convertMapToCostantiIntegrazione(
								this.reader.readPropertiesAsHashMapConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.keyword."));
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.soap.keyword.*': "+e.getMessage(),e);
				this.keyValue_HeaderIntegrazioneSoap = null;
			}    
		}

		return this.keyValue_HeaderIntegrazioneSoap;
	}
	
	private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2 = null;
	public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2() {	
		if(this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2==null){

			try{ 

				this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2 =  
						_convertMapToCostantiIntegrazione(
								this.reader.readPropertiesAsHashMapConvertEnvProperties("org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop2.soap.keyword."));
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop2.soap.keyword.*': "+e.getMessage(),e);
				this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2 = null;
			}    
		}

		return this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2;
	}
	
	private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1 = null;
	public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1() {	
		if(this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1==null){

			try{ 

				this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1 =  
						_convertMapToCostantiIntegrazione(
								this.reader.readPropertiesAsHashMapConvertEnvProperties("org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop1.soap.keyword."));
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop1.soap.keyword.*': "+e.getMessage(),e);
				this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1 = null;
			}    
		}

		return this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1;
	}
	
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_setPD_request = null;
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_setPD_response = null;
	public Map<MapKey<String>, Boolean> getKeyPDSetEnabled_HeaderIntegrazioneSoap(boolean request) throws CoreException {
		
		if( (request && this.keyValue_HeaderIntegrazioneSoap_setPD_request==null)
				||
				(!request && this.keyValue_HeaderIntegrazioneSoap_setPD_response==null)
				){

			String pName = "org.openspcoop2.pdd.integrazione.soap.pd.set.request.enabled.";
			if(!request) {
				pName = "org.openspcoop2.pdd.integrazione.soap.pd.set.response.enabled.";
			}

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties(pName);
				Map<String, Boolean> _tmp = new HashMap<String, Boolean>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = (Object) it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						try {
							boolean b = Boolean.parseBoolean(value);
							_tmp.put(key, b);
						}catch(Exception e) {
							throw new CoreException("Rilevato errore durante il parsing della property '"+pName+"."+key+"' (atteso: true/false): "+e.getMessage(),e);
						}
					}
				}
				if(request) {
					this.keyValue_HeaderIntegrazioneSoap_setPD_request = _convertMapToCostantiIntegrazione(_tmp);
				}
				else {
					this.keyValue_HeaderIntegrazioneSoap_setPD_response = _convertMapToCostantiIntegrazione(_tmp);
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		if(request) {
			return this.keyValue_HeaderIntegrazioneSoap_setPD_request;
		}
		else {
			return this.keyValue_HeaderIntegrazioneSoap_setPD_response;
		}
	}
	
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_readPD = null;
	public Map<MapKey<String>, Boolean> getKeyPDReadEnabled_HeaderIntegrazioneSoap() throws CoreException {	
		if(this.keyValue_HeaderIntegrazioneSoap_readPD==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.pd.read.enabled.");
				Map<String, Boolean> _tmp = new HashMap<String, Boolean>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = (Object) it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						try {
							boolean b = Boolean.parseBoolean(value);
							_tmp.put(key, b);
						}catch(Exception e) {
							throw new CoreException("Rilevato errore durante il parsing della property 'org.openspcoop2.pdd.integrazione.soap.pd.read.enabled."+key+"' (atteso: true/false): "+e.getMessage(),e);
						}
					}
				}
				this.keyValue_HeaderIntegrazioneSoap_readPD = _convertMapToCostantiIntegrazione(_tmp);
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.soap.pd.read.enabled.*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.keyValue_HeaderIntegrazioneSoap_readPD;
	}
	
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_setPA_request = null;
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_setPA_response = null;
	public Map<MapKey<String>, Boolean> getKeyPASetEnabled_HeaderIntegrazioneSoap(boolean request) throws CoreException {	
		if( (request && this.keyValue_HeaderIntegrazioneSoap_setPA_request==null)
				||
				(!request && this.keyValue_HeaderIntegrazioneSoap_setPA_response==null)
				){

			String pName = "org.openspcoop2.pdd.integrazione.soap.pa.set.request.enabled.";
			if(!request) {
				pName = "org.openspcoop2.pdd.integrazione.soap.pa.set.response.enabled.";
			}

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties(pName);
				Map<String, Boolean> _tmp = new HashMap<String, Boolean>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = (Object) it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						try {
							boolean b = Boolean.parseBoolean(value);
							//if(request) {
							//	_tmp.put(key, b);
							//}
							//else {
							_tmp.put(key, b);
							//}
						}catch(Exception e) {
							throw new CoreException("Rilevato errore durante il parsing della property '"+pName+"."+key+"' (atteso: true/false): "+e.getMessage(),e);
						}
					}
				}
				if(request) {
					this.keyValue_HeaderIntegrazioneSoap_setPA_request = _convertMapToCostantiIntegrazione(_tmp);
				}
				else {
					this.keyValue_HeaderIntegrazioneSoap_setPA_response = _convertMapToCostantiIntegrazione(_tmp);
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		if(request) {
			return this.keyValue_HeaderIntegrazioneSoap_setPA_request;
		}
		else {
			return this.keyValue_HeaderIntegrazioneSoap_setPA_response;
		}
	}
	
	private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_readPA = null;
	public Map<MapKey<String>, Boolean> getKeyPAReadEnabled_HeaderIntegrazioneSoap() throws CoreException {	
		if(this.keyValue_HeaderIntegrazioneSoap_readPA==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.pa.read.enabled.");
				Map<String, Boolean> _tmp = new HashMap<String, Boolean>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = (Object) it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						try {
							boolean b = Boolean.parseBoolean(value);
							_tmp.put(key, b);
						}catch(Exception e) {
							throw new CoreException("Rilevato errore durante il parsing della property 'org.openspcoop2.pdd.integrazione.soap.pa.read.enabled."+key+"' (atteso: true/false): "+e.getMessage(),e);
						}
					}
				}
				this.keyValue_HeaderIntegrazioneSoap_readPA = _convertMapToCostantiIntegrazione(_tmp);
								
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.soap.pa.read.enabled.*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.keyValue_HeaderIntegrazioneSoap_readPA;
	}
	
	private String headerIntegrazioneSOAPPdDVersione = null;
	public String getHeaderIntegrazioneSOAPPdDVersione(){
		if(this.headerIntegrazioneSOAPPdDVersione==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.pddVersion"); 

				if (value != null){
					value = value.trim();
					this.headerIntegrazioneSOAPPdDVersione = value;
				}else{
					//NON EMETTO WARNING: this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.pddVersion' non impostata, viene utilizzato il default="+this.getVersione());
					this.headerIntegrazioneSOAPPdDVersione = this.getVersione();
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.pddVersion' non impostata, viene utilizzato il default=true, errore:"+this.getVersione());
				this.headerIntegrazioneSOAPPdDVersione = this.getVersione();
			}
		}

		return this.headerIntegrazioneSOAPPdDVersione;
	}
	
	private Boolean readHeaderIntegrazioneSOAPPdDDetails = null;
	private String headerIntegrazioneSOAPPdDDetails = null;
	public String getHeaderIntegrazioneSOAPPdDDetails(){
		if(this.readHeaderIntegrazioneSOAPPdDDetails==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.pddDetails"); 

				if (value != null){
					value = value.trim();
					this.headerIntegrazioneSOAPPdDDetails = value;
				}else{
					this.headerIntegrazioneSOAPPdDDetails = this.getDetails();
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.pddDetails' non impostata correttamente: "+e.getMessage(),e);
				this.headerIntegrazioneSOAPPdDDetails = this.getDetails();
			}
		}

		this.readHeaderIntegrazioneSOAPPdDDetails = true;
		return this.headerIntegrazioneSOAPPdDDetails;
	}
	
	/**
	 * Restituisce l'indicazione l'header di integrazione letto
	 * durante l'integrazione tra servizio applicativo e PdD
	 * deve essere eliminato o meno
	 *  
	 * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
	 * 
	 */
	private Boolean deleteHeaderIntegrazioneRequestPD = null;
	public boolean deleteHeaderIntegrazioneRequestPD(){
		if(this.deleteHeaderIntegrazioneRequestPD==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pd.request.readAndDelete"); 

				if (value != null){
					value = value.trim();
					this.deleteHeaderIntegrazioneRequestPD = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.pd.request.readAndDelete' non impostata, viene utilizzato il default=true");
					this.deleteHeaderIntegrazioneRequestPD = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.pd.request.readAndDelete' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.deleteHeaderIntegrazioneRequestPD = true;
			}
		}

		return this.deleteHeaderIntegrazioneRequestPD;
	}
	
	/**
	 * Restituisce l'indicazione l'header di integrazione letto
	 * durante l'integrazione tra servizio applicativo e PdD
	 * deve essere eliminato o meno
	 *  
	 * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
	 * 
	 */
	private Boolean deleteHeaderIntegrazioneResponsePD = null;
	public boolean deleteHeaderIntegrazioneResponsePD(){
		if(this.deleteHeaderIntegrazioneResponsePD==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pd.response.readAndDelete"); 

				if (value != null){
					value = value.trim();
					this.deleteHeaderIntegrazioneResponsePD = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.pd.response.readAndDelete' non impostata, viene utilizzato il default=true");
					this.deleteHeaderIntegrazioneResponsePD = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.pd.response.readAndDelete' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.deleteHeaderIntegrazioneResponsePD = true;
			}
		}

		return this.deleteHeaderIntegrazioneResponsePD;
	}

	/**
	 * Restituisce l'indicazione l'header di integrazione letto
	 * durante l'integrazione tra servizio applicativo e PdD
	 * deve essere eliminato o meno
	 *  
	 * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
	 * 
	 */
	private Boolean processHeaderIntegrazionePDResponse = null;
	public boolean processHeaderIntegrazionePDResponse(boolean functionAsRouter){
		if(functionAsRouter){
			return false;
		}
		if(this.processHeaderIntegrazionePDResponse==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pd.response.process"); 

				if (value != null){
					value = value.trim();
					this.processHeaderIntegrazionePDResponse = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.pd.response.process' non impostata, viene utilizzato il default=false");
					this.processHeaderIntegrazionePDResponse = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.pd.response.process' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.processHeaderIntegrazionePDResponse = false;
			}
		}

		return this.processHeaderIntegrazionePDResponse;
	}
	
	
	
	/**
	 * Restituisce l'indicazione l'header di integrazione letto
	 * durante l'integrazione tra servizio applicativo e PdD
	 * deve essere eliminato o meno
	 *  
	 * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
	 * 
	 */
	private Boolean deleteHeaderIntegrazioneRequestPA = null;
	public boolean deleteHeaderIntegrazioneRequestPA(){
		if(this.deleteHeaderIntegrazioneRequestPA==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pa.request.readAndDelete"); 

				if (value != null){
					value = value.trim();
					this.deleteHeaderIntegrazioneRequestPA = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.pa.request.readAndDelete' non impostata, viene utilizzato il default=true");
					this.deleteHeaderIntegrazioneRequestPA = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.pa.request.readAndDelete' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.deleteHeaderIntegrazioneRequestPA = true;
			}
		}

		return this.deleteHeaderIntegrazioneRequestPA;
	}
	
	/**
	 * Restituisce l'indicazione l'header di integrazione letto
	 * durante l'integrazione tra servizio applicativo e PdD
	 * deve essere eliminato o meno
	 *  
	 * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
	 * 
	 */
	private Boolean deleteHeaderIntegrazioneResponsePA = null;
	public boolean deleteHeaderIntegrazioneResponsePA(){
		if(this.deleteHeaderIntegrazioneResponsePA==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pa.response.readAndDelete"); 

				if (value != null){
					value = value.trim();
					this.deleteHeaderIntegrazioneResponsePA = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.pa.response.readAndDelete' non impostata, viene utilizzato il default=true");
					this.deleteHeaderIntegrazioneResponsePA = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.pa.response.readAndDelete' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.deleteHeaderIntegrazioneResponsePA = true;
			}
		}

		return this.deleteHeaderIntegrazioneResponsePA;
	}

	/**
	 * Restituisce l'indicazione l'header di integrazione letto
	 * durante l'integrazione tra servizio applicativo e PdD
	 * deve essere eliminato o meno
	 *  
	 * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
	 * 
	 */
	private Boolean processHeaderIntegrazionePARequest = null;
	public boolean processHeaderIntegrazionePARequest(boolean functionAsRouter){
		if(functionAsRouter){
			return false;
		}
		if(this.processHeaderIntegrazionePARequest==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pa.request.process"); 

				if (value != null){
					value = value.trim();
					this.processHeaderIntegrazionePARequest = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.pa.request.process' non impostata, viene utilizzato il default=false");
					this.processHeaderIntegrazionePARequest = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.pa.request.process' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.processHeaderIntegrazionePARequest = false;
			}
		}

		return this.processHeaderIntegrazionePARequest;
	}
	

	/**
	 * Restituisce il nome dell'header Soap di integrazione di default
	 * 
	 * @return Restituisce il nome dell'header Soap di integrazione di default
	 */
	private String headerSoapNameIntegrazione = null;
	public String getHeaderSoapNameIntegrazione() {
		if(this.headerSoapNameIntegrazione==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.headerName");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapNameIntegrazione = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.headerName': "+e.getMessage(),e);
				this.headerSoapNameIntegrazione = null;
			}    
		}

		return this.headerSoapNameIntegrazione;
	}
	
	private String headerSoapNameIntegrazione_backwardCompatibility_openspcoop2 = null;
	public String getHeaderSoapNameIntegrazione_backwardCompatibility_openspcoop2() {
		if(this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop2==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerName");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop2 = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerName': "+e.getMessage(),e);
				this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop2 = null;
			}    
		}

		return this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop2;
	}
	
	private String headerSoapNameIntegrazione_backwardCompatibility_openspcoop1 = null;
	public String getHeaderSoapNameIntegrazione_backwardCompatibility_openspcoop1() {
		if(this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop1==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerName");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop1 = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerName': "+e.getMessage(),e);
				this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop1 = null;
			}    
		}

		return this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop1;
	}

	/**
	 * Restituisce l'actord dell'header Soap di integrazione di default
	 * 
	 * @return Restituisce l'actor dell'header Soap di integrazione di default
	 */
	private String headerSoapActorIntegrazione = null;
	public String getHeaderSoapActorIntegrazione() {
		if(this.headerSoapActorIntegrazione==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.headerActor");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapActorIntegrazione = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.headerActor': "+e.getMessage(),e);
				this.headerSoapActorIntegrazione = null;
			}    
		}

		return this.headerSoapActorIntegrazione;
	}
	
	private String headerSoapActorIntegrazione_backwardCompatibility_openspcoop2 = null;
	public String getHeaderSoapActorIntegrazione_backwardCompatibility_openspcoop2() {
		if(this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop2==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerActor");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop2 = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerActor': "+e.getMessage(),e);
				this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop2 = null;
			}    
		}

		return this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop2;
	}
	
	private String headerSoapActorIntegrazione_backwardCompatibility_openspcoop1 = null;
	public String getHeaderSoapActorIntegrazione_backwardCompatibility_openspcoop1() {
		if(this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop1==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerActor");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop1 = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerActor': "+e.getMessage(),e);
				this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop1 = null;
			}    
		}

		return this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop1;
	}

	/**
	 * Restituisce il prefix dell'header Soap di integrazione di default
	 * 
	 * @return Restituisce il prefix dell'header Soap di integrazione di default
	 */
	private String headerSoapPrefixIntegrazione = null;
	public String getHeaderSoapPrefixIntegrazione() {
		if(this.headerSoapPrefixIntegrazione==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.headerPrefix");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapPrefixIntegrazione = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.headerPrefix': "+e.getMessage(),e);
				this.headerSoapPrefixIntegrazione = null;
			}    
		}

		return this.headerSoapPrefixIntegrazione;
	}
	
	private String headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2 = null;
	public String getHeaderSoapPrefixIntegrazione_backwardCompatibility_openspcoop2() {
		if(this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerPrefix");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2 = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerPrefix': "+e.getMessage(),e);
				this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2 = null;
			}    
		}

		return this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2;
	}
	
	private String headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1 = null;
	public String getHeaderSoapPrefixIntegrazione_backwardCompatibility_openspcoop1() {
		if(this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerPrefix");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1 = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerPrefix': "+e.getMessage(),e);
				this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1 = null;
			}    
		}

		return this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1;
	}
	
	/**
	 * Restituisce il nome dell'elemento che contiene le informazioni di protocollo
	 * 
	 * @return Restituisce il nome dell'elemento che contiene le informazioni di protocollo
	 */
	private String headerSoapExtProtocolInfoNomeElementoIntegrazione = null;
	public String getHeaderSoapExtProtocolInfoNomeElementoIntegrazione() {
		if(this.headerSoapExtProtocolInfoNomeElementoIntegrazione==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.extProtocolInfo.elemento.nome");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapExtProtocolInfoNomeElementoIntegrazione = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.extProtocolInfo.elemento.nome': "+e.getMessage(),e);
				this.headerSoapExtProtocolInfoNomeElementoIntegrazione = null;
			}    
		}

		return this.headerSoapExtProtocolInfoNomeElementoIntegrazione;
	}
	private String headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2 = null;
	public String getHeaderSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2() {
		if(this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.extProtocolInfo.elemento.nome");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2 = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.extProtocolInfo.elemento.nome': "+e.getMessage(),e);
				this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2 = null;
			}    
		}

		return this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2;
	}
	private String headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1 = null;
	public String getHeaderSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1() {
		if(this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.extProtocolInfo.elemento.nome");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1 = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.extProtocolInfo.elemento.nome': "+e.getMessage(),e);
				this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1 = null;
			}    
		}

		return this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1;
	}
	/**
	 * Restituisce il nome del tipo dell'elemento che contiene le informazioni di protocollo
	 * 
	 * @return Restituisce il nome del tipo dell'elemento che contiene le informazioni di protocollo
	 */
	private String headerSoapExtProtocolInfoNomeAttributoIntegrazione = null;
	public String getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione() {
		if(this.headerSoapExtProtocolInfoNomeAttributoIntegrazione==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.extProtocolInfo.attributo.nome");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapExtProtocolInfoNomeAttributoIntegrazione = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.extProtocolInfo.attributo.nome': "+e.getMessage(),e);
				this.headerSoapExtProtocolInfoNomeAttributoIntegrazione = null;
			}    
		}

		return this.headerSoapExtProtocolInfoNomeAttributoIntegrazione;
	}
	
	private String headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2 = null;
	public String getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2() {
		if(this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.extProtocolInfo.attributo.nome");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2 = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.extProtocolInfo.attributo.nome': "+e.getMessage(),e);
				this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2 = null;
			}    
		}

		return this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2;
	}
	
	private String headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1 = null;
	public String getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1() {
		if(this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.extProtocolInfo.attributo.nome");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1 = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.extProtocolInfo.attributo.nome': "+e.getMessage(),e);
				this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1 = null;
			}    
		}

		return this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1;
	}

	
	
	/* ********  INTEGRAZIONE INFORMAZIONI DINAMICHE  ******** */
	
	private Boolean isIntegrazioneDynamicInfoEnabled = null;
	public boolean isIntegrazioneDynamicInfoEnabled() {
		String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.enabled";
		if(this.isIntegrazioneDynamicInfoEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.isIntegrazioneDynamicInfoEnabled = Boolean.parseBoolean(name);
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isIntegrazioneDynamicInfoEnabled = false;
			}    
		}

		if(this.isIntegrazioneDynamicInfoEnabled==null){
			return false;
		}
		return this.isIntegrazioneDynamicInfoEnabled;
	}
	
	private InformazioniIntegrazioneSorgente getIntegrazioneDynamicInfoType = null;
	public InformazioniIntegrazioneSorgente getIntegrazioneDynamicInfoType() {
		String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.type";
		if(this.getIntegrazioneDynamicInfoType==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getIntegrazioneDynamicInfoType = InformazioniIntegrazioneSorgente.valueOf(name);
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}    
		}

		return this.getIntegrazioneDynamicInfoType;
	}
	
	private String getIntegrazioneDynamicInfoName = null;
	public String getIntegrazioneDynamicInfoName() {
		String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.name";
		if(this.getIntegrazioneDynamicInfoName==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getIntegrazioneDynamicInfoName = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}    
		}

		return this.getIntegrazioneDynamicInfoName;
	}
	
	private InformazioniIntegrazioneCodifica getIntegrazioneDynamicInfoEncodeType = null;
	public InformazioniIntegrazioneCodifica getIntegrazioneDynamicInfoEncodeType() {
		String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.encode";
		if(this.getIntegrazioneDynamicInfoEncodeType==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getIntegrazioneDynamicInfoEncodeType = InformazioniIntegrazioneCodifica.valueOf(name);
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}    
		}

		return this.getIntegrazioneDynamicInfoEncodeType;
	}
	
	private Boolean isIntegrazioneDynamicInfoRequired = null;
	public boolean isIntegrazioneDynamicInfoRequired() {
		String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.required";
		if(this.isIntegrazioneDynamicInfoRequired==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.isIntegrazioneDynamicInfoRequired = Boolean.parseBoolean(name);
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isIntegrazioneDynamicInfoRequired = false;
			}    
		}

		if(this.isIntegrazioneDynamicInfoRequired==null){
			return false;
		}
		return this.isIntegrazioneDynamicInfoRequired;
	}
	
	// risposta
	
	private Boolean isIntegrazioneResponseDynamicInfoEnabled = null;
	public boolean isIntegrazioneResponseDynamicInfoEnabled() {
		String pName = "org.openspcoop2.pdd.integrazione.responseDynamicInfo.enabled";
		if(this.isIntegrazioneResponseDynamicInfoEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.isIntegrazioneResponseDynamicInfoEnabled = Boolean.parseBoolean(name);
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isIntegrazioneResponseDynamicInfoEnabled = false;
			}    
		}

		if(this.isIntegrazioneResponseDynamicInfoEnabled==null){
			return false;
		}
		return this.isIntegrazioneResponseDynamicInfoEnabled;
	}
	
	private String getIntegrazioneResponseDynamicInfoName = null;
	public String getIntegrazioneResponseDynamicInfoName() {
		String pName = "org.openspcoop2.pdd.integrazione.responseDynamicInfo.name";
		if(this.getIntegrazioneResponseDynamicInfoName==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getIntegrazioneResponseDynamicInfoName = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}    
		}

		return this.getIntegrazioneResponseDynamicInfoName;
	}
	
	private InformazioniIntegrazioneCodifica getIntegrazioneResponseDynamicInfoEncodeType = null;
	public InformazioniIntegrazioneCodifica getIntegrazioneResponseDynamicInfoEncodeType() {
		String pName = "org.openspcoop2.pdd.integrazione.responseDynamicInfo.encode";
		if(this.getIntegrazioneResponseDynamicInfoEncodeType==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getIntegrazioneResponseDynamicInfoEncodeType = InformazioniIntegrazioneCodifica.valueOf(name);
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}    
		}

		return this.getIntegrazioneResponseDynamicInfoEncodeType;
	}
	
	private Boolean isIntegrazioneResponseDynamicInfoRequired = null;
	public boolean isIntegrazioneResponseDynamicInfoRequired() {
		String pName = "org.openspcoop2.pdd.integrazione.responseDynamicInfo.required";
		if(this.isIntegrazioneResponseDynamicInfoRequired==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.isIntegrazioneResponseDynamicInfoRequired = Boolean.parseBoolean(name);
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isIntegrazioneResponseDynamicInfoRequired = false;
			}    
		}

		if(this.isIntegrazioneResponseDynamicInfoRequired==null){
			return false;
		}
		return this.isIntegrazioneResponseDynamicInfoRequired;
	}
	
	
	
	/* ********  INTEGRAZIONE TEMPLATE  ******** */
    
	private String getIntegrazioneTemplateRequestPropertyTipo = null;
	public String getIntegrazioneTemplateRequestPropertyTipo() {
		String pName = "org.openspcoop2.pdd.integrazione.template.request.property.tipo";
		if(this.getIntegrazioneTemplateRequestPropertyTipo==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getIntegrazioneTemplateRequestPropertyTipo = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.getIntegrazioneTemplateRequestPropertyTipo = null;
			}    
		}

		return this.getIntegrazioneTemplateRequestPropertyTipo;
	}
	
	private String getIntegrazioneTemplateRequestPropertyFile = null;
	public String getIntegrazioneTemplateRequestPropertyFile() {
		String pName = "org.openspcoop2.pdd.integrazione.template.request.property.file";
		if(this.getIntegrazioneTemplateRequestPropertyFile==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getIntegrazioneTemplateRequestPropertyFile = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.getIntegrazioneTemplateRequestPropertyFile = null;
			}    
		}

		return this.getIntegrazioneTemplateRequestPropertyFile;
	}
	
	private String getIntegrazioneTemplateResponsePropertyTipo = null;
	public String getIntegrazioneTemplateResponsePropertyTipo() {
		String pName = "org.openspcoop2.pdd.integrazione.template.response.property.tipo";
		if(this.getIntegrazioneTemplateResponsePropertyTipo==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getIntegrazioneTemplateResponsePropertyTipo = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.getIntegrazioneTemplateResponsePropertyTipo = null;
			}    
		}

		return this.getIntegrazioneTemplateResponsePropertyTipo;
	}
	
	private String getIntegrazioneTemplateResponsePropertyFile = null;
	public String getIntegrazioneTemplateResponsePropertyFile() {
		String pName = "org.openspcoop2.pdd.integrazione.template.response.property.file";
		if(this.getIntegrazioneTemplateResponsePropertyFile==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getIntegrazioneTemplateResponsePropertyFile = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.getIntegrazioneTemplateResponsePropertyFile = null;
			}    
		}

		return this.getIntegrazioneTemplateResponsePropertyFile;
	}
	
	
    
	private Boolean getIntegrazioneTemplatePortaDelegataRequestTipo_read = null;
	private TipoTrasformazione getIntegrazioneTemplatePortaDelegataRequestTipo = null;
	public TipoTrasformazione getIntegrazioneTemplatePortaDelegataRequestTipo() throws CoreException{
		String pName = "org.openspcoop2.pdd.integrazione.template.pd.request.tipo";
		if(this.getIntegrazioneTemplatePortaDelegataRequestTipo_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null) {
					name = name.trim();
					this.getIntegrazioneTemplatePortaDelegataRequestTipo = UtilitiesTemplate.convert(name);
					
					this.getIntegrazioneTemplatePortaDelegataRequestTipo_read = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.getIntegrazioneTemplatePortaDelegataRequestTipo;
	}
	
	private Boolean getIntegrazioneTemplatePortaDelegataRequestFile_read = null;
	private String getIntegrazioneTemplatePortaDelegataRequestFile = null;
	public String getIntegrazioneTemplatePortaDelegataRequestFile() throws CoreException{
		String pName = "org.openspcoop2.pdd.integrazione.template.pd.request.file";
		if(this.getIntegrazioneTemplatePortaDelegataRequestFile_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null) {
					name = name.trim();
					this.getIntegrazioneTemplatePortaDelegataRequestFile = name;
					
					this.getIntegrazioneTemplatePortaDelegataRequestFile_read = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.getIntegrazioneTemplatePortaDelegataRequestFile;
	}
	
	private Boolean getIntegrazioneTemplatePortaDelegataResponseTipo_read = null;
	private TipoTrasformazione getIntegrazioneTemplatePortaDelegataResponseTipo = null;
	public TipoTrasformazione getIntegrazioneTemplatePortaDelegataResponseTipo() throws CoreException{
		String pName = "org.openspcoop2.pdd.integrazione.template.pd.response.tipo";
		if(this.getIntegrazioneTemplatePortaDelegataResponseTipo_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null) {
					name = name.trim();
					this.getIntegrazioneTemplatePortaDelegataResponseTipo = UtilitiesTemplate.convert(name);

					this.getIntegrazioneTemplatePortaDelegataResponseTipo_read = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.getIntegrazioneTemplatePortaDelegataResponseTipo;
	}
	
	private Boolean getIntegrazioneTemplatePortaDelegataResponseFile_read = null;
	private String getIntegrazioneTemplatePortaDelegataResponseFile = null;
	public String getIntegrazioneTemplatePortaDelegataResponseFile() throws CoreException{
		String pName = "org.openspcoop2.pdd.integrazione.template.pd.response.file";
		if(this.getIntegrazioneTemplatePortaDelegataResponseFile_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null) {
					name = name.trim();
					this.getIntegrazioneTemplatePortaDelegataResponseFile = name;
					
					this.getIntegrazioneTemplatePortaDelegataResponseFile_read = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.getIntegrazioneTemplatePortaDelegataResponseFile;
	}
    
	
	private Boolean getIntegrazioneTemplatePortaApplicativaRequestTipo_read = null;
	private TipoTrasformazione getIntegrazioneTemplatePortaApplicativaRequestTipo = null;
	public TipoTrasformazione getIntegrazioneTemplatePortaApplicativaRequestTipo() throws CoreException{
		String pName = "org.openspcoop2.pdd.integrazione.template.pa.request.tipo";
		if(this.getIntegrazioneTemplatePortaApplicativaRequestTipo_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null) {
					name = name.trim();
					this.getIntegrazioneTemplatePortaApplicativaRequestTipo = UtilitiesTemplate.convert(name);
					
					this.getIntegrazioneTemplatePortaApplicativaRequestTipo_read = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.getIntegrazioneTemplatePortaApplicativaRequestTipo;
	}
	
	private Boolean getIntegrazioneTemplatePortaApplicativaRequestFile_read = null;
	private String getIntegrazioneTemplatePortaApplicativaRequestFile = null;
	public String getIntegrazioneTemplatePortaApplicativaRequestFile() throws CoreException{
		String pName = "org.openspcoop2.pdd.integrazione.template.pa.request.file";
		if(this.getIntegrazioneTemplatePortaApplicativaRequestFile_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null) {
					name = name.trim();
					this.getIntegrazioneTemplatePortaApplicativaRequestFile = name;
					
					this.getIntegrazioneTemplatePortaApplicativaRequestFile_read = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.getIntegrazioneTemplatePortaApplicativaRequestFile;
	}
	
	private Boolean getIntegrazioneTemplatePortaApplicativaResponseTipo_read = null;
	private TipoTrasformazione getIntegrazioneTemplatePortaApplicativaResponseTipo = null;
	public TipoTrasformazione getIntegrazioneTemplatePortaApplicativaResponseTipo() throws CoreException{
		String pName = "org.openspcoop2.pdd.integrazione.template.pa.response.tipo";
		if(this.getIntegrazioneTemplatePortaApplicativaResponseTipo_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null) {
					name = name.trim();
					this.getIntegrazioneTemplatePortaApplicativaResponseTipo = UtilitiesTemplate.convert(name);
					
					this.getIntegrazioneTemplatePortaApplicativaResponseTipo_read = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.getIntegrazioneTemplatePortaApplicativaResponseTipo;
	}
	
	private Boolean getIntegrazioneTemplatePortaApplicativaResponseFile_read = null;
	private String getIntegrazioneTemplatePortaApplicativaResponseFile = null;
	public String getIntegrazioneTemplatePortaApplicativaResponseFile() throws CoreException{
		String pName = "org.openspcoop2.pdd.integrazione.template.pa.response.file";
		if(this.getIntegrazioneTemplatePortaApplicativaResponseFile_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null) {
					name = name.trim();
					this.getIntegrazioneTemplatePortaApplicativaResponseFile = name;
					
					this.getIntegrazioneTemplatePortaApplicativaResponseFile_read = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.getIntegrazioneTemplatePortaApplicativaResponseFile;
	}
	
	
	/* ********  INTEGRAZIONE AUTENTICAZIONE  ******** */
	
	private List<String> getIntegrazioneAutenticazionePortaDelegataRequestHeaders = null;
	public List<String> getIntegrazioneAutenticazionePortaDelegataRequestHeaders() throws CoreException{
		String pName = "org.openspcoop2.pdd.integrazione.autenticazione.pd.request.headers";
		if(this.getIntegrazioneAutenticazionePortaDelegataRequestHeaders==null){
			try{
				
				this.getIntegrazioneAutenticazionePortaDelegataRequestHeaders = new ArrayList<>();
				
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null) {
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							String v = split[i];
							if(v!=null) {
								v = v.trim();
							}
							if(!"".equals(v)) {
								this.getIntegrazioneAutenticazionePortaDelegataRequestHeaders.add(v);
							}
						}
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.getIntegrazioneAutenticazionePortaDelegataRequestHeaders;
	}
   
	private Map<String, String> getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap = null;
	public Map<String, String> getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap() throws CoreException{
		String pNamePrefix = "org.openspcoop2.pdd.integrazione.autenticazione.pd.request.header.";
		if(this.getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap==null){
			try{
				
				this.getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap = new HashMap<>();
				List<String> getIntegrazioneAutenticazionePortaDelegataRequestHeaders = getIntegrazioneAutenticazionePortaDelegataRequestHeaders();
				if(getIntegrazioneAutenticazionePortaDelegataRequestHeaders!=null && !getIntegrazioneAutenticazionePortaDelegataRequestHeaders.isEmpty()) {
					for (String hdrName : getIntegrazioneAutenticazionePortaDelegataRequestHeaders) {
						String pName = pNamePrefix+hdrName;
						try {
							String hdrValue = this.reader.getValueConvertEnvProperties(pName);
							if(hdrValue==null) {
								throw new CoreException(NON_DEFINITA);
							}
							hdrValue = hdrValue.trim();
							this.getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap.put(hdrName, hdrValue);
						}catch(java.lang.Exception e) {
							throw new CoreException ("Proprietà '"+pName+"' "+e.getMessage(),e);
						}   
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNamePrefix+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap;
	}
	
	private List<String> getIntegrazioneAutenticazionePortaApplicativaRequestHeaders = null;
	public List<String> getIntegrazioneAutenticazionePortaApplicativaRequestHeaders() throws CoreException{
		String pName = "org.openspcoop2.pdd.integrazione.autenticazione.pa.request.headers";
		if(this.getIntegrazioneAutenticazionePortaApplicativaRequestHeaders==null){
			try{
				
				this.getIntegrazioneAutenticazionePortaApplicativaRequestHeaders = new ArrayList<>();
				
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null) {
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							String v = split[i];
							if(v!=null) {
								v = v.trim();
							}
							if(!"".equals(v)) {
								this.getIntegrazioneAutenticazionePortaApplicativaRequestHeaders.add(v);
							}
						}
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.getIntegrazioneAutenticazionePortaApplicativaRequestHeaders;
	}
   
	private Map<String, String> getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap = null;
	public Map<String, String> getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap() throws CoreException{
		String pNamePrefix = "org.openspcoop2.pdd.integrazione.autenticazione.pa.request.header.";
		if(this.getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap==null){
			try{
				
				this.getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap = new HashMap<>();
				List<String> getIntegrazioneAutenticazionePortaApplicativaRequestHeaders = getIntegrazioneAutenticazionePortaApplicativaRequestHeaders();
				if(getIntegrazioneAutenticazionePortaApplicativaRequestHeaders!=null && !getIntegrazioneAutenticazionePortaApplicativaRequestHeaders.isEmpty()) {
					for (String hdrName : getIntegrazioneAutenticazionePortaApplicativaRequestHeaders) {
						String pName = pNamePrefix+hdrName;
						try {
							String hdrValue = this.reader.getValueConvertEnvProperties(pName);
							if(hdrValue==null) {
								throw new CoreException(NON_DEFINITA);
							}
							hdrValue = hdrValue.trim();
							this.getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap.put(hdrName, hdrValue);
						}catch(java.lang.Exception e) {
							throw new CoreException ("Proprietà '"+pName+"' "+e.getMessage(),e);
						}   
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNamePrefix+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap;
	}
	
	private String getIntegrazioneAutenticazionePropertyHeaders = null;
	public String getIntegrazioneAutenticazionePropertyHeaders() {
		String pName = "org.openspcoop2.pdd.integrazione.autenticazione.request.property.headers";
		if(this.getIntegrazioneAutenticazionePropertyHeaders==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getIntegrazioneAutenticazionePropertyHeaders = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.getIntegrazioneAutenticazionePropertyHeaders = null;
			}    
		}

		return this.getIntegrazioneAutenticazionePropertyHeaders;
	}
	
	private String getIntegrazioneAutenticazionePropertyHeaderPrefix = null;
	public String getIntegrazioneAutenticazionePropertyHeaderPrefix() {
		String pName = "org.openspcoop2.pdd.integrazione.autenticazione.request.property.header.prefix";
		if(this.getIntegrazioneAutenticazionePropertyHeaderPrefix==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.getIntegrazioneAutenticazionePropertyHeaderPrefix = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.getIntegrazioneAutenticazionePropertyHeaderPrefix = null;
			}    
		}

		return this.getIntegrazioneAutenticazionePropertyHeaderPrefix;
	}


	/* ********  CONNETTORI  ******** */

	private Boolean isRitardoConsegnaAbilitato = null;
	public boolean isRitardoConsegnaAbilitato() throws CoreException{
		if(this.isRitardoConsegnaAbilitato==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettore.ritardo.stato");
				if(name==null)
					throw new CoreException(NON_DEFINITA);
				name = name.trim();
				this.isRitardoConsegnaAbilitato = CostantiConfigurazione.ABILITATO.equals(name);

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettore.ritardo.stato': "+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.isRitardoConsegnaAbilitato;
	}

	private Long ritardoConsegnaEsponenziale = null;
	public long getRitardoConsegnaEsponenziale() {	
		if(this.ritardoConsegnaEsponenziale==null){
			try{ 
				long r = -1;
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettore.ritardo.fattore");
				if (name != null) {
					name = name.trim();
					r = java.lang.Long.parseLong(name);
				}
				if(r<0)
					throw new CoreException("Il ritardo deve essere > 0");
				this.ritardoConsegnaEsponenziale = r;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettore.ritardo.fattore': "+e.getMessage(),e);
				this.ritardoConsegnaEsponenziale = -1L;
			}    
		}

		return this.ritardoConsegnaEsponenziale;
	}

	private Boolean isRitardoConsegnaEsponenzialeConMoltiplicazione = null;
	public boolean isRitardoConsegnaEsponenzialeConMoltiplicazione() throws CoreException{
		if(this.isRitardoConsegnaEsponenzialeConMoltiplicazione==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettore.ritardo.operazione");
				if (name != null) {
					name = name.trim();
					if(name.equals("+")){
						this.isRitardoConsegnaEsponenzialeConMoltiplicazione = false;
					}else if(name.equals("*")){
						this.isRitardoConsegnaEsponenzialeConMoltiplicazione = true;
					}else{
						throw new CoreException("Tipo di operazione non conosciuta: "+name);
					}
				}else{
					throw new CoreException("Tipo di operazione non definita");
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettore.ritardo.operazione': "+e.getMessage(),e);
				throw new CoreException (e);
			}    
		}

		return this.isRitardoConsegnaEsponenzialeConMoltiplicazione;
	}

	private Long ritardoConsegnaEsponenzialeLimite = null;
	public long getRitardoConsegnaEsponenzialeLimite() {	
		if(this.ritardoConsegnaEsponenzialeLimite==null){
			try{ 
				long r = 0;
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettore.ritardo.limite");
				if (name != null) {
					name = name.trim();
					r = java.lang.Long.parseLong(name);
				}
				if(r<=0)
					throw new CoreException("Il limite deve essere > 0");
				this.ritardoConsegnaEsponenzialeLimite = r;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettore.ritardo.limite': "+e.getMessage(),e);
				this.ritardoConsegnaEsponenzialeLimite = -1L;
			}    
		}

		return this.ritardoConsegnaEsponenzialeLimite;
	}














	/* ************* CACHE GESTORE MESSAGGIO *******************/

	/**
	 * Restituisce l'indicazione se la cache e' abilitata
	 *
	 * @return Restituisce l'indicazione se la cache e' abilitata
	 */
	private Boolean isAbilitataCacheGestoreMessaggi_value = null;
	public boolean isAbilitataCacheGestoreMessaggi() {
		if(this.isAbilitataCacheGestoreMessaggi_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.enable"); 

				if (value != null){
					value = value.trim();
					this.isAbilitataCacheGestoreMessaggi_value = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.enable' non impostata, viene utilizzato il default=false");
					this.isAbilitataCacheGestoreMessaggi_value = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.enable' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isAbilitataCacheGestoreMessaggi_value = false;
			}
		}

		return this.isAbilitataCacheGestoreMessaggi_value;
	}

	/**
	 * Restituisce la dimensione della cache
	 *
	 * @return Restituisce la dimensione della cache
	 */
	private Integer dimensioneCacheGestoreMessaggi_value = null;
	public int getDimensioneCacheGestoreMessaggi() throws OpenSPCoop2ConfigurationException{	
		if(this.dimensioneCacheGestoreMessaggi_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.dimensione"); 
				if(value!=null){
					value = value.trim();
					this.dimensioneCacheGestoreMessaggi_value = Integer.parseInt(value);
				}else{
					this.dimensioneCacheGestoreMessaggi_value = -1;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.dimensione': "+e.getMessage(),e);
				throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.dimensione'",e);
			}
		}

		return this.dimensioneCacheGestoreMessaggi_value;
	}

	/**
	 * Restituisce l'algoritmo della cache
	 *
	 * @return Restituisce l'algoritmo della cache
	 */
	private String algoritmoCacheGestoreMessaggi_value = null;
	public String getAlgoritmoCacheGestoreMessaggi() throws OpenSPCoop2ConfigurationException{	
		if(this.algoritmoCacheGestoreMessaggi_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.algoritmo"); 
				if(value!=null){
					value = value.trim();
					this.algoritmoCacheGestoreMessaggi_value = value;
				}else{
					this.algoritmoCacheGestoreMessaggi_value = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.algoritmo': "+e.getMessage(),e);
				throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.algoritmo'",e);
			}
		}

		return this.algoritmoCacheGestoreMessaggi_value;
	}

	/**
	 * Restituisce la itemIdleTime della cache
	 *
	 * @return Restituisce la itemIdleTime della cache
	 */
	private Integer itemIdleTimeCacheGestoreMessaggi_value = null;
	public int getItemIdleTimeCacheGestoreMessaggi() throws OpenSPCoop2ConfigurationException{	
		if(this.itemIdleTimeCacheGestoreMessaggi_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemIdleTime"); 
				if(value!=null){
					value = value.trim();
					this.itemIdleTimeCacheGestoreMessaggi_value = Integer.parseInt(value);
				}else{
					this.itemIdleTimeCacheGestoreMessaggi_value = -1;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemIdleTime': "+e.getMessage(),e);
				throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemIdleTime'",e);
			}
		}

		return this.itemIdleTimeCacheGestoreMessaggi_value;
	}

	/**
	 * Restituisce la  itemLifeSecond della cache
	 *
	 * @return Restituisce la itemLifeSecond della cache
	 */
	private Integer itemLifeSecondCacheGestoreMessaggi_value = null;
	public int getItemLifeSecondCacheGestoreMessaggi() throws OpenSPCoop2ConfigurationException{
		if(this.itemLifeSecondCacheGestoreMessaggi_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemLifeSecond"); 
				if(value!=null){
					value = value.trim();
					this.itemLifeSecondCacheGestoreMessaggi_value = Integer.parseInt(value);
				}else{
					this.itemLifeSecondCacheGestoreMessaggi_value = -1;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemLifeSecond': "+e.getMessage(),e);
				throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemLifeSecond'",e);
			}
		}

		return this.itemLifeSecondCacheGestoreMessaggi_value;
	}





	/* ******* GESTORE JMX *********** */
	/**
	 * Restituisce l'indicazione se istanziare le risorse JMX
	 *
	 * @return Restituisce Restituisce l'indicazione se istanziare le risorse JMX
	 * 
	 */
	private Boolean isRisorseJMXAbilitate = null;
	public boolean isRisorseJMXAbilitate(){
		if(this.isRisorseJMXAbilitate==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.jmx.enable"); 

				if (value != null){
					value = value.trim();
					this.isRisorseJMXAbilitate = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.jmx.enable' non impostata, viene utilizzato il default=false");
					this.isRisorseJMXAbilitate = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.jmx.enable' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isRisorseJMXAbilitate = false;
			}
		}

		return this.isRisorseJMXAbilitate;
	}

	/**
	 * Restituisce il Nome JNDI del MBeanServer
	 *
	 * @return il Nome JNDI del MBeanServer
	 * 
	 */
	private String jndiNameMBeanServer = null;
	public String getJNDIName_MBeanServer() {	
		if(this.jndiNameMBeanServer==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.jmx.jndi.mbeanServer");
				if(name!=null)
					name = name.trim();
				this.jndiNameMBeanServer = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.core.jmx.jndi.mbeanServer': "+e.getMessage(),e);
				this.jndiNameMBeanServer = null;
			}    
		}

		return this.jndiNameMBeanServer;
	}

	/**
	 * Restituisce le proprieta' da utilizzare con il contesto JNDI di lookup, se impostate.
	 *
	 * @return proprieta' da utilizzare con il contesto JNDI di lookup.
	 * 
	 */
	private java.util.Properties jndiContextMBeanServer = null;
	public java.util.Properties getJNDIContext_MBeanServer() {
		if(this.jndiContextMBeanServer==null){
			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.core.jmx.jndi.property.");
				this.jndiContextMBeanServer = prop;

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle propriete' JNDI 'org.openspcoop2.pdd.core.jmx.jndi.property.*': "+e.getMessage(),e);
				this.jndiContextMBeanServer = null;
			}    
		}

		return this.jndiContextMBeanServer;
	}









	/* ************* CONNETTORI ***************** */
	
	private Boolean isConnettoriUseLimitedInputStream = null;
	public boolean isConnettoriUseLimitedInputStream() {	
		if(this.isConnettoriUseLimitedInputStream==null){
			String pName = "org.openspcoop2.pdd.connettori.useLimitedInputStream";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.isConnettoriUseLimitedInputStream = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isConnettoriUseLimitedInputStream = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isConnettoriUseLimitedInputStream = false;
			}  
		}

		return this.isConnettoriUseLimitedInputStream;
	}
	
	private Long getLimitedInputStreamThreshold = null;
	private boolean limitedInputStreamThresholdDefined = false;
	public boolean isLimitedInputStreamThresholdDefined() {
		return this.limitedInputStreamThresholdDefined;
	}
	public long getLimitedInputStreamThresholdKb() {	
		if(this.getLimitedInputStreamThreshold==null){
			String pName = "org.openspcoop2.pdd.connettori.limitedInputStream.threshold";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.getLimitedInputStreamThreshold = java.lang.Long.valueOf(name);
					this.limitedInputStreamThresholdDefined = true;
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, Integer.MAX_VALUE));
					this.getLimitedInputStreamThreshold = (long)Integer.MAX_VALUE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, Integer.MAX_VALUE),e);
				this.getLimitedInputStreamThreshold = (long)Integer.MAX_VALUE;
			}  
		}

		return this.getLimitedInputStreamThreshold;
	}
	
	private Boolean isConnettoriUseTimeoutInputStream = null;
	public boolean isConnettoriUseTimeoutInputStream() {	
		if(this.isConnettoriUseTimeoutInputStream==null){
			String pName = "org.openspcoop2.pdd.connettori.useTimeoutInputStream";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.isConnettoriUseTimeoutInputStream = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isConnettoriUseTimeoutInputStream = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isConnettoriUseTimeoutInputStream = false;
			}  
		}

		return this.isConnettoriUseTimeoutInputStream;
	}
	
	/**
	 * Restituisce timeout per la istanziazione della connessione
	 *
	 * @return Restituisce timeout per la istanziazione della connessione
	 * 
	 */
	private Integer connectionTimeout_inoltroBuste = null;
	public int getConnectionTimeout_inoltroBuste() {	
		if(this.connectionTimeout_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.connection.timeout");
				if(name!=null){
					name = name.trim();
					this.connectionTimeout_inoltroBuste = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.connection.timeout' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_INOLTRO_BUSTE);
					this.connectionTimeout_inoltroBuste = CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.connection.timeout' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_INOLTRO_BUSTE+", errore:"+e.getMessage(),e);
				this.connectionTimeout_inoltroBuste = CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
			}  
		}

		return this.connectionTimeout_inoltroBuste;
	}


	/**
	 * Restituisce timeout per la istanziazione della connessione
	 *
	 * @return Restituisce timeout per la istanziazione della connessione
	 * 
	 */
	private Integer connectionTimeout_consegnaContenutiApplicativi = null;
	public int getConnectionTimeout_consegnaContenutiApplicativi() {	
		if(this.connectionTimeout_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.connection.timeout");
				if(name!=null){
					name = name.trim();
					this.connectionTimeout_consegnaContenutiApplicativi = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.connection.timeout' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI);
					this.connectionTimeout_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.connection.timeout' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI+", errore:"+e.getMessage(),e);
				this.connectionTimeout_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI;
			}  
		}

		return this.connectionTimeout_consegnaContenutiApplicativi;
	}


	/**
	 * Restituisce timeout per la lettura dalla connessione
	 *
	 * @return Restituisce timeout per la lettura dalla connessione
	 * 
	 */
	private Integer readConnectionTimeout_inoltroBuste = null;
	public int getReadConnectionTimeout_inoltroBuste() {	
		if(this.readConnectionTimeout_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.readConnection.timeout");
				if(name!=null){
					name = name.trim();
					this.readConnectionTimeout_inoltroBuste = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.readConnection.timeout' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE);
					this.readConnectionTimeout_inoltroBuste = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.readConnection.timeout' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE+", errore:"+e.getMessage(),e);
				this.readConnectionTimeout_inoltroBuste = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
			}  
		}

		return this.readConnectionTimeout_inoltroBuste;
	}


	/**
	 * Restituisce timeout per la lettura dalla connessione
	 *
	 * @return Restituisce timeout per la lettura dalla connessione
	 * 
	 */
	private Integer readConnectionTimeout_consegnaContenutiApplicativi = null;
	public int getReadConnectionTimeout_consegnaContenutiApplicativi() {	
		if(this.readConnectionTimeout_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.readConnection.timeout");
				if(name!=null){
					name = name.trim();
					this.readConnectionTimeout_consegnaContenutiApplicativi = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.readConnection.timeout' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI);
					this.readConnectionTimeout_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.readConnection.timeout' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI+", errore:"+e.getMessage(),e);
				this.readConnectionTimeout_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI;
			}  
		}

		return this.readConnectionTimeout_consegnaContenutiApplicativi;
	}

	/**
	 * Restituisce timeout in millisecondi massimi durante il quale una connessione viene mantenuta aperta dalla PdD. 
	 *
	 * @return Restituisce timeout in millisecondi massimi durante il quale una connessione viene mantenuta aperta dalla PdD. 
	 * 
	 */
	private Integer connectionLife_inoltroBuste = null;
	public int getConnectionLife_inoltroBuste() {	
		if(this.connectionLife_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.connection.life");
				if(name!=null){
					name = name.trim();
					this.connectionLife_inoltroBuste = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.connection.life' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_CONNECTION_LIFE_INOLTRO_BUSTE);
					this.connectionLife_inoltroBuste = CostantiPdD.CONNETTORE_CONNECTION_LIFE_INOLTRO_BUSTE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.connection.life' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_CONNECTION_LIFE_INOLTRO_BUSTE+", errore:"+e.getMessage(),e);
				this.connectionLife_inoltroBuste = CostantiPdD.CONNETTORE_CONNECTION_LIFE_INOLTRO_BUSTE;
			}  
		}

		return this.connectionLife_inoltroBuste;
	}


	/**
	 * Restituisce timeout in millisecondi massimi durante il quale una connessione viene mantenuta aperta dalla PdD. 
	 *
	 * @return Restituisce timeout in millisecondi massimi durante il quale una connessione viene mantenuta aperta dalla PdD. 
	 * 
	 */
	private Integer connectionLife_consegnaContenutiApplicativi = null;
	public int getConnectionLife_consegnaContenutiApplicativi() {	
		if(this.connectionLife_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.connection.life");
				if(name!=null){
					name = name.trim();
					this.connectionLife_consegnaContenutiApplicativi = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.connection.life' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_CONNECTION_LIFE_CONSEGNA_CONTENUTI_APPLICATIVI);
					this.connectionLife_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_CONNECTION_LIFE_CONSEGNA_CONTENUTI_APPLICATIVI;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.connection.life' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_CONNECTION_LIFE_CONSEGNA_CONTENUTI_APPLICATIVI+", errore:"+e.getMessage(),e);
				this.connectionLife_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_CONNECTION_LIFE_CONSEGNA_CONTENUTI_APPLICATIVI;
			}  
		}

		return this.connectionLife_consegnaContenutiApplicativi;
	}

	
	private Integer readConnectionTimeout_ricezioneContenutiApplicativi = null;
	public int getReadConnectionTimeout_ricezioneContenutiApplicativi() {	
		String pName = "org.openspcoop2.pdd.connettori.ricezioneContenutiApplicativi.readConnection.timeout";
		if(this.readConnectionTimeout_ricezioneContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.readConnectionTimeout_ricezioneContenutiApplicativi = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE));
					this.readConnectionTimeout_ricezioneContenutiApplicativi = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE),e);
				this.readConnectionTimeout_ricezioneContenutiApplicativi = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
			}  
		}

		return this.readConnectionTimeout_ricezioneContenutiApplicativi;
	}
	
	private Integer readConnectionTimeout_ricezioneBuste = null;
	public int getReadConnectionTimeout_ricezioneBuste() {	
		String pName = "org.openspcoop2.pdd.connettori.ricezioneBuste.readConnection.timeout";
		if(this.readConnectionTimeout_ricezioneBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.readConnectionTimeout_ricezioneBuste = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE));
					this.readConnectionTimeout_ricezioneBuste = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE),e);
				this.readConnectionTimeout_ricezioneBuste = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
			}  
		}

		return this.readConnectionTimeout_ricezioneBuste;
	}
	
	
	
	private Boolean isConnettoriUseDiagnosticInputStream_inoltroBuste = null;
	public boolean isConnettoriUseDiagnosticInputStream_inoltroBuste() {	
		if(this.isConnettoriUseDiagnosticInputStream_inoltroBuste==null){
			String pName = "org.openspcoop2.pdd.connettori.inoltroBuste.useDiagnosticInputStream";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.isConnettoriUseDiagnosticInputStream_inoltroBuste = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isConnettoriUseDiagnosticInputStream_inoltroBuste = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isConnettoriUseDiagnosticInputStream_inoltroBuste = true;
			}  
		}

		return this.isConnettoriUseDiagnosticInputStream_inoltroBuste;
	}
	
	private Boolean isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi = null;
	public boolean isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi() {	
		if(this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi==null){
			String pName = "org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.useDiagnosticInputStream";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi = true;
			}  
		}

		return this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi;
	}
	
	private Boolean isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi = null;
	public boolean isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi() {	
		if(this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi==null){
			String pName = "org.openspcoop2.pdd.connettori.ricezioneContenutiApplicativi.useDiagnosticInputStream";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi = true;
			}  
		}

		return this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi;
	}
	
	private Boolean isConnettoriUseDiagnosticInputStream_ricezioneBuste = null;
	public boolean isConnettoriUseDiagnosticInputStream_ricezioneBuste() {	
		if(this.isConnettoriUseDiagnosticInputStream_ricezioneBuste==null){
			String pName = "org.openspcoop2.pdd.connettori.ricezioneBuste.useDiagnosticInputStream";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.isConnettoriUseDiagnosticInputStream_ricezioneBuste = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isConnettoriUseDiagnosticInputStream_ricezioneBuste = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isConnettoriUseDiagnosticInputStream_ricezioneBuste = true;
			}  
		}

		return this.isConnettoriUseDiagnosticInputStream_ricezioneBuste;
	}
	
	
	private Boolean isConnettoriUseDiagnosticInputStream_setDateEmptyStream = null;
	public boolean isConnettoriUseDiagnosticInputStream_setDateEmptyStream() {	
		if(this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream==null){
			String pName = "org.openspcoop2.pdd.connettori.useDiagnosticInputStream.setDateEmptyStream";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream = false;
			}  
		}

		return this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream;
	}
	
	
	

	/* ***************** HTTPS  ************* */
	
	private Boolean isConnettoreHttps_useSecureRandom = null;
	public boolean isConnettoreHttps_useSecureRandom() {	
		if(this.isConnettoreHttps_useSecureRandom==null){
			String pName = "org.openspcoop2.pdd.connettori.secureRandom";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.isConnettoreHttps_useSecureRandom = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isConnettoreHttps_useSecureRandom = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isConnettoreHttps_useSecureRandom = false;
			}  
		}

		return this.isConnettoreHttps_useSecureRandom;
	}
	private String getConnettoreHttps_secureRandomAlgo = null;
	private Boolean getConnettoreHttps_secureRandomAlgoRead = null;
	public String getConnettoreHttps_secureRandomAlgo() {	
		if(this.getConnettoreHttps_secureRandomAlgoRead==null){
			String pName = "org.openspcoop2.pdd.connettori.secureRandomAlgorithm";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.getConnettoreHttps_secureRandomAlgo = name;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"', errore:"+e.getMessage(),e);
			}  
			
			this.getConnettoreHttps_secureRandomAlgoRead=true;
		}

		return this.getConnettoreHttps_secureRandomAlgo;
	}
	
	private Boolean isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste = null;
	public boolean isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste() {	
		if(this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.overrideDefaultConfiguration");
				if(name!=null){
					name = name.trim();
					this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.overrideDefaultConfiguration' non impostata, viene utilizzato il default="+true);
					this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.overrideDefaultConfiguration' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
				this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste = true;
			}  
		}

		return this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste;
	}
	
	private Boolean isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi = null;
	public boolean isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi() {	
		if(this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.overrideDefaultConfiguration");
				if(name!=null){
					name = name.trim();
					this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.overrideDefaultConfiguration' non impostata, viene utilizzato il default="+true);
					this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.overrideDefaultConfiguration' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
				this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi = true;
			}  
		}

		return this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi;
	}
	
	private File getConnettoreHttp_urlHttps_repository_inoltroBuste = null;
	public File getConnettoreHttp_urlHttps_repository_inoltroBuste() throws CoreException {	
		if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.repository");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getConnettoreHttp_urlHttps_repository_inoltroBuste = new File(name);
				if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste.exists()) {
					if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste.isDirectory()==false) {
						throw newCoreExceptionNotDir(this.getConnettoreHttp_urlHttps_repository_inoltroBuste,true);
					}
					if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste.canRead()==false) {
						throw newCoreExceptionCannotRead(this.getConnettoreHttp_urlHttps_repository_inoltroBuste,true);
					}
					if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste.canWrite()==false) {
						throw newCoreExceptionCannotWrite(this.getConnettoreHttp_urlHttps_repository_inoltroBuste,true);
					}
				}
				else {
					// viene creata automaticamente
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.repository': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getConnettoreHttp_urlHttps_repository_inoltroBuste;
	}
	
	private File getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi = null;
	public File getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi() throws CoreException {	
		if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.repository");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi = new File(name);
				if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi.exists()) {
					if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi.isDirectory()==false) {
						throw newCoreExceptionNotDir(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi,true);
					}
					if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi.canRead()==false) {
						throw newCoreExceptionCannotRead(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi,true);
					}
					if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi.canWrite()==false) {
						throw newCoreExceptionCannotWrite(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi,true);
					}
				}
				else {
					// viene creata automaticamente
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.repository': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi;
	}
	
	private Boolean isConnettoreHttp_urlHttps_cacheEnabled = null;
	public boolean isConnettoreHttp_urlHttps_cacheEnabled() {	
		if(this.isConnettoreHttp_urlHttps_cacheEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.http.urlHttps.cache.enabled");
				if(name!=null){
					name = name.trim();
					this.isConnettoreHttp_urlHttps_cacheEnabled = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.http.urlHttps.cache.enabled' non impostata, viene utilizzato il default="+true);
					this.isConnettoreHttp_urlHttps_cacheEnabled = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.http.urlHttps.cache.enabled' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
				this.isConnettoreHttp_urlHttps_cacheEnabled = true;
			}  
		}

		return this.isConnettoreHttp_urlHttps_cacheEnabled;
	}
	
	private Integer getConnettoreHttp_urlHttps_cacheSize = null;
	public int getConnettoreHttp_urlHttps_cacheSize() {	
		if(this.getConnettoreHttp_urlHttps_cacheSize==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.http.urlHttps.cache.size");
				if(name!=null){
					name = name.trim();
					this.getConnettoreHttp_urlHttps_cacheSize = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.http.urlHttps.cache.size' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_HTTP_URL_HTTPS_CACHE_SIZE);
					this.getConnettoreHttp_urlHttps_cacheSize = CostantiPdD.CONNETTORE_HTTP_URL_HTTPS_CACHE_SIZE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.http.urlHttps.cache.size' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_HTTP_URL_HTTPS_CACHE_SIZE+", errore:"+e.getMessage(),e);
				this.getConnettoreHttp_urlHttps_cacheSize = CostantiPdD.CONNETTORE_HTTP_URL_HTTPS_CACHE_SIZE;
			}  
		}

		return this.getConnettoreHttp_urlHttps_cacheSize;
	}
	
	
	
	
	/* ***************** Servizi HTTP  ************* */
	
	private Boolean isHttpDisableKeepAlive = null;
	public boolean isHttpDisableKeepAlive() {	
		String pName = "org.openspcoop2.pdd.services.http.disableKeepAlive";
		if(this.isHttpDisableKeepAlive==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.isHttpDisableKeepAlive = Boolean.parseBoolean(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isHttpDisableKeepAlive = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isHttpDisableKeepAlive = false;
			}  
		}

		return this.isHttpDisableKeepAlive;
	}
	
	private Boolean serviceRequestHttpMethodPatchEnabled = null;
	public boolean isServiceRequestHttpMethodPatchEnabled() {	
		if(this.serviceRequestHttpMethodPatchEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.request.method.PATCH");
				if(name!=null){
					name = name.trim();
					this.serviceRequestHttpMethodPatchEnabled = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.PATCH' non impostata, viene utilizzato il default="+true);
					this.serviceRequestHttpMethodPatchEnabled = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.PATCH' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
				this.serviceRequestHttpMethodPatchEnabled = true;
			}  
		}

		return this.serviceRequestHttpMethodPatchEnabled;
	}
	
	private Boolean serviceRequestHttpMethodLinkEnabled = null;
	public boolean isServiceRequestHttpMethodLinkEnabled() {	
		if(this.serviceRequestHttpMethodLinkEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.request.method.LINK");
				if(name!=null){
					name = name.trim();
					this.serviceRequestHttpMethodLinkEnabled = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.LINK' non impostata, viene utilizzato il default="+true);
					this.serviceRequestHttpMethodLinkEnabled = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.LINK' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
				this.serviceRequestHttpMethodLinkEnabled = true;
			}  
		}

		return this.serviceRequestHttpMethodLinkEnabled;
	}
	
	private Boolean serviceRequestHttpMethodUnlinkEnabled = null;
	public boolean isServiceRequestHttpMethodUnlinkEnabled() {	
		if(this.serviceRequestHttpMethodUnlinkEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.request.method.UNLINK");
				if(name!=null){
					name = name.trim();
					this.serviceRequestHttpMethodUnlinkEnabled = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.UNLINK' non impostata, viene utilizzato il default="+true);
					this.serviceRequestHttpMethodUnlinkEnabled = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.UNLINK' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
				this.serviceRequestHttpMethodUnlinkEnabled = true;
			}  
		}

		return this.serviceRequestHttpMethodUnlinkEnabled;
	}
	
	
	private TransferLengthModes readTransferLengthModes_ricezioneContenutiApplicativi = null;
	public TransferLengthModes getTransferLengthModes_ricezioneContenutiApplicativi() {	
		if(this.readTransferLengthModes_ricezioneContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.httpTransferLength");
				if(name!=null){
					name = name.trim();
					this.readTransferLengthModes_ricezioneContenutiApplicativi = TransferLengthModes.getTransferLengthModes(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.WEBSERVER_DEFAULT);
					this.readTransferLengthModes_ricezioneContenutiApplicativi = TransferLengthModes.WEBSERVER_DEFAULT;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.WEBSERVER_DEFAULT+", errore:"+e.getMessage(),e);
				this.readTransferLengthModes_ricezioneContenutiApplicativi = TransferLengthModes.WEBSERVER_DEFAULT;
			}  
		}

		return this.readTransferLengthModes_ricezioneContenutiApplicativi;
	}
	
	private TransferLengthModes readTransferLengthModes_ricezioneBuste = null;
	public TransferLengthModes getTransferLengthModes_ricezioneBuste() {	
		if(this.readTransferLengthModes_ricezioneBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.httpTransferLength");
				if(name!=null){
					name = name.trim();
					this.readTransferLengthModes_ricezioneBuste = TransferLengthModes.getTransferLengthModes(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.WEBSERVER_DEFAULT);
					this.readTransferLengthModes_ricezioneBuste = TransferLengthModes.WEBSERVER_DEFAULT;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.WEBSERVER_DEFAULT+", errore:"+e.getMessage(),e);
				this.readTransferLengthModes_ricezioneBuste = TransferLengthModes.WEBSERVER_DEFAULT;
			}  
		}

		return this.readTransferLengthModes_ricezioneBuste;
	}
	
	private TransferLengthModes readTransferLengthModes_inoltroBuste = null;
	public TransferLengthModes getTransferLengthModes_inoltroBuste() {	
		if(this.readTransferLengthModes_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength");
				if(name!=null){
					name = name.trim();
					this.readTransferLengthModes_inoltroBuste = TransferLengthModes.getTransferLengthModes(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.CONTENT_LENGTH);
					this.readTransferLengthModes_inoltroBuste = TransferLengthModes.CONTENT_LENGTH;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.CONTENT_LENGTH+", errore:"+e.getMessage(),e);
				this.readTransferLengthModes_inoltroBuste = TransferLengthModes.CONTENT_LENGTH;
			}  
		}

		return this.readTransferLengthModes_inoltroBuste;
	}
	
	private Integer getChunkLength_inoltroBuste = null;
	public int getChunkLength_inoltroBuste() {	
		if(this.getChunkLength_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength.chunkLength");
				if(name!=null){
					name = name.trim();
					this.getChunkLength_inoltroBuste = Integer.parseInt(name);
				}else{
					int DEFAULT_CHUNKLEN = 0;
					this.getChunkLength_inoltroBuste = DEFAULT_CHUNKLEN;
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength.chunkLength' posside un valore non corretto:"+e.getMessage(),e);
				this.getChunkLength_inoltroBuste = -1;
			}  
		}

		return this.getChunkLength_inoltroBuste;
	}
	
	private TransferLengthModes readTransferLengthModes_consegnaContenutiApplicativi = null;
	public TransferLengthModes getTransferLengthModes_consegnaContenutiApplicativi() {	
		if(this.readTransferLengthModes_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength");
				if(name!=null){
					name = name.trim();
					this.readTransferLengthModes_consegnaContenutiApplicativi = TransferLengthModes.getTransferLengthModes(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.CONTENT_LENGTH);
					this.readTransferLengthModes_consegnaContenutiApplicativi = TransferLengthModes.CONTENT_LENGTH;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.CONTENT_LENGTH+", errore:"+e.getMessage(),e);
				this.readTransferLengthModes_consegnaContenutiApplicativi = TransferLengthModes.CONTENT_LENGTH;
			}  
		}

		return this.readTransferLengthModes_consegnaContenutiApplicativi;
	}
	
	private Integer getChunkLength_consegnaContenutiApplicativi = null;
	public int getChunkLength_consegnaContenutiApplicativi() {	
		if(this.getChunkLength_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength.chunkLength");
				if(name!=null){
					name = name.trim();
					this.getChunkLength_consegnaContenutiApplicativi = Integer.parseInt(name);
				}else{
					int DEFAULT_CHUNKLEN = 0;
					this.getChunkLength_consegnaContenutiApplicativi = DEFAULT_CHUNKLEN;
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength.chunkLength' posside un valore non corretto:"+e.getMessage(),e);
				this.getChunkLength_consegnaContenutiApplicativi = -1;
			}  
		}

		return this.getChunkLength_consegnaContenutiApplicativi;
	}
	
	private Boolean isAcceptOnlyReturnCode_200_202_inoltroBuste = null;
	public boolean isAcceptOnlyReturnCode_200_202_inoltroBuste() {	
		if(this.isAcceptOnlyReturnCode_200_202_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.2xx.acceptOnly_202_200");
				if(name!=null){
					name = name.trim();
					this.isAcceptOnlyReturnCode_200_202_inoltroBuste = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.2xx.acceptOnly_202_200' non impostata, viene utilizzato il default=true");
					this.isAcceptOnlyReturnCode_200_202_inoltroBuste = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.2xx.acceptOnly_202_200' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isAcceptOnlyReturnCode_200_202_inoltroBuste = true;
			}  
		}

		return this.isAcceptOnlyReturnCode_200_202_inoltroBuste;
	}
	
	private Boolean isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi = null;
	public boolean isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi() {	
		if(this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.2xx.acceptOnly_202_200");
				if(name!=null){
					name = name.trim();
					this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.2xx.acceptOnly_202_200' non impostata, viene utilizzato il default=true");
					this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.2xx.acceptOnly_202_200' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi = true;
			}  
		}

		return this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi;
	}
	
	private Boolean isAcceptOnlyReturnCode_307_inoltroBuste = null;
	public boolean isAcceptOnlyReturnCode_307_inoltroBuste() {	
		if(this.isAcceptOnlyReturnCode_307_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.3xx.acceptOnly_307");
				if(name!=null){
					name = name.trim();
					this.isAcceptOnlyReturnCode_307_inoltroBuste = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.3xx.acceptOnly_307' non impostata, viene utilizzato il default=false");
					this.isAcceptOnlyReturnCode_307_inoltroBuste = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.3xx.acceptOnly_307' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isAcceptOnlyReturnCode_307_inoltroBuste = false;
			}  
		}

		return this.isAcceptOnlyReturnCode_307_inoltroBuste;
	}
	
	private Boolean isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi = null;
	public boolean isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi() {	
		if(this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.3xx.acceptOnly_307");
				if(name!=null){
					name = name.trim();
					this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.3xx.acceptOnly_307' non impostata, viene utilizzato il default=false");
					this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.3xx.acceptOnly_307' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi = false;
			}  
		}

		return this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi;
	}
	
	private Boolean isFollowRedirects_inoltroBuste_soap = null;
	public boolean isFollowRedirects_inoltroBuste_soap() {	
		if(this.isFollowRedirects_inoltroBuste_soap==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.soap");
				if(name!=null){
					name = name.trim();
					this.isFollowRedirects_inoltroBuste_soap = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.soap' non impostata, viene utilizzato il default=false");
					this.isFollowRedirects_inoltroBuste_soap = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.soap' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isFollowRedirects_inoltroBuste_soap = false;
			}  
		}

		return this.isFollowRedirects_inoltroBuste_soap;
	}
	
	private Boolean isFollowRedirects_inoltroBuste_rest = null;
	public boolean isFollowRedirects_inoltroBuste_rest() {	
		if(this.isFollowRedirects_inoltroBuste_rest==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.rest");
				if(name!=null){
					name = name.trim();
					this.isFollowRedirects_inoltroBuste_rest = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.rest' non impostata, viene utilizzato il default=false");
					this.isFollowRedirects_inoltroBuste_rest = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.rest' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isFollowRedirects_inoltroBuste_rest = false;
			}  
		}

		return this.isFollowRedirects_inoltroBuste_rest;
	}
	

	
	private Boolean isFollowRedirects_consegnaContenutiApplicativi_soap = null;
	public boolean isFollowRedirects_consegnaContenutiApplicativi_soap() {	
		if(this.isFollowRedirects_consegnaContenutiApplicativi_soap==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.soap");
				if(name!=null){
					name = name.trim();
					this.isFollowRedirects_consegnaContenutiApplicativi_soap = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.soap' non impostata, viene utilizzato il default=false");
					this.isFollowRedirects_consegnaContenutiApplicativi_soap = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.soap' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isFollowRedirects_consegnaContenutiApplicativi_soap = false;
			}  
		}

		return this.isFollowRedirects_consegnaContenutiApplicativi_soap;
	}
	
	private Boolean isFollowRedirects_consegnaContenutiApplicativi_rest = null;
	public boolean isFollowRedirects_consegnaContenutiApplicativi_rest() {	
		if(this.isFollowRedirects_consegnaContenutiApplicativi_rest==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.rest");
				if(name!=null){
					name = name.trim();
					this.isFollowRedirects_consegnaContenutiApplicativi_rest = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.rest' non impostata, viene utilizzato il default=false");
					this.isFollowRedirects_consegnaContenutiApplicativi_rest = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.rest' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isFollowRedirects_consegnaContenutiApplicativi_rest = false;
			}  
		}

		return this.isFollowRedirects_consegnaContenutiApplicativi_rest;
	}
		
	private Integer getFollowRedirectsMaxHop_inoltroBuste = null;
	public int getFollowRedirectsMaxHop_inoltroBuste() {	
		if(this.getFollowRedirectsMaxHop_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.maxHop");
				if(name!=null){
					name = name.trim();
					this.getFollowRedirectsMaxHop_inoltroBuste = Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.maxHop' non impostata, viene utilizzato il default=5");
					this.getFollowRedirectsMaxHop_inoltroBuste = 5;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.maxHop' non impostata, viene utilizzato il default=5, errore:"+e.getMessage(),e);
				this.getFollowRedirectsMaxHop_inoltroBuste = 5;
			}  
		}

		return this.getFollowRedirectsMaxHop_inoltroBuste;
	}
	
	private Integer getFollowRedirectsMaxHop_consegnaContenutiApplicativi = null;
	public int getFollowRedirectsMaxHop_consegnaContenutiApplicativi() {	
		if(this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.maxHop");
				if(name!=null){
					name = name.trim();
					this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi = Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.maxHop' non impostata, viene utilizzato il default=5");
					this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi = 5;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.maxHop' non impostata, viene utilizzato il default=5, errore:"+e.getMessage(),e);
				this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi = 5;
			}  
		}

		return this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi;
	}

	
	private Boolean checkSoapActionQuotedString_ricezioneContenutiApplicativi = null;
	public boolean checkSoapActionQuotedString_ricezioneContenutiApplicativi() {	
		if(this.checkSoapActionQuotedString_ricezioneContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.soapAction.checkQuotedString");
				if(name!=null){
					name = name.trim();
					this.checkSoapActionQuotedString_ricezioneContenutiApplicativi = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.soapAction.checkQuotedString' non impostata, viene utilizzato il default=false");
					this.checkSoapActionQuotedString_ricezioneContenutiApplicativi = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.soapAction.checkQuotedString' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.checkSoapActionQuotedString_ricezioneContenutiApplicativi = false;
			}  
		}

		return this.checkSoapActionQuotedString_ricezioneContenutiApplicativi;
	}
	
	private Boolean checkSoapActionQuotedString_ricezioneBuste = null;
	public boolean checkSoapActionQuotedString_ricezioneBuste() {	
		if(this.checkSoapActionQuotedString_ricezioneBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.soapAction.checkQuotedString");
				if(name!=null){
					name = name.trim();
					this.checkSoapActionQuotedString_ricezioneBuste = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.soapAction.checkQuotedString' non impostata, viene utilizzato il default=false");
					this.checkSoapActionQuotedString_ricezioneBuste = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.soapAction.checkQuotedString' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.checkSoapActionQuotedString_ricezioneBuste = false;
			}  
		}

		return this.checkSoapActionQuotedString_ricezioneBuste;
	}
	
	private String httpUserAgent = null;
	public String getHttpUserAgent() {	
		if(this.httpUserAgent==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.http.userAgent");
				if(name!=null){
					name = name.trim();
					this.httpUserAgent = name;
				}else{
					//NON EMETTO WARNING: this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.userAgent' non impostata, viene utilizzato il default="+Costanti.OPENSPCOOP_PRODUCT_VERSION);
					this.httpUserAgent = this.getProductName();
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.userAgent' non impostata, viene utilizzato il default="+this.getProductName()+", errore:"+e.getMessage(),e);
				this.httpUserAgent = this.getProductName();
			}  
		}

		return this.httpUserAgent;
	}
	
	private String httpServer = null;
	public String getHttpServer() {	
		if(this.httpServer==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.http.xPdd");
				if(name!=null){
					name = name.trim();
					this.httpServer = name;
				}else{
					//NON EMETTO WARNING: this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.xPdd' non impostata, viene utilizzato il default="+this.getHttpUserAgent());
					this.httpServer = this.getVersione();
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.xPdd' non impostata, viene utilizzato il default="+this.getVersione()+", errore:"+e.getMessage(),e);
				this.httpServer = this.getVersione();
			}  
		}

		return this.httpServer;
	}
	
	private Boolean readHttpXPdDDetails = null;
	private String httpXPdDDetails = null;
	public String getHttpXPdDDetails() {	
		if(this.readHttpXPdDDetails==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.http.xDetails");
				if(name!=null){
					name = name.trim();
					this.httpXPdDDetails = name;
				}else{
					this.httpXPdDDetails = this.getDetails();
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.xDetails' non impostata correttamente:"+e.getMessage(),e);
				this.httpXPdDDetails = this.getDetails();
			}  
		}
		this.readHttpXPdDDetails = true;

		return this.httpXPdDDetails;
	}
	
	
	private Boolean isEnabledEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi = null;
	public boolean isEnabledEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi() {	
		if(this.isEnabledEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.enabled");
				if(name!=null){
					name = name.trim();
					this.isEnabledEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true");
					this.isEnabledEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isEnabledEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi = true;
			}  
		}

		return this.isEnabledEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi;
	}
	
	private Charset getCharsetEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi = null;
	public Charset getCharsetEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi() {	
		if(this.getCharsetEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.charset");
				if(name!=null){
					name = name.trim();
					this.getCharsetEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi = Charset.toEnumConstant(name);
					if(this.getCharsetEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi==null){
						throw new CoreException("Valore fornito non valido: "+name);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name());
					this.getCharsetEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi = Charset.US_ASCII;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name()+", errore:"+e.getMessage(),e);
				this.getCharsetEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi = Charset.US_ASCII;
			}  
		}

		return this.getCharsetEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi;
	}
	
	private RFC2047Encoding getEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi = null;
	public RFC2047Encoding getEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi() {	
		if(this.getEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.encoding");
				if(name!=null){
					name = name.trim();
					this.getEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi = RFC2047Encoding.valueOf(name);
					if(this.getEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi==null){
						throw new CoreException("Valore fornito non valido: "+name);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name());
					this.getEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi = RFC2047Encoding.Q;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name()+", errore:"+e.getMessage(),e);
				this.getEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi = RFC2047Encoding.Q;
			}  
		}

		return this.getEncodingRFC2047HeaderValue_ricezioneContenutiApplicativi;
	}
	
	private Boolean isEnabledEncodingRFC2047HeaderValue_ricezioneBuste = null;
	public boolean isEnabledEncodingRFC2047HeaderValue_ricezioneBuste() {	
		if(this.isEnabledEncodingRFC2047HeaderValue_ricezioneBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.enabled");
				if(name!=null){
					name = name.trim();
					this.isEnabledEncodingRFC2047HeaderValue_ricezioneBuste = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true");
					this.isEnabledEncodingRFC2047HeaderValue_ricezioneBuste = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isEnabledEncodingRFC2047HeaderValue_ricezioneBuste = true;
			}  
		}

		return this.isEnabledEncodingRFC2047HeaderValue_ricezioneBuste;
	}
	
	private Charset getCharsetEncodingRFC2047HeaderValue_ricezioneBuste = null;
	public Charset getCharsetEncodingRFC2047HeaderValue_ricezioneBuste() {	
		if(this.getCharsetEncodingRFC2047HeaderValue_ricezioneBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.charset");
				if(name!=null){
					name = name.trim();
					this.getCharsetEncodingRFC2047HeaderValue_ricezioneBuste = Charset.toEnumConstant(name);
					if(this.getCharsetEncodingRFC2047HeaderValue_ricezioneBuste==null){
						throw new CoreException("Valore fornito non valido: "+name);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name());
					this.getCharsetEncodingRFC2047HeaderValue_ricezioneBuste = Charset.US_ASCII;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name()+", errore:"+e.getMessage(),e);
				this.getCharsetEncodingRFC2047HeaderValue_ricezioneBuste = Charset.US_ASCII;
			}  
		}

		return this.getCharsetEncodingRFC2047HeaderValue_ricezioneBuste;
	}
	
	private RFC2047Encoding getEncodingRFC2047HeaderValue_ricezioneBuste = null;
	public RFC2047Encoding getEncodingRFC2047HeaderValue_ricezioneBuste() {	
		if(this.getEncodingRFC2047HeaderValue_ricezioneBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.encoding");
				if(name!=null){
					name = name.trim();
					this.getEncodingRFC2047HeaderValue_ricezioneBuste = RFC2047Encoding.valueOf(name);
					if(this.getEncodingRFC2047HeaderValue_ricezioneBuste==null){
						throw new CoreException("Valore fornito non valido: "+name);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name());
					this.getEncodingRFC2047HeaderValue_ricezioneBuste = RFC2047Encoding.Q;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name()+", errore:"+e.getMessage(),e);
				this.getEncodingRFC2047HeaderValue_ricezioneBuste = RFC2047Encoding.Q;
			}  
		}

		return this.getEncodingRFC2047HeaderValue_ricezioneBuste;
	}
	
	private Boolean isEnabledEncodingRFC2047HeaderValue_inoltroBuste = null;
	public boolean isEnabledEncodingRFC2047HeaderValue_inoltroBuste() {	
		if(this.isEnabledEncodingRFC2047HeaderValue_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.enabled");
				if(name!=null){
					name = name.trim();
					this.isEnabledEncodingRFC2047HeaderValue_inoltroBuste = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true");
					this.isEnabledEncodingRFC2047HeaderValue_inoltroBuste = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isEnabledEncodingRFC2047HeaderValue_inoltroBuste = true;
			}  
		}

		return this.isEnabledEncodingRFC2047HeaderValue_inoltroBuste;
	}
	
	private Charset getCharsetEncodingRFC2047HeaderValue_inoltroBuste = null;
	public Charset getCharsetEncodingRFC2047HeaderValue_inoltroBuste() {	
		if(this.getCharsetEncodingRFC2047HeaderValue_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.charset");
				if(name!=null){
					name = name.trim();
					this.getCharsetEncodingRFC2047HeaderValue_inoltroBuste = Charset.toEnumConstant(name);
					if(this.getCharsetEncodingRFC2047HeaderValue_inoltroBuste==null){
						throw new CoreException("Valore fornito non valido: "+name);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name());
					this.getCharsetEncodingRFC2047HeaderValue_inoltroBuste = Charset.US_ASCII;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name()+", errore:"+e.getMessage(),e);
				this.getCharsetEncodingRFC2047HeaderValue_inoltroBuste = Charset.US_ASCII;
			}  
		}

		return this.getCharsetEncodingRFC2047HeaderValue_inoltroBuste;
	}
	
	private RFC2047Encoding getEncodingRFC2047HeaderValue_inoltroBuste = null;
	public RFC2047Encoding getEncodingRFC2047HeaderValue_inoltroBuste() {	
		if(this.getEncodingRFC2047HeaderValue_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.encoding");
				if(name!=null){
					name = name.trim();
					this.getEncodingRFC2047HeaderValue_inoltroBuste = RFC2047Encoding.valueOf(name);
					if(this.getEncodingRFC2047HeaderValue_inoltroBuste==null){
						throw new CoreException("Valore fornito non valido: "+name);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name());
					this.getEncodingRFC2047HeaderValue_inoltroBuste = RFC2047Encoding.Q;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name()+", errore:"+e.getMessage(),e);
				this.getEncodingRFC2047HeaderValue_inoltroBuste = RFC2047Encoding.Q;
			}  
		}

		return this.getEncodingRFC2047HeaderValue_inoltroBuste;
	}
	
	private Boolean isEnabledEncodingRFC2047HeaderValue_consegnaContenutiApplicativi = null;
	public boolean isEnabledEncodingRFC2047HeaderValue_consegnaContenutiApplicativi() {	
		if(this.isEnabledEncodingRFC2047HeaderValue_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.enabled");
				if(name!=null){
					name = name.trim();
					this.isEnabledEncodingRFC2047HeaderValue_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true");
					this.isEnabledEncodingRFC2047HeaderValue_consegnaContenutiApplicativi = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isEnabledEncodingRFC2047HeaderValue_consegnaContenutiApplicativi = true;
			}  
		}

		return this.isEnabledEncodingRFC2047HeaderValue_consegnaContenutiApplicativi;
	}
	
	private Charset getCharsetEncodingRFC2047HeaderValue_consegnaContenutiApplicativi = null;
	public Charset getCharsetEncodingRFC2047HeaderValue_consegnaContenutiApplicativi() {	
		if(this.getCharsetEncodingRFC2047HeaderValue_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.charset");
				if(name!=null){
					name = name.trim();
					this.getCharsetEncodingRFC2047HeaderValue_consegnaContenutiApplicativi = Charset.toEnumConstant(name);
					if(this.getCharsetEncodingRFC2047HeaderValue_consegnaContenutiApplicativi==null){
						throw new CoreException("Valore fornito non valido: "+name);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name());
					this.getCharsetEncodingRFC2047HeaderValue_consegnaContenutiApplicativi = Charset.US_ASCII;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name()+", errore:"+e.getMessage(),e);
				this.getCharsetEncodingRFC2047HeaderValue_consegnaContenutiApplicativi = Charset.US_ASCII;
			}  
		}

		return this.getCharsetEncodingRFC2047HeaderValue_consegnaContenutiApplicativi;
	}
	
	private RFC2047Encoding getEncodingRFC2047HeaderValue_consegnaContenutiApplicativi = null;
	public RFC2047Encoding getEncodingRFC2047HeaderValue_consegnaContenutiApplicativi() {	
		if(this.getEncodingRFC2047HeaderValue_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.encoding");
				if(name!=null){
					name = name.trim();
					this.getEncodingRFC2047HeaderValue_consegnaContenutiApplicativi = RFC2047Encoding.valueOf(name);
					if(this.getEncodingRFC2047HeaderValue_consegnaContenutiApplicativi==null){
						throw new CoreException("Valore fornito non valido: "+name);
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name());
					this.getEncodingRFC2047HeaderValue_consegnaContenutiApplicativi = RFC2047Encoding.Q;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name()+", errore:"+e.getMessage(),e);
				this.getEncodingRFC2047HeaderValue_consegnaContenutiApplicativi = RFC2047Encoding.Q;
			}  
		}

		return this.getEncodingRFC2047HeaderValue_consegnaContenutiApplicativi;
	}
	

	private Boolean isEnabledValidazioneRFC2047HeaderNameValue_ricezioneContenutiApplicativi = null;
	public boolean isEnabledValidazioneRFC2047HeaderNameValue_ricezioneContenutiApplicativi() {	
		if(this.isEnabledValidazioneRFC2047HeaderNameValue_ricezioneContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerNameValue.validazione.enabled");
				if(name!=null){
					name = name.trim();
					this.isEnabledValidazioneRFC2047HeaderNameValue_ricezioneContenutiApplicativi = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true");
					this.isEnabledValidazioneRFC2047HeaderNameValue_ricezioneContenutiApplicativi = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isEnabledValidazioneRFC2047HeaderNameValue_ricezioneContenutiApplicativi = true;
			}  
		}

		return this.isEnabledValidazioneRFC2047HeaderNameValue_ricezioneContenutiApplicativi;
	}
	
	private Boolean isEnabledValidazioneRFC2047HeaderNameValue_ricezioneBuste = null;
	public boolean isEnabledValidazioneRFC2047HeaderNameValue_ricezioneBuste() {	
		if(this.isEnabledValidazioneRFC2047HeaderNameValue_ricezioneBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.headerNameValue.validazione.enabled");
				if(name!=null){
					name = name.trim();
					this.isEnabledValidazioneRFC2047HeaderNameValue_ricezioneBuste = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true");
					this.isEnabledValidazioneRFC2047HeaderNameValue_ricezioneBuste = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isEnabledValidazioneRFC2047HeaderNameValue_ricezioneBuste = true;
			}  
		}

		return this.isEnabledValidazioneRFC2047HeaderNameValue_ricezioneBuste;
	}
	
	private Boolean isEnabledValidazioneRFC2047HeaderNameValue_inoltroBuste = null;
	public boolean isEnabledValidazioneRFC2047HeaderNameValue_inoltroBuste() {	
		if(this.isEnabledValidazioneRFC2047HeaderNameValue_inoltroBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.headerNameValue.validazione.enabled");
				if(name!=null){
					name = name.trim();
					this.isEnabledValidazioneRFC2047HeaderNameValue_inoltroBuste = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true");
					this.isEnabledValidazioneRFC2047HeaderNameValue_inoltroBuste = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isEnabledValidazioneRFC2047HeaderNameValue_inoltroBuste = true;
			}  
		}

		return this.isEnabledValidazioneRFC2047HeaderNameValue_inoltroBuste;
	}
	
	private Boolean isEnabledValidazioneRFC2047HeaderNameValue_consegnaContenutiApplicativi = null;
	public boolean isEnabledValidazioneRFC2047HeaderNameValue_consegnaContenutiApplicativi() {	
		if(this.isEnabledValidazioneRFC2047HeaderNameValue_consegnaContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerNameValue.validazione.enabled");
				if(name!=null){
					name = name.trim();
					this.isEnabledValidazioneRFC2047HeaderNameValue_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true");
					this.isEnabledValidazioneRFC2047HeaderNameValue_consegnaContenutiApplicativi = true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isEnabledValidazioneRFC2047HeaderNameValue_consegnaContenutiApplicativi = true;
			}  
		}

		return this.isEnabledValidazioneRFC2047HeaderNameValue_consegnaContenutiApplicativi;
	}
	
	private Integer getGestioneCORS_returnCode_ricezioneContenutiApplicativi = null;
	public int getGestioneCORS_returnCode_ricezioneContenutiApplicativi() {	
		if(this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.cors.returnCode");
				if(name!=null){
					name = name.trim();
					this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.cors.returnCode' non impostata, viene utilizzato il default="+CostantiPdD.GESTIONE_CORS_RETURN_CODE);
					this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi = CostantiPdD.GESTIONE_CORS_RETURN_CODE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.cors.returnCode' non impostata, viene utilizzato il default="+CostantiPdD.GESTIONE_CORS_RETURN_CODE+", errore:"+e.getMessage(),e);
				this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi = CostantiPdD.GESTIONE_CORS_RETURN_CODE;
			}    
		}

		return this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi;
	}
	
	private Boolean isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi = null;
	public boolean isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi() {	
		if(this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi==null){
			String pName = "org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.cors.resourceHttpMethodQualsiasi";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi = java.lang.Boolean.valueOf(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi = false;
			}    
		}

		return this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi;
	}
	
	private Integer getGestioneCORS_returnCode_ricezioneBuste = null;
	public int getGestioneCORS_returnCode_ricezioneBuste() {	
		if(this.getGestioneCORS_returnCode_ricezioneBuste==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.cors.returnCode");
				if(name!=null){
					name = name.trim();
					this.getGestioneCORS_returnCode_ricezioneBuste = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.cors.returnCode' non impostata, viene utilizzato il default="+CostantiPdD.GESTIONE_CORS_RETURN_CODE);
					this.getGestioneCORS_returnCode_ricezioneBuste = CostantiPdD.GESTIONE_CORS_RETURN_CODE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.cors.returnCode' non impostata, viene utilizzato il default="+CostantiPdD.GESTIONE_CORS_RETURN_CODE+", errore:"+e.getMessage(),e);
				this.getGestioneCORS_returnCode_ricezioneBuste = CostantiPdD.GESTIONE_CORS_RETURN_CODE;
			}    
		}

		return this.getGestioneCORS_returnCode_ricezioneBuste;
	}
	
	private Boolean isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste = null;
	public boolean isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste() {	
		if(this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste==null){
			String pName = "org.openspcoop2.pdd.services.ricezioneBuste.cors.resourceHttpMethodQualsiasi";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste = java.lang.Boolean.valueOf(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste = false;
			}    
		}

		return this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste;
	}
	
	
	private ArchiveType getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType = null;
	public ArchiveType getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType() {	
		if(this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType==null){
			String pName = "org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.notificaRichiestaRisposta.archiveType";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType = ArchiveType.valueOf(name.toUpperCase());
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,ArchiveType.ZIP.toString()));
					this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType = ArchiveType.ZIP;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ArchiveType.ZIP.toString()),e);
				this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType = ArchiveType.ZIP;
			}    
		}

		return this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType;
	}
	


	/* ***************** DATE ************* */
	/**
	 * Restituisce il tipo di tempo da utilizzare
	 *
	 * @return il tipo di tempo da utilizzare
	 * 
	 */
	private TipoOraRegistrazione tipoTempo = null;
	public TipoOraRegistrazione getTipoTempoBusta(String implementazionePdDSoggetto) {
		
		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getBusta_TempoTipo(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TEMPO_TIPO_LOCALE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.TEMPO_TIPO_SINCRONIZZATO.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TEMPO_TIPO_LOCALE.equalsIgnoreCase(tipo))
					return TipoOraRegistrazione.LOCALE;
				else 
					return TipoOraRegistrazione.SINCRONIZZATO;
			}
		}

		if(this.tipoTempo==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.tempo.tipo");
				if(name!=null){
					name = name.trim();
					if(CostantiConfigurazione.TEMPO_TIPO_LOCALE.equals(name))
						this.tipoTempo = TipoOraRegistrazione.LOCALE;
					else if(CostantiConfigurazione.TEMPO_TIPO_SINCRONIZZATO.equals(name))
						this.tipoTempo = TipoOraRegistrazione.SINCRONIZZATO;
					else
						throw new CoreException("Tipo "+name+" non conosciuto");
				}
				else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.tempo.tipo' non impostata, viene utilizzato il default="+CostantiConfigurazione.TEMPO_TIPO_LOCALE);
					this.tipoTempo = TipoOraRegistrazione.LOCALE;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.tempo.tipo' non impostata, viene utilizzato il default="+CostantiConfigurazione.TEMPO_TIPO_LOCALE+", errore:"+e.getMessage(),e);
				this.tipoTempo = TipoOraRegistrazione.LOCALE;
			}    
		}

		return this.tipoTempo;
	}

	/**
	 * Restituisce il tipo di Date da utilizzare
	 *
	 * @return il tipo di Date da utilizzare
	 * 
	 */
	private String tipoDateManager = null;
	public String getTipoDateManager() {	
		if(this.tipoDateManager==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.date.tipo");
				if(name!=null)
					name = name.trim();
				else
					throw new CoreException(NON_DEFINITA);
				this.tipoDateManager = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.date.tipo': "+e.getMessage(),e);
				this.tipoDateManager = null;
			}    
		}

		return this.tipoDateManager;
	}
	
	private DateEngineType tipoDateTimeFormat = null;
	public DateEngineType getTipoDateTimeFormat() {	
		if(this.tipoDateTimeFormat==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dateTimeFormat");
				if(name!=null)
					name = name.trim();
				else
					throw new CoreException(NON_DEFINITA);
				this.tipoDateTimeFormat = DateEngineType.valueOf(name);
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.dateTimeFormat': "+e.getMessage(),e);
				this.tipoDateTimeFormat = null;
			}    
		}

		return this.tipoDateTimeFormat;
	}

	/**
	 * Restituisce le proprieta' da utilizzare sul tipo di Date da utilizzare
	 *
	 * @return proprieta' da utilizzare sul tipo di Date da utilizzare
	 * 
	 */
	private java.util.Properties dateManagerProperties = null;
	public java.util.Properties getDateManagerProperties() {
		if(this.dateManagerProperties==null){
			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.date.property.");
				this.dateManagerProperties = prop;

			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle propriete' 'org.openspcoop2.pdd.date.property.*': "+e.getMessage(),e);
				this.dateManagerProperties = null;
			}    
		}

		return this.dateManagerProperties;
	}








	/* ************** INTEGRATION MANAGER ****************** */

	private Boolean isIntegrationManagerEnabled = null;
	public boolean isIntegrationManagerEnabled() {	
		if(this.isIntegrationManagerEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrationManager.enabled' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isIntegrationManagerEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrationManager.enabled': "+e.getMessage(),e);
				this.isIntegrationManagerEnabled = false;
			}    
		}

		return this.isIntegrationManagerEnabled;
	}
	
	private Boolean isIntegrationManagerIdWithDate = null;
	public boolean isIntegrationManagerIdWithDate() {	
		if(this.isIntegrationManagerIdWithDate==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.idWithDate");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrationManager.idWithDate' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isIntegrationManagerIdWithDate = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrationManager.idWithDate': "+e.getMessage(),e);
				this.isIntegrationManagerIdWithDate = false;
			}    
		}

		return this.isIntegrationManagerIdWithDate;
	}
	
	private Integer getIntegrationManagerIdsLimit = null;
	private Boolean getIntegrationManagerIdsLimit_read = null;
	public Integer getIntegrationManagerIdsLimit() {	
		String pName = "org.openspcoop2.pdd.integrationManager.ids.limit";
		if(this.getIntegrationManagerIdsLimit_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.getIntegrationManagerIdsLimit = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.getIntegrationManagerIdsLimit = null;
			}   
			this.getIntegrationManagerIdsLimit_read = true;
		}

		return this.getIntegrationManagerIdsLimit;
	}
	
	private Boolean integrationManager_isNomePortaDelegataUrlBasedValue = null;
	public boolean integrationManager_isNomePortaDelegataUrlBased() {
		if(this.integrationManager_isNomePortaDelegataUrlBasedValue==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.service.IntegrationManager.nomePortaDelegataUrlBased"); 

				if(value!=null){
					value = value.trim();
					this.integrationManager_isNomePortaDelegataUrlBasedValue = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.service.IntegrationManager.nomePortaDelegataUrlBased' non impostata, viene utilizzato il default=false");
					this.integrationManager_isNomePortaDelegataUrlBasedValue = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.service.IntegrationManager.nomePortaDelegataUrlBased' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.integrationManager_isNomePortaDelegataUrlBasedValue = false;
			}
		}

		return this.integrationManager_isNomePortaDelegataUrlBasedValue;
	}

	private Boolean integrationManager_readInformazioniTrasportoValue = null;
	public boolean integrationManager_readInformazioniTrasporto() {
		if(this.integrationManager_readInformazioniTrasportoValue==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.service.IntegrationManager.infoTrasporto"); 

				if(value!=null){
					value = value.trim();
					this.integrationManager_readInformazioniTrasportoValue = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.service.IntegrationManager.infoTrasporto' non impostata, viene utilizzato il default=false");
					this.integrationManager_readInformazioniTrasportoValue = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.service.IntegrationManager.infoTrasporto' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.integrationManager_readInformazioniTrasportoValue = false;
			}
		}

		return this.integrationManager_readInformazioniTrasportoValue;
	}



	// *** Consegne, gestione runtime ***
	
	private Boolean isIntegrationManager_runtime_useRuntimeManager = null;
	public boolean isIntegrationManager_runtime_useRuntimeManager() {	
		if(this.isIntegrationManager_runtime_useRuntimeManager==null){
			String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.useRuntimeManager";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isIntegrationManager_runtime_useRuntimeManager = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isIntegrationManager_runtime_useRuntimeManager = true;
			}    
		}

		return this.isIntegrationManager_runtime_useRuntimeManager;
	}
	
	private Boolean isIntegrationManager_runtime_useConsegnePreseInCaricoManager = null;
	public boolean isIntegrationManager_runtime_useConsegnePreseInCaricoManager() {	
		if(this.isIntegrationManager_runtime_useConsegnePreseInCaricoManager==null){
			String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.useConsegnePreseInCaricoManager";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isIntegrationManager_runtime_useConsegnePreseInCaricoManager = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isIntegrationManager_runtime_useConsegnePreseInCaricoManager = true;
			}    
		}

		return this.isIntegrationManager_runtime_useConsegnePreseInCaricoManager;
	}
	
	private String getIntegrationManager_runtime_dataSource = null;
	public String getIntegrationManager_runtime_dataSource() throws CoreException {	
		if(this.getIntegrationManager_runtime_dataSource==null){
			String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.dataSource";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getIntegrationManager_runtime_dataSource = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getIntegrationManager_runtime_dataSource;
	}
	
	private Properties getIntegrationManager_runtime_dataSourceJndiContext = null;
	public Properties getIntegrationManager_runtime_dataSourceJndiContext() throws CoreException {	
		if(this.getIntegrationManager_runtime_dataSourceJndiContext==null){
			String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.dataSource.property.";
			try{ 
				this.getIntegrationManager_runtime_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getIntegrationManager_runtime_dataSourceJndiContext;
	}
	
	private Boolean isIntegrationManager_runtime_dataSource_useDBUtils = null;
	public boolean isIntegrationManager_runtime_dataSource_useDBUtils() {	
		if(this.isIntegrationManager_runtime_dataSource_useDBUtils==null){
			String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.datasource.useDSUtils";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isIntegrationManager_runtime_dataSource_useDBUtils = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isIntegrationManager_runtime_dataSource_useDBUtils = true;
			}    
		}

		return this.isIntegrationManager_runtime_dataSource_useDBUtils;
	}
	
	
	// *** Consegne, gestione tracce ***
	
	private Boolean isIntegrationManager_transazioni_useTransactionManager = null;
	public boolean isIntegrationManager_transazioni_useTransactionManager() {	
		if(this.isIntegrationManager_transazioni_useTransactionManager==null){
			String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.useTransactionManager";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isIntegrationManager_transazioni_useTransactionManager = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isIntegrationManager_transazioni_useTransactionManager = true;
			}    
		}

		return this.isIntegrationManager_transazioni_useTransactionManager;
	}
	
	private Boolean isIntegrationManager_transazioni_useConsegnePreseInCaricoManager = null;
	public boolean isIntegrationManager_transazioni_useConsegnePreseInCaricoManager() {	
		if(this.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager==null){
			String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.useConsegnePreseInCaricoManager";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager = true;
			}    
		}

		return this.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager;
	}
	
	private String getIntegrationManager_transazioni_dataSource = null;
	public String getIntegrationManager_transazioni_dataSource() throws CoreException {	
		if(this.getIntegrationManager_transazioni_dataSource==null){
			String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.dataSource";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getIntegrationManager_transazioni_dataSource = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getIntegrationManager_transazioni_dataSource;
	}
	
	private Properties getIntegrationManager_transazioni_dataSourceJndiContext = null;
	public Properties getIntegrationManager_transazioni_dataSourceJndiContext() throws CoreException {	
		if(this.getIntegrationManager_transazioni_dataSourceJndiContext==null){
			String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.dataSource.property.";
			try{ 
				this.getIntegrationManager_transazioni_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getIntegrationManager_transazioni_dataSourceJndiContext;
	}
	
	private Boolean isIntegrationManager_transazioni_dataSource_useDBUtils = null;
	public boolean isIntegrationManager_transazioni_dataSource_useDBUtils() {	
		if(this.isIntegrationManager_transazioni_dataSource_useDBUtils==null){
			String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.datasource.useDSUtils";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isIntegrationManager_transazioni_dataSource_useDBUtils = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isIntegrationManager_transazioni_dataSource_useDBUtils = true;
			}    
		}

		return this.isIntegrationManager_transazioni_dataSource_useDBUtils;
	}
	







	/* ************** GESTIONE ATTACHMENTS *************** */
	/**
	 * Restituisce l'indicazione se cancellare l'istruzione <?xml
	 *
	 * @return Restituisce Restituisce l'indicazione se cancellare l'istruzione <?xml
	 * 
	 */
	private Boolean isDeleteInstructionTargetMachineXml= null;
	public boolean isDeleteInstructionTargetMachineXml(){
		if(this.isDeleteInstructionTargetMachineXml==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.deleteInstructionTargetMachineXml"); 

				if(value!=null){
					value = value.trim();
					this.isDeleteInstructionTargetMachineXml = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.deleteInstructionTargetMachineXml' non impostata, viene utilizzato il default=false");
					this.isDeleteInstructionTargetMachineXml = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.deleteInstructionTargetMachineXml' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isDeleteInstructionTargetMachineXml = false;
			}
		}

		return this.isDeleteInstructionTargetMachineXml;
	}

	private Boolean tunnelSOAP_loadMailcap = null;
	public boolean isTunnelSOAP_loadMailcap() {	
		if(this.tunnelSOAP_loadMailcap==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.mailcap.load");
				if(name!=null){
					name = name.trim();
					this.tunnelSOAP_loadMailcap = Boolean.parseBoolean(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mailcap.load' non impostata, viene utilizzato il default="+false);
					this.tunnelSOAP_loadMailcap = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mailcap.load' non impostata, viene utilizzato il default="+false+", errore:"+e.getMessage(),e);
				this.tunnelSOAP_loadMailcap = false;
			}    
		}

		return this.tunnelSOAP_loadMailcap;
	}
	
	/**
	 * Restituisce il tipo di Date da utilizzare
	 *
	 * @return il tipo di Date da utilizzare
	 * 
	 */
	private String tunnelSOAPKeyWord_headerTrasporto = null;
	public String getTunnelSOAPKeyWord_headerTrasporto() {	
		if(this.tunnelSOAPKeyWord_headerTrasporto==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.trasporto");
				if(name!=null){
					name = name.trim();
					this.tunnelSOAPKeyWord_headerTrasporto = name;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.trasporto' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_ATTACHMENT);
					this.tunnelSOAPKeyWord_headerTrasporto = CostantiPdD.IMBUSTAMENTO_ATTACHMENT;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.trasporto' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_ATTACHMENT+", errore:"+e.getMessage(),e);
				this.tunnelSOAPKeyWord_headerTrasporto = CostantiPdD.IMBUSTAMENTO_ATTACHMENT;
			}    
		}

		return this.tunnelSOAPKeyWord_headerTrasporto;
	}

	/**
	 * Restituisce il tipo di Date da utilizzare
	 *
	 * @return il tipo di Date da utilizzare
	 * 
	 */
	private String tunnelSOAPKeyWordMimeType_headerTrasporto = null;
	public String getTunnelSOAPKeyWordMimeType_headerTrasporto() {	
		if(this.tunnelSOAPKeyWordMimeType_headerTrasporto==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.trasporto");
				if(name!=null){
					name = name.trim();
					this.tunnelSOAPKeyWordMimeType_headerTrasporto = name;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.trasporto' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_MIME_TYPE);
					this.tunnelSOAPKeyWordMimeType_headerTrasporto = CostantiPdD.IMBUSTAMENTO_MIME_TYPE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.trasporto' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_MIME_TYPE+", errore:"+e.getMessage(),e);
				this.tunnelSOAPKeyWordMimeType_headerTrasporto = CostantiPdD.IMBUSTAMENTO_MIME_TYPE;
			}    
		}

		return this.tunnelSOAPKeyWordMimeType_headerTrasporto;
	}

	/**
	 * Restituisce il tipo di Date da utilizzare
	 *
	 * @return il tipo di Date da utilizzare
	 * 
	 */
	private String tunnelSOAPKeyWord_urlBased = null;
	public String getTunnelSOAPKeyWord_urlBased() {	
		if(this.tunnelSOAPKeyWord_urlBased==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.urlBased");
				if(name!=null){
					name = name.trim();
					this.tunnelSOAPKeyWord_urlBased = name;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.urlBased' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_ATTACHMENT);
					this.tunnelSOAPKeyWord_urlBased = CostantiPdD.IMBUSTAMENTO_ATTACHMENT;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.urlBased' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_ATTACHMENT+", errore:"+e.getMessage(),e);
				this.tunnelSOAPKeyWord_urlBased = CostantiPdD.IMBUSTAMENTO_ATTACHMENT;
			}    
		}

		return this.tunnelSOAPKeyWord_urlBased;
	}

	/**
	 * Restituisce il tipo di Date da utilizzare
	 *
	 * @return il tipo di Date da utilizzare
	 * 
	 */
	private String tunnelSOAPKeyWordMimeType_urlBased = null;
	public String getTunnelSOAPKeyWordMimeType_urlBased() {	
		if(this.tunnelSOAPKeyWordMimeType_urlBased==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.urlBased");
				if(name!=null){
					name = name.trim();
					this.tunnelSOAPKeyWordMimeType_urlBased = name;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.urlBased' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_MIME_TYPE);
					this.tunnelSOAPKeyWordMimeType_urlBased = CostantiPdD.IMBUSTAMENTO_MIME_TYPE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.urlBased' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_MIME_TYPE+", errore:"+e.getMessage(),e);
				this.tunnelSOAPKeyWordMimeType_urlBased = CostantiPdD.IMBUSTAMENTO_MIME_TYPE;
			}    
		}

		return this.tunnelSOAPKeyWordMimeType_urlBased;
	}
	



	/* ***************** ASINCRONI ************/
	/**
	 * Restituisce il Timeout di attesa di una busta di richiesta/ricevutaRichiesta asincrona non completamente processata 
	 *
	 * @return Restituisce il Timeout di attesa di una busta
	 * 
	 */
	private Long timeoutBustaRispostaAsincrona = null;
	public long getTimeoutBustaRispostaAsincrona() {	
		if(this.timeoutBustaRispostaAsincrona == null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.attesaAttiva");
				if(name!=null){
					name = name.trim();
					this.timeoutBustaRispostaAsincrona = java.lang.Long.parseLong(name) * 1000;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.attesaAttiva' non impostata, viene utilizzato il default="+(CostantiPdD.RISPOSTA_ASINCRONA_ATTESA_ATTIVA/1000));
					this.timeoutBustaRispostaAsincrona = CostantiPdD.RISPOSTA_ASINCRONA_ATTESA_ATTIVA;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.attesaAttiva' non impostata" +
						", viene utilizzato il default="+(CostantiPdD.RISPOSTA_ASINCRONA_ATTESA_ATTIVA/1000)+", errore:"+e.getMessage(),e);
				this.timeoutBustaRispostaAsincrona = CostantiPdD.RISPOSTA_ASINCRONA_ATTESA_ATTIVA;
			}    
		}

		return this.timeoutBustaRispostaAsincrona;
	} 
	/**
	 * Restituisce la Frequenza di check di attesa di una busta di richiesta/ricevutaRichiesta asincrona non completamente processata 
	 *
	 * @return Restituisce la Frequenza di check di attesa di una busta di richiesta/ricevutaRichiesta asincrona non completamente processata 
	 * 
	 */
	private Integer checkIntervalBustaRispostaAsincrona = null;
	public int getCheckIntervalBustaRispostaAsincrona() {	
		if(this.checkIntervalBustaRispostaAsincrona==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.check");
				if(name!=null){
					name = name.trim();
					this.checkIntervalBustaRispostaAsincrona = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.check' non impostata, viene utilizzato il default="+CostantiPdD.RISPOSTA_ASINCRONA_CHECK_INTERVAL);
					this.checkIntervalBustaRispostaAsincrona = CostantiPdD.RISPOSTA_ASINCRONA_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.check' non impostata, viene utilizzato il default="+CostantiPdD.RISPOSTA_ASINCRONA_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.checkIntervalBustaRispostaAsincrona = CostantiPdD.RISPOSTA_ASINCRONA_CHECK_INTERVAL;
			}    
		}

		return this.checkIntervalBustaRispostaAsincrona;
	}




	/*---------- Cluster ID -------------*/

	private Boolean isClusterDinamico = null;
	public boolean isClusterDinamico(){
		String pName = "org.openspcoop2.pdd.cluster_dinamico.enabled";
		if(this.isClusterDinamico==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isClusterDinamico = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isClusterDinamico = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isClusterDinamico = false;
			}
		}
		return this.isClusterDinamico;
	}
	
	private Integer getClusterDinamicoRefreshSecondsInterval = null;
	public int getClusterDinamicoRefreshSecondsInterval() {	
		String pName = "org.openspcoop2.pdd.cluster_dinamico.refresh";
		if(this.getClusterDinamicoRefreshSecondsInterval==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.getClusterDinamicoRefreshSecondsInterval = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.CLUSTER_DINAMICO_REFRESH_SECONDS));
					this.getClusterDinamicoRefreshSecondsInterval = CostantiPdD.CLUSTER_DINAMICO_REFRESH_SECONDS;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.CLUSTER_DINAMICO_REFRESH_SECONDS),e);
				this.getClusterDinamicoRefreshSecondsInterval = CostantiPdD.CLUSTER_DINAMICO_REFRESH_SECONDS;
			}  
		}

		return this.getClusterDinamicoRefreshSecondsInterval;
	}
	
	private String cluster_hostname = null;
	public String getClusterHostname() {
		if(this.cluster_hostname==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cluster_id.hostname");
				if(name==null) {
					this.cluster_hostname = getClusterId(true);
				}
				else{
					name = name.trim();
					this.cluster_hostname = name;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.cluster_id.hostname': "+e.getMessage(),e);
				this.cluster_hostname = null;
			}  
		}

		return this.cluster_hostname;
	}
		
	private String group_id = null;
	public String getGroupId(boolean rateLimitingGestioneCluster) {
		String pName = "org.openspcoop2.pdd.group_id";
		if(this.group_id==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null) {
					// Gestione RateLimiting senza una effettiva attivazione di un cluster dinamico
					if(!isClusterDinamico()) {
						if(rateLimitingGestioneCluster) {
							this.group_id = org.openspcoop2.utils.Costanti.OPENSPCOOP2;
						}
						else {
							throw new CoreException(NON_DEFINITA);
						}
					}
					else {
						throw new CoreException(NON_DEFINITA);
					}
				}
				else if(name!=null){
					name = name.trim();
					this.group_id = name;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.group_id = null;
			}  
		}

		return this.group_id;
	}
	
	/**
	 * Restituisce il cluster id del nodo del cluster su cui gira la pdd 
	 *
	 * @return Il cluster id di questo nodo
	 * @added Fabio Tronci (tronci@link.it) 06/06/08 
	 */
	private String cluster_id = null;
	public String getClusterId(boolean required) {
		if(this.cluster_id==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cluster_id");
				if(name==null && required)
					throw new CoreException(NON_DEFINITA);
				if(name!=null){
					name = name.trim();
					this.cluster_id = name;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.cluster_id': "+e.getMessage(),e);
				this.cluster_id = null;
			}  
		}

		return this.cluster_id;
	}
	
	private Boolean isUseHashClusterId = null;
	public boolean isUseHashClusterId(){
		String pName = "org.openspcoop2.pdd.cluster_id.hash.enabled";
		if(this.isUseHashClusterId==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isUseHashClusterId = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isUseHashClusterId = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isUseHashClusterId = false;
			}
		}
		return this.isUseHashClusterId;
	}
	
	private String cluster_id_preCodificaHash = null;
	public String getCluster_id_preCodificaHash() {
		return this.cluster_id_preCodificaHash;
	}
	public void updateClusterId() {
		this.cluster_id_preCodificaHash = this.cluster_id;
		// calcolo il cluster fornito come hash value
		this.cluster_id = DynamicClusterManager.hashClusterId(this.cluster_id);
	}
	
	private String cluster_id_numerico =null;
	private Boolean cluster_id_numerico_read =null;
	public String getClusterIdNumerico() throws ProtocolException {
		if(this.cluster_id_numerico_read==null){
			try{ 
				String name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cluster_id.numeric");
				if(name!=null){
					int numero = Integer.parseInt(name.trim());
					if(numero<0 || numero>99){
						String msg = "Riscontrato errore durante la lettura della proprietà 'org.openspcoop2.pdd.cluster_id.numeric': il valore indicato ("+numero+") deve essere compreso tra 0 e 99";
						this.logError(msg);
						throw new ProtocolException(msg);
					}
					this.cluster_id_numerico = name.trim();
				}
				
				this.cluster_id_numerico_read = true;
				
			}catch(java.lang.Exception e) {
				String msg = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.cluster_id.numeric': "+e.getMessage();
				this.logError(msg,e);
				throw new ProtocolException(msg,e);
			}   
		}
		return this.cluster_id_numerico;
	}
	
	private Integer getClusterDinamicoIdNumericoCifre = null;
	public int getClusterDinamicoIdNumericoCifre(boolean rateLimitingGestioneCluster) {	
		String pName = "org.openspcoop2.pdd.cluster_id.numeric.dinamico.cifre";
		if(this.getClusterDinamicoIdNumericoCifre==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.getClusterDinamicoIdNumericoCifre = java.lang.Integer.parseInt(name);
					if(this.getClusterDinamicoIdNumericoCifre<=0) {
						throw new CoreException("Il valore indicato deve essere maggiore di 0");
					}
				}
				else{
					// Gestione RateLimiting senza una effettiva attivazione di un cluster dinamico
					if(!isClusterDinamico()) {
						if(rateLimitingGestioneCluster) {
							this.getClusterDinamicoIdNumericoCifre = 2; // per default si registra staticamente fino a 99 nodi
						}
						else {
							throw new CoreException("Non Impostato");
						}
					}
					else {
						throw new CoreException("Non Impostato");
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
				this.getClusterDinamicoIdNumericoCifre = -1;
			}  
		}

		return this.getClusterDinamicoIdNumericoCifre;
	}
	public boolean isClusterIdNumericoDinamico(boolean rateLimitingGestioneCluster) {
		return getClusterDinamicoIdNumericoCifre(rateLimitingGestioneCluster)>0;
	}

	private Boolean isTimerLockByDatabase = null;
	public boolean isTimerLockByDatabase(){
		if(this.isTimerLockByDatabase==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.lockDatabase"); 

				if(value!=null){
					value = value.trim();
					this.isTimerLockByDatabase = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.lockDatabase' non impostata, viene utilizzato il default=true");
					this.isTimerLockByDatabase = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.lockDatabase' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTimerLockByDatabase = true;
			}
			
			if(this.isTimerLockByDatabase) {
				// Richiede la definizione di un clusterId e di un tipo di database
				if(this.getClusterId(false)==null) {
					this.isTimerLockByDatabase = false;
				}
				else if(this.getDatabaseType()==null) {
					this.isTimerLockByDatabase = false;
				}
			}
		}
		return this.isTimerLockByDatabase;
	}
	
	private Boolean isTimerLockByDatabaseNotifyLogEnabled = null;
	public boolean isTimerLockByDatabaseNotifyLogEnabled(){
		if(this.isTimerLockByDatabaseNotifyLogEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.lockDatabase.notify.log"); 

				if(value!=null){
					value = value.trim();
					this.isTimerLockByDatabaseNotifyLogEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.lockDatabase.notify.log' non impostata, viene utilizzato il default=true");
					this.isTimerLockByDatabaseNotifyLogEnabled = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.lockDatabase.notify.log' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTimerLockByDatabaseNotifyLogEnabled = true;
			}
		}
		return this.isTimerLockByDatabaseNotifyLogEnabled;
	}
	
	private String pddContextSerializer = null;
	public String getPddContextSerializer() {
		if(this.pddContextSerializer==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.contextSerializer");
				if(name!=null){
					name = name.trim();
					this.pddContextSerializer = name;
				}else{
					this.pddContextSerializer = CostantiConfigurazione.NONE;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.contextSerializer': "+e.getMessage(),e);
				this.pddContextSerializer = CostantiConfigurazione.NONE;
			}  
		}

		return this.pddContextSerializer;
	}




	/*---------- Stateless -------------*/

	/**
	 * Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo oneway
	 *
	 * @return il Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo oneway
	 * 
	 */
	private String statelessOneWay = null;
	public String getStatelessOneWay() {	
		if(this.statelessOneWay==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.default.oneway");
				if(name!=null){
					name = name.trim();
					if( (CostantiConfigurazione.ABILITATO.equals(name)==false) && (CostantiConfigurazione.DISABILITATO.equals(name)==false) ){
						throw new CoreException("Valori ammessi sono abilitato/disabilito");
					}
				}
				else{
					throw new CoreException(NON_DEFINITA);
				}
				this.statelessOneWay = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.default.oneway': "+e.getMessage(),e);
				this.statelessOneWay = null;
			}    
		}

		return this.statelessOneWay;
	}

	/**
	 * Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo sincrono
	 *
	 * @return il Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo sincrono
	 * 
	 */
	private String statelessSincrono = null;
	public String getStatelessSincrono() {
		if(this.statelessSincrono==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.default.sincrono");
				if(name!=null){
					name = name.trim();
					if( (CostantiConfigurazione.ABILITATO.equals(name)==false) && (CostantiConfigurazione.DISABILITATO.equals(name)==false) ){
						throw new CoreException("Valori ammessi sono abilitato/disabilito");
					}
				}
				else{
					throw new CoreException(NON_DEFINITA);
				}
				this.statelessSincrono = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.default.sincrono': "+e.getMessage(),e);
				this.statelessSincrono = null;
			}    
		}
		//System.out.println("MODALITA default per sincrono: "+OpenSPCoopProperties.statelessSincrono);
		return this.statelessSincrono;
	}

	/**
	 * Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo asincrono simmetrico e asimmetrico
	 *
	 * @return il Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo asincrono simmetrico e asimmetrico
	 * 
	 */
	private String statelessAsincrono = null;
	public String getStatelessAsincroni() {	
		if(this.statelessAsincrono==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.default.asincroni");
				if(name!=null){
					name = name.trim();
					if( (CostantiConfigurazione.ABILITATO.equals(name)==false) && (CostantiConfigurazione.DISABILITATO.equals(name)==false) ){
						throw new CoreException("Valori ammessi sono abilitato/disabilito");
					}
				}
				else{
					throw new CoreException(NON_DEFINITA);
				}
				this.statelessAsincrono = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.default.asincroni': "+e.getMessage(),e);
				this.statelessAsincrono = null;
			}    
		}
		//System.out.println("MODALITA default per asincroni: "+OpenSPCoopProperties.statelessAsincrono);
		return this.statelessAsincrono;
	}

	/**
	 * Restituisce l'indicazione se gestire il oneway non stateless nella nuova modalita della versione 1.4 o come la vecchia 1.0
	 *
	 * @return Restituisce l'indicazione se gestire il oneway non stateless nella nuova modalita della versione 1.4 o come la vecchia 1.0
	 * 
	 */
	private Boolean isGestioneOnewayStateful_1_1= null;
	public boolean isGestioneOnewayStateful_1_1(){
		if(this.isGestioneOnewayStateful_1_1==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateful.oneway"); 

				if(value!=null){
					value = value.trim();
					if( (CostantiConfigurazione.ONEWAY_STATEFUL_1_0.equals(value)==false) && (CostantiConfigurazione.ONEWAY_STATEFUL_1_1.equals(value)==false) ){
						throw new CoreException("Valori ammessi sono 1.0/1.1");
					}
					this.isGestioneOnewayStateful_1_1 = CostantiConfigurazione.ONEWAY_STATEFUL_1_1.equals(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.stateful.oneway' non impostata, viene utilizzato il default=true");
					this.isGestioneOnewayStateful_1_1 = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.stateful.oneway' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isGestioneOnewayStateful_1_1 = true;
			}
		}
		//System.out.println("MODALITA 11 per gestione Oneway; "+OpenSPCoopProperties.isGestioneOnewayStateful_1_1);
		return this.isGestioneOnewayStateful_1_1;
	}

	/**
	 * Restituisce il comportamento per il routing
	 *
	 * @return il Restituisce il comportamento per il routing
	 * 
	 */
	private String statelessRouting = null;
	public String getStatelessRouting() {	
		if(this.statelessRouting==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.router");
				if(name!=null){
					name = name.trim();
					if( (CostantiConfigurazione.ABILITATO.equals(name)==false) && (CostantiConfigurazione.DISABILITATO.equals(name)==false) ){
						throw new CoreException("Valori ammessi sono abilitato/disabilito");
					}
				}
				else{
					throw new CoreException(NON_DEFINITA);
				}
				this.statelessRouting = name;
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.router': "+e.getMessage(),e);
				this.statelessRouting = null;
			}    
		}
		//System.out.println("MODALITA per routing: "+OpenSPCoopProperties.statelessRouting);
		return this.statelessRouting;
	}


	/**
	 * Restituisce l'indicazione se una gestione stateless deve rinegoziare la connessione
	 *
	 * @return Restituisce l'indicazione se una gestione stateless deve rinegoziare la connessione
	 * 
	 */
	private Boolean isGestioneStateful_RinegoziamentoConnessione= null;
	private boolean isRinegoziamentoConnessione(){
		if(this.isGestioneStateful_RinegoziamentoConnessione==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.dataSource.rinegoziamentoConnessione"); 

				if(value!=null){
					value = value.trim();
					if( (CostantiConfigurazione.ABILITATO.equals(value)==false) && (CostantiConfigurazione.DISABILITATO.equals(value)==false) ){
						throw new CoreException("Valori ammessi sono abilitato/disabilitato");
					}
					if( CostantiConfigurazione.DISABILITATO.equals(value) ){
						this.isGestioneStateful_RinegoziamentoConnessione = false;
					}else{
						this.isGestioneStateful_RinegoziamentoConnessione = true;
					}
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.dataSource.rinegoziamentoConnessione' non impostata, viene utilizzato il default=true");
					this.isGestioneStateful_RinegoziamentoConnessione = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.dataSource.rinegoziamentoConnessione' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isGestioneStateful_RinegoziamentoConnessione = true;
			}
		}
		return this.isGestioneStateful_RinegoziamentoConnessione;
	}
	
	public boolean isRinegoziamentoConnessione(ProfiloDiCollaborazione profilo){
		if(ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(profilo) || ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(profilo))
			return true;
		else
			return this.isRinegoziamentoConnessione();
	}




	private Boolean mergeHandlerBuiltInAndHandlerUser = null;
	public boolean isMergeHandlerBuiltInAndHandlerUser() {	
		if(this.mergeHandlerBuiltInAndHandlerUser==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.merge");
				if(v!=null){
					v = v.trim();
					this.mergeHandlerBuiltInAndHandlerUser = Boolean.parseBoolean(v);
				} 
				else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.merge' non impostata, viene utilizzato il default="+false);
					this.mergeHandlerBuiltInAndHandlerUser = false;
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.merge' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		return this.mergeHandlerBuiltInAndHandlerUser;
	}
	
	/*---------- Gestori handler built-in -------------*/
	
	private Boolean printInfoHandlerBuiltIn = null;
	public boolean isPrintInfoHandlerBuiltIn() {	
		if(this.printInfoHandlerBuiltIn==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.printInfo");
				if(v!=null){
					v = v.trim();
					this.printInfoHandlerBuiltIn = Boolean.parseBoolean(v);
				} 
				else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.built-in.printInfo' non impostata, viene utilizzato il default="+true);
					this.printInfoHandlerBuiltIn = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.built-in.printInfo' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		return this.printInfoHandlerBuiltIn;
	}
	
	
	/**
	 * Restituisce l'elenco degli handlers di tipo InitHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo InitHandlerBuiltIn
	 */
	private String[] tipiInitHandlerBuiltIn = null;
	private boolean tipiInitHandlerBuiltInRead = false;
	public String[] getInitHandlerBuiltIn() {
		if(this.tipiInitHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.init");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiInitHandlerBuiltIn = r;
				}else{
					this.tipiInitHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.init': "+e.getMessage(),e);
				this.tipiInitHandlerBuiltIn = null;
			}   
			this.tipiInitHandlerBuiltInRead = true;
		}

		return this.tipiInitHandlerBuiltIn;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo ExitHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo ExitHandlerBuiltIn
	 */
	private String[] tipiExitHandlerBuiltIn = null;
	private boolean tipiExitHandlerBuiltInRead = false;
	public String[] getExitHandlerBuiltIn() {
		if(this.tipiExitHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.exit");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiExitHandlerBuiltIn = r;
				}else{
					this.tipiExitHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.exit': "+e.getMessage(),e);
				this.tipiExitHandlerBuiltIn = null;
			}   
			this.tipiExitHandlerBuiltInRead = true;
		}

		return this.tipiExitHandlerBuiltIn;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo PreInRequestHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo PreInRequestHandlerBuiltIn
	 */
	private String[] tipiPreInRequestHandlerBuiltIn = null;
	private boolean tipiPreInRequestHandlerBuiltInRead = false;
	public String[] getPreInRequestHandlerBuiltIn() {
		if(this.tipiPreInRequestHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.pre-in-request");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiPreInRequestHandlerBuiltIn = r;
				}else{
					this.tipiPreInRequestHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.pre-in-request': "+e.getMessage(),e);
				this.tipiPreInRequestHandlerBuiltIn = null;
			}   
			this.tipiPreInRequestHandlerBuiltInRead = true;
		}

		return this.tipiPreInRequestHandlerBuiltIn;
	}

	
	/**
	 * Restituisce l'elenco degli handlers di tipo InRequestHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo InRequestHandlerBuiltIn
	 */
	private String[] tipiInRequestHandlerBuiltIn = null;
	private boolean tipiInRequestHandlerBuiltInRead = false;
	public String[] getInRequestHandlerBuiltIn() {
		if(this.tipiInRequestHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.in-request");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiInRequestHandlerBuiltIn = r;
				}else{
					this.tipiInRequestHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.in-request': "+e.getMessage(),e);
				this.tipiInRequestHandlerBuiltIn = null;
			}   
			this.tipiInRequestHandlerBuiltInRead = true;
		}

		return this.tipiInRequestHandlerBuiltIn;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo InRequestProtocolHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo InRequestProtocolHandlerBuiltIn
	 */
	private String[] tipiInRequestProtocolHandlerBuiltIn = null;
	private boolean tipiInRequestProtocolHandlerBuiltInRead = false;
	public String[] getInRequestProtocolHandlerBuiltIn() {
		if(this.tipiInRequestProtocolHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.in-protocol-request");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiInRequestProtocolHandlerBuiltIn = r;
				}else{
					this.tipiInRequestProtocolHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.in-protocol-request': "+e.getMessage(),e);
				this.tipiInRequestProtocolHandlerBuiltIn = null;
			}   
			this.tipiInRequestProtocolHandlerBuiltInRead = true;
		}

		return this.tipiInRequestProtocolHandlerBuiltIn;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo OutRequestHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo OutRequestHandlerBuiltIn
	 */
	private String[] tipiOutRequestHandlerBuiltIn = null;
	private boolean tipiOutRequestHandlerBuiltInRead = false;
	public String[] getOutRequestHandlerBuiltIn() {
		if(this.tipiOutRequestHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.out-request");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiOutRequestHandlerBuiltIn = r;
				}else{
					this.tipiOutRequestHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.out-request': "+e.getMessage(),e);
				this.tipiOutRequestHandlerBuiltIn = null;
			}   
			this.tipiOutRequestHandlerBuiltInRead = true;
		}

		return this.tipiOutRequestHandlerBuiltIn;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo PostOutRequestHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo PostOutRequestHandlerBuiltIn
	 */
	private String[] tipiPostOutRequestHandlerBuiltIn = null;
	private boolean tipiPostOutRequestHandlerBuiltInRead = false;
	public String[] getPostOutRequestHandlerBuiltIn() {
		if(this.tipiPostOutRequestHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.post-out-request");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiPostOutRequestHandlerBuiltIn = r;
				}else{
					this.tipiPostOutRequestHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.post-out-request': "+e.getMessage(),e);
				this.tipiPostOutRequestHandlerBuiltIn = null;
			}   
			this.tipiPostOutRequestHandlerBuiltInRead = true;
		}

		return this.tipiPostOutRequestHandlerBuiltIn;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo PreInResponseHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo PreInResponseHandlerBuiltIn
	 */
	private String[] tipiPreInResponseHandlerBuiltIn = null;
	private boolean tipiPreInResponseHandlerBuiltInRead = false;
	public String[] getPreInResponseHandlerBuiltIn() {
		if(this.tipiPreInResponseHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.pre-in-response");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiPreInResponseHandlerBuiltIn = r;
				}else{
					this.tipiPreInResponseHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.pre-in-response': "+e.getMessage(),e);
				this.tipiPreInResponseHandlerBuiltIn = null;
			}   
			this.tipiPreInResponseHandlerBuiltInRead = true;
		}

		return this.tipiPreInResponseHandlerBuiltIn;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo InResponseHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo InResponseHandlerBuiltIn
	 */
	private String[] tipiInResponseHandlerBuiltIn = null;
	private boolean tipiInResponseHandlerBuiltInRead = false;
	public String[] getInResponseHandlerBuiltIn() {
		if(this.tipiInResponseHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.in-response");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiInResponseHandlerBuiltIn = r;
				}else{
					this.tipiInResponseHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.in-response': "+e.getMessage(),e);
				this.tipiInResponseHandlerBuiltIn = null;
			}   
			this.tipiInResponseHandlerBuiltInRead = true;
		}

		return this.tipiInResponseHandlerBuiltIn;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo OutResponseHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo OutResponseHandlerBuiltIn
	 */
	private String[] tipiOutResponseHandlerBuiltIn = null;
	private boolean tipiOutResponseHandlerBuiltInRead = false;
	public String[] getOutResponseHandlerBuiltIn() {
		if(this.tipiOutResponseHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.out-response");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiOutResponseHandlerBuiltIn = r;
				}else{
					this.tipiOutResponseHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.out-response': "+e.getMessage(),e);
				this.tipiOutResponseHandlerBuiltIn = null;
			}   
			this.tipiOutResponseHandlerBuiltInRead = true;
		}

		return this.tipiOutResponseHandlerBuiltIn;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo PostOutResponseHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo PostOutResponseHandlerBuiltIn
	 */
	private String[] tipiPostOutResponseHandlerBuiltIn = null;
	private boolean tipiPostOutResponseHandlerBuiltInRead = false;
	public String[] getPostOutResponseHandlerBuiltIn() {
		if(this.tipiPostOutResponseHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.post-out-response");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiPostOutResponseHandlerBuiltIn = r;
				}else{
					this.tipiPostOutResponseHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.post-out-response': "+e.getMessage(),e);
				this.tipiPostOutResponseHandlerBuiltIn = null;
			}   
			this.tipiPostOutResponseHandlerBuiltInRead = true;
		}

		return this.tipiPostOutResponseHandlerBuiltIn;
	}

	/**
	 * Restituisce l'elenco degli handlers di tipo IntegrationManagerRequestHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo IntegrationManagerRequestHandlerBuiltIn
	 */
	private String[] tipiIntegrationManagerRequestHandlerBuiltIn = null;
	private boolean tipiIntegrationManagerRequestHandlerBuiltInRead = false;
	public String[] getIntegrationManagerRequestHandlerBuiltIn() {
		if(this.tipiIntegrationManagerRequestHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.handler.built-in.request");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiIntegrationManagerRequestHandlerBuiltIn = r;
				}else{
					this.tipiIntegrationManagerRequestHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.integrationManager.handler.built-in.request': "+e.getMessage(),e);
				this.tipiIntegrationManagerRequestHandlerBuiltIn = null;
			}   
			this.tipiIntegrationManagerRequestHandlerBuiltInRead = true;
		}

		return this.tipiIntegrationManagerRequestHandlerBuiltIn;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo IntegrationManagerResponseHandlerBuiltIn
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo IntegrationManagerResponseHandlerBuiltIn
	 */
	private String[] tipiIntegrationManagerResponseHandlerBuiltIn = null;
	private boolean tipiIntegrationManagerResponseHandlerBuiltInRead = false;
	public String[] getIntegrationManagerResponseHandlerBuiltIn() {
		if(this.tipiIntegrationManagerResponseHandlerBuiltInRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.handler.built-in.response");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiIntegrationManagerResponseHandlerBuiltIn = r;
				}else{
					this.tipiIntegrationManagerResponseHandlerBuiltIn = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.integrationManager.handler.built-in.response': "+e.getMessage(),e);
				this.tipiIntegrationManagerResponseHandlerBuiltIn = null;
			}   
			this.tipiIntegrationManagerResponseHandlerBuiltInRead = true;
		}

		return this.tipiIntegrationManagerResponseHandlerBuiltIn;
	}
	
	
	
	
	

	/*---------- Gestori handler -------------*/
	
	private Boolean printInfoHandler = null;
	public boolean isPrintInfoHandler() {	
		if(this.printInfoHandler==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.printInfo");
				if(v!=null){
					v = v.trim();
					this.printInfoHandler = Boolean.parseBoolean(v);
				} 
				else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.printInfo' non impostata, viene utilizzato il default="+true);
					this.printInfoHandler = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.printInfo' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		return this.printInfoHandler;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo InitHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo InitHandler
	 */
	private String[] tipiInitHandler = null;
	private boolean tipiInitHandlerRead = false;
	public String[] getInitHandler() {
		if(this.tipiInitHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.init");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiInitHandler = r;
				}else{
					this.tipiInitHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.init': "+e.getMessage(),e);
				this.tipiInitHandler = null;
			}   
			this.tipiInitHandlerRead = true;
		}

		return this.tipiInitHandler;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo ExitHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo ExitHandler
	 */
	private String[] tipiExitHandler = null;
	private boolean tipiExitHandlerRead = false;
	public String[] getExitHandler() {
		if(this.tipiExitHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.exit");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiExitHandler = r;
				}else{
					this.tipiExitHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.exit': "+e.getMessage(),e);
				this.tipiExitHandler = null;
			}   
			this.tipiExitHandlerRead = true;
		}

		return this.tipiExitHandler;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo PreInRequestHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo PreInRequestHandler
	 */
	private String[] tipiPreInRequestHandler = null;
	private boolean tipiPreInRequestHandlerRead = false;
	public String[] getPreInRequestHandler() {
		if(this.tipiPreInRequestHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.pre-in-request");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiPreInRequestHandler = r;
				}else{
					this.tipiPreInRequestHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.pre-in-request': "+e.getMessage(),e);
				this.tipiPreInRequestHandler = null;
			}   
			this.tipiPreInRequestHandlerRead = true;
		}

		return this.tipiPreInRequestHandler;
	}

	
	/**
	 * Restituisce l'elenco degli handlers di tipo InRequestHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo InRequestHandler
	 */
	private String[] tipiInRequestHandler = null;
	private boolean tipiInRequestHandlerRead = false;
	public String[] getInRequestHandler() {
		if(this.tipiInRequestHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.in-request");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiInRequestHandler = r;
				}else{
					this.tipiInRequestHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.in-request': "+e.getMessage(),e);
				this.tipiInRequestHandler = null;
			}   
			this.tipiInRequestHandlerRead = true;
		}

		return this.tipiInRequestHandler;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo InRequestProtocolHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo InRequestProtocolHandler
	 */
	private String[] tipiInRequestProtocolHandler = null;
	private boolean tipiInRequestProtocolHandlerRead = false;
	public String[] getInRequestProtocolHandler() {
		if(this.tipiInRequestProtocolHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.in-protocol-request");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiInRequestProtocolHandler = r;
				}else{
					this.tipiInRequestProtocolHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.in-protocol-request': "+e.getMessage(),e);
				this.tipiInRequestProtocolHandler = null;
			}   
			this.tipiInRequestProtocolHandlerRead = true;
		}

		return this.tipiInRequestProtocolHandler;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo OutRequestHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo OutRequestHandler
	 */
	private String[] tipiOutRequestHandler = null;
	private boolean tipiOutRequestHandlerRead = false;
	public String[] getOutRequestHandler() {
		if(this.tipiOutRequestHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.out-request");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiOutRequestHandler = r;
				}else{
					this.tipiOutRequestHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.out-request': "+e.getMessage(),e);
				this.tipiOutRequestHandler = null;
			}   
			this.tipiOutRequestHandlerRead = true;
		}

		return this.tipiOutRequestHandler;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo PostOutRequestHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo PostOutRequestHandler
	 */
	private String[] tipiPostOutRequestHandler = null;
	private boolean tipiPostOutRequestHandlerRead = false;
	public String[] getPostOutRequestHandler() {
		if(this.tipiPostOutRequestHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.post-out-request");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiPostOutRequestHandler = r;
				}else{
					this.tipiPostOutRequestHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.post-out-request': "+e.getMessage(),e);
				this.tipiPostOutRequestHandler = null;
			}   
			this.tipiPostOutRequestHandlerRead = true;
		}

		return this.tipiPostOutRequestHandler;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo PreInResponseHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo PreInResponseHandler
	 */
	private String[] tipiPreInResponseHandler = null;
	private boolean tipiPreInResponseHandlerRead = false;
	public String[] getPreInResponseHandler() {
		if(this.tipiPreInResponseHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.pre-in-response");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiPreInResponseHandler = r;
				}else{
					this.tipiPreInResponseHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.pre-in-response': "+e.getMessage(),e);
				this.tipiPreInResponseHandler = null;
			}   
			this.tipiPreInResponseHandlerRead = true;
		}

		return this.tipiPreInResponseHandler;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo InResponseHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo InResponseHandler
	 */
	private String[] tipiInResponseHandler = null;
	private boolean tipiInResponseHandlerRead = false;
	public String[] getInResponseHandler() {
		if(this.tipiInResponseHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.in-response");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiInResponseHandler = r;
				}else{
					this.tipiInResponseHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.in-response': "+e.getMessage(),e);
				this.tipiInResponseHandler = null;
			}   
			this.tipiInResponseHandlerRead = true;
		}

		return this.tipiInResponseHandler;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo OutResponseHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo OutResponseHandler
	 */
	private String[] tipiOutResponseHandler = null;
	private boolean tipiOutResponseHandlerRead = false;
	public String[] getOutResponseHandler() {
		if(this.tipiOutResponseHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.out-response");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiOutResponseHandler = r;
				}else{
					this.tipiOutResponseHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.out-response': "+e.getMessage(),e);
				this.tipiOutResponseHandler = null;
			}   
			this.tipiOutResponseHandlerRead = true;
		}

		return this.tipiOutResponseHandler;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo PostOutResponseHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo PostOutResponseHandler
	 */
	private String[] tipiPostOutResponseHandler = null;
	private boolean tipiPostOutResponseHandlerRead = false;
	public String[] getPostOutResponseHandler() {
		if(this.tipiPostOutResponseHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.post-out-response");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiPostOutResponseHandler = r;
				}else{
					this.tipiPostOutResponseHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.post-out-response': "+e.getMessage(),e);
				this.tipiPostOutResponseHandler = null;
			}   
			this.tipiPostOutResponseHandlerRead = true;
		}

		return this.tipiPostOutResponseHandler;
	}

	/**
	 * Restituisce l'elenco degli handlers di tipo IntegrationManagerRequestHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo IntegrationManagerRequestHandler
	 */
	private String[] tipiIntegrationManagerRequestHandler = null;
	private boolean tipiIntegrationManagerRequestHandlerRead = false;
	public String[] getIntegrationManagerRequestHandler() {
		if(this.tipiIntegrationManagerRequestHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.handler.request");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiIntegrationManagerRequestHandler = r;
				}else{
					this.tipiIntegrationManagerRequestHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.integrationManager.handler.request': "+e.getMessage(),e);
				this.tipiIntegrationManagerRequestHandler = null;
			}   
			this.tipiIntegrationManagerRequestHandlerRead = true;
		}

		return this.tipiIntegrationManagerRequestHandler;
	}
	
	/**
	 * Restituisce l'elenco degli handlers di tipo IntegrationManagerResponseHandler
	 * 
	 * @return  Restituisce l'elenco degli handlers di tipo IntegrationManagerResponseHandler
	 */
	private String[] tipiIntegrationManagerResponseHandler = null;
	private boolean tipiIntegrationManagerResponseHandlerRead = false;
	public String[] getIntegrationManagerResponseHandler() {
		if(this.tipiIntegrationManagerResponseHandlerRead == false){
			try{ 
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.handler.response");
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipiIntegrationManagerResponseHandler = r;
				}else{
					this.tipiIntegrationManagerResponseHandler = null;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.integrationManager.handler.response': "+e.getMessage(),e);
				this.tipiIntegrationManagerResponseHandler = null;
			}   
			this.tipiIntegrationManagerResponseHandlerRead = true;
		}

		return this.tipiIntegrationManagerResponseHandler;
	}









	/* ----------- MessageSecurity --------------------- */
	
	private Boolean isLoadApacheXMLDSig = null;
	public boolean isLoadApacheXMLDSig(){

		String pName = "org.openspcoop2.pdd.security.addApacheXMLDSigProvider";
		if(this.isLoadApacheXMLDSig==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isLoadApacheXMLDSig = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isLoadApacheXMLDSig = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isLoadApacheXMLDSig = true;
			}
		}

		return this.isLoadApacheXMLDSig;
	}
	
	private Boolean isLoadBouncyCastle = null;
	public boolean isLoadBouncyCastle(){

		if(this.isLoadBouncyCastle==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.security.addBouncyCastleProvider"); 

				if (value != null){
					value = value.trim();
					this.isLoadBouncyCastle = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.security.addBouncyCastleProvider' non impostata, viene utilizzato il default=true");
					this.isLoadBouncyCastle = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.security.addBouncyCastleProvider' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isLoadBouncyCastle = true;
			}
		}

		return this.isLoadBouncyCastle;
	}
	
	private Boolean secureRandomBouncyCastle_read = null;
	private String bouncyCastleSecureRandomAlgo = null;
	public String getBouncyCastleSecureRandomAlgorithm(){

		String pName = "org.openspcoop2.pdd.security.bouncyCastleProvider.secureRandomAlgorithm";
		if(this.secureRandomBouncyCastle_read==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.bouncyCastleSecureRandomAlgo = value;
				}

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
				this.bouncyCastleSecureRandomAlgo = null;
			}
			
			this.secureRandomBouncyCastle_read = true;
		}

		return this.bouncyCastleSecureRandomAlgo;
	}
	
	private Boolean isUseBouncyCastleProviderForCertificate = null;
	public boolean isUseBouncyCastleProviderForCertificate(){

		if(this.isUseBouncyCastleProviderForCertificate==null){
			String pName = "org.openspcoop2.pdd.security.cert.useBouncyCastleProvider";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isUseBouncyCastleProviderForCertificate = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isUseBouncyCastleProviderForCertificate = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isUseBouncyCastleProviderForCertificate = true;
			}
		}

		return this.isUseBouncyCastleProviderForCertificate;
	}
	
	private Boolean isUseBouncyCastleProviderForMessageDigest = null;
	public boolean isUseBouncyCastleProviderForMessageDigest(){

		if(this.isUseBouncyCastleProviderForMessageDigest==null){
			String pName = "org.openspcoop2.pdd.security.digest.useBouncyCastleProvider";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isUseBouncyCastleProviderForMessageDigest = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isUseBouncyCastleProviderForMessageDigest = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isUseBouncyCastleProviderForMessageDigest = true;
			}
		}

		return this.isUseBouncyCastleProviderForMessageDigest;
	}
	
	private Boolean isUseBouncyCastleProviderForWss4jCryptoMerlin = null;
	public boolean isUseBouncyCastleProviderForWss4jCryptoMerlin(){

		if(this.isUseBouncyCastleProviderForWss4jCryptoMerlin==null){
			String pName = "org.openspcoop2.pdd.security.wss4jCryptoMerlin.useBouncyCastleProvider";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isUseBouncyCastleProviderForWss4jCryptoMerlin = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isUseBouncyCastleProviderForWss4jCryptoMerlin = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isUseBouncyCastleProviderForWss4jCryptoMerlin = true;
			}
		}

		return this.isUseBouncyCastleProviderForWss4jCryptoMerlin;
	}
	
	private Boolean securityEgd_read = null;
	private String securityEgd = null;
	public String getSecurityEgd(){

		String pName = "org.openspcoop2.pdd.security.egd";
		if(this.securityEgd_read==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.securityEgd = value;
				}

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
				this.securityEgd = null;
			}
			
			this.securityEgd_read = true;
		}

		return this.securityEgd;
	}
	
	/**
	 * Indicazione se generare un actor di default
	 *   
	 * @return Indicazione se generare un actor di default
	 * 
	 */
	private Boolean isGenerazioneActorDefault = null;
	public boolean isGenerazioneActorDefault(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String tipo = this.pddReader.getMessageSecurity_ActorDefaultEnable(implementazionePdDSoggetto);
			if(tipo!=null && ( 
					CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
					CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
			){
				if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
					return true;
				else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
					return false;
			}
		}

		if(this.isGenerazioneActorDefault==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.actorDefault.enable"); 

				if (value != null){
					value = value.trim();
					this.isGenerazioneActorDefault = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.actorDefault.enable' non impostata, viene utilizzato il default=true");
					this.isGenerazioneActorDefault = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.actorDefault.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isGenerazioneActorDefault = true;
			}
		}

		return this.isGenerazioneActorDefault;
	}


	/**
	 * Actor di default
	 *   
	 * @return actor di default
	 * 
	 */
	private String actorDefault = null;
	public String getActorDefault(String implementazionePdDSoggetto){

		// ovverriding per implementazione porta di dominio
		if(this.pddReader!=null){
			String valore = this.pddReader.getMessageSecurity_ActorDefaultValue(implementazionePdDSoggetto);
			if(valore!=null){
				return valore;
			}
		}

		if(this.actorDefault==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.actorDefault.valore"); 

				if (value != null){
					value = value.trim();
					this.actorDefault = value;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.actorDefault.valore' non impostata, viene utilizzato il default=openspcoop");
					this.actorDefault = "openspcoop";
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.actorDefault.valore' non impostata, viene utilizzato il default=openspcoop, errore:"+e.getMessage(),e);
				this.actorDefault = "openspcoop";
			}
		}

		return this.actorDefault;
	}
	
	/**
	 * WsuId prefix associato agli id delle reference utilizzate dagli header di MessageSecurity
	 *   
	 * @return prefix
	 * 
	 */
	private String prefixWsuId = null;
	public String getPrefixWsuId(){

		if(this.prefixWsuId==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.prefixWsuId"); 

				if (value != null){
					value = value.trim();
					this.prefixWsuId = value;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.prefixWsuId' non impostata, viene utilizzato il default di MessageSecurity");
					this.prefixWsuId = "";
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.prefixWsuId' non impostata, viene utilizzato il default di MessageSecurity, errore:"+e.getMessage(),e);
				this.prefixWsuId = "";
			}
		}

		return this.prefixWsuId;
	}
	
	private Boolean secureRandomWsuId_read = null;
	private String wsuIdSecureRandomAlgo = null;
	public String getWsuIdSecureRandomAlgorithm(){

		String pName = "org.openspcoop2.pdd.messageSecurity.wsuId.secureRandomAlgorithm";
		if(this.secureRandomWsuId_read==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.wsuIdSecureRandomAlgo = value;
				}

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
				this.wsuIdSecureRandomAlgo = null;
			}
			
			this.secureRandomWsuId_read = true;
		}

		return this.wsuIdSecureRandomAlgo;
	}
	
	private Boolean removeAllWsuIdRef = null;
	public boolean isRemoveAllWsuIdRef(){

		if(this.removeAllWsuIdRef==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.removeAllWsuIdRef"); 

				if (value != null){
					value = value.trim();
					this.removeAllWsuIdRef = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.removeAllWsuIdRef' non impostata, viene utilizzato il default 'false'");
					this.removeAllWsuIdRef = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.removeAllWsuIdRef' non impostata, viene utilizzato il default 'false', errore:"+e.getMessage(),e);
				this.removeAllWsuIdRef = false;
			}
		}

		return this.removeAllWsuIdRef;
	}
	
	private String externalPWCallback = null;
	private Boolean externalPWCallbackReaded = null;
	public String getExternalPWCallbackPropertyFile(){

		if(this.externalPWCallbackReaded==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.externalPWCallback.propertiesFile"); 

				if (value != null){
					value = value.trim();
					this.externalPWCallback = value;
				}else{
					this.logDebug("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.externalPWCallback.propertiesFile' non impostata");
					this.externalPWCallback = null;
				}
				this.externalPWCallbackReaded = true;

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.externalPWCallback.propertiesFile' non impostata, errore:"+e.getMessage(),e);
				this.externalPWCallback = null;
				this.externalPWCallbackReaded = true;
			}
		}

		return this.externalPWCallback;
	}


	/**
	 * Restituisce l'indicazione se la cache messageSecurity e' abilitata
	 *
	 * @return Restituisce l'indicazione se la cache messageSecurity e' abilitata
	 */
	private Boolean isAbilitataCacheMessageSecurityKeystore_value = null;
	public boolean isAbilitataCacheMessageSecurityKeystore() {
		if(this.isAbilitataCacheMessageSecurityKeystore_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.keystore.cache.enable"); 
				if(value!=null){
					value = value.trim();
					this.isAbilitataCacheMessageSecurityKeystore_value = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.keystore.cache.enable' non impostata, viene utilizzato il default=false");
					this.isAbilitataCacheMessageSecurityKeystore_value = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.keystore.cache.enable' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isAbilitataCacheMessageSecurityKeystore_value = false;
			}
		}

		return this.isAbilitataCacheMessageSecurityKeystore_value;
	}

	/**
	 * Restituisce la dimensione della cache messageSecurity 
	 *
	 * @return Restituisce la dimensione della cache messageSecurity 
	 */
	private Integer dimensioneCacheMessageSecurityKeystore_value = null;
	public int getDimensioneCacheMessageSecurityKeystore() throws OpenSPCoop2ConfigurationException{	
		if(this.dimensioneCacheMessageSecurityKeystore_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.keystore.cache.dimensione"); 
				if(value!=null){
					value = value.trim();
					this.dimensioneCacheMessageSecurityKeystore_value = Integer.parseInt(value);
				}else{
					this.dimensioneCacheMessageSecurityKeystore_value = -1;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.keystore.cache.dimensione': "+e.getMessage(),e);
				throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop  'org.openspcoop2.pdd.messageSecurity.keystore.cache.dimensione'",e);
			}
		}

		return this.dimensioneCacheMessageSecurityKeystore_value;
	}

	/**
	 * Restituisce la  itemLifeSecond della cache messageSecurity
	 *
	 * @return Restituisce la itemLifeSecond della cache messageSecurity
	 */
	private Integer itemLifeSecondCacheMessageSecurityKeystore_value = null;
	public int getItemLifeSecondCacheMessageSecurityKeystore() throws OpenSPCoop2ConfigurationException{
		if(this.itemLifeSecondCacheMessageSecurityKeystore_value==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.keystore.cache.itemLifeSecond"); 
				if(value!=null){
					value = value.trim();
					this.itemLifeSecondCacheMessageSecurityKeystore_value = Integer.parseInt(value);
				}else{
					this.itemLifeSecondCacheMessageSecurityKeystore_value = -1;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.keystore.cache.itemLifeSecond': "+e.getMessage(),e);
				throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop  'org.openspcoop2.pdd.messageSecurity.keystore.cache.itemLifeSecond'",e);
			}
		}

		return this.itemLifeSecondCacheMessageSecurityKeystore_value;
	}
	
	
	
	
	
	
	/* ********  Gestore Credenziali  ******** */

	private Boolean getAutenticazioneLockPermitsRead = null;
	private Integer getAutenticazioneLockPermits = null;
	public Integer getAutenticazioneLockPermits() {

		String pName = "org.openspcoop2.pdd.core.autenticazione.lock.permits";
		if(this.getAutenticazioneLockPermitsRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					int permits = Integer.parseInt(value); 
					if(permits>1) {
						// altrimenti è un normale semaphore binario
						this.getAutenticazioneLockPermits = permits;
					}
				}
				
				
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			
			this.getAutenticazioneLockPermitsRead = true;
		}

		return this.getAutenticazioneLockPermits;
	}
	
	private Map<String, Integer> getTipoAutenticazioneLockPermits = null;
	public Integer getAutenticazioneLockPermits(String tipoAutenticazione) { 

		String pName = "org.openspcoop2.pdd.core.autenticazione.lock.permits.";
		if(this.getTipoAutenticazioneLockPermits==null){
			
			this.getTipoAutenticazioneLockPermits = new HashMap<>();
			
			try{  
				Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
				processAutenticazioneLockPermits(p);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			
		}

		return this.getTipoAutenticazioneLockPermits.get(tipoAutenticazione);
	}
	private void processAutenticazioneLockPermits(Properties p) {
		if(p!=null && !p.isEmpty()) {
			for (Object oKey : p.keySet()) {
				if(oKey!=null) {
					String key = (String) oKey;
					String value = p.getProperty(key);
					processAutenticazioneLockPermits(key, value);
				}
			}
		}
	}
	private void processAutenticazioneLockPermits(String key, String value) {
		if(value!=null) {
			int permits = Integer.parseInt(value);
			if(permits>1) {
				// altrimenti è un normale semaphore binario
				this.getTipoAutenticazioneLockPermits.put(key, permits);
			}
		}
	}
	
	private Boolean isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed = null;
	public boolean isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed(){

		if(this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed==null){
			String pName = "org.openspcoop2.pdd.core.autenticazione.gestioneToken.saveAuthenticationInfo.authenticationFailed";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed = true;
			}
		}

		return this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed;
	}
	
	private CryptConfig getCryptConfigAutenticazioneApplicativi = null;
	public CryptConfig getCryptConfigAutenticazioneApplicativi() {
		if(this.getCryptConfigAutenticazioneApplicativi == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.autenticazione.applicativi.password"); 
				if(value!=null){
					value = value.trim();
					this.getCryptConfigAutenticazioneApplicativi = new CryptConfig(value);
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.core.autenticazione.applicativi.password': "+e.getMessage(),e);
				return null;
			}
		}

		return this.getCryptConfigAutenticazioneApplicativi;
	}
	
	private CryptConfig getCryptConfigAutenticazioneSoggetti = null;
	public CryptConfig getCryptConfigAutenticazioneSoggetti() {
		if(this.getCryptConfigAutenticazioneSoggetti == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.autenticazione.soggetti.password"); 
				if(value!=null){
					value = value.trim();
					this.getCryptConfigAutenticazioneSoggetti = new CryptConfig(value);
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.core.autenticazione.soggetti.password': "+e.getMessage(),e);
				return null;
			}
		}

		return this.getCryptConfigAutenticazioneSoggetti;
	}

	private Boolean isAutenticazioneBasicLogPassword = null;
	public boolean isAutenticazioneBasicLogPassword() {
		String pName = "org.openspcoop2.pdd.core.autenticazione.basic.invalidCredentials.logPassword";
		if(this.isAutenticazioneBasicLogPassword == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.isAutenticazioneBasicLogPassword = Boolean.valueOf(value);
				}
				else {
					this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=false");
					this.isAutenticazioneBasicLogPassword = false;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=false. Errore: "+e.getMessage(),e);
				this.isAutenticazioneBasicLogPassword = false;
			}
		}

		return this.isAutenticazioneBasicLogPassword;
	}
	
	private WWWAuthenticateConfig getRealmAutenticazioneBasicWWWAuthenticateConfig = null;
	private boolean getRealmAutenticazioneBasicWWWAuthenticateConfig_read = false;
	public WWWAuthenticateConfig getRealmAutenticazioneBasicWWWAuthenticateConfig() {
		if(this.getRealmAutenticazioneBasicWWWAuthenticateConfig_read == false){
			
//			String pNameAuth = "org.openspcoop2.pdd.core.autenticazione.basic.authType";
//			String authType = null;
//			try{  
//				authType = this.reader.getValue_convertEnvProperties(pNameAuth); 
//				if(authType!=null){
//					authType = authType.trim();
//				}
//			}catch(java.lang.Exception e) {
//				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameAuth+"': "+e.getMessage(),e);
//			}
			String authType = HttpConstants.AUTHENTICATION_BASIC;
			
			String pNameRealm = "org.openspcoop2.pdd.core.autenticazione.basic.realm";
			String realm = null;
			try {
				realm = this.reader.getValueConvertEnvProperties(pNameRealm); 
				if(realm!=null){
					realm = realm.trim();
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameRealm+"': "+e.getMessage(),e);
			}
			
			if(authType!=null && !"".equals(authType) && realm!=null && !"".equals(realm)) {
				this.getRealmAutenticazioneBasicWWWAuthenticateConfig = new WWWAuthenticateConfig();
				this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setAuthType(authType);
				this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setRealm(realm);
				
				String pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.basic.error_description.notFound";
				String error_description = null;
				try {
					error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
					if(error_description!=null){
						error_description = error_description.trim();
						if(!"".equals(error_description)) {
							this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setNotFound_error(WWWAuthenticateErrorCode.invalid_request.name());
							this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setNotFound_error_description(error_description);
						}
					}
				}catch(java.lang.Exception e) {
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
				}
				
				pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.basic.error_description.invalid";
				error_description = null;
				try {
					error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
					if(error_description!=null){
						error_description = error_description.trim();
						if(!"".equals(error_description)) {
							this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setInvalid_error(WWWAuthenticateErrorCode.invalid_request.name());
							this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setInvalid_error_description(error_description);
						}
					}
				}catch(java.lang.Exception e) {
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
				}
			}
			
			this.getRealmAutenticazioneBasicWWWAuthenticateConfig_read = true;
		}

		return this.getRealmAutenticazioneBasicWWWAuthenticateConfig;
	}
	
	private WWWAuthenticateConfig getRealmAutenticazioneApiKeyWWWAuthenticateConfig = null;
	private boolean getRealmAutenticazioneApiKeyWWWAuthenticateConfig_read = false;
	public WWWAuthenticateConfig getRealmAutenticazioneApiKeyWWWAuthenticateConfig() {
		if(this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig_read == false){
			
			String pNameAuth = "org.openspcoop2.pdd.core.autenticazione.apiKey.authType";
			String authType = null;
			try{  
				authType = this.reader.getValueConvertEnvProperties(pNameAuth); 
				if(authType!=null){
					authType = authType.trim();
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameAuth+"': "+e.getMessage(),e);
			}
			
			String pNameRealm = "org.openspcoop2.pdd.core.autenticazione.apiKey.realm";
			String realm = null;
			try {
				realm = this.reader.getValueConvertEnvProperties(pNameRealm); 
				if(realm!=null){
					realm = realm.trim();
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameRealm+"': "+e.getMessage(),e);
			}
			
			if(authType!=null && !"".equals(authType) && realm!=null && !"".equals(realm)) {
				this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig = new WWWAuthenticateConfig();
				this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setAuthType(authType);
				this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setRealm(realm);
				
				String pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.apiKey.error_description.notFound";
				String error_description = null;
				try {
					error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
					if(error_description!=null){
						error_description = error_description.trim();
						if(!"".equals(error_description)) {
							this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setNotFound_error(WWWAuthenticateErrorCode.invalid_request.name());
							this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setNotFound_error_description(error_description);
						}
					}
				}catch(java.lang.Exception e) {
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
				}
				
				pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.apiKey.error_description.invalid";
				error_description = null;
				try {
					error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
					if(error_description!=null){
						error_description = error_description.trim();
						if(!"".equals(error_description)) {
							this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setInvalid_error(WWWAuthenticateErrorCode.invalid_request.name());
							this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setInvalid_error_description(error_description);
						}
					}
				}catch(java.lang.Exception e) {
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
				}
			}
			
			this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig_read = true;
		}

		return this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig;
	}
	
	private Boolean isAutenticazioneHttpsPortaDelegataValidityCheck = null;
	public boolean isAutenticazioneHttpsPortaDelegataValidityCheck() {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.validityCheck";
		if(this.isAutenticazioneHttpsPortaDelegataValidityCheck == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.isAutenticazioneHttpsPortaDelegataValidityCheck = Boolean.valueOf(value);
				}
				else {
					this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
					this.isAutenticazioneHttpsPortaDelegataValidityCheck = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
				this.isAutenticazioneHttpsPortaDelegataValidityCheck = true;
			}
		}

		return this.isAutenticazioneHttpsPortaDelegataValidityCheck;
	}
	
	private File getAutenticazioneHttpsPortaDelegataTruststorePath = null;
	private Boolean getAutenticazioneHttpsPortaDelegataTruststorePath_read = null;
	public File getAutenticazioneHttpsPortaDelegataTruststorePath() throws CoreException {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.path";
		if(this.getAutenticazioneHttpsPortaDelegataTruststorePath_read == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.getAutenticazioneHttpsPortaDelegataTruststorePath = new File(value);
					if(this.getAutenticazioneHttpsPortaDelegataTruststorePath.exists()) {
						if(!this.getAutenticazioneHttpsPortaDelegataTruststorePath.isFile()) {
							throw newCoreExceptionNotFile(this.getAutenticazioneHttpsPortaDelegataTruststorePath, false);
						}
						if(!this.getAutenticazioneHttpsPortaDelegataTruststorePath.canRead()) {
							throw newCoreExceptionCannotRead(this.getAutenticazioneHttpsPortaDelegataTruststorePath,false);
						}
					}
					else {
						this.getAutenticazioneHttpsPortaDelegataTruststorePath=null;
					}
				}
			}catch(java.lang.Exception e) {
				throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}
			this.getAutenticazioneHttpsPortaDelegataTruststorePath_read = true;
		}

		return this.getAutenticazioneHttpsPortaDelegataTruststorePath;
	}
	
	private String getAutenticazioneHttpsPortaDelegataTruststorePassword = null;
	private Boolean getAutenticazioneHttpsPortaDelegataTruststorePassword_read = null;
	public String getAutenticazioneHttpsPortaDelegataTruststorePassword() throws CoreException {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.password";
		if(this.getAutenticazioneHttpsPortaDelegataTruststorePassword_read == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.getAutenticazioneHttpsPortaDelegataTruststorePassword = value;
				}
			}catch(java.lang.Exception e) {
				throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}
			this.getAutenticazioneHttpsPortaDelegataTruststorePassword_read = true;
		}

		return this.getAutenticazioneHttpsPortaDelegataTruststorePassword;
	}
	
	private String getAutenticazioneHttpsPortaDelegataTruststoreType = null;
	public String getAutenticazioneHttpsPortaDelegataTruststoreType() throws CoreException {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.type";
		if(this.getAutenticazioneHttpsPortaDelegataTruststoreType == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.getAutenticazioneHttpsPortaDelegataTruststoreType = value;
				}
				else {
					this.getAutenticazioneHttpsPortaDelegataTruststoreType = KeystoreType.JKS.getNome();
				}
			}catch(java.lang.Exception e) {
				throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}
		}

		return this.getAutenticazioneHttpsPortaDelegataTruststoreType;
	}
	
	private String getAutenticazioneHttpsPortaDelegataTruststoreCRLs = null;
	private Boolean getAutenticazioneHttpsPortaDelegataTruststoreCRLs_read = null;
	public String getAutenticazioneHttpsPortaDelegataTruststoreCRLs() throws CoreException {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.crls";
		if(this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs_read == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs = value;
				}
			}catch(java.lang.Exception e) {
				throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}
			this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs_read = true;
		}

		return this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs;
	}
	
	private String getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy = null;
	private Boolean getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy_read = null;
	public String getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy() throws CoreException {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.ocspPolicy";
		if(this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy_read == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy = value;
				}
			}catch(java.lang.Exception e) {
				throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}
			this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy_read = true;
		}

		return this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy;
	}
	
	private Boolean isAutenticazioneHttpsPortaApplicativaValidityCheck = null;
	public boolean isAutenticazioneHttpsPortaApplicativaValidityCheck() {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.validityCheck";
		if(this.isAutenticazioneHttpsPortaApplicativaValidityCheck == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.isAutenticazioneHttpsPortaApplicativaValidityCheck = Boolean.valueOf(value);
				}
				else {
					this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
					this.isAutenticazioneHttpsPortaApplicativaValidityCheck = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
				this.isAutenticazioneHttpsPortaApplicativaValidityCheck = true;
			}
		}

		return this.isAutenticazioneHttpsPortaApplicativaValidityCheck;
	}
	
	private File getAutenticazioneHttpsPortaApplicativaTruststorePath = null;
	private Boolean getAutenticazioneHttpsPortaApplicativaTruststorePath_read = null;
	public File getAutenticazioneHttpsPortaApplicativaTruststorePath() throws CoreException {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.path";
		if(this.getAutenticazioneHttpsPortaApplicativaTruststorePath_read == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.getAutenticazioneHttpsPortaApplicativaTruststorePath = new File(value);
					if(this.getAutenticazioneHttpsPortaApplicativaTruststorePath.exists()) {
						if(!this.getAutenticazioneHttpsPortaApplicativaTruststorePath.isFile()) {
							throw newCoreExceptionNotFile(this.getAutenticazioneHttpsPortaApplicativaTruststorePath, false);
						}
						if(!this.getAutenticazioneHttpsPortaApplicativaTruststorePath.canRead()) {
							throw newCoreExceptionCannotRead(this.getAutenticazioneHttpsPortaApplicativaTruststorePath, false);
						}
					}
					else {
						this.getAutenticazioneHttpsPortaApplicativaTruststorePath=null;
					}
				}
			}catch(java.lang.Exception e) {
				throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}
			this.getAutenticazioneHttpsPortaApplicativaTruststorePath_read = true;
		}

		return this.getAutenticazioneHttpsPortaApplicativaTruststorePath;
	}
	
	private String getAutenticazioneHttpsPortaApplicativaTruststorePassword = null;
	private Boolean getAutenticazioneHttpsPortaApplicativaTruststorePassword_read = null;
	public String getAutenticazioneHttpsPortaApplicativaTruststorePassword() throws CoreException {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.password";
		if(this.getAutenticazioneHttpsPortaApplicativaTruststorePassword_read == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.getAutenticazioneHttpsPortaApplicativaTruststorePassword = value;
				}
			}catch(java.lang.Exception e) {
				throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}
			this.getAutenticazioneHttpsPortaApplicativaTruststorePassword_read = true;
		}

		return this.getAutenticazioneHttpsPortaApplicativaTruststorePassword;
	}
	
	private String getAutenticazioneHttpsPortaApplicativaTruststoreType = null;
	public String getAutenticazioneHttpsPortaApplicativaTruststoreType() throws CoreException {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.type";
		if(this.getAutenticazioneHttpsPortaApplicativaTruststoreType == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.getAutenticazioneHttpsPortaApplicativaTruststoreType = value;
				}
				else {
					this.getAutenticazioneHttpsPortaApplicativaTruststoreType = KeystoreType.JKS.getNome();
				}
			}catch(java.lang.Exception e) {
				throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}
		}

		return this.getAutenticazioneHttpsPortaApplicativaTruststoreType;
	}
	
	private String getAutenticazioneHttpsPortaApplicativaTruststoreCRLs = null;
	private Boolean getAutenticazioneHttpsPortaApplicativaTruststoreCRLs_read = null;
	public String getAutenticazioneHttpsPortaApplicativaTruststoreCRLs() throws CoreException {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.crls";
		if(this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs_read == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs = value;
				}
			}catch(java.lang.Exception e) {
				throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}
			this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs_read = true;
		}

		return this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs;
	}
	
	private String getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy = null;
	private Boolean getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy_read = null;
	public String getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy() throws CoreException {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.ocspPolicy";
		if(this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy_read == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy = value;
				}
			}catch(java.lang.Exception e) {
				throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}
			this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy_read = true;
		}

		return this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy;
	}
	
	
	private Boolean isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari = null;
	public boolean isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari() {
		String pName = "org.openspcoop2.pdd.core.autenticazione.https.portaDelegata.checkSoggettiProprietari";
		if(this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari = Boolean.valueOf(value);
				}
				else {
					this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
					this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
				this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari = true;
			}
		}

		return this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari;
	}
	
	private WWWAuthenticateConfig getRealmAutenticazioneHttpsWWWAuthenticateConfig = null;
	private boolean getRealmAutenticazioneHttpsWWWAuthenticateConfig_read = false;
	public WWWAuthenticateConfig getRealmAutenticazioneHttpsWWWAuthenticateConfig() {
		if(this.getRealmAutenticazioneHttpsWWWAuthenticateConfig_read == false){
			
			String pNameAuth = "org.openspcoop2.pdd.core.autenticazione.https.authType";
			String authType = null;
			try{  
				authType = this.reader.getValueConvertEnvProperties(pNameAuth); 
				if(authType!=null){
					authType = authType.trim();
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameAuth+"': "+e.getMessage(),e);
			}
			
			String pNameRealm = "org.openspcoop2.pdd.core.autenticazione.https.realm";
			String realm = null;
			try {
				realm = this.reader.getValueConvertEnvProperties(pNameRealm); 
				if(realm!=null){
					realm = realm.trim();
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameRealm+"': "+e.getMessage(),e);
			}
			
			if(authType!=null && !"".equals(authType) && realm!=null && !"".equals(realm)) {
				this.getRealmAutenticazioneHttpsWWWAuthenticateConfig = new WWWAuthenticateConfig();
				this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setAuthType(authType);
				this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setRealm(realm);
				
				String pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.https.error_description.notFound";
				String error_description = null;
				try {
					error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
					if(error_description!=null){
						error_description = error_description.trim();
						if(!"".equals(error_description)) {
							this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setNotFound_error(WWWAuthenticateErrorCode.invalid_request.name());
							this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setNotFound_error_description(error_description);
						}
					}
				}catch(java.lang.Exception e) {
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
				}
				
				pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.https.error_description.invalid";
				error_description = null;
				try {
					error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
					if(error_description!=null){
						error_description = error_description.trim();
						if(!"".equals(error_description)) {
							this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setInvalid_error(WWWAuthenticateErrorCode.invalid_request.name());
							this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setInvalid_error_description(error_description);
						}
					}
				}catch(java.lang.Exception e) {
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
				}
			}
			
			this.getRealmAutenticazioneHttpsWWWAuthenticateConfig_read = true;
		}

		return this.getRealmAutenticazioneHttpsWWWAuthenticateConfig;
	}
	
	private Boolean isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari = null;
	public boolean isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari() {
		String pName = "org.openspcoop2.pdd.core.autenticazione.principal.portaDelegata.checkSoggettiProprietari";
		if(this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari = Boolean.valueOf(value);
				}
				else {
					this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
					this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
				this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari = true;
			}
		}

		return this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari;
	}
	
	private Map<TipoAutenticazionePrincipal, WWWAuthenticateConfig> getRealmAutenticazionePrincipalWWWAuthenticateConfig = new HashMap<TipoAutenticazionePrincipal, WWWAuthenticateConfig>();
	public WWWAuthenticateConfig getRealmAutenticazionePrincipalWWWAuthenticateConfig(TipoAutenticazionePrincipal principal) {
		if(!this.getRealmAutenticazionePrincipalWWWAuthenticateConfig.containsKey(principal)){
			
			String pNameAuth = "org.openspcoop2.pdd.core.autenticazione.principal."+principal.getValue()+".authType";
			String authType = null;
			try{  
				authType = this.reader.getValueConvertEnvProperties(pNameAuth); 
				if(authType!=null){
					authType = authType.trim();
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameAuth+"': "+e.getMessage(),e);
			}
			
			String pNameRealm = "org.openspcoop2.pdd.core.autenticazione.principal."+principal.getValue()+".realm";
			String realm = null;
			try {
				realm = this.reader.getValueConvertEnvProperties(pNameRealm); 
				if(realm!=null){
					realm = realm.trim();
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameRealm+"': "+e.getMessage(),e);
			}
			
			WWWAuthenticateConfig wwwConfig = null;
			if(authType!=null && !"".equals(authType) && realm!=null && !"".equals(realm)) {
				
				wwwConfig = new WWWAuthenticateConfig();
				wwwConfig.setAuthType(authType);
				wwwConfig.setRealm(realm);
				
				String pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.principal."+principal.getValue()+".error_description.notFound";
				String error_description = null;
				try {
					error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
					if(error_description!=null){
						error_description = error_description.trim();
						if(!"".equals(error_description)) {
							wwwConfig.setNotFound_error(WWWAuthenticateErrorCode.invalid_request.name());
							wwwConfig.setNotFound_error_description(error_description);
						}
					}
				}catch(java.lang.Exception e) {
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
				}
				
				pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.principal."+principal.getValue()+".error_description.invalid";
				error_description = null;
				try {
					error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
					if(error_description!=null){
						error_description = error_description.trim();
						if(!"".equals(error_description)) {
							wwwConfig.setInvalid_error(WWWAuthenticateErrorCode.invalid_request.name());
							wwwConfig.setInvalid_error_description(error_description);
						}
					}
				}catch(java.lang.Exception e) {
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
				}
				
			}
			
			this.getRealmAutenticazionePrincipalWWWAuthenticateConfig.put(principal, wwwConfig);
		}

		return this.getRealmAutenticazionePrincipalWWWAuthenticateConfig.get(principal);
	}
	
	private Boolean isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari = null;
	public boolean isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari() {
		String pName = "org.openspcoop2.pdd.core.autenticazione.token.portaDelegata.checkSoggettiProprietari";
		if(this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari == null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 
				if(value!=null){
					value = value.trim();
					this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari = Boolean.valueOf(value);
				}
				else {
					this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
					this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
				this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari = true;
			}
		}

		return this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari;
	}
	
	/**
	 * Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare lato Porta Delegata
	 * 
	 * @return Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare lato Porta Delegata
	 */
	private String[] tipoGestoreCredenzialiPD = null;
	private boolean tipoGestoreCredenzialiPDRead = false;
	public String[] getTipoGestoreCredenzialiPD() {
		if(this.tipoGestoreCredenzialiPDRead == false){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.pd.gestoriCredenziali"); 
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipoGestoreCredenzialiPD = r;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.services.pd.gestoriCredenziali': "+e.getMessage(),e);
				this.tipoGestoreCredenzialiPD = null;
			}
			this.tipoGestoreCredenzialiPDRead = true;
		}

		return this.tipoGestoreCredenzialiPD;
	}
	
	/**
	 * Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare lato Porta Applicativa
	 * 
	 * @return Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare lato Porta Applicativa
	 */
	private String[] tipoGestoreCredenzialiPA = null;
	private boolean tipoGestoreCredenzialiPARead = false;
	public String[] getTipoGestoreCredenzialiPA() {
		if(this.tipoGestoreCredenzialiPARead == false){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.pa.gestoriCredenziali"); 
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipoGestoreCredenzialiPA = r;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.services.pa.gestoriCredenziali': "+e.getMessage(),e);
				this.tipoGestoreCredenzialiPA = null;
			}
			this.tipoGestoreCredenzialiPARead = true;
		}

		return this.tipoGestoreCredenzialiPA;
	}
	
	/**
	 * Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare sul servizio di IntegrationManager
	 * 
	 * @return Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare sul servizio di IntegrationManager
	 */
	private String[] tipoGestoreCredenzialiIM = null;
	private boolean tipoGestoreCredenzialiIMRead = false;
	public String[] getTipoGestoreCredenzialiIM() {
		if(this.tipoGestoreCredenzialiIMRead == false){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.integrationManager.gestoriCredenziali"); 
				if(value!=null){
					value = value.trim();
					String [] r = value.split(",");
					this.tipoGestoreCredenzialiIM = r;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.services.integrationManager.gestoriCredenziali': "+e.getMessage(),e);
				this.tipoGestoreCredenzialiIM = null;
			}
			this.tipoGestoreCredenzialiIMRead = true;
		}

		return this.tipoGestoreCredenzialiIM;
	}
	
	
	
	
	
	




	/* ----------- Accesso Registro Servizi --------------------- */
	/**
	 * Indicazione se la porta di dominio deve processare gli accordi di servizio, i servizi e i fruitori ancora in stato di bozza
	 *   
	 * @return Indicazione se la porta di dominio deve processare gli accordi di servizio, i servizi e i fruitori ancora in stato di bozza
	 * 
	 */
	private Boolean isReadObjectStatoBozza = null;
	public boolean isReadObjectStatoBozza(){

		if(this.isReadObjectStatoBozza==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.registroServizi.readObjectStatoBozza"); 

				if (value != null){
					value = value.trim();
					this.isReadObjectStatoBozza = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.registroServizi.readObjectStatoBozza' non impostata, viene utilizzato il default=true");
					this.isReadObjectStatoBozza = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.registroServizi.readObjectStatoBozza' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isReadObjectStatoBozza = false;
			}
		}

		return this.isReadObjectStatoBozza;
	}
	
	
	
	
	
	
	/* ----------- Tracce --------------------- */
	/**
	 * Indicazione se la porta di dominio deve generare un errore in caso di tracciamento non riuscito
	 *   
	 * @return Indicazione se la porta di dominio deve generare un errore in caso di tracciamento non riuscito
	 * 
	 */
	private Boolean isTracciaturaFallita_BloccaCooperazioneInCorso = null;
	public boolean isTracciaturaFallita_BloccaCooperazioneInCorso(){

		if(this.isTracciaturaFallita_BloccaCooperazioneInCorso==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.tracciamento.registrazioneFallita.bloccaCooperazioneInCorso"); 

				if (value != null){
					value = value.trim();
					this.isTracciaturaFallita_BloccaCooperazioneInCorso = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.tracciamento.registrazioneFallita.bloccaCooperazioneInCorso' non impostata, viene utilizzato il default=true");
					this.isTracciaturaFallita_BloccaCooperazioneInCorso = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.tracciamento.registrazioneFallita.bloccaCooperazioneInCorso' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isTracciaturaFallita_BloccaCooperazioneInCorso = true;
			}
		}

		return this.isTracciaturaFallita_BloccaCooperazioneInCorso;
	}
	/**
	 * Indica se in caso di rilevamento di un errore di tracciatura devono essere bloccati tutti i servizi esposti da GovWay, in modo da non permettere alla PdD di gestire ulteriori richieste fino ad un intervento sistemistico.
	 *   
	 * @return Indica se in caso di rilevamento di un errore di tracciatura devono essere bloccati tutti i servizi esposti da GovWay, in modo da non permettere alla PdD di gestire ulteriori richieste fino ad un intervento sistemistico.
	 * 
	 */
	private Boolean isTracciaturaFallita_BloccoServiziPdD = null;
	public boolean isTracciaturaFallita_BloccoServiziPdD(){

		if(this.isTracciaturaFallita_BloccoServiziPdD==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.tracciamento.registrazione.bloccoServiziPdD"); 

				if (value != null){
					value = value.trim();
					this.isTracciaturaFallita_BloccoServiziPdD = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.tracciamento.registrazione.bloccoServiziPdD' non impostata, viene utilizzato il default=false");
					this.isTracciaturaFallita_BloccoServiziPdD = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.tracciamento.registrazione.bloccoServiziPdD' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isTracciaturaFallita_BloccoServiziPdD = false;
			}
		}

		return this.isTracciaturaFallita_BloccoServiziPdD;
	}
	
	
	
	
	
	
	
	
	
	
	
	/* ----------- MsgDiagnostici --------------------- */
	
	private Boolean isRegistrazioneDiagnosticaFile_intestazione_formatValues = null;
	public boolean isRegistrazioneDiagnosticaFile_intestazione_formatValues(){

		if(this.isRegistrazioneDiagnosticaFile_intestazione_formatValues==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.msgDiagnostici.file.header.formatValues"); 

				if (value != null){
					value = value.trim();
					this.isRegistrazioneDiagnosticaFile_intestazione_formatValues = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.msgDiagnostici.file.header.formatValues' non impostata, viene utilizzato il default=true");
					this.isRegistrazioneDiagnosticaFile_intestazione_formatValues = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.msgDiagnostici.file.header.formatValues' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isRegistrazioneDiagnosticaFile_intestazione_formatValues = true;
			}
		}

		return this.isRegistrazioneDiagnosticaFile_intestazione_formatValues;
	}
	
	/**
	 * Indica se in caso di rilevamento di un errore di emissione di un messaggio diagnostico (es. salvataggio su database non riuscito) devono essere bloccati tutti i servizi esposti da GovWay, in modo da non permettere alla PdD di gestire ulteriori richieste fino ad un intervento sistemistico.
	 *   
	 * @return Indica se in caso di rilevamento di un errore di emissione di un messaggio diagnostico (es. salvataggio su database non riuscito) devono essere bloccati tutti i servizi esposti da GovWay, in modo da non permettere alla PdD di gestire ulteriori richieste fino ad un intervento sistemistico.
	 * 
	 */
	private Boolean isRegistrazioneDiagnosticaFallita_BloccoServiziPdD = null;
	public boolean isRegistrazioneDiagnosticaFallita_BloccoServiziPdD(){

		if(this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.msgDiagnostici.emissioneFallita.bloccoServiziPdD"); 

				if (value != null){
					value = value.trim();
					this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.msgDiagnostici.emissioneFallita.bloccoServiziPdD' non impostata, viene utilizzato il default=false");
					this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.msgDiagnostici.emissioneFallita.bloccoServiziPdD' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD = false;
			}
		}

		return this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD;
	}
	
	private Boolean isLoggerSaajDisabilitato = null;
	public boolean isLoggerSaajDisabilitato(){

		if(this.isLoggerSaajDisabilitato==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.com.sun.xml.messaging.saaj.disabled"); 

				if (value != null){
					value = value.trim();
					this.isLoggerSaajDisabilitato = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.com.sun.xml.messaging.saaj.disabled' non impostata, viene utilizzato il default=true");
					this.isLoggerSaajDisabilitato = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.com.sun.xml.messaging.saaj.disabled' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isLoggerSaajDisabilitato = true;
			}
		}

		return this.isLoggerSaajDisabilitato;
	}
	
	
	
	
	
	
	
	
	/* ----------- Dump --------------------- */
	
	private String getDumpBufferImpl = null;
	private Boolean getDumpBufferImplRead = null;
	public String getDumpBufferImpl() {	
		if(this.getDumpBufferImplRead==null){
			String pName = "org.openspcoop2.pdd.logger.dump.buffer.impl";
			
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.getDumpBufferImpl = name;
				}
				
				this.getDumpBufferImplRead = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}    
		}

		return this.getDumpBufferImpl;
	}
	
	/**
	 * Indicazione se la porta di dominio deve registrare tutti gli attachments (in caso di dump abilitato) o solo quelli "visualizzabili"
	 *   
	 * @return Indicazione se la porta di dominio deve registrare tutti gli attachments (in caso di dump abilitato) o solo quelli "visualizzabili"
	 * 
	 */
	private Boolean isDumpAllAttachments = null;
	public boolean isDumpAllAttachments(){

		if(this.isDumpAllAttachments==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.dump.allAttachments"); 

				if (value != null){
					value = value.trim();
					this.isDumpAllAttachments = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.allAttachments' non impostata, viene utilizzato il default=true");
					this.isDumpAllAttachments = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.registroServizi.readObjectStatoBozza' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isDumpAllAttachments = true;
			}
		}

		return this.isDumpAllAttachments;
	}
	
	/**
	 * Indica se in caso di errore di dump applicativo (es. salvataggio contenuto non riuscito) deve essere bloccata la gestione del messaggio e generato un errore al client
	 *   
	 * @return Indica se in caso di errore di dump applicativo (es. salvataggio contenuto non riuscito) deve essere bloccata la gestione del messaggio e generato un errore al client
	 * 
	 */
	private Boolean isDumpFallitoBloccaCooperazioneInCorso = null;
	public boolean isDumpFallitoBloccaCooperazioneInCorso(){

		if(this.isDumpFallitoBloccaCooperazioneInCorso==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.dump.registrazioneFallita.bloccaCooperazioneInCorso"); 

				if (value != null){
					value = value.trim();
					this.isDumpFallitoBloccaCooperazioneInCorso = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.registrazioneFallita.bloccaCooperazioneInCorso' non impostata, viene utilizzato il default=false");
					this.isDumpFallitoBloccaCooperazioneInCorso = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.registrazioneFallita.bloccaCooperazioneInCorso' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isDumpFallitoBloccaCooperazioneInCorso = false;
			}
		}

		return this.isDumpFallitoBloccaCooperazioneInCorso;
	}
	/**
	 * Indica se in caso di rilevamento di un errore di tracciatura devono essere bloccati tutti i servizi esposti da GovWay, in modo da non permettere alla PdD di gestire ulteriori richieste fino ad un intervento sistemistico.
	 *   
	 * @return Indica se in caso di rilevamento di un errore di tracciatura devono essere bloccati tutti i servizi esposti da GovWay, in modo da non permettere alla PdD di gestire ulteriori richieste fino ad un intervento sistemistico.
	 * 
	 */
	private Boolean isDumpFallitoBloccoServiziPdD = null;
	public boolean isDumpFallitoBloccoServiziPdD(){

		if(this.isDumpFallitoBloccoServiziPdD==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.dump.registrazione.bloccoServiziPdD"); 

				if (value != null){
					value = value.trim();
					this.isDumpFallitoBloccoServiziPdD = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.registrazione.bloccoServiziPdD' non impostata, viene utilizzato il default=false");
					this.isDumpFallitoBloccoServiziPdD = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.registrazione.bloccoServiziPdD' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isDumpFallitoBloccoServiziPdD = false;
			}
		}

		return this.isDumpFallitoBloccoServiziPdD;
	}

	private List<String> getDumpHeaderWhiteList = null;
	public List<String> getDumpHeaderWhiteList(){

		if(this.getDumpHeaderWhiteList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.whiteList";
			try{
				this.getDumpHeaderWhiteList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName);
				initDumpList(this.getDumpHeaderWhiteList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderWhiteList;
	}
	
	private List<String> getDumpHeaderBlackList = null;
	public List<String> getDumpHeaderBlackList(){

		if(this.getDumpHeaderBlackList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.blackList";
			try{
				this.getDumpHeaderBlackList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName); 
				initDumpList(this.getDumpHeaderBlackList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderBlackList;
	}
	
	private List<String> getDumpHeaderErogazioniWhiteList = null;
	public List<String> getDumpHeaderErogazioniWhiteList(){

		if(this.getDumpHeaderErogazioniWhiteList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.whiteList";
			try{
				this.getDumpHeaderErogazioniWhiteList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName);
				initDumpList(this.getDumpHeaderErogazioniWhiteList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderErogazioniWhiteList;
	}
	
	private List<String> getDumpHeaderErogazioniBlackList = null;
	public List<String> getDumpHeaderErogazioniBlackList(){

		if(this.getDumpHeaderErogazioniBlackList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.blackList";
			try{
				this.getDumpHeaderErogazioniBlackList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName); 
				initDumpList(this.getDumpHeaderErogazioniBlackList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderErogazioniBlackList;
	}
	
	private List<String> getDumpHeaderFruizioniWhiteList = null;
	public List<String> getDumpHeaderFruizioniWhiteList(){

		if(this.getDumpHeaderFruizioniWhiteList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.whiteList";
			try{
				this.getDumpHeaderFruizioniWhiteList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName);
				initDumpList(this.getDumpHeaderFruizioniWhiteList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderFruizioniWhiteList;
	}
	
	private List<String> getDumpHeaderFruizioniBlackList = null;
	public List<String> getDumpHeaderFruizioniBlackList(){

		if(this.getDumpHeaderFruizioniBlackList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.blackList";
			try{
				this.getDumpHeaderFruizioniBlackList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName); 
				initDumpList(this.getDumpHeaderFruizioniBlackList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderFruizioniBlackList;
	}
	
	private List<String> getDumpHeaderErogazioniRichiestaIngressoWhiteList = null;
	public List<String> getDumpHeaderErogazioniRichiestaIngressoWhiteList(){

		if(this.getDumpHeaderErogazioniRichiestaIngressoWhiteList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.richiesta-ingresso.whiteList";
			try{
				this.getDumpHeaderErogazioniRichiestaIngressoWhiteList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName);
				initDumpList(this.getDumpHeaderErogazioniRichiestaIngressoWhiteList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderErogazioniRichiestaIngressoWhiteList;
	}
	
	private List<String> getDumpHeaderErogazioniRichiestaIngressoBlackList = null;
	public List<String> getDumpHeaderErogazioniRichiestaIngressoBlackList(){

		if(this.getDumpHeaderErogazioniRichiestaIngressoBlackList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.richiesta-ingresso.blackList";
			try{
				this.getDumpHeaderErogazioniRichiestaIngressoBlackList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName); 
				initDumpList(this.getDumpHeaderErogazioniRichiestaIngressoBlackList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderErogazioniRichiestaIngressoBlackList;
	}
	
	private List<String> getDumpHeaderErogazioniRichiestaUscitaWhiteList = null;
	public List<String> getDumpHeaderErogazioniRichiestaUscitaWhiteList(){

		if(this.getDumpHeaderErogazioniRichiestaUscitaWhiteList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.richiesta-uscita.whiteList";
			try{
				this.getDumpHeaderErogazioniRichiestaUscitaWhiteList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName);
				initDumpList(this.getDumpHeaderErogazioniRichiestaUscitaWhiteList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderErogazioniRichiestaUscitaWhiteList;
	}
	
	private List<String> getDumpHeaderErogazioniRichiestaUscitaBlackList = null;
	public List<String> getDumpHeaderErogazioniRichiestaUscitaBlackList(){

		if(this.getDumpHeaderErogazioniRichiestaUscitaBlackList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.richiesta-uscita.blackList";
			try{
				this.getDumpHeaderErogazioniRichiestaUscitaBlackList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName); 
				initDumpList(this.getDumpHeaderErogazioniRichiestaUscitaBlackList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderErogazioniRichiestaUscitaBlackList;
	}
	
	private List<String> getDumpHeaderErogazioniRispostaIngressoWhiteList = null;
	public List<String> getDumpHeaderErogazioniRispostaIngressoWhiteList(){

		if(this.getDumpHeaderErogazioniRispostaIngressoWhiteList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.risposta-ingresso.whiteList";
			try{
				this.getDumpHeaderErogazioniRispostaIngressoWhiteList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName);
				initDumpList(this.getDumpHeaderErogazioniRispostaIngressoWhiteList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderErogazioniRispostaIngressoWhiteList;
	}
	
	private List<String> getDumpHeaderErogazioniRispostaIngressoBlackList = null;
	public List<String> getDumpHeaderErogazioniRispostaIngressoBlackList(){

		if(this.getDumpHeaderErogazioniRispostaIngressoBlackList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.risposta-ingresso.blackList";
			try{
				this.getDumpHeaderErogazioniRispostaIngressoBlackList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName); 
				initDumpList(this.getDumpHeaderErogazioniRispostaIngressoBlackList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderErogazioniRispostaIngressoBlackList;
	}
	
	private List<String> getDumpHeaderErogazioniRispostaUscitaWhiteList = null;
	public List<String> getDumpHeaderErogazioniRispostaUscitaWhiteList(){

		if(this.getDumpHeaderErogazioniRispostaUscitaWhiteList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.risposta-uscita.whiteList";
			try{
				this.getDumpHeaderErogazioniRispostaUscitaWhiteList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName);
				initDumpList(this.getDumpHeaderErogazioniRispostaUscitaWhiteList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderErogazioniRispostaUscitaWhiteList;
	}
	
	private List<String> getDumpHeaderErogazioniRispostaUscitaBlackList = null;
	public List<String> getDumpHeaderErogazioniRispostaUscitaBlackList(){

		if(this.getDumpHeaderErogazioniRispostaUscitaBlackList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.risposta-uscita.blackList";
			try{
				this.getDumpHeaderErogazioniRispostaUscitaBlackList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName); 
				initDumpList(this.getDumpHeaderErogazioniRispostaUscitaBlackList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderErogazioniRispostaUscitaBlackList;
	}
	
	private List<String> getDumpHeaderFruizioniRichiestaIngressoWhiteList = null;
	public List<String> getDumpHeaderFruizioniRichiestaIngressoWhiteList(){

		if(this.getDumpHeaderFruizioniRichiestaIngressoWhiteList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.richiesta-ingresso.whiteList";
			try{
				this.getDumpHeaderFruizioniRichiestaIngressoWhiteList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName);
				initDumpList(this.getDumpHeaderFruizioniRichiestaIngressoWhiteList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderFruizioniRichiestaIngressoWhiteList;
	}
	
	private List<String> getDumpHeaderFruizioniRichiestaIngressoBlackList = null;
	public List<String> getDumpHeaderFruizioniRichiestaIngressoBlackList(){

		if(this.getDumpHeaderFruizioniRichiestaIngressoBlackList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.richiesta-ingresso.blackList";
			try{
				this.getDumpHeaderFruizioniRichiestaIngressoBlackList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName); 
				initDumpList(this.getDumpHeaderFruizioniRichiestaIngressoBlackList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderFruizioniRichiestaIngressoBlackList;
	}
	
	private List<String> getDumpHeaderFruizioniRichiestaUscitaWhiteList = null;
	public List<String> getDumpHeaderFruizioniRichiestaUscitaWhiteList(){

		if(this.getDumpHeaderFruizioniRichiestaUscitaWhiteList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.richiesta-uscita.whiteList";
			try{
				this.getDumpHeaderFruizioniRichiestaUscitaWhiteList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName);
				initDumpList(this.getDumpHeaderFruizioniRichiestaUscitaWhiteList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderFruizioniRichiestaUscitaWhiteList;
	}
	
	private List<String> getDumpHeaderFruizioniRichiestaUscitaBlackList = null;
	public List<String> getDumpHeaderFruizioniRichiestaUscitaBlackList(){

		if(this.getDumpHeaderFruizioniRichiestaUscitaBlackList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.richiesta-uscita.blackList";
			try{
				this.getDumpHeaderFruizioniRichiestaUscitaBlackList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName); 
				initDumpList(this.getDumpHeaderFruizioniRichiestaUscitaBlackList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderFruizioniRichiestaUscitaBlackList;
	}
	
	private List<String> getDumpHeaderFruizioniRispostaIngressoWhiteList = null;
	public List<String> getDumpHeaderFruizioniRispostaIngressoWhiteList(){

		if(this.getDumpHeaderFruizioniRispostaIngressoWhiteList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.risposta-ingresso.whiteList";
			try{
				this.getDumpHeaderFruizioniRispostaIngressoWhiteList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName);
				initDumpList(this.getDumpHeaderFruizioniRispostaIngressoWhiteList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderFruizioniRispostaIngressoWhiteList;
	}
	
	private List<String> getDumpHeaderFruizioniRispostaIngressoBlackList = null;
	public List<String> getDumpHeaderFruizioniRispostaIngressoBlackList(){

		if(this.getDumpHeaderFruizioniRispostaIngressoBlackList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.risposta-ingresso.blackList";
			try{
				this.getDumpHeaderFruizioniRispostaIngressoBlackList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName); 
				initDumpList(this.getDumpHeaderFruizioniRispostaIngressoBlackList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderFruizioniRispostaIngressoBlackList;
	}
	
	private List<String> getDumpHeaderFruizioniRispostaUscitaWhiteList = null;
	public List<String> getDumpHeaderFruizioniRispostaUscitaWhiteList(){

		if(this.getDumpHeaderFruizioniRispostaUscitaWhiteList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.risposta-uscita.whiteList";
			try{
				this.getDumpHeaderFruizioniRispostaUscitaWhiteList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName);
				initDumpList(this.getDumpHeaderFruizioniRispostaUscitaWhiteList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderFruizioniRispostaUscitaWhiteList;
	}
	
	private List<String> getDumpHeaderFruizioniRispostaUscitaBlackList = null;
	public List<String> getDumpHeaderFruizioniRispostaUscitaBlackList(){

		if(this.getDumpHeaderFruizioniRispostaUscitaBlackList==null){
			String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.risposta-uscita.blackList";
			try{
				this.getDumpHeaderFruizioniRispostaUscitaBlackList = new ArrayList<>();
				String tmp = this.reader.getValueConvertEnvProperties(pName); 
				initDumpList(this.getDumpHeaderFruizioniRispostaUscitaBlackList, tmp);
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
		}

		return this.getDumpHeaderFruizioniRispostaUscitaBlackList;
	}
	
	private void initDumpList(List<String> list, String tmp) {
		if(tmp!=null && !"".equals(tmp.trim())) {
			tmp = tmp.trim();
			if(tmp.contains(",")) {
				String [] split = tmp.split(",");
				initDumpList(list, split);
			}
			else {
				list.add(tmp);
			}
		}
	}
	private void initDumpList(List<String> list, String [] split) {
		if(split!=null && split.length>0) {
			for (String s : split) {
				if(s!=null) {
					s = s.trim();
					if(!"".equals(s)) {
						list.add(s);
					}
				}
			}
		}
	}
	
	
	private Boolean isDumpEmitDiagnostic = null;
	public boolean isDumpEmitDiagnostic(){

		if(this.isDumpEmitDiagnostic==null){
			String pName = "org.openspcoop2.pdd.logger.dump.emitDiagnostic";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isDumpEmitDiagnostic = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isDumpEmitDiagnostic = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isDumpEmitDiagnostic = true;
			}
		}

		return this.isDumpEmitDiagnostic;
	}
	
	
	/* ----------- Dump (Binario) --------------------- */
	
	private Boolean isDumpBinarioRegistrazioneDatabase = null;
	public boolean isDumpBinarioRegistrazioneDatabase(){

		if(this.isDumpBinarioRegistrazioneDatabase==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.dumpBinario.registrazioneDatabase"); 

				if (value != null){
					value = value.trim();
					this.isDumpBinarioRegistrazioneDatabase = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dumpBinario.registrazioneDatabase' non impostata, viene utilizzato il default=false");
					this.isDumpBinarioRegistrazioneDatabase = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dumpBinario.registrazioneDatabase' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isDumpBinarioRegistrazioneDatabase = false;
			}
		}

		return this.isDumpBinarioRegistrazioneDatabase;
	}
	
	private Integer getDumpBinarioInMemoryThreshold = null;
	public int getDumpBinarioInMemoryThreshold() {	
		String pName = "org.openspcoop2.pdd.logger.dumpBinario.inMemory.threshold";
		if(this.getDumpBinarioInMemoryThreshold==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.getDumpBinarioInMemoryThreshold = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.DUMP_BINARIO_THRESHOLD));
					this.getDumpBinarioInMemoryThreshold = CostantiPdD.DUMP_BINARIO_THRESHOLD;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.DUMP_BINARIO_THRESHOLD),e);
				this.getDumpBinarioInMemoryThreshold = CostantiPdD.DUMP_BINARIO_THRESHOLD;
			}  
		}

		return this.getDumpBinarioInMemoryThreshold;
	}
	
	private File getDumpBinarioRepository = null;
	public File getDumpBinarioRepository() throws CoreException {	
		String pName = "org.openspcoop2.pdd.logger.dumpBinario.msgRepository";
		if(this.getDumpBinarioRepository==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getDumpBinarioRepository = new File(name);
				checkDumpBinarioRepository();
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getDumpBinarioRepository;
	}
	private void checkDumpBinarioRepository() throws CoreException {
		if(this.getDumpBinarioRepository.exists()) {
			if(!this.getDumpBinarioRepository.isDirectory()) {
				throw newCoreExceptionNotDir(this.getDumpBinarioRepository,true);
			}
			if(!this.getDumpBinarioRepository.canRead()) {
				throw newCoreExceptionCannotRead(this.getDumpBinarioRepository, true);
			}
			if(!this.getDumpBinarioRepository.canWrite()) {
				throw newCoreExceptionCannotWrite(this.getDumpBinarioRepository, true);
			}
		}
		else {
			// viene creata automaticamente
		}
	}
	
	
	
	
	/* ----------- Dump (NonRealtime) --------------------- */
	
	private Integer getDumpNonRealtimeInMemoryThreshold = null;
	public int getDumpNonRealtimeInMemoryThreshold() {	
		if(this.getDumpNonRealtimeInMemoryThreshold==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dump.nonRealTime.inMemory.threshold");
				if(name!=null){
					name = name.trim();
					this.getDumpNonRealtimeInMemoryThreshold = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.inMemory.threshold' non impostata, viene utilizzato il default="+CostantiPdD.DUMP_NON_REALTIME_THRESHOLD);
					this.getDumpNonRealtimeInMemoryThreshold = CostantiPdD.DUMP_NON_REALTIME_THRESHOLD;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.inMemory.threshold' non impostata, viene utilizzato il default="+CostantiPdD.DUMP_NON_REALTIME_THRESHOLD+", errore:"+e.getMessage(),e);
				this.getDumpNonRealtimeInMemoryThreshold = CostantiPdD.DUMP_NON_REALTIME_THRESHOLD;
			}  
		}

		return this.getDumpNonRealtimeInMemoryThreshold;
	}
	
	private String getDumpNonRealtimeMode = null;
	private String getDumpNonRealtimeMode() throws CoreException {	
		if(this.getDumpNonRealtimeMode==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dump.nonRealTime.mode");
				if(name!=null){
					name = name.trim();
					if(!CostantiPdD.DUMP_NON_REALTIME_MODE_DB.equalsIgnoreCase(name) && 
							!CostantiPdD.DUMP_NON_REALTIME_MODE_FILE_SYSTEM.equalsIgnoreCase(name) && 
							!CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO.equalsIgnoreCase(name) ) {
						throw new CoreException("Modalità non supportata (attesi: "+CostantiPdD.DUMP_NON_REALTIME_MODE_DB+","+CostantiPdD.DUMP_NON_REALTIME_MODE_FILE_SYSTEM+","+CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO+")");
					}
					this.getDumpNonRealtimeMode = name;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.mode' non impostata, viene utilizzato il default="+CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO);
					this.getDumpNonRealtimeMode = CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO;
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop ''org.openspcoop2.pdd.dump.nonRealTime.mode' non impostata, errore:"+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}  
			
			checkDumpNonRealtimeMode();
		}

		return this.getDumpNonRealtimeMode;
	}
	private void checkDumpNonRealtimeMode() throws CoreException {	
		if(CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO.equalsIgnoreCase(this.getDumpNonRealtimeMode)) {
			String databaseTypeCheck = this.getDatabaseType();
			if(databaseTypeCheck==null) {
				throw new CoreException("Proprieta' 'org.openspcoop2.pdd.dump.nonRealTime.mode=auto' richiede che sia indicato un tipo di database nella proprieta' 'org.openspcoop2.pdd.repository.tipoDatabase'");
			}
			if(TipiDatabase.POSTGRESQL.getNome().equalsIgnoreCase(databaseTypeCheck) || TipiDatabase.HSQL.getNome().equalsIgnoreCase(databaseTypeCheck)) {
				// Allo stato attuale (13/02/2014) i sequenti sql server (postgresql e hsql) non supportano la funzionalita' jdbc per fare setStream senza fornire la lenght
				this.getDumpNonRealtimeMode = CostantiPdD.DUMP_NON_REALTIME_MODE_FILE_SYSTEM;
			}
			else {
				this.getDumpNonRealtimeMode = CostantiPdD.DUMP_NON_REALTIME_MODE_DB;
			}
		}
	}
	
	public boolean isDumpNonRealtimeDatabaseMode() {
		return CostantiPdD.DUMP_NON_REALTIME_MODE_DB.equalsIgnoreCase(this.getDumpNonRealtimeMode);
	}
	public boolean isDumpNonRealtimeFileSystemMode() {
		return CostantiPdD.DUMP_NON_REALTIME_MODE_FILE_SYSTEM.equalsIgnoreCase(this.getDumpNonRealtimeMode);
	}
	
	private File getDumpNonRealtimeRepository = null;
	public File getDumpNonRealtimeRepository() throws CoreException {	
		if(this.getDumpNonRealtimeRepository==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dump.nonRealTime.msgRepository");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getDumpNonRealtimeRepository = new File(name);
				checkDumpNonRealtimeRepository();
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.msgRepository': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getDumpNonRealtimeRepository;
	}
	private void checkDumpNonRealtimeRepository() throws CoreException {	
		if(this.getDumpNonRealtimeRepository.exists()) {
			if(!this.getDumpNonRealtimeRepository.isDirectory()) {
				throw newCoreExceptionNotDir(this.getDumpNonRealtimeRepository,true);
			}
			if(!this.getDumpNonRealtimeRepository.canRead()) {
				throw newCoreExceptionCannotRead(this.getDumpNonRealtimeRepository, true);
			}
			if(!this.getDumpNonRealtimeRepository.canWrite()) {
				throw newCoreExceptionCannotWrite(this.getDumpNonRealtimeRepository, true);
			}
		}
		else {
			// viene creata automaticamente
		}
	}
	
	private Boolean isDumpNonRealtimeThrowStreamingHandlerException = null;
	public boolean isDumpNonRealtimeThrowStreamingHandlerException(){

		if(this.isDumpNonRealtimeThrowStreamingHandlerException==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dump.nonRealTime.throwStreamingHandlerException"); 

				if (value != null){
					value = value.trim();
					this.isDumpNonRealtimeThrowStreamingHandlerException = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.throwStreamingHandlerException' non impostata, viene utilizzato il default=true");
					this.isDumpNonRealtimeThrowStreamingHandlerException = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.throwStreamingHandlerException' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isDumpNonRealtimeThrowStreamingHandlerException = true;
			}
		}

		return this.isDumpNonRealtimeThrowStreamingHandlerException;
	}
	
	
	
	
	
	/* ------------- ID ---------------------*/
	/**
	 * Restituisce il tipo di generatore id identificativi unici
	 *
	 * @return il tipo di generatore id identificativi unici
	 * 
	 */
	private String tipoIDManager = null;
	public String getTipoIDManager() {	
		if(this.tipoIDManager==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.idGenerator");
				if(name!=null){
					name = name.trim();
					this.tipoIDManager = name;
				}else{
					this.tipoIDManager = CostantiConfigurazione.NONE;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.idGenerator': "+e.getMessage(),e);
				this.tipoIDManager = CostantiConfigurazione.NONE;
			}    
		}

		return this.tipoIDManager;
	}
	
	private Boolean useIDManagerWithThreadLocal = null;
	public boolean useIDManagerWithThreadLocal(){

		String pName = "org.openspcoop2.pdd.idGenerator.useThreadLocal";
		if(this.useIDManagerWithThreadLocal==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.useIDManagerWithThreadLocal = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.useIDManagerWithThreadLocal = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.useIDManagerWithThreadLocal = false;
			}
		}

		return this.useIDManagerWithThreadLocal;
	}
	
	private Boolean listIDManagerParametersRead = null;
	private List<String> listIDManagerParameters = null;
	public List<String> getIDManagerParameters(){

		String pName = "org.openspcoop2.pdd.idGenerator."+this.getTipoIDManager()+".parameters";
		if(this.listIDManagerParametersRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				initIDManagerParameters(value);

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			this.listIDManagerParametersRead = true;
		}

		return this.listIDManagerParameters;
	}
	private void initIDManagerParameters(String value){
		if (value != null){
			value = value.trim();
			
			if(value.contains(",")) {
				String [] tmp = value.split(",");
				if(tmp!=null && tmp.length>0) {
					this.listIDManagerParameters = new ArrayList<>();
					for (String v : tmp) {
						this.listIDManagerParameters.add(v);
					}
				}
			}
			else {
				this.listIDManagerParameters = new ArrayList<>();
				this.listIDManagerParameters.add(value);
			}
		}
	}
	
	private Integer getIDManagerBufferSize = null;
	public int getIDManagerBufferSize(){

		String pName = "org.openspcoop2.pdd.idGenerator.buffer";
		if(this.getIDManagerBufferSize==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getIDManagerBufferSize = Integer.parseInt(value);
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=-1");
					this.getIDManagerBufferSize = -1;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=-1, errore:"+e.getMessage(),e);
				this.getIDManagerBufferSize = -1;
			}
		}

		return this.getIDManagerBufferSize;
	}
	
	
	
	
	
	/* ------------- DEMO Mode ---------------------*/
	private Boolean generazioneDateCasualiLogAbilitato = null;
	private Date generazioneDateCasualiLogDataInizioIntervallo = null;
	private Date generazioneDateCasualiLogDataFineIntervallo = null;
	public Date getGenerazioneDateCasualiLogDataInizioIntervallo() {
		return this.generazioneDateCasualiLogDataInizioIntervallo;
	}
	public Date getGenerazioneDateCasualiLogDataFineIntervallo() {
		return this.generazioneDateCasualiLogDataFineIntervallo;
	}
	public boolean generazioneDateCasualiLogAbilitato() {	
		if(this.generazioneDateCasualiLogAbilitato==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.generazioneDateCasuali.enabled");
				if(name!=null){
					name = name.trim();
					this.generazioneDateCasualiLogAbilitato = Boolean.parseBoolean(name);
					
					initDateCasualiLogAbilitato();
					
				}else{
					this.generazioneDateCasualiLogAbilitato = false; //default, anche senza che sia definita la proprieta'
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.generazioneDateCasuali.enabled' non impostata correttamente,  errore:"+e.getMessage(),e);
				this.generazioneDateCasualiLogAbilitato = false;
			}    
		}

		return this.generazioneDateCasualiLogAbilitato;
	}
	private void initDateCasualiLogAbilitato() throws CoreException, UtilsException, ParseException {	
		if(this.generazioneDateCasualiLogAbilitato.booleanValue()){
			
			if(getTipoIDManager()==null || CostantiConfigurazione.NONE.equals(getTipoIDManager())){
				throw new CoreException("Non e' possibile utilizzare la modalita' di generazione casuale delle date, se non si abilita la generazione di un ID");
			}
			
			String inizioIntervallo = this.reader.getValueConvertEnvProperties("org.openspcoop2.generazioneDateCasuali.inizioIntervallo");
			String fineIntervallo = this.reader.getValueConvertEnvProperties("org.openspcoop2.generazioneDateCasuali.fineIntervallo");
			SimpleDateFormat sdf = DateUtils.getDefaultDateTimeFormatter("yyyy-MM-dd hh:mm");
			if(inizioIntervallo==null){
				throw new CoreException("Non e' stato definito l'intervallo di inizio per la modalita' di generazione casuale delle date");
			}
			else{inizioIntervallo=inizioIntervallo.trim();}
			this.generazioneDateCasualiLogDataInizioIntervallo = sdf.parse(inizioIntervallo);
			if(fineIntervallo==null){
				throw new CoreException("Non e' stato definito l'intervallo di fine per la modalita' di generazione casuale delle date");
			}
			else{fineIntervallo=fineIntervallo.trim();}
			this.generazioneDateCasualiLogDataFineIntervallo = sdf.parse(fineIntervallo);
			
			if(this.generazioneDateCasualiLogDataInizioIntervallo.after(this.generazioneDateCasualiLogDataFineIntervallo)){
				throw new CoreException("Non e' stato definito un intervallo di generazione casuale delle date corretto (inizioIntervallo>fineIntervallo)");
			}
		}
	}
	
	
	
	
	
	/* ------------- Factory ---------------------*/
	
	private Boolean openspcoop2MessageFactoryRead = null;
	private String openspcoop2MessageFactory = null;
	public String getOpenspcoop2MessageFactory() {	
		if(this.openspcoop2MessageFactoryRead==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messagefactory");
				if(v!=null){
					v = v.trim();
					this.openspcoop2MessageFactory = v;
				} else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messagefactory' non impostata, viene utilizzato il default="+OpenSPCoop2MessageFactory.messageFactoryImpl);
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messagefactory' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		this.openspcoop2MessageFactoryRead = true;
		return this.openspcoop2MessageFactory;
	}
	
	private Boolean messageSecurityContextRead = null;
	private String messageSecurityContext = null;
	public String getMessageSecurityContext() {	
		if(this.messageSecurityContextRead==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.context");
				if(v!=null){
					v = v.trim();
					this.messageSecurityContext = v;
				} else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.context' non impostata, viene utilizzato il default="+MessageSecurityFactory.messageSecurityContextImplClass);
				}
			} catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.context' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		this.messageSecurityContextRead = true;
		return this.messageSecurityContext;
	}
	
	private Boolean messageSecurityDigestReaderRead = null;
	private String messageSecurityDigestReader = null;
	public String getMessageSecurityDigestReader() {	
		if(this.messageSecurityDigestReaderRead==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.digestReader");
				if(v!=null){
					v = v.trim();
					this.messageSecurityDigestReader = v;
				} else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.digestReader' non impostata, viene utilizzato il default="+MessageSecurityFactory.messageSecurityDigestReaderImplClass);
				}
			} catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.digestReader' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		this.messageSecurityDigestReaderRead = true;
		return this.messageSecurityDigestReader;
	}
	
	private Boolean printInfoFactory = null;
	public boolean isPrintInfoFactory() {	
		if(this.printInfoFactory==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messagefactory.printInfo");
				if(v!=null){
					v = v.trim();
					this.printInfoFactory = Boolean.parseBoolean(v);
				} 
				else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messagefactory.printInfo' non impostata, viene utilizzato il default="+true);
					this.printInfoFactory = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messagefactory.printInfo' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		return this.printInfoFactory;
	}
		
	private Boolean printInfoMessageSecurity = null;
	public boolean isPrintInfoMessageSecurity() {	
		if(this.printInfoMessageSecurity==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.printInfo");
				if(v!=null){
					v = v.trim();
					this.printInfoMessageSecurity = Boolean.parseBoolean(v);
				} 
				else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.printInfo' non impostata, viene utilizzato il default="+true);
					this.printInfoMessageSecurity = true;
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.printInfo' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		return this.printInfoMessageSecurity;
	}
	
	
	
	/* ------------- Utility ---------------------*/
	
	private Boolean freeMemoryLog = null;
	public boolean getFreeMemoryLog() {	
		if(this.freeMemoryLog==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.freememorylog");
				if(v!=null){
					v = v.trim();
					this.freeMemoryLog = Boolean.parseBoolean(v);
				} 
				else{
					this.freeMemoryLog = false;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.freememorylog' non impostata correttamente. Assumo valore di default 'false'.");
				this.freeMemoryLog = false;
			} 
		}
		return this.freeMemoryLog;
	}
	
	
	
	
	
	
	/* ------------- Protocol ---------------------*/
	
	private String defaultProtocolName = null;		
	public String getDefaultProtocolName(){
		if(this.defaultProtocolName==null){
			try{ 
				this.defaultProtocolName = this.reader.getValue("org.openspcoop2.pdd.services.defaultProtocol");
				if(this.defaultProtocolName!=null){
					this.defaultProtocolName = this.defaultProtocolName.trim();
				}
			} catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.defaultProtocol' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		return this.defaultProtocolName;
	}

	
		
	
	/* ------------- Soggetti Virtuali ---------------------*/
	
	private Boolean isSoggettiVirtualiEnabled = null;
	public boolean isSoggettiVirtualiEnabled() {	
		if(this.isSoggettiVirtualiEnabled==null){
			String pName = "org.openspcoop2.pdd.SoggettiVirtuali.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isSoggettiVirtualiEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isSoggettiVirtualiEnabled = false;
			}    
		}

		return this.isSoggettiVirtualiEnabled;
	}
	
	
	/* ------------- Generazione Errore Protocol non supportato ---------------------*/
	
	private Boolean isGenerazioneErroreProtocolloNonSupportato = null;
	public boolean isGenerazioneErroreProtocolloNonSupportato() {	
		if(this.isGenerazioneErroreProtocolloNonSupportato==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.protocolNotSupported.generateErrorMessage");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.protocolNotSupported.generateErrorMessage' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isGenerazioneErroreProtocolloNonSupportato = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.protocolNotSupported.generateErrorMessage': "+e.getMessage(),e);
				this.isGenerazioneErroreProtocolloNonSupportato = false;
			}    
		}

		return this.isGenerazioneErroreProtocolloNonSupportato;
	}
	
	
	
	
	/* ------------- Generazione Errore HttpMethodUnsupported ---------------------*/
	
	private Boolean isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled = null;
	public boolean isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled() {	
		if(this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pd.httpMethodUnsupported.generateErrorMessage");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pd.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pd.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
				this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled = true;
			}    
		}

		return this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled;
	}
	
	private Boolean isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled = null;
	public boolean isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled() {	
		if(this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pdToSoap.httpMethodUnsupported.generateErrorMessage");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pdToSoap.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pdToSoap.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
				this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled = true;
			}    
		}

		return this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled;
	}
	
	private Boolean isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled = null;
	public boolean isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled() {	
		if(this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pa.httpMethodUnsupported.generateErrorMessage");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pa.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pa.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
				this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled = true;
			}    
		}

		return this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled;
	}
	
	private Boolean isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled = null;
	public boolean isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled() {	
		if(this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.im.httpMethodUnsupported.generateErrorMessage");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.im.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.im.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
				this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled = true;
			}    
		}

		return this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled;
	}
	
	private Boolean isGenerazioneErroreHttpMethodUnsupportedCheckEnabled = null;
	public boolean isGenerazioneErroreHttpMethodUnsupportedCheckEnabled() {	
		if(this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.httpMethodUnsupported.generateErrorMessage");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.check.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
				this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled = true;
			}    
		}

		return this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled;
	}
	
	private Boolean isGenerazioneErroreHttpMethodUnsupportedProxyEnabled = null;
	public boolean isGenerazioneErroreHttpMethodUnsupportedProxyEnabled() {	
		if(this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxy.httpMethodUnsupported.generateErrorMessage");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxy.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxy.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
				this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled = true;
			}    
		}

		return this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled;
	}
	
	
	
	
	/* ------------- Generazione WSDL ---------------------*/
	
	private Boolean isGenerazioneWsdlPortaDelegataEnabled = null;
	public boolean isGenerazioneWsdlPortaDelegataEnabled() {	
		if(this.isGenerazioneWsdlPortaDelegataEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pd.generateWsdl");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pd.generateWsdl' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isGenerazioneWsdlPortaDelegataEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pd.generateWsdl': "+e.getMessage(),e);
				this.isGenerazioneWsdlPortaDelegataEnabled = false;
			}    
		}

		return this.isGenerazioneWsdlPortaDelegataEnabled;
	}
	
	private Boolean isGenerazioneWsdlPortaApplicativaEnabled = null;
	public boolean isGenerazioneWsdlPortaApplicativaEnabled() {	
		if(this.isGenerazioneWsdlPortaApplicativaEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pa.generateWsdl");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pa.generateWsdl' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isGenerazioneWsdlPortaApplicativaEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pa.generateWsdl': "+e.getMessage(),e);
				this.isGenerazioneWsdlPortaApplicativaEnabled = false;
			}    
		}

		return this.isGenerazioneWsdlPortaApplicativaEnabled;
	}
	
	private Boolean isGenerazioneWsdlIntegrationManagerEnabled = null;
	public boolean isGenerazioneWsdlIntegrationManagerEnabled() {	
		if(this.isGenerazioneWsdlIntegrationManagerEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.im.generateWsdl");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.im.generateWsdl' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isGenerazioneWsdlIntegrationManagerEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.im.generateWsdl': "+e.getMessage(),e);
				this.isGenerazioneWsdlIntegrationManagerEnabled = true;
			}    
		}

		return this.isGenerazioneWsdlIntegrationManagerEnabled;
	}
	
	
	
	
	/* ------------- Check Reader Risorse JMX ---------------------*/
	
	private Boolean isCheckEnabled = null;
	public boolean isCheckEnabled() {	
		if(this.isCheckEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.check.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isCheckEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.enabled': "+e.getMessage(),e);
				this.isCheckEnabled = true;
			}    
		}

		return this.isCheckEnabled;
	}
	
	private Boolean isCheckHealthCheckApiRestEnabled = null;
	public boolean isCheckHealthCheckApiRestEnabled() {	
		if(this.isCheckHealthCheckApiRestEnabled==null){
			String pName = "org.openspcoop2.pdd.check.healthCheck.apiRest.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isCheckHealthCheckApiRestEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isCheckHealthCheckApiRestEnabled = false;
			}    
		}

		return this.isCheckHealthCheckApiRestEnabled;
	}
	
	private String getCheckHealthCheckApiRestEndpoint = null;
	public String getCheckHealthCheckApiRestEndpoint() {	
		if(this.getCheckHealthCheckApiRestEndpoint==null){
			String pName = "org.openspcoop2.pdd.check.healthCheck.apiRest.endpoint";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Non definita");
				}
				name = name.trim();
				this.getCheckHealthCheckApiRestEndpoint = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.getCheckHealthCheckApiRestEndpoint = null;
			}    
		}

		return this.getCheckHealthCheckApiRestEndpoint;
	}
	
	private Boolean isCheckHealthCheckApiSoapEnabled = null;
	public boolean isCheckHealthCheckApiSoapEnabled() {	
		if(this.isCheckHealthCheckApiSoapEnabled==null){
			String pName = "org.openspcoop2.pdd.check.healthCheck.apiSoap.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isCheckHealthCheckApiSoapEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isCheckHealthCheckApiSoapEnabled = false;
			}    
		}

		return this.isCheckHealthCheckApiSoapEnabled;
	}
	
	private String getCheckHealthCheckApiSoapEndpoint = null;
	public String getCheckHealthCheckApiSoapEndpoint() {	
		if(this.getCheckHealthCheckApiSoapEndpoint==null){
			String pName = "org.openspcoop2.pdd.check.healthCheck.apiSoap.endpoint";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Non definita");
				}
				name = name.trim();
				this.getCheckHealthCheckApiSoapEndpoint = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.getCheckHealthCheckApiSoapEndpoint = null;
			}    
		}

		return this.getCheckHealthCheckApiSoapEndpoint;
	}
	
	private Boolean isCheckReadJMXResourcesEnabled = null;
	public boolean isCheckReadJMXResourcesEnabled() {	
		if(this.isCheckReadJMXResourcesEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.readJMXResources.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.check.readJMXResources.enabled' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isCheckReadJMXResourcesEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.readJMXResources.enabled': "+e.getMessage(),e);
				this.isCheckReadJMXResourcesEnabled = false;
			}    
		}

		return this.isCheckReadJMXResourcesEnabled;
	}
	
	private String getCheckReadJMXResourcesUsername = null;
	private Boolean getCheckReadJMXResourcesUsernameRead = null;
	public String getCheckReadJMXResourcesUsername() {	
		if(this.getCheckReadJMXResourcesUsernameRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.readJMXResources.username");
				if(name!=null){
					name = name.trim();
				}
				this.getCheckReadJMXResourcesUsernameRead = true;
				this.getCheckReadJMXResourcesUsername = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.readJMXResources.username': "+e.getMessage(),e);
			}    
		}
		return this.getCheckReadJMXResourcesUsername;
	}
	
	private String getCheckReadJMXResourcesPassword = null;
	private Boolean getCheckReadJMXResourcesPasswordRead = null;
	public String getCheckReadJMXResourcesPassword() {	
		if(this.getCheckReadJMXResourcesPasswordRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.readJMXResources.password");
				if(name!=null){
					name = name.trim();
				}
				this.getCheckReadJMXResourcesPasswordRead = true;
				this.getCheckReadJMXResourcesPassword = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.readJMXResources.password': "+e.getMessage(),e);
			}    
		}
		return this.getCheckReadJMXResourcesPassword;
	}
	
	
	private Boolean isProxyReadJMXResourcesEnabled = null;
	public boolean isProxyReadJMXResourcesEnabled() {	
		if(this.isProxyReadJMXResourcesEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.enabled' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isProxyReadJMXResourcesEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.enabled': "+e.getMessage(),e);
				this.isProxyReadJMXResourcesEnabled = false;
			}    
		}

		return this.isProxyReadJMXResourcesEnabled;
	}
	
	private Boolean isProxyReadJMXResourcesAsyncProcessByTimer = null;
	public boolean isProxyReadJMXResourcesAsyncProcessByTimer() {	
		if(this.isProxyReadJMXResourcesAsyncProcessByTimer==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isProxyReadJMXResourcesAsyncProcessByTimer = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate': "+e.getMessage(),e);
				this.isProxyReadJMXResourcesAsyncProcessByTimer = false;
			}    
		}

		return this.isProxyReadJMXResourcesAsyncProcessByTimer;
	}
	
	private String getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass = null;
	private Boolean getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClassRead = null;
	public String getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass() {	
		if(this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClassRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.serviceClass");
				if(name!=null){
					name = name.trim();
				}
				this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClassRead = true;
				this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass = name;
			} catch(java.lang.Exception e) {
				this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.serviceClass': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass;
	}
	
	private Boolean isProxyReadJMXResourcesAsyncProcessByTimerDebug = null;
	public boolean isProxyReadJMXResourcesAsyncProcessByTimerDebug() {	
		if(this.isProxyReadJMXResourcesAsyncProcessByTimerDebug==null){
			String pName = "org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.debug";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isProxyReadJMXResourcesAsyncProcessByTimerDebug = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isProxyReadJMXResourcesAsyncProcessByTimerDebug = true;
			}    
		}

		return this.isProxyReadJMXResourcesAsyncProcessByTimerDebug;
	}
	
	private String getProxyReadJMXResourcesAsyncProcessByTimerHostname = null;
	private Boolean getProxyReadJMXResourcesAsyncProcessByTimerHostnameRead = null;
	public String getProxyReadJMXResourcesAsyncProcessByTimerHostname() {	
		if(this.getProxyReadJMXResourcesAsyncProcessByTimerHostnameRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.hostname");
				if(name!=null){
					name = name.trim();
				}
				this.getProxyReadJMXResourcesAsyncProcessByTimerHostnameRead = true;
				this.getProxyReadJMXResourcesAsyncProcessByTimerHostname = name;
			} catch(java.lang.Exception e) {
				this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.hostname': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesAsyncProcessByTimerHostname;
	}
	
	private String getProxyReadJMXResourcesAsyncProcessByTimerSchema = null;
	private Boolean getProxyReadJMXResourcesAsyncProcessByTimerSchemaRead = null;
	public String getProxyReadJMXResourcesAsyncProcessByTimerSchema() {	
		if(this.getProxyReadJMXResourcesAsyncProcessByTimerSchemaRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.schema");
				if(name!=null){
					name = name.trim();
				}
				this.getProxyReadJMXResourcesAsyncProcessByTimerSchemaRead = true;
				this.getProxyReadJMXResourcesAsyncProcessByTimerSchema = name;
			} catch(java.lang.Exception e) {
				this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.schema': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesAsyncProcessByTimerSchema;
	}
	
	private Integer getProxyReadJMXResourcesAsyncProcessByTimerPort = null;
	private Boolean getProxyReadJMXResourcesAsyncProcessByTimerPortRead = null;
	public Integer getProxyReadJMXResourcesAsyncProcessByTimerPort() {	
		if(this.getProxyReadJMXResourcesAsyncProcessByTimerPortRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.port");
				if(name!=null){
					name = name.trim();
					this.getProxyReadJMXResourcesAsyncProcessByTimerPort = Integer.valueOf(name);
				}
				this.getProxyReadJMXResourcesAsyncProcessByTimerPortRead = true;
			} catch(java.lang.Exception e) {
				this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.port': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesAsyncProcessByTimerPort;
	}
	
	private Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval = null;
	private Boolean getProxyReadJMXResourcesAsyncProcessByTimerCheckIntervalRead = null;
	public Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval() {	
		if(this.getProxyReadJMXResourcesAsyncProcessByTimerCheckIntervalRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.checkInterval");
				if(name!=null){
					name = name.trim();
					this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval = Integer.valueOf(name);
				}
				else {
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.checkInterval' non impostata, viene utilizzato il default=60");
					this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval = 60;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.checkInterval': "+e.getMessage()+". Viene utilizzato il default=60",e);
				this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval = 60;
			}
			this.getProxyReadJMXResourcesAsyncProcessByTimerCheckIntervalRead = true;
		}
		return this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval;
	}
	
	private Integer getProxyReadJMXResourcesAsyncProcessByTimerLimit = null;
	private Boolean getProxyReadJMXResourcesAsyncProcessByTimerLimitRead = null;
	public Integer getProxyReadJMXResourcesAsyncProcessByTimerLimit() {	
		if(this.getProxyReadJMXResourcesAsyncProcessByTimerLimitRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.limit");
				if(name!=null){
					name = name.trim();
					this.getProxyReadJMXResourcesAsyncProcessByTimerLimit = Integer.valueOf(name);
				}
				else {
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.limit' non impostata, viene utilizzato il default=100");
					this.getProxyReadJMXResourcesAsyncProcessByTimerLimit = 100;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.limit': "+e.getMessage()+". Viene utilizzato il default=100",e);
				this.getProxyReadJMXResourcesAsyncProcessByTimerLimit = 100;
			}
			this.getProxyReadJMXResourcesAsyncProcessByTimerLimitRead = true;
		}
		return this.getProxyReadJMXResourcesAsyncProcessByTimerLimit;
	}
	
	private Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval = null;
	private Boolean getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordIntervalRead = null;
	public Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval() {	
		if(this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordIntervalRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.checkInterval");
				if(name!=null){
					name = name.trim();
					this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval = Integer.valueOf(name);
				}
				else {
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.checkInterval' non impostata, viene utilizzato il default=3600");
					this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval = 3600;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.checkInterval': "+e.getMessage()+". Viene utilizzato il default=3600",e);
				this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval = 3600;
			}
			this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordIntervalRead = true;
		}
		return this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval;
	}
	
	private Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes = null;
	private Boolean getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutesRead = null;
	public Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes() {	
		if(this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutesRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.olderThanMinutes");
				if(name!=null){
					name = name.trim();
					this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes = Integer.valueOf(name);
				}
				else {
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.olderThanMinutes' non impostata, viene utilizzato il default=60");
					this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes = 60;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.olderThanMinutes': "+e.getMessage()+". Viene utilizzato il default=60",e);
				this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes = 60;
			}
			this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutesRead = true;
		}
		return this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes;
	}
	
	private String getProxyReadJMXResourcesSchema = null;
	private Boolean getProxyReadJMXResourcesSchemaRead = null;
	public String getProxyReadJMXResourcesSchema() {	
		if(this.getProxyReadJMXResourcesSchemaRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.schema");
				if(name!=null){
					name = name.trim();
				}
				this.getProxyReadJMXResourcesSchemaRead = true;
				this.getProxyReadJMXResourcesSchema = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.schema': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesSchema;
	}
	
	private Integer getProxyReadJMXResourcesPort = null;
	private Boolean getProxyReadJMXResourcesPortRead = null;
	public Integer getProxyReadJMXResourcesPort() {	
		if(this.getProxyReadJMXResourcesPortRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.port");
				if(name!=null){
					name = name.trim();
					this.getProxyReadJMXResourcesPort = Integer.valueOf(name);
				}
				this.getProxyReadJMXResourcesPortRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.port': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesPort;
	}
	
	// utile per debug: invoco tutte le volte
	public Integer getProxyReadJMXResourcesPort(String hostname) {	
		try{ 
			String name = null;
			name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.port."+hostname);
			if(name!=null){
				name = name.trim();
				return Integer.valueOf(name);
			}
		} catch(java.lang.Exception e) {
			this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.port."+hostname+"': "+e.getMessage(),e);
		}    
		return null;
	}
	
	private String getProxyReadJMXResourcesUsername = null;
	private Boolean getProxyReadJMXResourcesUsernameRead = null;
	public String getProxyReadJMXResourcesUsername() {	
		if(this.getProxyReadJMXResourcesUsernameRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.username");
				if(name!=null){
					name = name.trim();
				}
				this.getProxyReadJMXResourcesUsernameRead = true;
				this.getProxyReadJMXResourcesUsername = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.username': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesUsername;
	}
	
	private String getProxyReadJMXResourcesPassword = null;
	private Boolean getProxyReadJMXResourcesPasswordRead = null;
	public String getProxyReadJMXResourcesPassword() {	
		if(this.getProxyReadJMXResourcesPasswordRead==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.password");
				if(name!=null){
					name = name.trim();
				}
				this.getProxyReadJMXResourcesPasswordRead = true;
				this.getProxyReadJMXResourcesPassword = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.password': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesPassword;
	}
	
	private Boolean isProxyReadJMXResourcesHttpsEnabled = null;
	public boolean isProxyReadJMXResourcesHttpsEnabled() {	
		if(this.isProxyReadJMXResourcesHttpsEnabled==null){
			String pName = "org.openspcoop2.pdd.proxyJMXResources.https";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logDebug(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isProxyReadJMXResourcesHttpsEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isProxyReadJMXResourcesHttpsEnabled = false;
			}    
		}

		return this.isProxyReadJMXResourcesHttpsEnabled;
	}
	
	private Boolean isProxyReadJMXResourcesHttpsEnabledVerificaHostName = null;
	public boolean isProxyReadJMXResourcesHttpsEnabledVerificaHostName() {	
		if(this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName==null){
			String pName = "org.openspcoop2.pdd.proxyJMXResources.https.verificaHostName";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logDebug(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName = true;
			}    
		}

		return this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName;
	}
	
	private Boolean isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer = null;
	public boolean isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer() {	
		if(this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer==null){
			String pName = "org.openspcoop2.pdd.proxyJMXResources.https.autenticazioneServer";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logDebug(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer = true;
			}    
		}

		return this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer;
	}
	
	private String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath = null;
	private Boolean getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePathRead = null;
	public String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath() {	
		if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePathRead==null){
			String pName = "org.openspcoop2.pdd.proxyJMXResources.https.autenticazioneServer.truststorePath";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
				}
				else {
					throw new CoreException(NON_DEFINITA);
				}
				this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePathRead = true;
				this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath;
	}
	
	private String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType = null;
	private Boolean getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreTypeRead = null;
	public String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType() {	
		if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreTypeRead==null){
			String pName = "org.openspcoop2.pdd.proxyJMXResources.https.autenticazioneServer.truststoreType";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
				}
				else {
					throw new CoreException(NON_DEFINITA);
				}
				this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreTypeRead = true;
				this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType;
	}
	
	private String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword = null;
	private Boolean getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePasswordRead = null;
	public String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword() {	
		if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePasswordRead==null){
			String pName = "org.openspcoop2.pdd.proxyJMXResources.https.autenticazioneServer.truststorePassword";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
				}
				else {
					throw new CoreException(NON_DEFINITA);
				}
				this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePasswordRead = true;
				this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword;
	}
	
	private Integer getProxyReadJMXResourcesConnectionTimeout = null;
	public Integer getProxyReadJMXResourcesConnectionTimeout() {	
		if(this.getProxyReadJMXResourcesConnectionTimeout==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.connection.timeout");
				if(name!=null){
					name = name.trim();
				}
				else {
					throw new CoreException("non esistente");
				}
				this.getProxyReadJMXResourcesConnectionTimeout = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.connection.timeout': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesConnectionTimeout;
	}
	
	private Integer getProxyReadJMXResourcesReadTimeout = null;
	public Integer getProxyReadJMXResourcesReadTimeout() {	
		if(this.getProxyReadJMXResourcesReadTimeout==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.readConnection.timeout");
				if(name!=null){
					name = name.trim();
				}
				else {
					throw new CoreException("non esistente");
				}
				this.getProxyReadJMXResourcesReadTimeout = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.readConnection.timeout': "+e.getMessage(),e);
			}    
		}
		return this.getProxyReadJMXResourcesReadTimeout;
	}
	
	

	
	/* -------------Datasource Wrapped  ---------------------*/
	
	private Boolean isDSOp2UtilsEnabled = null;
	public boolean isDSOp2UtilsEnabled() {	
		if(this.isDSOp2UtilsEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.datasource.useDSUtils");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.datasource.useDSUtils' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isDSOp2UtilsEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.datasource.useDSUtils': "+e.getMessage(),e);
				this.isDSOp2UtilsEnabled = false;
			}    
		}

		return this.isDSOp2UtilsEnabled;
	}
	
	
	
	/* ------------- Datasource check in getConnection event  ---------------------*/
	
	private Boolean isDataSourceGetConnectionCheckAutoCommitDisabled = null;
	public boolean isDataSourceGetConnectionCheckAutoCommitDisabled() {	
		String pName = "org.openspcoop2.pdd.datasource.getConnection.checkAutoCommitDisabled";
		if(this.isDataSourceGetConnectionCheckAutoCommitDisabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isDataSourceGetConnectionCheckAutoCommitDisabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isDataSourceGetConnectionCheckAutoCommitDisabled = true;
			}    
		}

		return this.isDataSourceGetConnectionCheckAutoCommitDisabled;
	}
	
	private Boolean isDataSourceGetConnectionCheckTransactionIsolationLevel = null;
	public boolean isDataSourceGetConnectionCheckTransactionIsolationLevel() {	
		String pName = "org.openspcoop2.pdd.datasource.getConnection.checkTransactionIsolationLevel";
		if(this.isDataSourceGetConnectionCheckTransactionIsolationLevel==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isDataSourceGetConnectionCheckTransactionIsolationLevel = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isDataSourceGetConnectionCheckTransactionIsolationLevel = true;
			}    
		}

		return this.isDataSourceGetConnectionCheckTransactionIsolationLevel;
	}
	
	private Integer getDataSourceGetConnectionCheckTransactionIsolationLevelExpected = null;
	public int getDataSourceGetConnectionCheckTransactionIsolationLevelExpected() {	
		String pName = "org.openspcoop2.pdd.datasource.getConnection.checkTransactionIsolationLevel.expected";
		if(this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName,Connection.TRANSACTION_READ_COMMITTED));
					name=Connection.TRANSACTION_READ_COMMITTED+"";
				}
				name = name.trim();
				this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected = Connection.TRANSACTION_READ_COMMITTED;
			}    
		}

		return this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected;
	}
	

	
	
	/* ------------- NotifierInputStream  ---------------------*/
	
	private Boolean isNotifierInputStreamEnabled = null;
	public boolean isNotifierInputStreamEnabled(){

		if(this.isNotifierInputStreamEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.notifierInputStream.enabled"); 

				if (value != null){
					value = value.trim();
					this.isNotifierInputStreamEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.notifierInputStream.enabled' non impostata, viene utilizzato il default=false");
					this.isNotifierInputStreamEnabled = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.notifierInputStream.enabled' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isNotifierInputStreamEnabled = false;
			}
		}

		return this.isNotifierInputStreamEnabled;
	}
	
	private String notifierInputStreamCallback = null;		
	private Boolean notifierInputStreamCallbackRead = null;		
	public String getNotifierInputStreamCallback() throws CoreException{
		if(this.notifierInputStreamCallbackRead==null){
			try{ 
				this.notifierInputStreamCallback = this.reader.getValue("org.openspcoop2.pdd.notifierInputStream.tipo");
				if(this.notifierInputStreamCallback!=null){
					this.notifierInputStreamCallback = this.notifierInputStreamCallback.trim();
				}
				this.notifierInputStreamCallbackRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.notifierInputStream.tipo' non impostata correttamente,  errore:"+e.getMessage(),e);
				throw new CoreException("Proprieta' di openspcoop 'org.openspcoop2.pdd.notifierInputStream.tipo' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		return this.notifierInputStreamCallback;
	}
	
	
	/* ------------- PipeUnblockedVersion  ---------------------*/
	
	private String pipedUnblockedStreamClassName = null;		
	private Boolean pipedUnblockedStreamClassNameRead = null;		
	public String getPipedUnblockedStreamClassName() throws CoreException{
		if(this.pipedUnblockedStreamClassNameRead==null){
			String pName = "org.openspcoop2.pdd.pipedUnblockedStream.className";
			try{ 
				this.pipedUnblockedStreamClassName = this.reader.getValue(pName);
				if(this.pipedUnblockedStreamClassName!=null){
					this.pipedUnblockedStreamClassName = this.pipedUnblockedStreamClassName.trim();
				}
				this.pipedUnblockedStreamClassNameRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
				throw new CoreException("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		return this.pipedUnblockedStreamClassName;
	}
	
	
	
	
	/* ------------- FORMURLEncoder  ---------------------*/
	
	private Boolean isFormUrlEncodedFilterEnabled = null;
	public boolean isFormUrlEncodedFilterEnabled(){

		if(this.isFormUrlEncodedFilterEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.formUrlEncodedFilter.enabled"); 

				if (value != null){
					value = value.trim();
					this.isFormUrlEncodedFilterEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.formUrlEncodedFilter.enabled' non impostata, viene utilizzato il default=false");
					this.isFormUrlEncodedFilterEnabled = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.formUrlEncodedFilter.enabled' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isFormUrlEncodedFilterEnabled = false;
			}
		}

		return this.isFormUrlEncodedFilterEnabled;
	}
	
	
	
	/* ------------- FORMURLEncoder  ---------------------*/
	
	private Boolean isWildflyUndertowClientCertificateFilterEnabled = null;
	public boolean isWildflyUndertowClientCertificateFilterEnabled(){

		String pName = "org.openspcoop2.pdd.wildflyUndertowClientCertificateFilter.enabled";
		if(this.isWildflyUndertowClientCertificateFilterEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isWildflyUndertowClientCertificateFilterEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isWildflyUndertowClientCertificateFilterEnabled = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isWildflyUndertowClientCertificateFilterEnabled = false;
			}
		}

		return this.isWildflyUndertowClientCertificateFilterEnabled;
	}
	
	
	
	
	/* ------------- SEMAPHORE  ---------------------*/
	
	private Long getSemaphoreTimeoutMS = null;
	public long getSemaphoreTimeoutMS(){

		String pName = "org.openspcoop2.pdd.semaphore.timeoutMS";
		if(this.getSemaphoreTimeoutMS==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getSemaphoreTimeoutMS = Long.parseLong(value);
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=-1");
					this.getSemaphoreTimeoutMS = -1l;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=1-, errore:"+e.getMessage(),e);
				this.getSemaphoreTimeoutMS = -1l;
			}
		}

		return this.getSemaphoreTimeoutMS;
	}
	
	private Boolean isSemaphoreDebug = null;
	public boolean isSemaphoreDebug(){

		String pName = "org.openspcoop2.pdd.semaphore.debug";
		if(this.isSemaphoreDebug==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isSemaphoreDebug = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isSemaphoreDebug = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isSemaphoreDebug = false;
			}
		}

		return this.isSemaphoreDebug;
	}
	
	private SemaphoreType getSemaphoreType = null;
	public SemaphoreType getSemaphoreType(){

		String pName = "org.openspcoop2.pdd.semaphore.type";
		if(this.getSemaphoreType==null){
			
			SemaphoreType defaultV = SemaphoreType.Semaphore;
			
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getSemaphoreType = SemaphoreType.valueOf(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultV.toString()));
					this.getSemaphoreType = defaultV;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,defaultV.toString()),e);
				this.getSemaphoreType = defaultV;
			}
		}

		return this.getSemaphoreType;
	}
	
	private Boolean isSemaphoreFair = null;
	public boolean isSemaphoreFair(){

		String pName = "org.openspcoop2.pdd.semaphore.fair";
		if(this.isSemaphoreFair==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isSemaphoreFair = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isSemaphoreFair = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isSemaphoreFair = true;
			}
		}

		return this.isSemaphoreFair;
	}
	
	
		
	/* ------------- JMINIX Console  ---------------------*/
	
	private Integer portJminixConsole = null;
	private Boolean portJminixConsoleReaded = null;
	public Integer getPortJminixConsole() {	
		if(this.portJminixConsoleReaded==null){
			try{ 
				String p = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.jminix.port");
				if(p!=null){
					p = p.trim();
					this.portJminixConsole = Integer.parseInt(p);
				}
				this.portJminixConsoleReaded = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.jminix.port': "+e.getMessage(),e);
				this.portJminixConsoleReaded = true;
			}    
		}

		return this.portJminixConsole;
	}
	
	
	
	

	/* ------------- Custom Function ---------------------*/
	
	private Boolean isEnabledFunctionPD = null;
	public boolean isEnabledFunctionPD() {	
		if(this.isEnabledFunctionPD==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.function.pd.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.function.pd.enabled' non impostata, viene utilizzato il default=false");
					name="true";
				}
				name = name.trim();
				this.isEnabledFunctionPD = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.function.pd.enabled': "+e.getMessage(),e);
				this.isEnabledFunctionPD = false;
			}    
		}

		return this.isEnabledFunctionPD;
	}
	
	private Boolean isEnabledFunctionPDtoSOAP = null;
	public boolean isEnabledFunctionPDtoSOAP() {	
		if(this.isEnabledFunctionPDtoSOAP==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.function.pdToSoap.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.function.pdToSoap.enabled' non impostata, viene utilizzato il default=false");
					name="true";
				}
				name = name.trim();
				this.isEnabledFunctionPDtoSOAP = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.function.pdToSoap.enabled': "+e.getMessage(),e);
				this.isEnabledFunctionPDtoSOAP = false;
			}    
		}

		return this.isEnabledFunctionPDtoSOAP;
	}
	
	private Boolean isEnabledFunctionPA = null;
	public boolean isEnabledFunctionPA() {	
		if(this.isEnabledFunctionPA==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.function.pa.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.function.pa.enabled' non impostata, viene utilizzato il default=false");
					name="true";
				}
				name = name.trim();
				this.isEnabledFunctionPA = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.function.pa.enabled': "+e.getMessage(),e);
				this.isEnabledFunctionPA = false;
			}    
		}

		return this.isEnabledFunctionPA;
	}
	
	
	private FunctionContextsCustom customContexts = null;
	public FunctionContextsCustom getCustomContexts() throws UtilsException {	
		if(this.customContexts==null){
			try{ 
				Properties p = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.function.custom.");
				if(p!=null && p.size()>0) {
					Enumeration<Object> en = p.keys();
					while (en.hasMoreElements()) {
						Object object = (Object) en.nextElement();
						if(object instanceof String) {
							String s = (String) object;
							if(s.endsWith(".context")) {
								String alias = s.substring(0,s.indexOf(".context"));
								
								String context = p.getProperty(s);
								if(context==null || "".equals(context.trim())) {
									throw new CoreException("Context not defined for alias '"+alias+"'");
								}
								context = context.trim();
								
								String service = p.getProperty(alias+".service");
								boolean serviceFound = false;
								FunctionContextCustom customWithoutSubContext = null;
								IDService idServiceCustomWithoutSubContext = null;
								if(service!=null && !"".equals(service.trim())) {
									idServiceCustomWithoutSubContext = IDService.toEnumConstant(service);
									if(idServiceCustomWithoutSubContext==null) {
										throw new CoreException("Value '"+service+"' unsupported for service in alias '"+alias+"'");
									}
									customWithoutSubContext = new FunctionContextCustom(context, idServiceCustomWithoutSubContext);
									serviceFound = true;
									// lo registro dopo gli eventuali subcontext
								}

								Properties pSubContext = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.function.custom."+alias+".subcontext.");
								if(pSubContext==null || pSubContext.size()<=0) {
									if(!serviceFound) {
										throw new CoreException("Service and SubContext undefined for alias '"+alias+"'");
									}
								}
								else {
									HashMap<String,IDService> subcontextMap = new HashMap<String,IDService>();
									Enumeration<Object> enSubContext = pSubContext.keys();
									while (enSubContext.hasMoreElements()) {
										Object objectSubContext = (Object) enSubContext.nextElement();
										if(objectSubContext instanceof String) {
											String subContextKey = (String) objectSubContext;
											if(subContextKey.endsWith(".url")) {
												String aliasSubContext = subContextKey.substring(0,subContextKey.indexOf(".url"));
												
												String subContext = pSubContext.getProperty(subContextKey);
												if(subContext==null || "".equals(subContext.trim())) {
													throw new CoreException("Url not defined for alias '"+alias+"', subcontext '"+aliasSubContext+"'");
												}
												subContext = subContext.trim();
												
												String serviceSubContext = pSubContext.getProperty(aliasSubContext+".service");
												if(serviceSubContext!=null && !"".equals(serviceSubContext.trim())) {
													IDService idService = IDService.toEnumConstant(serviceSubContext);
													if(idService==null) {
														throw new CoreException("Value '"+serviceSubContext+"' unsupported for service in alias '"+alias+"', subcontext '"+aliasSubContext+"'");
													}
													subcontextMap.put(subContext, idService);	
												}
												else {
													throw new CoreException("Service not defined for alias '"+alias+"', subcontext '"+aliasSubContext+"'");
												}
											}
										}
									}
									if(subcontextMap.size()<=0) {
										if(!serviceFound) {
											throw new CoreException("SubContext undefined (wrong configuration) for alias '"+alias+"'");
										}
									}
									else {
										FunctionContextCustom custom = new FunctionContextCustom(context, subcontextMap);
										if(this.customContexts==null) {
											this.customContexts = new FunctionContextsCustom();
										}
										this.customContexts.getContexts().add(custom);
										Iterator<String> itS = subcontextMap.keySet().iterator();
										while (itS.hasNext()) {
											String subContext = (String) itS.next();
											this.logInfo("Registrato context '"+context+"', subcontext '"+subContext+"',  per service '"+subcontextMap.get(subContext)+"'");		
										}
									}
								}
								
								if(customWithoutSubContext!=null) {
									if(this.customContexts==null) {
										this.customContexts = new FunctionContextsCustom();
									}
									this.customContexts.getContexts().add(customWithoutSubContext);
									this.logInfo("Registrato context '"+context+"' per service '"+idServiceCustomWithoutSubContext+"'");
								}
							}
						}
					}
				}
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura dei custom contexts: "+e.getMessage(),e);
				throw new UtilsException("Riscontrato errore durante la lettura dei custom contexts: "+e.getMessage(),e);
			}    
		}

		return this.customContexts;
	}
	
	
	
	
	/* ------------- Custom Container ---------------------*/
	
	private Boolean realContainerCustomRead = null;
	private String realContainerCustom = null;
	public String getRealContainerCustom() {	
		if(this.realContainerCustomRead==null){
			try{ 
				String v = null;
				v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.realmContainer.custom");
				if(v!=null){
					v = v.trim();
					this.realContainerCustom = v;
				} 
			} catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.realmContainer.custom' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		this.realContainerCustomRead = true;
		return this.realContainerCustom;
	}
	
	
	/* ------------- govway_configurazioneSistema ---------------------*/
	
	private Boolean isConfigurazioneSistema_javaProperties_showPassword = null;
	public boolean isConfigurazioneSistema_javaProperties_showPassword(){

		String pName = "org.openspcoop2.pdd.configurazioneSistema.javaProperties.showPassword";
		if(this.isConfigurazioneSistema_javaProperties_showPassword==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isConfigurazioneSistema_javaProperties_showPassword = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isConfigurazioneSistema_javaProperties_showPassword = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isConfigurazioneSistema_javaProperties_showPassword = false;
			}
		}

		return this.isConfigurazioneSistema_javaProperties_showPassword;
	}
	
	
	/* ------------- govway startup ---------------------*/
	
	private Integer getStartup_richiesteIngressoTimeout = null;
	public int getStartup_richiesteIngressoTimeout_secondi() {	
		if(this.getStartup_richiesteIngressoTimeout==null){
			String pName = "org.openspcoop2.pdd.startup.richiesteIngresso.timeout";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					this.getStartup_richiesteIngressoTimeout = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS));
					this.getStartup_richiesteIngressoTimeout = CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS),e);
				this.getStartup_richiesteIngressoTimeout = CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS;
			}
		}

		return this.getStartup_richiesteIngressoTimeout;
	}
	private Integer getStartup_richiesteIngressoCheck = null;
	public int getStartup_richiesteIngressoCheck_ms() {	
		if(this.getStartup_richiesteIngressoCheck==null){
			String pName = "org.openspcoop2.pdd.startup.richiesteIngresso.check";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					this.getStartup_richiesteIngressoCheck = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS));
					this.getStartup_richiesteIngressoCheck = CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS),e);
				this.getStartup_richiesteIngressoCheck = CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS;
			}
		}

		return this.getStartup_richiesteIngressoCheck;
	}
	
	private Integer getStartup_lockMaxLife = null;
	public int getStartup_lockMaxLife() {	
		if(this.getStartup_lockMaxLife==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.startup.lock.maxLife");

				if(name!=null){
					name = name.trim();
					this.getStartup_lockMaxLife = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
					this.getStartup_lockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE+", errore:"+e.getMessage(),e);
				this.getStartup_lockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
			}
			if(this.getStartup_lockMaxLife!=null && this.getStartup_lockMaxLife>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getStartup_lockMaxLife = this.getStartup_lockMaxLife *1000;
			}
		}

		return this.getStartup_lockMaxLife;
	}
	
	private Integer getStartup_lockIdleTime = null;
	public int getStartup_lockIdleTime() {	
		if(this.getStartup_lockIdleTime==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.startup.lock.idleTime");

				if(name!=null){
					name = name.trim();
					this.getStartup_lockIdleTime = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
					this.getStartup_lockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME+", errore:"+e.getMessage(),e);
				this.getStartup_lockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
			}
			if(this.getStartup_lockIdleTime!=null && this.getStartup_lockIdleTime>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getStartup_lockIdleTime = this.getStartup_lockIdleTime *1000;
			}
		}

		return this.getStartup_lockIdleTime;
	}
	
	private Long getStartup_getLockAttesaAttiva = null;
	public long getStartup_getLockAttesaAttiva() {	
		if(this.getStartup_getLockAttesaAttiva==null){
			String pName = "org.openspcoop2.pdd.startup.lock.attesaAttiva";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					long time = java.lang.Long.parseLong(name);
					this.getStartup_getLockAttesaAttiva = time*1000;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
					this.getStartup_getLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.getStartup_getLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
			}    
		}

		return this.getStartup_getLockAttesaAttiva;
	}

	private Integer getStartup_getLockCheckInterval = null;
	public int getStartup_getLockCheckInterval() {	
		if(this.getStartup_getLockCheckInterval==null){
			String pName = "org.openspcoop2.pdd.startup.lock.check";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.getStartup_getLockCheckInterval = time;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
					this.getStartup_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.getStartup_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
			}  
		}

		return this.getStartup_getLockCheckInterval;
	}
	
	
	/* ------------- ExtendedInfo ---------------------*/
	
	private String extendedInfoConfigurazione = null;		
	private Boolean extendedInfoConfigurazioneRead = null;		
	public String getExtendedInfoConfigurazione() throws CoreException{
		if(this.extendedInfoConfigurazioneRead==null){
			String pName = "org.openspcoop2.pdd.config.extendedInfo.configurazione";
			try{ 
				this.extendedInfoConfigurazione = this.reader.getValue(pName);
				if(this.extendedInfoConfigurazione!=null){
					this.extendedInfoConfigurazione = this.extendedInfoConfigurazione.trim();
					this.extendedInfoConfigurazioneRead = true;
				}
			} catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
				throw new CoreException("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		return this.extendedInfoConfigurazione;
	}
	
	private String extendedInfoPortaDelegata = null;		
	private Boolean extendedInfoPortaDelegataRead = null;		
	public String getExtendedInfoPortaDelegata() throws CoreException{
		if(this.extendedInfoPortaDelegataRead==null){
			String pName = "org.openspcoop2.pdd.config.extendedInfo.portaDelegata";
			try{ 
				this.extendedInfoPortaDelegata = this.reader.getValue(pName);
				if(this.extendedInfoPortaDelegata!=null){
					this.extendedInfoPortaDelegata = this.extendedInfoPortaDelegata.trim();
					this.extendedInfoPortaDelegataRead = true;
				}
			} catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
				throw new CoreException("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		return this.extendedInfoPortaDelegata;
	}
	
	private String extendedInfoPortaApplicativa = null;		
	private Boolean extendedInfoPortaApplicativaRead = null;		
	public String getExtendedInfoPortaApplicativa() throws CoreException{
		if(this.extendedInfoPortaApplicativaRead==null){
			String pName = "org.openspcoop2.pdd.config.extendedInfo.portaApplicativa";
			try{ 
				this.extendedInfoPortaApplicativa = this.reader.getValue(pName);
				if(this.extendedInfoPortaApplicativa!=null){
					this.extendedInfoPortaApplicativa = this.extendedInfoPortaApplicativa.trim();
					this.extendedInfoPortaApplicativaRead = true;
				}
			} catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
				throw new CoreException("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
			} 
		}
		return this.extendedInfoPortaApplicativa;
	}
	
	
	
	
	
	
	
	/* ------------- Validazione Contenuti Applicativi ---------------------*/
	
	private Boolean isValidazioneContenutiApplicativi_debug = null;
	public boolean isValidazioneContenutiApplicativi_debug(){

		if(this.isValidazioneContenutiApplicativi_debug==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.debug"); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_debug = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.debug' non impostata, viene utilizzato il default=false");
					this.isValidazioneContenutiApplicativi_debug = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.debug' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isValidazioneContenutiApplicativi_debug = false;
			}
		}

		return this.isValidazioneContenutiApplicativi_debug;
	}
	
	private Boolean isValidazioneContenutiApplicativi_bufferContentRead = null;
	public boolean isValidazioneContenutiApplicativi_bufferContentRead(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.buffer";
		if(this.isValidazioneContenutiApplicativi_bufferContentRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_bufferContentRead = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isValidazioneContenutiApplicativi_bufferContentRead = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isValidazioneContenutiApplicativi_bufferContentRead = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_bufferContentRead;
	}
	
	private Boolean isValidazioneContenutiApplicativi_rpcLiteral_xsiType_gestione = null;
	public boolean isValidazioneContenutiApplicativi_rpcLiteral_xsiType_gestione(){

		if(this.isValidazioneContenutiApplicativi_rpcLiteral_xsiType_gestione==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.gestione"); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_rpcLiteral_xsiType_gestione = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.gestione' non impostata, viene utilizzato il default=true");
					this.isValidazioneContenutiApplicativi_rpcLiteral_xsiType_gestione = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.gestione' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isValidazioneContenutiApplicativi_rpcLiteral_xsiType_gestione = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_rpcLiteral_xsiType_gestione;
	}
	
	private Boolean isValidazioneContenutiApplicativi_rpcLiteral_xsiType_ripulituraDopoValidazione = null;
	public boolean isValidazioneContenutiApplicativi_rpcLiteral_xsiType_ripulituraDopoValidazione(){

		if(this.isValidazioneContenutiApplicativi_rpcLiteral_xsiType_ripulituraDopoValidazione==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.ripulituraDopoValidazione"); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_rpcLiteral_xsiType_ripulituraDopoValidazione = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.ripulituraDopoValidazione' non impostata, viene utilizzato il default=true");
					this.isValidazioneContenutiApplicativi_rpcLiteral_xsiType_ripulituraDopoValidazione = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.ripulituraDopoValidazione' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isValidazioneContenutiApplicativi_rpcLiteral_xsiType_ripulituraDopoValidazione = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_rpcLiteral_xsiType_ripulituraDopoValidazione;
	}
	
	private Boolean isValidazioneContenutiApplicativi_rpc_acceptRootElementUnqualified = null;
	public boolean isValidazioneContenutiApplicativi_rpc_acceptRootElementUnqualified(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.rpc.rootElement.unqualified.accept";
		if(this.isValidazioneContenutiApplicativi_rpc_acceptRootElementUnqualified==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_rpc_acceptRootElementUnqualified = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isValidazioneContenutiApplicativi_rpc_acceptRootElementUnqualified = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isValidazioneContenutiApplicativi_rpc_acceptRootElementUnqualified = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_rpc_acceptRootElementUnqualified;
	}
	
	private Boolean isValidazioneContenutiApplicativi_checkSoapAction = null;
	public boolean isValidazioneContenutiApplicativi_checkSoapAction(){

		if(this.isValidazioneContenutiApplicativi_checkSoapAction==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.soapAction.check"); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_checkSoapAction = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.soapAction.check' non impostata, viene utilizzato il default=true");
					this.isValidazioneContenutiApplicativi_checkSoapAction = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.soapAction.check' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isValidazioneContenutiApplicativi_checkSoapAction = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_checkSoapAction;
	}
	
	private ADDITIONAL getValidazioneContenutiApplicativi_json_policyAdditionalProperties = null;
	public ADDITIONAL getValidazioneContenutiApplicativi_json_policyAdditionalProperties(){

		if(this.getValidazioneContenutiApplicativi_json_policyAdditionalProperties==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.json.additionalProperties"); 

				if (value != null){
					value = value.trim();
					this.getValidazioneContenutiApplicativi_json_policyAdditionalProperties = ADDITIONAL.valueOf(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.json.additionalProperties' non impostata, viene utilizzato il default");
					this.getValidazioneContenutiApplicativi_json_policyAdditionalProperties = ADDITIONAL.DEFAULT;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.json.additionalProperties' con un valore non ammesso (valori consentiti: "+ADDITIONAL.DEFAULT.name()+","+ADDITIONAL.IF_NULL_DISABLE+","+ADDITIONAL.FORCE_DISABLE+"), viene utilizzato il default, errore:"+e.getMessage(),e);
				this.getValidazioneContenutiApplicativi_json_policyAdditionalProperties = ADDITIONAL.DEFAULT;
			}
		}

		return this.getValidazioneContenutiApplicativi_json_policyAdditionalProperties;
	}
	
	
	private ApiName getValidazioneContenutiApplicativi_openApi_jsonValidator = null;
	public ApiName getValidazioneContenutiApplicativi_openApi_jsonValidator(){

		if(this.getValidazioneContenutiApplicativi_openApi_jsonValidator==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.json.validator"); 

				if (value != null){
					value = value.trim();
					this.getValidazioneContenutiApplicativi_openApi_jsonValidator = ApiName.valueOf(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.json.validator' non impostata, viene utilizzato il default "+ApiName.NETWORK_NT);
					this.getValidazioneContenutiApplicativi_openApi_jsonValidator = ApiName.NETWORK_NT;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.json.validator' con un valore non ammesso (valori consentiti: "+ApiName.NETWORK_NT.name()+","+ApiName.FGE+","+ApiName.EVERIT+"), viene utilizzato il default, errore:"+e.getMessage(),e);
				this.getValidazioneContenutiApplicativi_openApi_jsonValidator = ApiName.NETWORK_NT;
			}
		}

		return this.getValidazioneContenutiApplicativi_openApi_jsonValidator;
	}
	
	private OpenAPILibrary getValidazioneContenutiApplicativi_openApi_library = null;
	public OpenAPILibrary getValidazioneContenutiApplicativi_openApi_library(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.library";
		OpenAPILibrary defaultValue = OpenAPILibrary.openapi4j;
		
		if(this.getValidazioneContenutiApplicativi_openApi_library==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getValidazioneContenutiApplicativi_openApi_library = OpenAPILibrary.valueOf(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue.toString()));
					this.getValidazioneContenutiApplicativi_openApi_library = defaultValue;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, defaultValue.toString()),e);
				this.getValidazioneContenutiApplicativi_openApi_library = defaultValue;
			}
		}

		return this.getValidazioneContenutiApplicativi_openApi_library;
	}

	private Boolean isValidazioneContenutiApplicativi_openApi_mergeAPISpec = null;
	public boolean isValidazioneContenutiApplicativi_openApi_mergeAPISpec(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.mergeAPISpec";
		
		if(this.isValidazioneContenutiApplicativi_openApi_mergeAPISpec==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_mergeAPISpec = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isValidazioneContenutiApplicativi_openApi_mergeAPISpec = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isValidazioneContenutiApplicativi_openApi_mergeAPISpec = false;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_mergeAPISpec;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_validateAPISpec = null;
	public boolean isValidazioneContenutiApplicativi_openApi_validateAPISpec(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateAPISpec";
		
		if(this.isValidazioneContenutiApplicativi_openApi_validateAPISpec==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_validateAPISpec = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isValidazioneContenutiApplicativi_openApi_validateAPISpec = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isValidazioneContenutiApplicativi_openApi_validateAPISpec = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_validateAPISpec;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_validateRequestPath = null;
	public boolean isValidazioneContenutiApplicativi_openApi_validateRequestPath(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestPath";
		
		if(this.isValidazioneContenutiApplicativi_openApi_validateRequestPath==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_validateRequestPath = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isValidazioneContenutiApplicativi_openApi_validateRequestPath = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isValidazioneContenutiApplicativi_openApi_validateRequestPath = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_validateRequestPath;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_validateRequestQuery = null;
	public boolean isValidazioneContenutiApplicativi_openApi_validateRequestQuery(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestQuery";
		
		if(this.isValidazioneContenutiApplicativi_openApi_validateRequestQuery==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_validateRequestQuery = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isValidazioneContenutiApplicativi_openApi_validateRequestQuery = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isValidazioneContenutiApplicativi_openApi_validateRequestQuery = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_validateRequestQuery;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_validateRequestUnexpectedQueryParam = null;
	public boolean isValidazioneContenutiApplicativi_openApi_validateRequestUnexpectedQueryParam(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestUnexpectedQueryParam";
		
		if(this.isValidazioneContenutiApplicativi_openApi_validateRequestUnexpectedQueryParam==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_validateRequestUnexpectedQueryParam = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isValidazioneContenutiApplicativi_openApi_validateRequestUnexpectedQueryParam = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isValidazioneContenutiApplicativi_openApi_validateRequestUnexpectedQueryParam = false;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_validateRequestUnexpectedQueryParam;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_validateRequestHeaders = null;
	public boolean isValidazioneContenutiApplicativi_openApi_validateRequestHeaders(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestHeaders";
		
		if(this.isValidazioneContenutiApplicativi_openApi_validateRequestHeaders==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_validateRequestHeaders = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isValidazioneContenutiApplicativi_openApi_validateRequestHeaders = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isValidazioneContenutiApplicativi_openApi_validateRequestHeaders = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_validateRequestHeaders;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_validateRequestCookie = null;
	public boolean isValidazioneContenutiApplicativi_openApi_validateRequestCookie(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestCookie";
		
		if(this.isValidazioneContenutiApplicativi_openApi_validateRequestCookie==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_validateRequestCookie = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isValidazioneContenutiApplicativi_openApi_validateRequestCookie = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isValidazioneContenutiApplicativi_openApi_validateRequestCookie = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_validateRequestCookie;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_validateRequestBody = null;
	public boolean isValidazioneContenutiApplicativi_openApi_validateRequestBody(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestBody";
		
		if(this.isValidazioneContenutiApplicativi_openApi_validateRequestBody==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_validateRequestBody = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isValidazioneContenutiApplicativi_openApi_validateRequestBody = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isValidazioneContenutiApplicativi_openApi_validateRequestBody = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_validateRequestBody;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_validateResponseHeaders = null;
	public boolean isValidazioneContenutiApplicativi_openApi_validateResponseHeaders(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateResponseHeaders";
		
		if(this.isValidazioneContenutiApplicativi_openApi_validateResponseHeaders==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_validateResponseHeaders = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isValidazioneContenutiApplicativi_openApi_validateResponseHeaders = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isValidazioneContenutiApplicativi_openApi_validateResponseHeaders = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_validateResponseHeaders;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_validateResponseBody = null;
	public boolean isValidazioneContenutiApplicativi_openApi_validateResponseBody(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateResponseBody";
		
		if(this.isValidazioneContenutiApplicativi_openApi_validateResponseBody==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_validateResponseBody = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isValidazioneContenutiApplicativi_openApi_validateResponseBody = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isValidazioneContenutiApplicativi_openApi_validateResponseBody = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_validateResponseBody;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_validateWildcardSubtypeAsJson = null;
	public boolean isValidazioneContenutiApplicativi_openApi_validateWildcardSubtypeAsJson(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateWildcardSubtypeAsJson";
		
		if(this.isValidazioneContenutiApplicativi_openApi_validateWildcardSubtypeAsJson==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_validateWildcardSubtypeAsJson = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isValidazioneContenutiApplicativi_openApi_validateWildcardSubtypeAsJson = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isValidazioneContenutiApplicativi_openApi_validateWildcardSubtypeAsJson = true;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_validateWildcardSubtypeAsJson;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_validateMultipartOptimization = null;
	public boolean isValidazioneContenutiApplicativi_openApi_validateMultipartOptimization(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateMultipartOptimization";
		
		if(this.isValidazioneContenutiApplicativi_openApi_validateMultipartOptimization==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_validateMultipartOptimization = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isValidazioneContenutiApplicativi_openApi_validateMultipartOptimization = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isValidazioneContenutiApplicativi_openApi_validateMultipartOptimization = false;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_validateMultipartOptimization;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_injectingAdditionalPropertiesFalse = null;
	public boolean isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_injectingAdditionalPropertiesFalse(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.swaggerRequestValidator.injectingAdditionalPropertiesFalse";
		
		if(this.isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_injectingAdditionalPropertiesFalse==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_injectingAdditionalPropertiesFalse = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_injectingAdditionalPropertiesFalse = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_injectingAdditionalPropertiesFalse = false;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_injectingAdditionalPropertiesFalse;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_resolveFullyApiSpec = null;
	public boolean isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_resolveFullyApiSpec(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.swaggerRequestValidator.resolveFullyApiSpec";
		
		if(this.isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_resolveFullyApiSpec==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_resolveFullyApiSpec = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_resolveFullyApiSpec = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_resolveFullyApiSpec = false;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_swaggerRequestValidator_resolveFullyApiSpec;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_openapi4j_validateBase64Values = null;
	public boolean isValidazioneContenutiApplicativi_openApi_openapi4j_validateBase64Values(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.openapi4j.validateBase64Values";
		
		if(this.isValidazioneContenutiApplicativi_openApi_openapi4j_validateBase64Values==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_openapi4j_validateBase64Values = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isValidazioneContenutiApplicativi_openApi_openapi4j_validateBase64Values = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isValidazioneContenutiApplicativi_openApi_openapi4j_validateBase64Values = false;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_openapi4j_validateBase64Values;
	}
	
	private Boolean isValidazioneContenutiApplicativi_openApi_openapi4j_validateUriReferenceAsUrl = null;
	public boolean isValidazioneContenutiApplicativi_openApi_openapi4j_validateUriReferenceAsUrl(){

		String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.openapi4j.validateUriReferenceAsUrl";
		
		if(this.isValidazioneContenutiApplicativi_openApi_openapi4j_validateUriReferenceAsUrl==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isValidazioneContenutiApplicativi_openApi_openapi4j_validateUriReferenceAsUrl = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isValidazioneContenutiApplicativi_openApi_openapi4j_validateUriReferenceAsUrl = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isValidazioneContenutiApplicativi_openApi_openapi4j_validateUriReferenceAsUrl = false;
			}
		}

		return this.isValidazioneContenutiApplicativi_openApi_openapi4j_validateUriReferenceAsUrl;
	}
	
	
	
	/* ------------- XML ---------------------*/
	
	private Boolean isXmlFactoryDTDsEnabled = null;
	public boolean isXmlFactoryDTDsEnabled(){

		String pName = "org.openspcoop2.pdd.xmlFactory.DTDs.enabled";
		
		if(this.isXmlFactoryDTDsEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isXmlFactoryDTDsEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isXmlFactoryDTDsEnabled = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isXmlFactoryDTDsEnabled = false;
			}
		}

		return this.isXmlFactoryDTDsEnabled;
	}
	
	private Boolean isXsltProcessAsDOMSource = null;
	public boolean isXsltProcessAsDOMSource(){

		String pName = "org.openspcoop2.pdd.xslt.processAsDOMSource";
		
		if(this.isXsltProcessAsDOMSource==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isXsltProcessAsDOMSource = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isXsltProcessAsDOMSource = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isXsltProcessAsDOMSource = true;
			}
		}

		return this.isXsltProcessAsDOMSource;
	}
	
	
	/* ------------- YAML ---------------------*/
	
	private Properties yamlSnakeLimits = null;
	private Boolean yamlSnakeLimits_read = null;
	public Properties getYamlSnakeLimits(){

		String pName = "org.openspcoop2.pdd.yaml.snakeLimits";
		
		if(this.yamlSnakeLimits_read==null){
			try{  
				String file = this.reader.getValueConvertEnvProperties(pName); 
				if(file!=null && StringUtils.isNotEmpty(file)) {
					File f = new File(file);
					if(f.exists()) {
						if(!f.isFile()) {
							throw new CoreException("Il file indicato '"+f.getAbsolutePath()+"' non è un file");
						}
						if(!f.canRead()) {
							throw new CoreException("Il file indicato '"+f.getAbsolutePath()+"' non è accessibile in lettura");
						}
						try(InputStream is = new FileInputStream(f)){
							Properties p = new Properties();
							p.load(is);
							if (p != null && !p.isEmpty()){
								this.yamlSnakeLimits = p;
							}
						}
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostate, errore:"+e.getMessage(),e);
			}
			this.yamlSnakeLimits_read=true;
		}

		return this.yamlSnakeLimits;
	}
	
	
	/* ------------- XPath e JSON Path ---------------------*/
	
	private Boolean isJsonPathCacheEnabled = null;
	public boolean isJsonPathCacheEnabled(){

		String pName = "org.openspcoop2.pdd.jsonPath.cache.enabled";
		
		if(this.isJsonPathCacheEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isJsonPathCacheEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isJsonPathCacheEnabled = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isJsonPathCacheEnabled = false;
			}
		}

		return this.isJsonPathCacheEnabled;
	}
	
	private Boolean isReadByPathBufferEnabled = null;
	public boolean isReadByPathBufferEnabled(){

		String pName = "org.openspcoop2.pdd.readByPath.buffer";
		
		if(this.isReadByPathBufferEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isReadByPathBufferEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isReadByPathBufferEnabled = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isReadByPathBufferEnabled = true;
			}
		}

		return this.isReadByPathBufferEnabled;
	}
	
	
	
	/* ------------- Caching Response ---------------------*/
	
	private String getCachingResponseDigestAlgorithm = null;
	public String getCachingResponseDigestAlgorithm(){

		if(this.getCachingResponseDigestAlgorithm==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cachingResponse.digestAlgorithm"); 

				if (value != null){
					value = value.trim();
					MessageDigest.getInstance(value); // valida
					this.getCachingResponseDigestAlgorithm = value;
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.cachingResponse.digestAlgorithm' non impostata, viene utilizzato il default="+CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST_DEFAULT_ALGORITHM);
					this.getCachingResponseDigestAlgorithm = CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST_DEFAULT_ALGORITHM;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.cachingResponse.digestAlgorithm' non impostata, viene utilizzato il default="+CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST_DEFAULT_ALGORITHM+", errore:"+e.getMessage(),e);
				this.getCachingResponseDigestAlgorithm = CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST_DEFAULT_ALGORITHM;
			}
		}

		return this.getCachingResponseDigestAlgorithm;
	}
	
	private Boolean getCachingResponseHeaderCacheKey_read = null;
	private String getCachingResponseHeaderCacheKey = null;
	public String getCachingResponseHeaderCacheKey(){

		if(this.getCachingResponseHeaderCacheKey_read==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cachingResponse.header.cacheKey"); 

				if (value != null){
					value = value.trim();
					this.getCachingResponseHeaderCacheKey = value;
				}

				this.getCachingResponseHeaderCacheKey_read = true;
				
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.cachingResponse.header.cacheKey', errore:"+e.getMessage(),e);
				
			}
		}

		return this.getCachingResponseHeaderCacheKey;
	}
	
	
	
	/* ------------- Gestione Token ---------------------*/
	
	private Boolean isGestioneTokenDynamicDiscoveryDebug = null;
	public boolean isGestioneTokenDynamicDiscoveryDebug(){

		String pName = "org.openspcoop2.pdd.gestioneToken.dynamicDiscovery.debug";
		if(this.isGestioneTokenDynamicDiscoveryDebug==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneTokenDynamicDiscoveryDebug = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneTokenDynamicDiscoveryDebug = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneTokenDynamicDiscoveryDebug = false;
			}
		}

		return this.isGestioneTokenDynamicDiscoveryDebug;
	}
	
	private Boolean isGestioneTokenIntrospectionDebug = null;
	public boolean isGestioneTokenIntrospectionDebug(){

		String pName = "org.openspcoop2.pdd.gestioneToken.introspection.debug";
		if(this.isGestioneTokenIntrospectionDebug==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneTokenIntrospectionDebug = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneTokenIntrospectionDebug = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneTokenIntrospectionDebug = false;
			}
		}

		return this.isGestioneTokenIntrospectionDebug;
	}
	
	private Boolean isGestioneTokenUserInfoDebug = null;
	public boolean isGestioneTokenUserInfoDebug(){

		String pName = "org.openspcoop2.pdd.gestioneToken.userInfo.debug";
		if(this.isGestioneTokenUserInfoDebug==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneTokenUserInfoDebug = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneTokenUserInfoDebug = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneTokenUserInfoDebug = false;
			}
		}

		return this.isGestioneTokenUserInfoDebug;
	}
	
	private Boolean getGestioneTokenDynamicDiscoveryLockPermitsRead = null;
	private Integer getGestioneTokenDynamicDiscoveryLockPermits = null;
	public Integer getGestioneTokenDynamicDiscoveryLockPermits() {

		String pName = "org.openspcoop2.pdd.gestioneToken.dynamicDiscovery.lock.permits";
		if(this.getGestioneTokenDynamicDiscoveryLockPermitsRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					int permits = Integer.parseInt(value); 
					if(permits>1) {
						// altrimenti è un normale semaphore binario
						this.getGestioneTokenDynamicDiscoveryLockPermits = permits;
					}
				}
				
				
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			
			this.getGestioneTokenDynamicDiscoveryLockPermitsRead = true;
		}

		return this.getGestioneTokenDynamicDiscoveryLockPermits;
	}
	
	private Boolean getGestioneTokenValidazioneJWTLockPermitsRead = null;
	private Integer getGestioneTokenValidazioneJWTLockPermits = null;
	public Integer getGestioneTokenValidazioneJWTLockPermits() {

		String pName = "org.openspcoop2.pdd.gestioneToken.validazioneJWT.lock.permits";
		if(this.getGestioneTokenValidazioneJWTLockPermitsRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					int permits = Integer.parseInt(value); 
					if(permits>1) {
						// altrimenti è un normale semaphore binario
						this.getGestioneTokenValidazioneJWTLockPermits = permits;
					}
				}
				
				
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			
			this.getGestioneTokenValidazioneJWTLockPermitsRead = true;
		}

		return this.getGestioneTokenValidazioneJWTLockPermits;
	}
	
	private Boolean getGestioneTokenIntrospectionLockPermitsRead = null;
	private Integer getGestioneTokenIntrospectionLockPermits = null;
	public Integer getGestioneTokenIntrospectionLockPermits() {

		String pName = "org.openspcoop2.pdd.gestioneToken.introspection.lock.permits";
		if(this.getGestioneTokenIntrospectionLockPermitsRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					int permits = Integer.parseInt(value); 
					if(permits>1) {
						// altrimenti è un normale semaphore binario
						this.getGestioneTokenIntrospectionLockPermits = permits;
					}
				}
				
				
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			
			this.getGestioneTokenIntrospectionLockPermitsRead = true;
		}

		return this.getGestioneTokenIntrospectionLockPermits;
	}
	
	private Boolean getGestioneTokenUserInfoLockPermitsRead = null;
	private Integer getGestioneTokenUserInfoLockPermits = null;
	public Integer getGestioneTokenUserInfoLockPermits() {

		String pName = "org.openspcoop2.pdd.gestioneToken.userInfo.lock.permits";
		if(this.getGestioneTokenUserInfoLockPermitsRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					int permits = Integer.parseInt(value); 
					if(permits>1) {
						// altrimenti è un normale semaphore binario
						this.getGestioneTokenUserInfoLockPermits = permits;
					}
				}
				
				
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			
			this.getGestioneTokenUserInfoLockPermitsRead = true;
		}

		return this.getGestioneTokenUserInfoLockPermits;
	}
	
	private Boolean isGestioneTokenDynamicDiscoveryKeyCacheUseToken = null;
	public boolean isGestioneTokenDynamicDiscoveryKeyCacheUseToken(){

		String pName = "org.openspcoop2.pdd.gestioneToken.dynamicDiscovery.keyCache.useToken";
		if(this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken = false;
			}
		}

		return this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken;
	}
	
	private Boolean isGestioneTokenDynamicDiscoveryUseCacheConfig = null;
	public boolean isGestioneTokenDynamicDiscoveryUseCacheConfig(){

		String pName = "org.openspcoop2.pdd.gestioneToken.dynamicDiscovery.useCacheConfig";
		if(this.isGestioneTokenDynamicDiscoveryUseCacheConfig==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneTokenDynamicDiscoveryUseCacheConfig = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isGestioneTokenDynamicDiscoveryUseCacheConfig = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isGestioneTokenDynamicDiscoveryUseCacheConfig = true;
			}
		}

		return this.isGestioneTokenDynamicDiscoveryUseCacheConfig;
	}
	
	private Boolean getGestioneTokenIatTimeCheckMillisecondsRead = null;
	private Long getGestioneTokenIatTimeCheckMilliseconds = null;
	public Long getGestioneTokenIatTimeCheckMilliseconds() throws CoreException{

		String pName = "org.openspcoop2.pdd.gestioneToken.iat";
		if(this.getGestioneTokenIatTimeCheckMillisecondsRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					long minuti = Long.parseLong(value); // minuti
					this.getGestioneTokenIatTimeCheckMilliseconds = minuti * 60l * 1000l;
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}
			
			this.getGestioneTokenIatTimeCheckMillisecondsRead = true;
		}

		return this.getGestioneTokenIatTimeCheckMilliseconds;
	}
	
	private Boolean getGestioneTokenIatTimeCheckFutureToleranceMillisecondsRead = null;
	private Long getGestioneTokenIatTimeCheckFutureToleranceMilliseconds = null;
	public Long getGestioneTokenIatTimeCheckFutureToleranceMilliseconds() throws CoreException{

		String pName = "org.openspcoop2.pdd.gestioneToken.iat.future.toleranceMilliseconds";
		if(this.getGestioneTokenIatTimeCheckFutureToleranceMillisecondsRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds = Long.parseLong(value); // gia' millisecondi
					if(this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds<=0) {
						// disabilito il controllo
						this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds=null;
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}
			
			this.getGestioneTokenIatTimeCheckFutureToleranceMillisecondsRead = true;
		}

		return this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds;
	}
	
	private Boolean isGestioneTokenExpTimeCheck = null;
	public boolean isGestioneTokenExpTimeCheck(){

		if(this.isGestioneTokenExpTimeCheck==null){
			String pName = "org.openspcoop2.pdd.gestioneToken.exp.checkEnabled";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneTokenExpTimeCheck = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isGestioneTokenExpTimeCheck = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isGestioneTokenExpTimeCheck = true;
			}
		}

		return this.isGestioneTokenExpTimeCheck;
	}
	
	private Boolean getGestioneTokenExpTimeCheckToleranceMillisecondsRead = null;
	private Long getGestioneTokenExpTimeCheckToleranceMilliseconds = null;
	public Long getGestioneTokenExpTimeCheckToleranceMilliseconds() throws CoreException{

		String pName = "org.openspcoop2.pdd.gestioneToken.exp.toleranceMilliseconds";
		if(this.getGestioneTokenExpTimeCheckToleranceMillisecondsRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getGestioneTokenExpTimeCheckToleranceMilliseconds = Long.parseLong(value); // gia' millisecondi
					if(this.getGestioneTokenExpTimeCheckToleranceMilliseconds<=0) {
						// disabilito il controllo
						this.getGestioneTokenExpTimeCheckToleranceMilliseconds=null;
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}
			
			this.getGestioneTokenExpTimeCheckToleranceMillisecondsRead = true;
		}

		return this.getGestioneTokenExpTimeCheckToleranceMilliseconds;
	}
	
	private Boolean isGestioneTokenSaveSourceTokenInfo = null;
	public boolean isGestioneTokenSaveSourceTokenInfo(){

		if(this.isGestioneTokenSaveSourceTokenInfo==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.saveSourceTokenInfo"); 

				if (value != null){
					value = value.trim();
					this.isGestioneTokenSaveSourceTokenInfo = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.saveSourceTokenInfo' non impostata, viene utilizzato il default=false");
					this.isGestioneTokenSaveSourceTokenInfo = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.saveSourceTokenInfo' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isGestioneTokenSaveSourceTokenInfo = false;
			}
		}

		return this.isGestioneTokenSaveSourceTokenInfo;
	}
	
	private Boolean isGestioneTokenSaveTokenInfoValidationFailed = null;
	public boolean isGestioneTokenSaveTokenInfoValidationFailed(){

		if(this.isGestioneTokenSaveTokenInfoValidationFailed==null){
			String pName = "org.openspcoop2.pdd.gestioneToken.saveTokenInfo.validationFailed";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneTokenSaveTokenInfoValidationFailed = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneTokenSaveTokenInfoValidationFailed = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneTokenSaveTokenInfoValidationFailed = false;
			}
		}

		return this.isGestioneTokenSaveTokenInfoValidationFailed;
	}
	
	private Boolean isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature = null;
	public boolean isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature(){

		if(this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature==null){
			String pName = "org.openspcoop2.pdd.gestioneToken.saveTokenInfo.validationFailed.excludeJwtSignature";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature = true;
			}
		}

		return this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature;
	}
	
	private Boolean isGestioneTokenSaveTokenAuthenticationInfoValidationFailed = null;
	public boolean isGestioneTokenSaveTokenAuthenticationInfoValidationFailed(){

		if(this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed==null){
			String pName = "org.openspcoop2.pdd.gestioneToken.saveTokenAuthenticationInfo.validationFailed";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed = true;
			}
		}

		return this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed;
	}
	
	private Boolean isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed = null;
	public boolean isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed(){

		if(this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed==null){
			String pName = "org.openspcoop2.pdd.gestioneToken.saveTokenAuthenticationInfo.authenticationFailed";
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed = true;
			}
		}

		return this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed;
	}
	
	private Boolean getGestioneTokenFormatDateRead = null;
	private String getGestioneTokenFormatDate = null;
	public String getGestioneTokenFormatDate() throws CoreException{

		if(this.getGestioneTokenFormatDateRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.date.format"); 

				if (value != null){
					value = value.trim();
					this.getGestioneTokenFormatDate = value;
				}

			}catch(java.lang.Exception e) {
				String msg = "Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.date.format' non impostata, errore:"+e.getMessage();
				this.logError(msg,e);
				throw new CoreException(msg);
			}
			
			this.getGestioneTokenFormatDateRead = true;
		}

		return this.getGestioneTokenFormatDate;
	}
	
	private String getGestioneTokenHeaderTrasportoJSON = null;
	public String getGestioneTokenHeaderTrasportoJSON() throws CoreException{

		if(this.getGestioneTokenHeaderTrasportoJSON==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.jsonHeader"); 

				if (value != null){
					value = value.trim();
					this.getGestioneTokenHeaderTrasportoJSON = value;
				}else{
					throw new CoreException("Non impostata");
				}

			}catch(java.lang.Exception e) {
				String msg = "Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.jsonHeader' non impostata, errore:"+e.getMessage();
				this.logError(msg,e);
				throw new CoreException(msg);
			}
		}

		return this.getGestioneTokenHeaderTrasportoJSON;
	}
	
	private String getGestioneTokenHeaderTrasportoJWT = null;
	public String getGestioneTokenHeaderTrasportoJWT() throws CoreException{

		if(this.getGestioneTokenHeaderTrasportoJWT==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.jwsHeader"); 

				if (value != null){
					value = value.trim();
					this.getGestioneTokenHeaderTrasportoJWT = value;
				}else{
					throw new CoreException("Non impostata");
				}

			}catch(java.lang.Exception e) {
				String msg = "Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.jwsHeader' non impostata, errore:"+e.getMessage();
				this.logError(msg,e);
				throw new CoreException(msg);
			}
		}

		return this.getGestioneTokenHeaderTrasportoJWT;
	}

	/**
	 * Restituisce le proprieta' che identificano gli header di integrazione in caso di 'trasporto' 
	 *
	 * @return Restituisce le proprieta' che identificano gli header di integrazione in caso di 'trasporto'
	 *  
	 */
	private Map<String, String> keyValueGestioneTokenHeaderIntegrazioneTrasporto = null;
	public Map<String, String> getKeyValueGestioneTokenHeaderIntegrazioneTrasporto() {	
		if(this.keyValueGestioneTokenHeaderIntegrazioneTrasporto==null){

			try{ 

				this.keyValueGestioneTokenHeaderIntegrazioneTrasporto = this.reader.readPropertiesAsHashMapConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.keyword.");
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.keyword.*': "+e.getMessage(),e);
				this.keyValueGestioneTokenHeaderIntegrazioneTrasporto = null;
			}    
		}

		return this.keyValueGestioneTokenHeaderIntegrazioneTrasporto;
	}
	
	private Map<String, Boolean> keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD = null;
	public Map<String, Boolean> getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto() throws CoreException {	
		if(this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled.");
				this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD = new HashMap<>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						processKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(key, value);
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled.*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD;
	}
	private void processKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String key, String value) throws CoreException {
		try {
			boolean b = Boolean.parseBoolean(value);
			this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD.put(key, b);
		}catch(Exception e) {
			throw new CoreException("Rilevato errore durante il parsing della property 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled."+key+"' (atteso: true/false): "+e.getMessage(),e);
		}
	}

	
	private Map<String, Boolean> keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA = null;
	public Map<String, Boolean> getKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto() throws CoreException {	
		if(this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled.");
				this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA = new HashMap<>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						processKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(key, value);
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled.*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA;
	}
	private void processKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String key, String value) throws CoreException {
		try {
			boolean b = Boolean.parseBoolean(value);
			this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA.put(key, b);
		}catch(Exception e) {
			throw new CoreException("Rilevato errore durante il parsing della property 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled."+key+"' (atteso: true/false): "+e.getMessage(),e);
		}
	}
	
	private Map<String, Boolean> keyValueGestioneTokenHeaderIntegrazioneJsonSetPD = null;
	public Map<String, Boolean> getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson() throws CoreException {	
		if(this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPD==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled.");
				this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPD = new HashMap<>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						processKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(key, value);
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled.*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPD;
	}
	private void processKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(String key, String value) throws CoreException {
		try {
			boolean b = Boolean.parseBoolean(value);
			this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPD.put(key, b);
		}catch(Exception e) {
			throw new CoreException("Rilevato errore durante il parsing della property 'org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled."+key+"' (atteso: true/false): "+e.getMessage(),e);
		}
	}

	
	private Map<String, Boolean> keyValueGestioneTokenHeaderIntegrazioneJsonSetPA = null;
	public Map<String, Boolean> getKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson() throws CoreException {	
		if(this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPA==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled.");
				this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPA = new HashMap<>();
				Iterator<?> it = prop.keySet().iterator();
				while (it.hasNext()) {
					Object object = it.next();
					if(object instanceof String) {
						String key = (String) object;
						String value = prop.getProperty(key);
						processKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(key, value);
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled.*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPA;
	}
	private void processKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(String key, String value) throws CoreException {
		try {
			boolean b = Boolean.parseBoolean(value);
			this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPA.put(key, b);
		}catch(Exception e) {
			throw new CoreException("Rilevato errore durante il parsing della property 'org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled."+key+"' (atteso: true/false): "+e.getMessage(),e);
		}
	}
	
	private static final String PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX = "org.openspcoop2.pdd.gestioneToken.forward.custom.";
	
	private List<String> getCustomClaimsKeysGestioneTokenForward = null;
	public List<String> getCustomClaimsKeysGestioneTokenForward() throws CoreException {	
		if(this.getCustomClaimsKeysGestioneTokenForward==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				this.getCustomClaimsKeysGestioneTokenForward= new ArrayList<>();
				prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
				if(prop!=null && !prop.isEmpty()) {
					Enumeration<?> en = prop.keys();
					while (en.hasMoreElements()) {
						String key = (String) en.nextElement();
						processCustomClaimsKeysGestioneTokenForward(key);
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.custom.CLAIM_NAME.name': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getCustomClaimsKeysGestioneTokenForward;
	}
	private void processCustomClaimsKeysGestioneTokenForward(String key) {
		if(key.contains(".")) {
			String keySub = key.substring(key.indexOf(".")+1); 
			if("name".equals(keySub)) {
				String tmp = key.substring(0, key.indexOf("."));
				if(tmp!=null) {
					this.getCustomClaimsKeysGestioneTokenForward.add(tmp.trim());
				}
			}
		}
	}
	
	private Character gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator = null;
	public Character getGestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator(){

		if(this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.audience.separator"); 

				if (value != null){
					value = value.trim();
					if(value.length()<1 || value.length()>1) {
						throw new CoreException(ATTESO_UN_CARATTERE_TROVATI+value.length());
					}
					this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator = value.charAt(0);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.audience.separator' non impostata, viene utilizzato il default=,");
					this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator = ',';
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.audience.separator' non impostata, viene utilizzato il default=, ; errore:"+e.getMessage(),e);
				this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator = ',';
			}
		}

		return this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator;
	}
	
	private Character gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator = null;
	public Character getGestioneTokenHeaderIntegrazioneTrasportoScopeSeparator(){

		if(this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.scopes.separator"); 

				if (value != null){
					value = value.trim();
					if(value.length()<1 || value.length()>1) {
						throw new CoreException(ATTESO_UN_CARATTERE_TROVATI+value.length());
					}
					this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator = value.charAt(0);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.scopes.separator' non impostata, viene utilizzato il default=,");
					this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator = ',';
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.scopes.separator' non impostata, viene utilizzato il default=, ; errore:"+e.getMessage(),e);
				this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator = ',';
			}
		}

		return this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator;
	}
	
	private Character gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator = null;
	public Character getGestioneTokenHeaderIntegrazioneTrasportoRoleSeparator(){

		if(this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.roles.separator"); 

				if (value != null){
					value = value.trim();
					if(value.length()<1 || value.length()>1) {
						throw new CoreException(ATTESO_UN_CARATTERE_TROVATI+value.length());
					}
					this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator = value.charAt(0);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.roles.separator' non impostata, viene utilizzato il default=,");
					this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator = ',';
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.roles.separator' non impostata, viene utilizzato il default=, ; errore:"+e.getMessage(),e);
				this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator = ',';
			}
		}

		return this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator;
	}
	
	private Map<String, String> getCustomClaimsNameGestioneTokenHeaderIntegrazione = null;
	public String getCustomClaimsNameGestioneTokenHeaderIntegrazione(String claimName) throws CoreException {	
		if(this.getCustomClaimsNameGestioneTokenHeaderIntegrazione==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				this.getCustomClaimsNameGestioneTokenHeaderIntegrazione = new HashMap<>();
				prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
				if(prop!=null && !prop.isEmpty()) {
					Enumeration<?> en = prop.keys();
					while (en.hasMoreElements()) {
						String key = (String) en.nextElement();
						processCustomClaimsNameGestioneTokenHeaderIntegrazioneEngine(key, prop);
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".trasporto.name': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getCustomClaimsNameGestioneTokenHeaderIntegrazione.get(claimName);
	}
	private void processCustomClaimsNameGestioneTokenHeaderIntegrazioneEngine(String key, java.util.Properties prop) throws CoreException {	
		if(key.contains(".")) {
			String keySub = key.substring(key.indexOf(".")+1); 
			if("name".equals(keySub)) {
				String tmp = prop.getProperty(key);
				if(tmp!=null) {
					String claimNameTmp = key.substring(0, key.indexOf("."));
					this.getCustomClaimsNameGestioneTokenHeaderIntegrazione.put(claimNameTmp, tmp.trim());
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			}
		}
	}
	
	private Map<String, String> getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto = null;
	public String getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto(String claimName) throws CoreException {	
		if(this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto = new HashMap<>();
				prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
				if(prop!=null && !prop.isEmpty()) {
					Enumeration<?> en = prop.keys();
					while (en.hasMoreElements()) {
						String key = (String) en.nextElement();
						processCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto(key, prop);
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".trasporto.name': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto.get(claimName);
	}
	private void processCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto(String key, java.util.Properties prop) throws CoreException {	
		if(key.contains(".")) {
			String keySub = key.substring(key.indexOf(".")+1); 
			if("trasporto.name".equals(keySub)) {
				String tmp = prop.getProperty(key);
				if(tmp!=null) {
					String claimNameTmp = key.substring(0, key.indexOf("."));
					this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto.put(claimNameTmp, tmp.trim());
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			}
		}
	}
	
	private Map<String, Boolean> getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD = null;
	public Boolean getCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String claimName) throws CoreException {	
		if(this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD = new HashMap<>();
				prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
				if(prop!=null && !prop.isEmpty()) {
					Enumeration<?> en = prop.keys();
					while (en.hasMoreElements()) {
						String key = (String) en.nextElement();
						processCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(key, prop);
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".trasporto.pd.set.enabled': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD.get(claimName);
	}
	private void processCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String key, java.util.Properties prop) throws CoreException {	
		if(key.contains(".")) {
			String keySub = key.substring(key.indexOf(".")+1); 
			if("trasporto.pd.set.enabled".equals(keySub)) {
				String tmp = prop.getProperty(key);
				if(tmp!=null) {
					try {
						boolean b = Boolean.parseBoolean(tmp.trim());
						String claimNameTmp = key.substring(0, key.indexOf("."));
						this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD.put(claimNameTmp, b);
					}catch(Exception e) {
						throw new CoreException("Rilevato errore durante il parsing della property '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+key+"' (atteso: true/false): "+e.getMessage(),e);
					}
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			}
		}
	}

	
	private Map<String, Boolean> getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA = null;
	public Boolean getCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String claimName) throws CoreException {	
		if(this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA = new HashMap<>();
				prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
				if(prop!=null && !prop.isEmpty()) {
					Enumeration<?> en = prop.keys();
					while (en.hasMoreElements()) {
						String key = (String) en.nextElement();
						processCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(key, prop);
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".trasporto.pa.set.enabled': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA.get(claimName);
	}
	private void processCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String key, java.util.Properties prop) throws CoreException {	
		if(key.contains(".")) {
			String keySub = key.substring(key.indexOf(".")+1); 
			if("trasporto.pa.set.enabled".equals(keySub)) {
				String tmp = prop.getProperty(key);
				if(tmp!=null) {
					try {
						boolean b = Boolean.parseBoolean(tmp.trim());
						String claimNameTmp = key.substring(0, key.indexOf("."));
						this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA.put(claimNameTmp, b);
					}catch(Exception e) {
						throw new CoreException("Rilevato errore durante il parsing della property '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+key+"' (atteso: true/false): "+e.getMessage(),e);
					}
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			}
		}
	}
	
	private Map<String, String> getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson = null;
	public String getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson(String claimName) throws CoreException {	
		if(this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson = new HashMap<>();
				prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
				if(prop!=null && !prop.isEmpty()) {
					Enumeration<?> en = prop.keys();
					while (en.hasMoreElements()) {
						String key = (String) en.nextElement();
						processCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson(key, prop);
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".json.name': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson.get(claimName);
	}
	private void processCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson(String key, java.util.Properties prop) throws CoreException {	
		if(key.contains(".")) {
			String keySub = key.substring(key.indexOf(".")+1); 
			if("json.name".equals(keySub)) {
				String tmp = prop.getProperty(key);
				if(tmp!=null) {
					String claimNameTmp = key.substring(0, key.indexOf("."));
					this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson.put(claimNameTmp, tmp.trim());
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			}
		}
	}
	
	private Map<String, Boolean> getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD = null;
	public Boolean getCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(String claimName) throws CoreException {	
		if(this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD = new HashMap<>();
				prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
				if(prop!=null && !prop.isEmpty()) {
					Enumeration<?> en = prop.keys();
					while (en.hasMoreElements()) {
						String key = (String) en.nextElement();
						processCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(key, prop);
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".json.pd.set.enabled': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD.get(claimName);
	}
	private void processCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(String key, java.util.Properties prop) throws CoreException {	
		if(key.contains(".")) {
			String keySub = key.substring(key.indexOf(".")+1); 
			if("json.pd.set.enabled".equals(keySub)) {
				String tmp = prop.getProperty(key);
				if(tmp!=null) {
					try {
						boolean b = Boolean.parseBoolean(tmp.trim());
						String claimNameTmp = key.substring(0, key.indexOf("."));
						this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD.put(claimNameTmp, b);
					}catch(Exception e) {
						throw new CoreException("Rilevato errore durante il parsing della property '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+key+"' (atteso: true/false): "+e.getMessage(),e);
					}
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			}
		}
	}

	
	private Map<String, Boolean> getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA = null;
	public Boolean getCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(String claimName) throws CoreException {	
		if(this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA==null){

			java.util.Properties prop = new java.util.Properties();
			try{ 

				this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA = new HashMap<>();
				prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
				if(prop!=null && !prop.isEmpty()) {
					Enumeration<?> en = prop.keys();
					while (en.hasMoreElements()) {
						String key = (String) en.nextElement();
						processCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(key, prop);
					}
				}
				
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".json.pa.set.enabled': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA.get(claimName);
	}
	private void processCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(String key, java.util.Properties prop) throws CoreException {	
		if(key.contains(".")) {
			String keySub = key.substring(key.indexOf(".")+1); 
			if("json.pa.set.enabled".equals(keySub)) {
				String tmp = prop.getProperty(key);
				if(tmp!=null) {
					try {
						boolean b = Boolean.parseBoolean(tmp.trim());
						String claimNameTmp = key.substring(0, key.indexOf("."));
						this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA.put(claimNameTmp, b);
					}catch(Exception e) {
						throw new CoreException("Rilevato errore durante il parsing della property '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+key+"' (atteso: true/false): "+e.getMessage(),e);
					}
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			}
		}
	}
	
	
	
	/* ------------- Gestione Retrieve Token ---------------------*/
	
	private Boolean isGestioneRetrieveToken_debug = null;
	private Boolean isGestioneRetrieveToken_debug_read = null;
	public Boolean getGestioneRetrieveToken_debug(){

		String pName = "org.openspcoop2.pdd.retrieveToken.debug";
		if(this.isGestioneRetrieveToken_debug_read==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_debug = Boolean.parseBoolean(value);
				}
				
				this.isGestioneRetrieveToken_debug_read=true;

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default='Utilizzo dell'impostazione del connettore', errore:"+e.getMessage(),e);
				this.isGestioneRetrieveToken_debug = false;
			}
		}

		return this.isGestioneRetrieveToken_debug;
	}
	
	private Boolean getGestioneRetrieveTokenLockPermitsRead = null;
	private Integer getGestioneRetrieveTokenLockPermits = null;
	public Integer getGestioneRetrieveTokenLockPermits() {

		String pName = "org.openspcoop2.pdd.retrieveToken.lock.permits";
		if(this.getGestioneRetrieveTokenLockPermitsRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					int permits = Integer.parseInt(value); 
					if(permits>1) {
						// altrimenti è un normale semaphore binario
						this.getGestioneRetrieveTokenLockPermits = permits;
					}
				}
				
				
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			
			this.getGestioneRetrieveTokenLockPermitsRead = true;
		}

		return this.getGestioneRetrieveTokenLockPermits;
	}
	
	private Integer isGestioneRetrieveToken_refreshTokenBeforeExpire_percent = null;
	private Boolean isGestioneRetrieveToken_refreshTokenBeforeExpire_percent_read = null;
	private String isGestioneRetrieveToken_refreshTokenBeforeExpire_percent_pName = "org.openspcoop2.pdd.retrieveToken.refreshTokenBeforeExpire.percent";
	public Integer getGestioneRetrieveToken_refreshTokenBeforeExpire_percent(){

		if(this.isGestioneRetrieveToken_refreshTokenBeforeExpire_percent_read==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(this.isGestioneRetrieveToken_refreshTokenBeforeExpire_percent_pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_refreshTokenBeforeExpire_percent = Integer.parseInt(value);
				}
				
				this.isGestioneRetrieveToken_refreshTokenBeforeExpire_percent_read=true;

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+this.isGestioneRetrieveToken_refreshTokenBeforeExpire_percent_pName+"' non impostata, errore:"+e.getMessage(),e);
				this.isGestioneRetrieveToken_refreshTokenBeforeExpire_percent = null;
			}
		}

		return this.isGestioneRetrieveToken_refreshTokenBeforeExpire_percent;
	}
	
	private Integer isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds = null;
	private Boolean isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds_read = null;
	private String isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds_pName = "org.openspcoop2.pdd.retrieveToken.refreshTokenBeforeExpire.seconds";
	public Integer getGestioneRetrieveToken_refreshTokenBeforeExpire_seconds(){

		if(this.isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds_read==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(this.isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds_pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds = Integer.parseInt(value);
				}
				
				this.isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds_read=true;

			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+this.isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds_pName+"' non impostata, errore:"+e.getMessage(),e);
				this.isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds = null;
			}
		}

		return this.isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds;
	}
	
	private boolean validateGestioneRetrieveToken_refreshTokenBeforeExpire() {
		Integer percent = getGestioneRetrieveToken_refreshTokenBeforeExpire_percent();
		Integer seconds = getGestioneRetrieveToken_refreshTokenBeforeExpire_seconds();
		boolean percentDefined = percent !=null && percent>0;
		boolean secondsDefined = seconds!=null && seconds>0;
		/*
		 *Fix: lascio la possibilità di usare il token fino alla scadenza prossima se non vengono definite nessuna delle due proprietà
		if(!percentDefined && !secondsDefined) {
			this.logError("Almeno una proprietà tra le seguenti deve essere definita: '"+isGestioneRetrieveToken_refreshTokenBeforeExpire_percent_pName+"' o '"+isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds_pName+"'");
			return false;
		}*/
		if(percentDefined && secondsDefined) {
			this.logError("Non è possibile definire contemporaneamente entrambe le seguenti proprietà: '"+this.isGestioneRetrieveToken_refreshTokenBeforeExpire_percent_pName+"' o '"+this.isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds_pName+"'");
			return false;
		}
		return true;
	}
	
	private Boolean isGestioneRetrieveToken_refreshToken_grantType_clientCredentials = null;
	public boolean isGestioneRetrieveToken_refreshToken_grantType_clientCredentials(){

		String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.clientCredentials";
		if(this.isGestioneRetrieveToken_refreshToken_grantType_clientCredentials==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_refreshToken_grantType_clientCredentials = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneRetrieveToken_refreshToken_grantType_clientCredentials = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneRetrieveToken_refreshToken_grantType_clientCredentials = false;
			}
		}

		return this.isGestioneRetrieveToken_refreshToken_grantType_clientCredentials;
	}
	
	private Boolean isGestioneRetrieveToken_refreshToken_grantType_usernamePassword = null;
	public boolean isGestioneRetrieveToken_refreshToken_grantType_usernamePassword(){

		String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.usernamePassword";
		if(this.isGestioneRetrieveToken_refreshToken_grantType_usernamePassword==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_refreshToken_grantType_usernamePassword = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneRetrieveToken_refreshToken_grantType_usernamePassword = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneRetrieveToken_refreshToken_grantType_usernamePassword = false;
			}
		}

		return this.isGestioneRetrieveToken_refreshToken_grantType_usernamePassword;
	}
	
	private Boolean isGestioneRetrieveToken_refreshToken_grantType_rfc7523_x509 = null;
	public boolean isGestioneRetrieveToken_refreshToken_grantType_rfc7523_x509(){

		String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.rfc7523_x509";
		if(this.isGestioneRetrieveToken_refreshToken_grantType_rfc7523_x509==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_refreshToken_grantType_rfc7523_x509 = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneRetrieveToken_refreshToken_grantType_rfc7523_x509 = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneRetrieveToken_refreshToken_grantType_rfc7523_x509 = false;
			}
		}

		return this.isGestioneRetrieveToken_refreshToken_grantType_rfc7523_x509;
	}
	
	private Boolean isGestioneRetrieveToken_refreshToken_grantType_rfc7523_clientSecret = null;
	public boolean isGestioneRetrieveToken_refreshToken_grantType_rfc7523_clientSecret(){

		String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.rfc7523_clientSecret";
		if(this.isGestioneRetrieveToken_refreshToken_grantType_rfc7523_clientSecret==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_refreshToken_grantType_rfc7523_clientSecret = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneRetrieveToken_refreshToken_grantType_rfc7523_clientSecret = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneRetrieveToken_refreshToken_grantType_rfc7523_clientSecret = false;
			}
		}

		return this.isGestioneRetrieveToken_refreshToken_grantType_rfc7523_clientSecret;
	}
	
	private Boolean isGestioneRetrieveToken_refreshToken_grantType_custom = null;
	public boolean isGestioneRetrieveToken_refreshToken_grantType_custom(){

		String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.custom";
		if(this.isGestioneRetrieveToken_refreshToken_grantType_custom==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_refreshToken_grantType_custom = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneRetrieveToken_refreshToken_grantType_custom = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneRetrieveToken_refreshToken_grantType_custom = false;
			}
		}

		return this.isGestioneRetrieveToken_refreshToken_grantType_custom;
	}
	
	private Boolean isGestioneRetrieveToken_saveAsTokenInfo = null;
	public boolean isGestioneRetrieveToken_saveAsTokenInfo(){

		String pName = "org.openspcoop2.pdd.retrieveToken.saveAsTokenInfo";
		if(this.isGestioneRetrieveToken_saveAsTokenInfo==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_saveAsTokenInfo = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isGestioneRetrieveToken_saveAsTokenInfo = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isGestioneRetrieveToken_saveAsTokenInfo = true;
			}
		}

		return this.isGestioneRetrieveToken_saveAsTokenInfo;
	}
	
	private Boolean isGestioneRetrieveToken_saveAsTokenInfo_excludeJwtSignature = null;
	public boolean isGestioneRetrieveToken_saveAsTokenInfo_excludeJwtSignature(){

		String pName = "org.openspcoop2.pdd.retrieveToken.saveAsTokenInfo.excludeJwtSignature";
		if(this.isGestioneRetrieveToken_saveAsTokenInfo_excludeJwtSignature==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_saveAsTokenInfo_excludeJwtSignature = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isGestioneRetrieveToken_saveAsTokenInfo_excludeJwtSignature = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isGestioneRetrieveToken_saveAsTokenInfo_excludeJwtSignature = true;
			}
		}

		return this.isGestioneRetrieveToken_saveAsTokenInfo_excludeJwtSignature;
	}
	
	private Boolean isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest = null;
	public boolean isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest(){

		String pName = "org.openspcoop2.pdd.retrieveToken.saveAsTokenInfo.saveSourceRequest";
		if(this.isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest = true;
			}
		}

		return this.isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest;
	}
	
	private Boolean isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest_date = null;
	public boolean isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest_date(){

		String pName = "org.openspcoop2.pdd.retrieveToken.saveAsTokenInfo.saveSourceRequest.date";
		if(this.isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest_date==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest_date = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest_date = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest_date = true;
			}
		}

		return this.isGestioneRetrieveToken_saveAsTokenInfo_saveSourceRequest_date;
	}
	
	private Boolean isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_transazioniRegistrazioneInformazioniNormalizzate = null;
	public boolean isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_transazioniRegistrazioneInformazioniNormalizzate(){

		String pName = "org.openspcoop2.pdd.retrieveToken.grantType_rfc7523.saveClientAssertionJWTInfo.transazioniRegistrazioneInformazioniNormalizzate";
		if(this.isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_transazioniRegistrazioneInformazioniNormalizzate==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_transazioniRegistrazioneInformazioniNormalizzate = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_transazioniRegistrazioneInformazioniNormalizzate = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_transazioniRegistrazioneInformazioniNormalizzate = false;
			}
		}

		return this.isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_transazioniRegistrazioneInformazioniNormalizzate;
	}
	
	private Boolean isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_excludeJwtSignature = null;
	public boolean isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_excludeJwtSignature(){

		String pName = "org.openspcoop2.pdd.retrieveToken.grantType_rfc7523.saveClientAssertionJWTInfo.excludeJwtSignature";
		if(this.isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_excludeJwtSignature==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_excludeJwtSignature = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_excludeJwtSignature = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_excludeJwtSignature = true;
			}
		}

		return this.isGestioneRetrieveToken_grantType_rfc7523_saveClientAssertionJWTInfo_excludeJwtSignature;
	}
	
	private Boolean isGestioneRetrieveToken_saveTokenInfo_retrieveFailed = null;
	public boolean isGestioneRetrieveToken_saveTokenInfo_retrieveFailed(){

		String pName = "org.openspcoop2.pdd.retrieveToken.saveTokenInfo.retrieveFailed";
		if(this.isGestioneRetrieveToken_saveTokenInfo_retrieveFailed==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneRetrieveToken_saveTokenInfo_retrieveFailed = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneRetrieveToken_saveTokenInfo_retrieveFailed = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneRetrieveToken_saveTokenInfo_retrieveFailed = false;
			}
		}

		return this.isGestioneRetrieveToken_saveTokenInfo_retrieveFailed;
	}

	private Map<String, Boolean> gestioneRetrieveTokenCacheKey = null;
	private void initGestioneRetrieveTokenCacheKey() throws CoreException {
		Properties p = null;
		try {
			p = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.retrieveToken.cacheKey.");
		}catch(Exception e) {
			throw new CoreException(e.getMessage(),e);
		}
		if(p!=null) {
			this.gestioneRetrieveTokenCacheKey = new HashMap<>();
			for (Object oKey : p.keySet()) {
				if(oKey instanceof String) {
					String key = (String) oKey;
					String v = p.getProperty(key);
					if(v!=null) {
						boolean b = Boolean.parseBoolean(v.trim());
						this.gestioneRetrieveTokenCacheKey.put(key,b);
					}
				}
			}
		}
	}
	public boolean isGestioneRetrieveTokenCacheKey(String tipo) {
		if(this.gestioneRetrieveTokenCacheKey!=null && !this.gestioneRetrieveTokenCacheKey.isEmpty() && this.gestioneRetrieveTokenCacheKey.containsKey(tipo)) {
			return this.gestioneRetrieveTokenCacheKey.get(tipo);
		}
		
		// logica di default
		if(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_IDENTIFIER.equals(tipo) || 
				CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SESSION_INFO.equals(tipo)) {
			return false;
		}
		else {
			return true;
		}
	}
	
	
	
	/* ------------- Gestione Attribute Authority ---------------------*/
	
	private Boolean isGestioneAttributeAuthority_debug = null;
	public boolean isGestioneAttributeAuthority_debug(){

		String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.debug";
		if(this.isGestioneAttributeAuthority_debug==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneAttributeAuthority_debug = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneAttributeAuthority_debug = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneAttributeAuthority_debug = false;
			}
		}

		return this.isGestioneAttributeAuthority_debug;
	}
	
	private Boolean getGestioneAttributeAuthorityLockPermitsRead = null;
	private Integer getGestioneAttributeAuthorityLockPermits = null;
	public Integer getGestioneAttributeAuthorityLockPermits() {

		String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.lock.permits";
		if(this.getGestioneAttributeAuthorityLockPermitsRead==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					int permits = Integer.parseInt(value); 
					if(permits>1) {
						// altrimenti è un normale semaphore binario
						this.getGestioneAttributeAuthorityLockPermits = permits;
					}
				}
				
				
			}catch(java.lang.Exception e) {
				this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
			}
			
			this.getGestioneAttributeAuthorityLockPermitsRead = true;
		}

		return this.getGestioneAttributeAuthorityLockPermits;
	}
	
	private Boolean isGestioneAttributeAuthority_saveSourceAttributeResponseInfo = null;
	public boolean isGestioneAttributeAuthority_saveSourceAttributeResponseInfo(){

		String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.saveSourceAttributeResponseInfo";
		if(this.isGestioneAttributeAuthority_saveSourceAttributeResponseInfo==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneAttributeAuthority_saveSourceAttributeResponseInfo = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneAttributeAuthority_saveSourceAttributeResponseInfo = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneAttributeAuthority_saveSourceAttributeResponseInfo = false;
			}
		}

		return this.isGestioneAttributeAuthority_saveSourceAttributeResponseInfo;
	}
	
	private Boolean isGestioneAttributeAuthority_transazioniRegistrazioneAttributiInformazioniNormalizzate = null;
	public boolean isGestioneAttributeAuthority_transazioniRegistrazioneAttributiInformazioniNormalizzate(){

		String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.transazioniRegistrazioneAttributiInformazioniNormalizzate";
		if(this.isGestioneAttributeAuthority_transazioniRegistrazioneAttributiInformazioniNormalizzate==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isGestioneAttributeAuthority_transazioniRegistrazioneAttributiInformazioniNormalizzate = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isGestioneAttributeAuthority_transazioniRegistrazioneAttributiInformazioniNormalizzate = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isGestioneAttributeAuthority_transazioniRegistrazioneAttributiInformazioniNormalizzate = false;
			}
		}

		return this.isGestioneAttributeAuthority_transazioniRegistrazioneAttributiInformazioniNormalizzate;
	}
	
	
	
	
	
	
	/* ------------- JMX Statistiche ---------------------*/
	
	private Boolean isStatisticheViaJmx = null;
	public boolean isStatisticheViaJmx(){

		if(this.isStatisticheViaJmx==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.jmx.statistiche"); 

				if (value != null){
					value = value.trim();
					this.isStatisticheViaJmx = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jmx.statistiche' non impostata, viene utilizzato il default=false");
					this.isStatisticheViaJmx = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jmx.statistiche' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
				this.isStatisticheViaJmx = false;
			}
		}

		return this.isStatisticheViaJmx;
	}
	
	
	
	/* ------------- REST / SOAP Trasporto Utils ---------------------*/
	
	private void _list_add(List<MapKey<String>> tmp, List<MapKey<String>> addList) {
		if(tmp!=null && tmp.size()>0) {
			for (MapKey<String> hdr : tmp) {
				if(addList.contains(hdr)==false) {
					addList.add(hdr);
				}
			}
		}
	}
	
	/* ------------- Forward Proxy ---------------------*/
	
	private Boolean isForwardProxyEnable = null;
	public boolean isForwardProxyEnable(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.enable";
		if(this.isForwardProxyEnable==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isForwardProxyEnable = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isForwardProxyEnable = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isForwardProxyEnable = false;
			}
		}

		return this.isForwardProxyEnable;
	}
	
	
	private Boolean isForwardProxyHeaderEnable = null;
	private boolean isForwardProxyHeaderEnable(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.header.enable";
		if(this.isForwardProxyHeaderEnable==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isForwardProxyHeaderEnable = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isForwardProxyHeaderEnable = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isForwardProxyHeaderEnable = false;
			}
		}

		return this.isForwardProxyHeaderEnable;
	}
	
	private String getForwardProxyHeaderName = null;
	private String getForwardProxyHeaderName(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.header.nome";
		if(this.getForwardProxyHeaderName==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getForwardProxyHeaderName = value;
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER));
					this.getForwardProxyHeaderName = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER),e);
				this.getForwardProxyHeaderName = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER;
			}
		}

		return this.getForwardProxyHeaderName;
	}
	
	private Boolean isForwardProxyHeaderBase64 = null;
	private boolean isForwardProxyHeaderBase64(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.header.base64";
		if(this.isForwardProxyHeaderBase64==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isForwardProxyHeaderBase64 = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64));
					this.isForwardProxyHeaderBase64 = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64),e);
				this.isForwardProxyHeaderBase64 = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64;
			}
		}

		return this.isForwardProxyHeaderBase64;
	}
	
	
	private Boolean isForwardProxyQueryParameterEnable = null;
	private boolean isForwardProxyQueryParameterEnable(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.urlParameter.enable";
		if(this.isForwardProxyQueryParameterEnable==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isForwardProxyQueryParameterEnable = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isForwardProxyQueryParameterEnable = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isForwardProxyQueryParameterEnable = false;
			}
		}

		return this.isForwardProxyQueryParameterEnable;
	}
	
	private String getForwardProxyQueryParameterName = null;
	private String getForwardProxyQueryParameterName(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.urlParameter.nome";
		if(this.getForwardProxyQueryParameterName==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getForwardProxyQueryParameterName = value;
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER));
					this.getForwardProxyQueryParameterName = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER),e);
				this.getForwardProxyQueryParameterName = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER;
			}
		}

		return this.getForwardProxyQueryParameterName;
	}
	
	private Boolean isForwardProxyQueryParameterBase64 = null;
	private boolean isForwardProxyQueryParameterBase64(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.urlParameter.base64";
		if(this.isForwardProxyQueryParameterBase64==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isForwardProxyQueryParameterBase64 = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64));
					this.isForwardProxyQueryParameterBase64 = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64),e);
				this.isForwardProxyQueryParameterBase64 = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64;
			}
		}

		return this.isForwardProxyQueryParameterBase64;
	}
	
	private Boolean isForwardProxyTokenDynamicDiscoveryEnabled = null;
	private boolean isForwardProxyTokenDynamicDiscoveryEnabled(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenDynamicDiscovery.enable";
		if(this.isForwardProxyTokenDynamicDiscoveryEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isForwardProxyTokenDynamicDiscoveryEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_DYNAMIC_DISCOVERY));
					this.isForwardProxyTokenDynamicDiscoveryEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_DYNAMIC_DISCOVERY;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_DYNAMIC_DISCOVERY),e);
				this.isForwardProxyTokenDynamicDiscoveryEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_DYNAMIC_DISCOVERY;
			}
		}

		return this.isForwardProxyTokenDynamicDiscoveryEnabled;
	}
	
	private Boolean isForwardProxyTokenValidazioneJwtEnabled = null;
	private boolean isForwardProxyTokenValidazioneJwtEnabled(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenJwtValidation.enable";
		if(this.isForwardProxyTokenValidazioneJwtEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isForwardProxyTokenValidazioneJwtEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_VALIDAZIONE_JWT));
					this.isForwardProxyTokenValidazioneJwtEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_VALIDAZIONE_JWT;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_VALIDAZIONE_JWT),e);
				this.isForwardProxyTokenValidazioneJwtEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_VALIDAZIONE_JWT;
			}
		}

		return this.isForwardProxyTokenValidazioneJwtEnabled;
	}
	
	private Boolean isForwardProxyTokenIntrospectionEnabled = null;
	private boolean isForwardProxyTokenIntrospectionEnabled(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenIntrospection.enable";
		if(this.isForwardProxyTokenIntrospectionEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isForwardProxyTokenIntrospectionEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_INTROSPECTION));
					this.isForwardProxyTokenIntrospectionEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_INTROSPECTION;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_INTROSPECTION),e);
				this.isForwardProxyTokenIntrospectionEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_INTROSPECTION;
			}
		}

		return this.isForwardProxyTokenIntrospectionEnabled;
	}
	
	private Boolean isForwardProxyTokenUserInfoEnabled = null;
	private boolean isForwardProxyTokenUserInfoEnabled(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenUserInfo.enable";
		if(this.isForwardProxyTokenUserInfoEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isForwardProxyTokenUserInfoEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_USERINFO));
					this.isForwardProxyTokenUserInfoEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_USERINFO;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_USERINFO),e);
				this.isForwardProxyTokenUserInfoEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_USERINFO;
			}
		}

		return this.isForwardProxyTokenUserInfoEnabled;
	}
	
	private Boolean isForwardProxyTokenRetrieveEnabled = null;
	private boolean isForwardProxyTokenRetrieveEnabled(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenRetrieve.enable";
		if(this.isForwardProxyTokenRetrieveEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isForwardProxyTokenRetrieveEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_RETRIEVE));
					this.isForwardProxyTokenRetrieveEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_RETRIEVE;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_RETRIEVE),e);
				this.isForwardProxyTokenRetrieveEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_RETRIEVE;
			}
		}

		return this.isForwardProxyTokenRetrieveEnabled;
	}
	
	private Boolean isForwardProxyAttributeAuthorityEnabled = null;
	private boolean isForwardProxyAttributeAuthorityEnabled(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.attributeAuthority.enable";
		if(this.isForwardProxyAttributeAuthorityEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isForwardProxyAttributeAuthorityEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY));
					this.isForwardProxyAttributeAuthorityEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY),e);
				this.isForwardProxyAttributeAuthorityEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY;
			}
		}

		return this.isForwardProxyAttributeAuthorityEnabled;
	}
	
	private Boolean isForwardProxyAttributeAuthorityResponseJwtValidationEnabled = null;
	private boolean isForwardProxyAttributeAuthorityResponseJwtValidationEnabled(){

		String pName = "org.openspcoop2.pdd.connettori.govwayProxy.attributeAuthority.responseJwtValidation.enable";
		if(this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY_RESPONSE_JWT_VALIDATION));
					this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY_RESPONSE_JWT_VALIDATION;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY_RESPONSE_JWT_VALIDATION),e);
				this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY_RESPONSE_JWT_VALIDATION;
			}
		}

		return this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled;
	}
	
	public ForwardProxyConfigurazione getForwardProxyConfigurazioneDefault() {
		ForwardProxyConfigurazione config = new ForwardProxyConfigurazione();
		if(this.isForwardProxyHeaderEnable()) {
			config.setHeader(this.getForwardProxyHeaderName());
			config.setHeaderBase64(this.isForwardProxyHeaderBase64());
		}
		if(this.isForwardProxyQueryParameterEnable()) {
			config.setQuery(this.getForwardProxyQueryParameterName());
			config.setQueryBase64(this.isForwardProxyQueryParameterBase64());
		}
		return config;
	}
	
	public ForwardProxyConfigurazioneToken getForwardProxyConfigurazioneTokenDefault() {
		ForwardProxyConfigurazioneToken config = new ForwardProxyConfigurazioneToken();
		config.setTokenDynamicDiscoveryEnabled(this.isForwardProxyTokenDynamicDiscoveryEnabled());
		config.setTokenJwtValidationEnabled(this.isForwardProxyTokenValidazioneJwtEnabled());
		config.setTokenIntrospectionEnabled(this.isForwardProxyTokenIntrospectionEnabled());
		config.setTokenUserInfoEnabled(this.isForwardProxyTokenUserInfoEnabled());
		config.setTokenRetrieveEnabled(this.isForwardProxyTokenRetrieveEnabled());
		config.setAttributeAuthorityEnabled(this.isForwardProxyAttributeAuthorityEnabled());
		config.setAttributeAuthorityResponseJwtValidationEnabled(this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled());
		return config;
	}

	
	
	
	
	
	
	/* ------------- Trasformazioni ---------------------*/
	
	private Boolean isTrasformazioni_readCharsetFromContentType = null;
	public boolean isTrasformazioni_readCharsetFromContentType(){

		String pName = "org.openspcoop2.pdd.trasformazioni.readCharsetFromContentType.enable";
		if(this.isTrasformazioni_readCharsetFromContentType==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.isTrasformazioni_readCharsetFromContentType = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isTrasformazioni_readCharsetFromContentType = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isTrasformazioni_readCharsetFromContentType = false;
			}
		}

		return this.isTrasformazioni_readCharsetFromContentType;
	}
	
	private Map<String, String> getTrasformazioni_backwardCompatibility = null;
	private Boolean getTrasformazioni_backwardCompatibility_read = null;
	public Map<String, String> getTrasformazioni_backwardCompatibility(){

		String pName = "org.openspcoop2.pdd.trasformazioni.backwardCompatibility.";
		if(this.getTrasformazioni_backwardCompatibility_read==null){
			try{  
				Properties p = this.reader.readPropertiesConvertEnvProperties(pName);

				if (p != null && !p.isEmpty()){
					Enumeration<?> keys = p.keys();
					if(keys!=null) {
						while (keys.hasMoreElements()) {
							Object object = (Object) keys.nextElement();
							if(object!=null && object instanceof String) {
								String key = (String) object;
								String value = p.getProperty(key);
								if(value!=null) {
									key = key.trim();
									value = value.trim();
									if(StringUtils.isNotEmpty(key) && StringUtils.isNotEmpty(value)) {
										if(this.getTrasformazioni_backwardCompatibility==null) {
											this.getTrasformazioni_backwardCompatibility=new HashMap<>();
										}
										this.getTrasformazioni_backwardCompatibility.put(key, value); // old, new
									}
								}
							}
						}
					}
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isTrasformazioni_readCharsetFromContentType = false;
			}
			
			this.getTrasformazioni_backwardCompatibility_read = true;
		}

		return this.getTrasformazioni_backwardCompatibility;
	}
	
	
	
	
	
	
	/* ------------- SOAP (Trasporto - URLParameters) ---------------------*/
	
	private Boolean isSOAPServicesUrlParametersForward = null;
	private boolean isSOAPServicesUrlParametersForward(){

		if(this.isSOAPServicesUrlParametersForward==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.urlParameters.forward.enable"); 

				if (value != null){
					value = value.trim();
					this.isSOAPServicesUrlParametersForward = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.forward.enable' non impostata, viene utilizzato il default=true");
					this.isSOAPServicesUrlParametersForward = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.forward.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isSOAPServicesUrlParametersForward = true;
			}
		}

		return this.isSOAPServicesUrlParametersForward;
	}
	
	private Boolean getSOAPServicesBlackListInternalUrlParametersRead = null;
	private List<MapKey<String>> getSOAPServicesBlackListInternalUrlParametersList = null;
	private List<MapKey<String>> getSOAPServicesBlackListInternalUrlParameters() {	
		if(this.getSOAPServicesBlackListInternalUrlParametersRead==null){
			try{ 
				this.getSOAPServicesBlackListInternalUrlParametersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.urlParameters.blackList.internal");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getSOAPServicesBlackListInternalUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getSOAPServicesBlackListInternalUrlParametersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.blackList.internal': "+e.getMessage(),e);
			}    
		}
		
		return this.getSOAPServicesBlackListInternalUrlParametersList;
	}
	
	private Boolean getSOAPServicesBlackListUrlParametersRead = null;
	private List<MapKey<String>> getSOAPServicesBlackListUrlParametersList = null;
	private List<MapKey<String>> getSOAPServicesBlackListUrlParameters() {	
		if(this.getSOAPServicesBlackListUrlParametersRead==null){
			try{ 
				this.getSOAPServicesBlackListUrlParametersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.urlParameters.blackList");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getSOAPServicesBlackListUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getSOAPServicesBlackListUrlParametersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.blackList': "+e.getMessage(),e);
			}    
		}
		
		return this.getSOAPServicesBlackListUrlParametersList;
	}
	
	private Boolean getSOAPServicesWhiteListUrlParametersRead = null;
	private List<MapKey<String>> getSOAPServicesWhiteListUrlParametersList = null;
	private List<MapKey<String>> getSOAPServicesWhiteListUrlParameters() {	
		if(this.getSOAPServicesWhiteListUrlParametersRead==null){
			try{ 
				this.getSOAPServicesWhiteListUrlParametersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.urlParameters.whiteList");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getSOAPServicesWhiteListUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getSOAPServicesWhiteListUrlParametersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.whiteList': "+e.getMessage(),e);
			}    
		}
		
		return this.getSOAPServicesWhiteListUrlParametersList;
	}
	
	private List<String> _getSOAPServicesBlackListUrlParameters() {	
		
		List<MapKey<String>> blackList = new ArrayList<>();
		List<MapKey<String>> tmp = this.getSOAPServicesBlackListInternalUrlParameters();
		this._list_add(tmp, blackList);
		tmp = this.getSOAPServicesBlackListUrlParameters();
		this._list_add(tmp, blackList);
		
		List<String> l = new ArrayList<>();
		if(!blackList.isEmpty()) {
			for (MapKey<String> key : blackList) {
				l.add(key.getValue());
			}
		}
		return l;
	}
	private List<String> _getSOAPServicesWhiteListUrlParameters() {	
		
		List<MapKey<String>> whiteList = new ArrayList<>();
		List<MapKey<String>> tmp = this.getSOAPServicesWhiteListUrlParameters();
		this._list_add(tmp, whiteList);
		
		List<String> l = new ArrayList<>();
		if(!whiteList.isEmpty()) {
			for (MapKey<String> key : whiteList) {
				l.add(key.getValue());
			}
		}
		return l;
	}
	public ForwardConfig getSOAPServicesUrlParametersForwardConfig() {
		ForwardConfig f = new ForwardConfig();
		f.setForwardEnable(this.isSOAPServicesUrlParametersForward());
		f.setBlackList(_getSOAPServicesBlackListUrlParameters());
		f.setWhiteList(_getSOAPServicesWhiteListUrlParameters());
		return f;
	}
	
	
	
	
	/* ------------- SOAP (Trasporto - Headers) ---------------------*/
	
	private Boolean isSOAPServicesHeadersForward = null;
	private boolean isSOAPServicesHeadersForward(){

		if(this.isSOAPServicesHeadersForward==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.forward.enable"); 

				if (value != null){
					value = value.trim();
					this.isSOAPServicesHeadersForward = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.forward.enable' non impostata, viene utilizzato il default=true");
					this.isSOAPServicesHeadersForward = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.forward.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isSOAPServicesHeadersForward = true;
			}
		}

		return this.isSOAPServicesHeadersForward;
	}
	
	private Boolean getSOAPServicesBlackListBothInternalHeadersRead = null;
	private List<MapKey<String>> getSOAPServicesBlackListBothInternalHeadersList = null;
	private List<MapKey<String>> getSOAPServicesBlackListBothInternalHeaders() {	
		if(this.getSOAPServicesBlackListBothInternalHeadersRead==null){
			try{ 
				this.getSOAPServicesBlackListBothInternalHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.internal.both");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getSOAPServicesBlackListBothInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getSOAPServicesBlackListBothInternalHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.internal.both': "+e.getMessage(),e);
			}    
		}
		
		return this.getSOAPServicesBlackListBothInternalHeadersList;
	}
	
	private Boolean getSOAPServicesBlackListRequestInternalHeadersRead = null;
	private List<MapKey<String>> getSOAPServicesBlackListRequestInternalHeadersList = null;
	private List<MapKey<String>> getSOAPServicesBlackListRequestInternalHeaders() {	
		if(this.getSOAPServicesBlackListRequestInternalHeadersRead==null){
			try{ 
				this.getSOAPServicesBlackListRequestInternalHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.internal.request");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getSOAPServicesBlackListRequestInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getSOAPServicesBlackListRequestInternalHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.internal.request': "+e.getMessage(),e);
			}    
		}
		
		return this.getSOAPServicesBlackListRequestInternalHeadersList;
	}
	
	private Boolean getSOAPServicesBlackListResponseInternalHeadersRead = null;
	private List<MapKey<String>> getSOAPServicesBlackListResponseInternalHeadersList = null;
	private List<MapKey<String>> getSOAPServicesBlackListResponseInternalHeaders() {	
		if(this.getSOAPServicesBlackListResponseInternalHeadersRead==null){
			try{ 
				this.getSOAPServicesBlackListResponseInternalHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.internal.response");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getSOAPServicesBlackListResponseInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getSOAPServicesBlackListResponseInternalHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.internal.response': "+e.getMessage(),e);
			}    
		}
		
		return this.getSOAPServicesBlackListResponseInternalHeadersList;
	}
	
	private Boolean getSOAPServicesBlackListBothHeadersRead = null;
	private List<MapKey<String>> getSOAPServicesBlackListBothHeadersList = null;
	private List<MapKey<String>> getSOAPServicesBlackListBothHeaders() {	
		if(this.getSOAPServicesBlackListBothHeadersRead==null){
			try{ 
				this.getSOAPServicesBlackListBothHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.both");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getSOAPServicesBlackListBothHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getSOAPServicesBlackListBothHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.both': "+e.getMessage(),e);
			}    
		}
		
		return this.getSOAPServicesBlackListBothHeadersList;
	}
	
	private Boolean getSOAPServicesBlackListRequestHeadersRead = null;
	private List<MapKey<String>> getSOAPServicesBlackListRequestHeadersList = null;
	private List<MapKey<String>> getSOAPServicesBlackListRequestHeaders() {	
		if(this.getSOAPServicesBlackListRequestHeadersRead==null){
			try{ 
				this.getSOAPServicesBlackListRequestHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.request");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getSOAPServicesBlackListRequestHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getSOAPServicesBlackListRequestHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.request': "+e.getMessage(),e);
			}    
		}
		
		return this.getSOAPServicesBlackListRequestHeadersList;
	}
	
	private Boolean getSOAPServicesBlackListResponseHeadersRead = null;
	private List<MapKey<String>> getSOAPServicesBlackListResponseHeadersList = null;
	private List<MapKey<String>> getSOAPServicesBlackListResponseHeaders() {	
		if(this.getSOAPServicesBlackListResponseHeadersRead==null){
			try{ 
				this.getSOAPServicesBlackListResponseHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.response");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getSOAPServicesBlackListResponseHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getSOAPServicesBlackListResponseHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.response': "+e.getMessage(),e);
			}    
		}
		
		return this.getSOAPServicesBlackListResponseHeadersList;
	}
	
	private Boolean getSOAPServicesWhiteListBothHeadersRead = null;
	private List<MapKey<String>> getSOAPServicesWhiteListBothHeadersList = null;
	private List<MapKey<String>> getSOAPServicesWhiteListBothHeaders() {	
		if(this.getSOAPServicesWhiteListBothHeadersRead==null){
			try{ 
				this.getSOAPServicesWhiteListBothHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.whiteList.both");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getSOAPServicesWhiteListBothHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getSOAPServicesWhiteListBothHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.whiteList.both': "+e.getMessage(),e);
			}    
		}
		
		return this.getSOAPServicesWhiteListBothHeadersList;
	}
	
	private Boolean getSOAPServicesWhiteListRequestHeadersRead = null;
	private List<MapKey<String>> getSOAPServicesWhiteListRequestHeadersList = null;
	private List<MapKey<String>> getSOAPServicesWhiteListRequestHeaders() {	
		if(this.getSOAPServicesWhiteListRequestHeadersRead==null){
			try{ 
				this.getSOAPServicesWhiteListRequestHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.whiteList.request");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getSOAPServicesWhiteListRequestHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getSOAPServicesWhiteListRequestHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.whiteList.request': "+e.getMessage(),e);
			}    
		}
		
		return this.getSOAPServicesWhiteListRequestHeadersList;
	}
	
	private Boolean getSOAPServicesWhiteListResponseHeadersRead = null;
	private List<MapKey<String>> getSOAPServicesWhiteListResponseHeadersList = null;
	private List<MapKey<String>> getSOAPServicesWhiteListResponseHeaders() {	
		if(this.getSOAPServicesWhiteListResponseHeadersRead==null){
			try{ 
				this.getSOAPServicesWhiteListResponseHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.whiteList.response");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getSOAPServicesWhiteListResponseHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getSOAPServicesWhiteListResponseHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.whiteList.response': "+e.getMessage(),e);
			}    
		}
		
		return this.getSOAPServicesWhiteListResponseHeadersList;
	}
	
	private List<String> getSOAPServicesBlackListHeaders(boolean request) {	
		
		List<MapKey<String>> blackList = new ArrayList<>();
		List<MapKey<String>> tmp = this.getSOAPServicesBlackListBothInternalHeaders();
		this._list_add(tmp, blackList);
		tmp = this.getSOAPServicesBlackListBothHeaders();
		this._list_add(tmp, blackList);
		
		if(request) {
			tmp = this.getSOAPServicesBlackListRequestInternalHeaders();
			this._list_add(tmp, blackList);
			tmp = this.getSOAPServicesBlackListRequestHeaders();
			this._list_add(tmp, blackList);
		}
		else {
			tmp = this.getSOAPServicesBlackListResponseInternalHeaders();
			this._list_add(tmp, blackList);
			tmp = this.getSOAPServicesBlackListResponseHeaders();
			this._list_add(tmp, blackList);
		}
		
		List<String> l = new ArrayList<>();
		if(!blackList.isEmpty()) {
			for (MapKey<String> key : blackList) {
				l.add(key.getValue());
			}
		}
		return l;
	}
	private List<String> getSOAPServicesWhiteListHeaders(boolean request) {	
		
		List<MapKey<String>> whiteList = new ArrayList<>();
		List<MapKey<String>> tmp = this.getSOAPServicesWhiteListBothHeaders();
		this._list_add(tmp, whiteList);
		if(request) {
			tmp = this.getSOAPServicesWhiteListRequestHeaders();
			this._list_add(tmp, whiteList);
		}
		else {
			tmp = this.getSOAPServicesWhiteListResponseHeaders();
			this._list_add(tmp, whiteList);
		}
		
		List<String> l = new ArrayList<>();
		if(!whiteList.isEmpty()) {
			for (MapKey<String> key : whiteList) {
				l.add(key.getValue());
			}
		}
		return l;
	}
	public ForwardConfig getSOAPServicesHeadersForwardConfig(boolean request) {
		ForwardConfig f = new ForwardConfig();
		f.setForwardEnable(this.isSOAPServicesHeadersForward());
		f.setBlackList(getSOAPServicesBlackListHeaders(request));
		f.setWhiteList(getSOAPServicesWhiteListHeaders(request));
		return f;
	}

	
	/* ------------- SOAP (Trasporto - Headers - Proxy Pass Reverse) ---------------------*/
	
	// Location
	
	private Boolean isSOAPServices_inoltroBuste_proxyPassReverse = null;
	public boolean isSOAPServices_inoltroBuste_proxyPassReverse() {	
		if(this.isSOAPServices_inoltroBuste_proxyPassReverse==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isSOAPServices_inoltroBuste_proxyPassReverse = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse': "+e.getMessage(),e);
				this.isSOAPServices_inoltroBuste_proxyPassReverse = false;
			}    
		}

		return this.isSOAPServices_inoltroBuste_proxyPassReverse;
	}
	
	private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse = null;
	public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse() {	
		if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse': "+e.getMessage(),e);
				this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse = false;
			}    
		}

		return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse;
	}
	
	private List<String> getSOAPServices_inoltroBuste_proxyPassReverse_headers = null;
	public List<String> getSOAPServices_inoltroBuste_proxyPassReverse_headers() throws CoreException {	
		if(this.getSOAPServices_inoltroBuste_proxyPassReverse_headers==null){
			try{ 
				this.getSOAPServices_inoltroBuste_proxyPassReverse_headers = new ArrayList<>();
				
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.headers");
				if(name!=null){
					name = name.trim();
				}
				if(name!=null && !"".equals(name)) {
					if(name.contains(",")) {
						String [] tmp = name.split(",");
						for (int i = 0; i < tmp.length; i++) {
							this.getSOAPServices_inoltroBuste_proxyPassReverse_headers.add(tmp[i].trim());
						}
					}
					else {
						this.getSOAPServices_inoltroBuste_proxyPassReverse_headers.add(name);
					}
				}
			} catch(java.lang.Exception e) {
				String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.headers': "+e.getMessage();
				this.logError(error,e);
				throw new CoreException(error);
			}    
		}

		return this.getSOAPServices_inoltroBuste_proxyPassReverse_headers;
	}
	
	private List<String> getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers = null;
	public List<String> getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers() throws CoreException {	
		if(this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers==null){
			try{ 
				this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers = new ArrayList<>();
				
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.headers");
				if(name!=null){
					name = name.trim();
				}
				if(name!=null && !"".equals(name)) {
					if(name.contains(",")) {
						String [] tmp = name.split(",");
						for (int i = 0; i < tmp.length; i++) {
							this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers.add(tmp[i].trim());
						}
					}
					else {
						this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers.add(name);
					}
				}
			} catch(java.lang.Exception e) {
				String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.headers': "+e.getMessage();
				this.logError(error,e);
				throw new CoreException(error);
			}    
		}

		return this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers;
	}
	
	// Set-Cookie
	
	private Boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie = null;
	public boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie() {	
		if(this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie==null){
			String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie = false;
			}    
		}

		return this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie;
	}
	
	private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = null;
	public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie() {	
		if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie==null){
			String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = false;
			}    
		}

		return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie;
	}
	
	private Boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path = null;
	public boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path() {	
		if(this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path==null){
			String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie.path";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isSOAPServices_inoltroBuste_proxyPassReverse_setCookie()));
					name=""+isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
				}
				name = name.trim();
				this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path = isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
			}    
		}

		return this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path;
	}
	
	private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = null;
	public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path() {	
		if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path==null){
			String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.path";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie()));
					name=""+isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
				}
				name = name.trim();
				this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
			}    
		}

		return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path;
	}
	
	private Boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain = null;
	public boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain() {	
		if(this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain==null){
			String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie.domain";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isSOAPServices_inoltroBuste_proxyPassReverse_setCookie()));
					name=""+isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
				}
				name = name.trim();
				this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain = isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
			}    
		}

		return this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain;
	}
	
	private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = null;
	public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain() {	
		if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain==null){
			String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.domain";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie()));
					name=""+isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
				}
				name = name.trim();
				this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
			}    
		}

		return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain;
	}
	
	private List<String> getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers = null;
	public List<String> getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers() throws CoreException {	
		if(this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers==null){
			try{ 
				this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers = new ArrayList<>();
				
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie.headers");
				if(name!=null){
					name = name.trim();
				}
				if(name!=null && !"".equals(name)) {
					if(name.contains(",")) {
						String [] tmp = name.split(",");
						for (int i = 0; i < tmp.length; i++) {
							this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers.add(tmp[i].trim());
						}
					}
					else {
						this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers.add(name);
					}
				}
			} catch(java.lang.Exception e) {
				String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie.headers': "+e.getMessage();
				this.logError(error,e);
				throw new CoreException(error);
			}    
		}

		return this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers;
	}
	
	private List<String> getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers = null;
	public List<String> getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers() throws CoreException {	
		if(this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers==null){
			try{ 
				this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers = new ArrayList<>();
				
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.headers");
				if(name!=null){
					name = name.trim();
				}
				if(name!=null && !"".equals(name)) {
					if(name.contains(",")) {
						String [] tmp = name.split(",");
						for (int i = 0; i < tmp.length; i++) {
							this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers.add(tmp[i].trim());
						}
					}
					else {
						this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers.add(name);
					}
				}
			} catch(java.lang.Exception e) {
				String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.headers': "+e.getMessage();
				this.logError(error,e);
				throw new CoreException(error);
			}    
		}

		return this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers;
	}
	
	// useProtocolPrefix
	
	private Boolean isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = null;
	public boolean isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix() {	
		if(this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix': "+e.getMessage(),e);
				this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = false;
			}    
		}

		return this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix;
	}
	
	private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = null;
	public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix() {	
		if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix': "+e.getMessage(),e);
				this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = false;
			}    
		}

		return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix;
	}
	
	private Boolean isSOAPServices_inoltroBuste_response_securityHeaders = null;
	public boolean isSOAPServices_inoltroBuste_response_securityHeaders() {	
		if(this.isSOAPServices_inoltroBuste_response_securityHeaders==null){
			String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.response.securityHeaders";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isSOAPServices_inoltroBuste_response_securityHeaders = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isSOAPServices_inoltroBuste_response_securityHeaders = true;
			}    
		}

		return this.isSOAPServices_inoltroBuste_response_securityHeaders;
	}
	
	private Properties getSOAPServices_inoltroBuste_response_securityHeaders = null;
	public Properties getSOAPServices_inoltroBuste_response_securityHeaders() throws CoreException {	
		if(this.getSOAPServices_inoltroBuste_response_securityHeaders==null){
			String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.response.securityHeaders.";
			try{ 
				this.getSOAPServices_inoltroBuste_response_securityHeaders = this.reader.readPropertiesConvertEnvProperties(pName);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getSOAPServices_inoltroBuste_response_securityHeaders;
	}
	
	private Boolean isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = null;
	public boolean isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders() {	
		if(this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders==null){
			String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.response.securityHeaders";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = true;
			}    
		}

		return this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders;
	}
	
	private Properties getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = null;
	public Properties getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders() throws CoreException {	
		if(this.getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders==null){
			String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.response.securityHeaders.";
			try{ 
				this.getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = this.reader.readPropertiesConvertEnvProperties(pName);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders;
	}
	
	
	
	/* ------------- REST (Trasporto - URLParameters) ---------------------*/
	
	private Boolean isRESTServicesUrlParametersForward = null;
	private boolean isRESTServicesUrlParametersForward(){

		if(this.isRESTServicesUrlParametersForward==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.urlParameters.forward.enable"); 

				if (value != null){
					value = value.trim();
					this.isRESTServicesUrlParametersForward = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.forward.enable' non impostata, viene utilizzato il default=true");
					this.isRESTServicesUrlParametersForward = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.forward.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isRESTServicesUrlParametersForward = true;
			}
		}

		return this.isRESTServicesUrlParametersForward;
	}
	
	private Boolean getRESTServicesBlackListInternalUrlParametersRead = null;
	private List<MapKey<String>> getRESTServicesBlackListInternalUrlParametersList = null;
	private List<MapKey<String>> getRESTServicesBlackListInternalUrlParameters() {	
		if(this.getRESTServicesBlackListInternalUrlParametersRead==null){
			try{ 
				this.getRESTServicesBlackListInternalUrlParametersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.urlParameters.blackList.internal");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getRESTServicesBlackListInternalUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getRESTServicesBlackListInternalUrlParametersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.blackList.internal': "+e.getMessage(),e);
			}    
		}
		
		return this.getRESTServicesBlackListInternalUrlParametersList;
	}
	
	private Boolean getRESTServicesBlackListUrlParametersRead = null;
	private List<MapKey<String>> getRESTServicesBlackListUrlParametersList = null;
	private List<MapKey<String>> getRESTServicesBlackListUrlParameters() {	
		if(this.getRESTServicesBlackListUrlParametersRead==null){
			try{ 
				this.getRESTServicesBlackListUrlParametersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.urlParameters.blackList");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getRESTServicesBlackListUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getRESTServicesBlackListUrlParametersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.blackList': "+e.getMessage(),e);
			}    
		}
		
		return this.getRESTServicesBlackListUrlParametersList;
	}
	
	private Boolean getRESTServicesWhiteListUrlParametersRead = null;
	private List<MapKey<String>> getRESTServicesWhiteListUrlParametersList = null;
	private List<MapKey<String>> getRESTServicesWhiteListUrlParameters() {	
		if(this.getRESTServicesWhiteListUrlParametersRead==null){
			try{ 
				this.getRESTServicesWhiteListUrlParametersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.urlParameters.whiteList");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getRESTServicesWhiteListUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getRESTServicesWhiteListUrlParametersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.whiteList': "+e.getMessage(),e);
			}    
		}
		
		return this.getRESTServicesWhiteListUrlParametersList;
	}
		
	private List<String> _getRESTServicesBlackListUrlParameters() {	
		
		List<MapKey<String>> blackList = new ArrayList<>();
		List<MapKey<String>> tmp = this.getRESTServicesBlackListInternalUrlParameters();
		this._list_add(tmp, blackList);
		tmp = this.getRESTServicesBlackListUrlParameters();
		this._list_add(tmp, blackList);
		
		List<String> l = new ArrayList<>();
		if(!blackList.isEmpty()) {
			for (MapKey<String> key : blackList) {
				l.add(key.getValue());
			}
		}
		return l;
	}
	private List<String> _getRESTServicesWhiteListUrlParameters() {	
		
		List<MapKey<String>> whiteList = new ArrayList<>();
		List<MapKey<String>> tmp = this.getRESTServicesWhiteListUrlParameters();
		this._list_add(tmp, whiteList);
		
		List<String> l = new ArrayList<>();
		if(!whiteList.isEmpty()) {
			for (MapKey<String> key : whiteList) {
				l.add(key.getValue());
			}
		}
		return l;
	}
	public ForwardConfig getRESTServicesUrlParametersForwardConfig() {
		ForwardConfig f = new ForwardConfig();
		f.setForwardEnable(this.isRESTServicesUrlParametersForward());
		f.setBlackList(_getRESTServicesBlackListUrlParameters());
		f.setWhiteList(_getRESTServicesWhiteListUrlParameters());
		return f;
	}
	
	
	
	
	/* ------------- REST (Trasporto - Headers) ---------------------*/
	
	private Boolean isRESTServicesHeadersForward = null;
	private boolean isRESTServicesHeadersForward(){

		if(this.isRESTServicesHeadersForward==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.forward.enable"); 

				if (value != null){
					value = value.trim();
					this.isRESTServicesHeadersForward = Boolean.parseBoolean(value);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.forward.enable' non impostata, viene utilizzato il default=true");
					this.isRESTServicesHeadersForward = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.forward.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
				this.isRESTServicesHeadersForward = true;
			}
		}

		return this.isRESTServicesHeadersForward;
	}
	
	private Boolean getRESTServicesBlackListBothInternalHeadersRead = null;
	private List<MapKey<String>> getRESTServicesBlackListBothInternalHeadersList = null;
	private List<MapKey<String>> getRESTServicesBlackListBothInternalHeaders() {	
		if(this.getRESTServicesBlackListBothInternalHeadersRead==null){
			try{ 
				this.getRESTServicesBlackListBothInternalHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.internal.both");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getRESTServicesBlackListBothInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getRESTServicesBlackListBothInternalHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.internal.both': "+e.getMessage(),e);
			}    
		}
		
		return this.getRESTServicesBlackListBothInternalHeadersList;
	}
	
	private Boolean getRESTServicesBlackListRequestInternalHeadersRead = null;
	private List<MapKey<String>> getRESTServicesBlackListRequestInternalHeadersList = null;
	private List<MapKey<String>> getRESTServicesBlackListRequestInternalHeaders() {	
		if(this.getRESTServicesBlackListRequestInternalHeadersRead==null){
			try{ 
				this.getRESTServicesBlackListRequestInternalHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.internal.request");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getRESTServicesBlackListRequestInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getRESTServicesBlackListRequestInternalHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.internal.request': "+e.getMessage(),e);
			}    
		}
		
		return this.getRESTServicesBlackListRequestInternalHeadersList;
	}
	
	private Boolean getRESTServicesBlackListResponseInternalHeadersRead = null;
	private List<MapKey<String>> getRESTServicesBlackListResponseInternalHeadersList = null;
	private List<MapKey<String>> getRESTServicesBlackListResponseInternalHeaders() {	
		if(this.getRESTServicesBlackListResponseInternalHeadersRead==null){
			try{ 
				this.getRESTServicesBlackListResponseInternalHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.internal.response");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getRESTServicesBlackListResponseInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getRESTServicesBlackListResponseInternalHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.internal.response': "+e.getMessage(),e);
			}    
		}
		
		return this.getRESTServicesBlackListResponseInternalHeadersList;
	}
	
	private Boolean getRESTServicesBlackListBothHeadersRead = null;
	private List<MapKey<String>> getRESTServicesBlackListBothHeadersList = null;
	private List<MapKey<String>> getRESTServicesBlackListBothHeaders() {	
		if(this.getRESTServicesBlackListBothHeadersRead==null){
			try{ 
				this.getRESTServicesBlackListBothHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.both");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getRESTServicesBlackListBothHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getRESTServicesBlackListBothHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.both': "+e.getMessage(),e);
			}    
		}
		
		return this.getRESTServicesBlackListBothHeadersList;
	}
	
	private Boolean getRESTServicesBlackListRequestHeadersRead = null;
	private List<MapKey<String>> getRESTServicesBlackListRequestHeadersList = null;
	private List<MapKey<String>> getRESTServicesBlackListRequestHeaders() {	
		if(this.getRESTServicesBlackListRequestHeadersRead==null){
			try{ 
				this.getRESTServicesBlackListRequestHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.request");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getRESTServicesBlackListRequestHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getRESTServicesBlackListRequestHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.request': "+e.getMessage(),e);
			}    
		}
		
		return this.getRESTServicesBlackListRequestHeadersList;
	}
	
	private Boolean getRESTServicesBlackListResponseHeadersRead = null;
	private List<MapKey<String>> getRESTServicesBlackListResponseHeadersList = null;
	private List<MapKey<String>> getRESTServicesBlackListResponseHeaders() {	
		if(this.getRESTServicesBlackListResponseHeadersRead==null){
			try{ 
				this.getRESTServicesBlackListResponseHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.response");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getRESTServicesBlackListResponseHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getRESTServicesBlackListResponseHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.response': "+e.getMessage(),e);
			}    
		}
		
		return this.getRESTServicesBlackListResponseHeadersList;
	}
	
	private Boolean getRESTServicesWhiteListBothHeadersRead = null;
	private List<MapKey<String>> getRESTServicesWhiteListBothHeadersList = null;
	private List<MapKey<String>> getRESTServicesWhiteListBothHeaders() {	
		if(this.getRESTServicesWhiteListBothHeadersRead==null){
			try{ 
				this.getRESTServicesWhiteListBothHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.whiteList.both");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getRESTServicesWhiteListBothHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getRESTServicesWhiteListBothHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.whiteList.both': "+e.getMessage(),e);
			}    
		}
		
		return this.getRESTServicesWhiteListBothHeadersList;
	}
	
	private Boolean getRESTServicesWhiteListRequestHeadersRead = null;
	private List<MapKey<String>> getRESTServicesWhiteListRequestHeadersList = null;
	private List<MapKey<String>> getRESTServicesWhiteListRequestHeaders() {	
		if(this.getRESTServicesWhiteListRequestHeadersRead==null){
			try{ 
				this.getRESTServicesWhiteListRequestHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.whiteList.request");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getRESTServicesWhiteListRequestHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getRESTServicesWhiteListRequestHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.whiteList.request': "+e.getMessage(),e);
			}    
		}
		
		return this.getRESTServicesWhiteListRequestHeadersList;
	}
	
	private Boolean getRESTServicesWhiteListResponseHeadersRead = null;
	private List<MapKey<String>> getRESTServicesWhiteListResponseHeadersList = null;
	private List<MapKey<String>> getRESTServicesWhiteListResponseHeaders() {	
		if(this.getRESTServicesWhiteListResponseHeadersRead==null){
			try{ 
				this.getRESTServicesWhiteListResponseHeadersList = new ArrayList<MapKey<String>>();
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.whiteList.response");
				if(name!=null){
					name = name.trim();
					String [] split = name.split(",");
					if(split!=null){
						for (int i = 0; i < split.length; i++) {
							this.getRESTServicesWhiteListResponseHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
						}
					}
				}
				this.getRESTServicesWhiteListResponseHeadersRead = true;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.whiteList.response': "+e.getMessage(),e);
			}    
		}
		
		return this.getRESTServicesWhiteListResponseHeadersList;
	}
	
	private List<String> getRESTServicesBlackListHeaders(boolean request) {	
		
		List<MapKey<String>> blackList = new ArrayList<MapKey<String>>();
		List<MapKey<String>> tmp = this.getRESTServicesBlackListBothInternalHeaders();
		this._list_add(tmp, blackList);
		tmp = this.getRESTServicesBlackListBothHeaders();
		this._list_add(tmp, blackList);
		
		if(request) {
			tmp = this.getRESTServicesBlackListRequestInternalHeaders();
			this._list_add(tmp, blackList);
			tmp = this.getRESTServicesBlackListRequestHeaders();
			this._list_add(tmp, blackList);
		}
		else {
			tmp = this.getRESTServicesBlackListResponseInternalHeaders();
			this._list_add(tmp, blackList);
			tmp = this.getRESTServicesBlackListResponseHeaders();
			this._list_add(tmp, blackList);
		}
		
		List<String> l = new ArrayList<>();
		if(!blackList.isEmpty()) {
			for (MapKey<String> key : blackList) {
				l.add(key.getValue());
			}
		}
		return l;
	}
	private List<String> getRESTServicesWhiteListHeaders(boolean request) {	
		
		List<MapKey<String>> whiteList = new ArrayList<>();
		List<MapKey<String>> tmp = this.getRESTServicesWhiteListBothHeaders();
		this._list_add(tmp, whiteList);
		if(request) {
			tmp = this.getRESTServicesWhiteListRequestHeaders();
			this._list_add(tmp, whiteList);
		}
		else {
			tmp = this.getRESTServicesWhiteListResponseHeaders();
			this._list_add(tmp, whiteList);
		}
		
		List<String> l = new ArrayList<>();
		if(!whiteList.isEmpty()) {
			for (MapKey<String> key : whiteList) {
				l.add(key.getValue());
			}
		}
		return l;
	}
	public ForwardConfig getRESTServicesHeadersForwardConfig(boolean request) {
		ForwardConfig f = new ForwardConfig();
		f.setForwardEnable(this.isRESTServicesHeadersForward());
		f.setBlackList(getRESTServicesBlackListHeaders(request));
		f.setWhiteList(getRESTServicesWhiteListHeaders(request));
		return f;
	}


	/* ------------- REST (Trasporto - Headers - Proxy Pass Reverse) ---------------------*/
	
	// Location
	
	private Boolean isRESTServices_inoltroBuste_proxyPassReverse = null;
	public boolean isRESTServices_inoltroBuste_proxyPassReverse() {	
		if(this.isRESTServices_inoltroBuste_proxyPassReverse==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isRESTServices_inoltroBuste_proxyPassReverse = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse': "+e.getMessage(),e);
				this.isRESTServices_inoltroBuste_proxyPassReverse = false;
			}    
		}

		return this.isRESTServices_inoltroBuste_proxyPassReverse;
	}
	
	private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse = null;
	public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse() {	
		if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse': "+e.getMessage(),e);
				this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse = false;
			}    
		}

		return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse;
	}
		
	private List<String> getRESTServices_inoltroBuste_proxyPassReverse_headers = null;
	public List<String> getRESTServices_inoltroBuste_proxyPassReverse_headers() throws CoreException {	
		if(this.getRESTServices_inoltroBuste_proxyPassReverse_headers==null){
			try{ 
				this.getRESTServices_inoltroBuste_proxyPassReverse_headers = new ArrayList<>();
				
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.headers");
				if(name!=null){
					name = name.trim();
				}
				if(name!=null && !"".equals(name)) {
					if(name.contains(",")) {
						String [] tmp = name.split(",");
						for (int i = 0; i < tmp.length; i++) {
							this.getRESTServices_inoltroBuste_proxyPassReverse_headers.add(tmp[i].trim());
						}
					}
					else {
						this.getRESTServices_inoltroBuste_proxyPassReverse_headers.add(name);
					}
				}
			} catch(java.lang.Exception e) {
				String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.headers': "+e.getMessage();
				this.logError(error,e);
				throw new CoreException(error);
			}    
		}

		return this.getRESTServices_inoltroBuste_proxyPassReverse_headers;
	}
	
	private List<String> getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers = null;
	public List<String> getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers() throws CoreException {	
		if(this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers==null){
			try{ 
				this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers = new ArrayList<>();
				
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.headers");
				if(name!=null){
					name = name.trim();
				}
				if(name!=null && !"".equals(name)) {
					if(name.contains(",")) {
						String [] tmp = name.split(",");
						for (int i = 0; i < tmp.length; i++) {
							this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers.add(tmp[i].trim());
						}
					}
					else {
						this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers.add(name);
					}
				}
			} catch(java.lang.Exception e) {
				String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.headers': "+e.getMessage();
				this.logError(error,e);
				throw new CoreException(error);
			}    
		}

		return this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers;
	}
	
	// Set-Cookie
	
	private Boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie = null;
	public boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie() {	
		if(this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie==null){
			String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie = false;
			}    
		}

		return this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie;
	}
	
	private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = null;
	public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie() {	
		if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie==null){
			String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = false;
			}    
		}

		return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie;
	}
	
	private Boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path = null;
	public boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path() {	
		if(this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path==null){
			String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie.path";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isRESTServices_inoltroBuste_proxyPassReverse_setCookie()));
					name=""+isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
				}
				name = name.trim();
				this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path = isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
			}    
		}

		return this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path;
	}
	
	private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = null;
	public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path() {	
		if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path==null){
			String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.path";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie()));
					name=""+isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
				}
				name = name.trim();
				this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
			}    
		}

		return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path;
	}
	
	private Boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain = null;
	public boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain() {	
		if(this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain==null){
			String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie.domain";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isRESTServices_inoltroBuste_proxyPassReverse_setCookie()));
					name=""+isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
				}
				name = name.trim();
				this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain = isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
			}    
		}

		return this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain;
	}
	
	private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = null;
	public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain() {	
		if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain==null){
			String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.domain";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie()));
					name=""+isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
				}
				name = name.trim();
				this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
			}    
		}

		return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain;
	}
	
	private List<String> getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers = null;
	public List<String> getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers() throws CoreException {	
		if(this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers==null){
			try{ 
				this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers = new ArrayList<>();
				
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie.headers");
				if(name!=null){
					name = name.trim();
				}
				if(name!=null && !"".equals(name)) {
					if(name.contains(",")) {
						String [] tmp = name.split(",");
						for (int i = 0; i < tmp.length; i++) {
							this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers.add(tmp[i].trim());
						}
					}
					else {
						this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers.add(name);
					}
				}
			} catch(java.lang.Exception e) {
				String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie.headers': "+e.getMessage();
				this.logError(error,e);
				throw new CoreException(error);
			}    
		}

		return this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers;
	}
	
	private List<String> getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers = null;
	public List<String> getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers() throws CoreException {	
		if(this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers==null){
			try{ 
				this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers = new ArrayList<>();
				
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.headers");
				if(name!=null){
					name = name.trim();
				}
				if(name!=null && !"".equals(name)) {
					if(name.contains(",")) {
						String [] tmp = name.split(",");
						for (int i = 0; i < tmp.length; i++) {
							this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers.add(tmp[i].trim());
						}
					}
					else {
						this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers.add(name);
					}
				}
			} catch(java.lang.Exception e) {
				String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.headers': "+e.getMessage();
				this.logError(error,e);
				throw new CoreException(error);
			}    
		}

		return this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers;
	}
	
	// useProtocolPrefix
	
	private Boolean isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = null;
	public boolean isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix() {	
		if(this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix': "+e.getMessage(),e);
				this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = false;
			}    
		}

		return this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix;
	}
	
	private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = null;
	public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix() {	
		if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix': "+e.getMessage(),e);
				this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = false;
			}    
		}

		return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix;
	}
	

	private Boolean isRESTServices_inoltroBuste_response_securityHeaders = null;
	public boolean isRESTServices_inoltroBuste_response_securityHeaders() {	
		if(this.isRESTServices_inoltroBuste_response_securityHeaders==null){
			String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.response.securityHeaders";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isRESTServices_inoltroBuste_response_securityHeaders = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isRESTServices_inoltroBuste_response_securityHeaders = true;
			}    
		}
	
		return this.isRESTServices_inoltroBuste_response_securityHeaders;
	}

	private Properties getRESTServices_inoltroBuste_response_securityHeaders = null;
	public Properties getRESTServices_inoltroBuste_response_securityHeaders() throws CoreException {	
		if(this.getRESTServices_inoltroBuste_response_securityHeaders==null){
			String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.response.securityHeaders.";
			try{ 
				this.getRESTServices_inoltroBuste_response_securityHeaders = this.reader.readPropertiesConvertEnvProperties(pName);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}
	
		return this.getRESTServices_inoltroBuste_response_securityHeaders;
	}
	
	private Boolean isRESTServices_consegnaContenutiApplicativi_response_securityHeaders = null;
	public boolean isRESTServices_consegnaContenutiApplicativi_response_securityHeaders() {	
		if(this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders==null){
			String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.response.securityHeaders";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders = true;
			}    
		}
	
		return this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders;
	}
	
	private Properties getRESTServices_consegnaContenutiApplicativi_response_securityHeaders = null;
	public Properties getRESTServices_consegnaContenutiApplicativi_response_securityHeaders() throws CoreException {	
		if(this.getRESTServices_consegnaContenutiApplicativi_response_securityHeaders==null){
			String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.response.securityHeaders.";
			try{ 
				this.getRESTServices_consegnaContenutiApplicativi_response_securityHeaders = this.reader.readPropertiesConvertEnvProperties(pName);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}
	
		return this.getRESTServices_consegnaContenutiApplicativi_response_securityHeaders;
	}

	
	
	/* ------------- Transazioni ---------------------*/
	
	private Boolean isTransazioniEnabled = null;
	public boolean isTransazioniEnabled() {	
		if(this.isTransazioniEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isTransazioniEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniEnabled = true;
			}    
		}

		return this.isTransazioniEnabled;
	}	
	
	private Boolean isTransazioniDebug = null;
	public boolean isTransazioniDebug() {	
		if(this.isTransazioniDebug==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.debug");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.debug' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isTransazioniDebug = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.debug', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniDebug = true;
			}    
		}

		return this.isTransazioniDebug;
	}	
	
	private Boolean isTransazioniUsePddRuntimeDatasource = null;
	public boolean isTransazioniUsePddRuntimeDatasource() {	
		if(this.isTransazioniUsePddRuntimeDatasource==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.dataSource.usePddRuntime");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dataSource.usePddRuntime' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isTransazioniUsePddRuntimeDatasource = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dataSource.usePddRuntime', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniUsePddRuntimeDatasource = true;
			}    
		}

		return this.isTransazioniUsePddRuntimeDatasource;
	}
	
	private String getTransazioniDatasource = null;
	public String getTransazioniDatasource() throws CoreException {	
		if(this.getTransazioniDatasource==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.dataSource");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getTransazioniDatasource = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dataSource': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTransazioniDatasource;
	}
	
	private Properties getTransazioniDatasourceJndiContext = null;
	public Properties getTransazioniDatasourceJndiContext() throws CoreException {	
		if(this.getTransazioniDatasourceJndiContext==null){
			try{ 
				this.getTransazioniDatasourceJndiContext = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.transazioni.dataSource.property.");
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dataSource.property.*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTransazioniDatasourceJndiContext;
	}
	
	private Boolean isTransazioniDatasourceUseDBUtils = null;
	public boolean isTransazioniDatasourceUseDBUtils() {	
		if(this.isTransazioniDatasourceUseDBUtils==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.datasource.useDSUtils");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.datasource.useDSUtils' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isTransazioniDatasourceUseDBUtils = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.datasource.useDSUtils', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniDatasourceUseDBUtils = true;
			}    
		}

		return this.isTransazioniDatasourceUseDBUtils;
	}
	
	private Boolean isTransazioniSaveTracceInUniqueTransaction = null;
	public boolean isTransazioniSaveTracceInUniqueTransaction() {	
		if(this.isTransazioniSaveTracceInUniqueTransaction==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isTransazioniSaveTracceInUniqueTransaction = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniSaveTracceInUniqueTransaction = true;
			}    
		}

		return this.isTransazioniSaveTracceInUniqueTransaction;
	}
	
	private Boolean isTransazioniSaveDiagnosticiInUniqueTransaction = null;
	public boolean isTransazioniSaveDiagnosticiInUniqueTransaction() {	
		if(this.isTransazioniSaveDiagnosticiInUniqueTransaction==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.diagnostici.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.diagnostici.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isTransazioniSaveDiagnosticiInUniqueTransaction = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.diagnostici.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniSaveDiagnosticiInUniqueTransaction = true;
			}    
		}

		return this.isTransazioniSaveDiagnosticiInUniqueTransaction;
	}
	
	private Boolean isTransazioniSaveDumpInUniqueTransaction = null;
	public boolean isTransazioniSaveDumpInUniqueTransaction() {	
		if(this.isTransazioniSaveDumpInUniqueTransaction==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.dump.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dump.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isTransazioniSaveDumpInUniqueTransaction = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dump.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniSaveDumpInUniqueTransaction = true;
			}    
		}

		return this.isTransazioniSaveDumpInUniqueTransaction;
	}
	
	private Boolean isTransazioniValorizzaDataIngressoConDataAccettazione = null;
	public boolean isTransazioniValorizzaDataIngressoConDataAccettazione() {	
		String pName = "org.openspcoop2.pdd.transazioni.dataIngresso.valorizzaConDataAccettazione";
		if(this.isTransazioniValorizzaDataIngressoConDataAccettazione==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTransazioniValorizzaDataIngressoConDataAccettazione = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniValorizzaDataIngressoConDataAccettazione = true;
			}    
		}

		return this.isTransazioniValorizzaDataIngressoConDataAccettazione;
	}
	
	private Boolean isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent = null;
	public boolean isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent() {	
		String pName = "org.openspcoop2.pdd.transazioni.dataUscitaRisposta.useDateAfterResponseSent";
		if(this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent = true;
			}    
		}

		return this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent;
	}
	
	private Boolean isTransazioniFaultPrettyPrint = null;
	public boolean isTransazioniFaultPrettyPrint() {	
		if(this.isTransazioniFaultPrettyPrint==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.fault.prettyPrint");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.fault.prettyPrint' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isTransazioniFaultPrettyPrint = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.fault.prettyPrint', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniFaultPrettyPrint = false;
			}    
		}

		return this.isTransazioniFaultPrettyPrint;
	}
	
	private Boolean isTransazioniHttpStatusAsEvent_inResponseCode = null;
	public boolean isTransazioniHttpStatusAsEvent_inResponseCode() {	
		if(this.isTransazioniHttpStatusAsEvent_inResponseCode==null){
			String pName = "org.openspcoop2.pdd.transazioni.httpStatusAsEvent.inResponseCode";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniHttpStatusAsEvent_inResponseCode = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniHttpStatusAsEvent_inResponseCode = false;
			}    
		}

		return this.isTransazioniHttpStatusAsEvent_inResponseCode;
	}
	private Boolean isTransazioniHttpStatusAsEvent_outResponseCode = null;
	public boolean isTransazioniHttpStatusAsEvent_outResponseCode() {	
		if(this.isTransazioniHttpStatusAsEvent_outResponseCode==null){
			String pName = "org.openspcoop2.pdd.transazioni.httpStatusAsEvent.outResponseCode";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniHttpStatusAsEvent_outResponseCode = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniHttpStatusAsEvent_outResponseCode = false;
			}    
		}

		return this.isTransazioniHttpStatusAsEvent_outResponseCode;
	}
	
	private Boolean isTransazioniTipoApiAsEvent = null;
	public boolean isTransazioniTipoApiAsEvent() {	
		if(this.isTransazioniTipoApiAsEvent==null){
			String pName = "org.openspcoop2.pdd.transazioni.tipoApiAsEvent";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniTipoApiAsEvent = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniTipoApiAsEvent = false;
			}    
		}

		return this.isTransazioniTipoApiAsEvent;
	}
	
	private Boolean isTransazioniConnettoriMultipliAsEvent = null;
	public boolean isTransazioniConnettoriMultipliAsEvent() {	
		if(this.isTransazioniConnettoriMultipliAsEvent==null){
			String pName = "org.openspcoop2.pdd.transazioni.connettoriMultipliAsEvent";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniConnettoriMultipliAsEvent = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniConnettoriMultipliAsEvent = false;
			}    
		}

		return this.isTransazioniConnettoriMultipliAsEvent;
	}
	
	private Boolean isTransazioniUpdateUseDayInterval = null;
	public boolean isTransazioniUpdateUseDayInterval() {	
		if(this.isTransazioniUpdateUseDayInterval==null){
			String pName = "org.openspcoop2.pdd.transazioni.update.useDayInterval";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTransazioniUpdateUseDayInterval = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniUpdateUseDayInterval = true;
			}    
		}

		return this.isTransazioniUpdateUseDayInterval;
	}
	
	private Boolean isTransazioniRegistrazioneSlowLog = null;
	public boolean isTransazioniRegistrazioneSlowLog() {	
		if(this.isTransazioniRegistrazioneSlowLog==null){
			String pName = "org.openspcoop2.pdd.transazioni.slowLog.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="false";
				}
				name = name.trim();
				this.isTransazioniRegistrazioneSlowLog = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniRegistrazioneSlowLog = false;
			}    
		}

		return this.isTransazioniRegistrazioneSlowLog;
	}
	
	private Integer getTransazioniRegistrazioneSlowLogThresholdMs = null;
	private final int getTransazioniRegistrazioneSlowLogThresholdMs_default = 1000;
	public int getTransazioniRegistrazioneSlowLogThresholdMs() {	
		if(this.getTransazioniRegistrazioneSlowLogThresholdMs==null){
			String pName = "org.openspcoop2.pdd.transazioni.slowLog.thresholdMs";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName,this.getTransazioniRegistrazioneSlowLogThresholdMs_default));
					name=""+this.getTransazioniRegistrazioneSlowLogThresholdMs_default;
				}
				name = name.trim();
				this.getTransazioniRegistrazioneSlowLogThresholdMs = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+this.getTransazioniRegistrazioneSlowLogThresholdMs_default+" : "+e.getMessage(),e);
				this.getTransazioniRegistrazioneSlowLogThresholdMs = this.getTransazioniRegistrazioneSlowLogThresholdMs_default;
			}    
		}

		return this.getTransazioniRegistrazioneSlowLogThresholdMs;
	}
	
	private Boolean isTransazioniRegistrazioneSlowLogBuildTransactionDetails = null;
	public boolean isTransazioniRegistrazioneSlowLogBuildTransactionDetails() {	
		if(this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails==null){
			String pName = "org.openspcoop2.pdd.transazioni.slowLog.buildTransactionDetails.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails = false;
			}    
		}

		return this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails;
	}
	
	private Boolean isTransazioniRegistrazioneSlowLogRateLimitingDetails = null;
	public boolean isTransazioniRegistrazioneSlowLogRateLimitingDetails() {	
		if(this.isTransazioniRegistrazioneSlowLogRateLimitingDetails==null){
			String pName = "org.openspcoop2.pdd.transazioni.slowLog.rateLimitingDetails.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniRegistrazioneSlowLogRateLimitingDetails = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniRegistrazioneSlowLogRateLimitingDetails = false;
			}    
		}

		return this.isTransazioniRegistrazioneSlowLogRateLimitingDetails;
	}
	
	private Boolean isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails = null;
	public boolean isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails() {	
		if(this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails==null){
			String pName = "org.openspcoop2.pdd.transazioni.slowLog.connettoriMultipli.processTransactionSADetails.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails = false;
			}    
		}

		return this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails;
	}
	
	private Boolean isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails = null;
	public boolean isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails() {	
		if(this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails==null){
			String pName = "org.openspcoop2.pdd.transazioni.slowLog.connettoriMultipli.updateTransactionDetails.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails = false;
			}    
		}

		return this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails;
	}
	
	
	// TracciamentoDB

	private Boolean isTransazioniTracciamentoDBOutRequestThrowRequestException = null;
	public boolean isTransazioniTracciamentoDBOutRequestThrowRequestException() {	
		if(this.isTransazioniTracciamentoDBOutRequestThrowRequestException==null){
			String pName = "org.openspcoop2.pdd.transazioni.tracciamentoDB.outRequest.throwRequestException";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTransazioniTracciamentoDBOutRequestThrowRequestException = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniTracciamentoDBOutRequestThrowRequestException = true;
			}    
		}

		return this.isTransazioniTracciamentoDBOutRequestThrowRequestException;
	}
	
	private Boolean isTransazioniTracciamentoDBOutResponseThrowRequestException = null;
	public boolean isTransazioniTracciamentoDBOutResponseThrowRequestException() {	
		if(this.isTransazioniTracciamentoDBOutResponseThrowRequestException==null){
			String pName = "org.openspcoop2.pdd.transazioni.tracciamentoDB.outResponse.throwRequestException";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTransazioniTracciamentoDBOutResponseThrowRequestException = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniTracciamentoDBOutResponseThrowRequestException = true;
			}    
		}

		return this.isTransazioniTracciamentoDBOutResponseThrowRequestException;
	}
	
	private Boolean isTransazioniTracciamentoDBPostOutResponseThrowRequestException = null;
	public boolean isTransazioniTracciamentoDBPostOutResponseThrowRequestException() {	
		if(this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException==null){
			String pName = "org.openspcoop2.pdd.transazioni.tracciamentoDB.postOutResponse.throwRequestException";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException = true;
			}    
		}

		return this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException;
	}
	
	private Boolean isTransazioniTracciamentoDBPostOutResponseThrowResponseException = null;
	public boolean isTransazioniTracciamentoDBPostOutResponseThrowResponseException() {	
		if(this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException==null){
			String pName = "org.openspcoop2.pdd.transazioni.tracciamentoDB.postOutResponse.throwResponseException";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException = true;
			}    
		}

		return this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException;
	}
	
	
	// FiltroDuplicati
	
	private Boolean isTransazioniFiltroDuplicatiSaveDateEnabled = null;
	private boolean _isTransazioniFiltroDuplicatiSaveDateEnabled() throws ProtocolException {	
		if(this.isTransazioniFiltroDuplicatiSaveDateEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.duplicati.dateIdentificativiProtocolloInCampiSeparati");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.dateIdentificativiProtocolloInCampiSeparati' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isTransazioniFiltroDuplicatiSaveDateEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.dateIdentificativiProtocolloInCampiSeparati', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniFiltroDuplicatiSaveDateEnabled = true;
			}    
		}

		return this.isTransazioniFiltroDuplicatiSaveDateEnabled;
	}
	public boolean isTransazioniFiltroDuplicatiSaveDateEnabled(IProtocolFactory<?> protocolFactory) throws ProtocolException {	
		return _isTransazioniFiltroDuplicatiSaveDateEnabled() && protocolFactory.createProtocolConfiguration().isDataPresenteInIdentificativoMessaggio();
	}
	
	private Boolean isTransazioniFiltroDuplicatiTramiteTransazioniEnabled = null;
	public boolean isTransazioniFiltroDuplicatiTramiteTransazioniEnabled() {	
		if(this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled = true;
			}    
		}

		return this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled;
	}
	
	private Boolean isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection = null;
	public boolean isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection() {	
		if(this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.usePdDConnection");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.usePdDConnection' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.usePdDConnection', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection = true;
			}    
		}

		return this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection;
	}
	
	private Boolean isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex = null;
	public boolean isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex() {	
		if(this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.forceIndex");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.forceIndex' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.forceIndex', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex = false;
			}    
		}

		return this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex;
	}
	
	
	// Stateful
	
	private Boolean isTransazioniStatefulEnabled = null;
	public boolean isTransazioniStatefulEnabled() {	
		if(this.isTransazioniStatefulEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.stateful.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.stateful.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isTransazioniStatefulEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.stateful.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniStatefulEnabled = true;
			}    
		}

		return this.isTransazioniStatefulEnabled;
	}
	
	private Boolean isTransazioniStatefulDebug = null;
	public boolean isTransazioniStatefulDebug() {	
		if(this.isTransazioniStatefulDebug==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.stateful.debug");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.stateful.debug' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isTransazioniStatefulDebug = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.stateful.debug', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isTransazioniStatefulDebug = true;
			}    
		}

		return this.isTransazioniStatefulDebug;
	}
	
	private Integer getTransazioniStatefulTimerIntervalSeconds = null;
	public int getTransazioniStatefulTimerIntervalSeconds() throws CoreException {	
		if(this.getTransazioniStatefulTimerIntervalSeconds==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.stateful.seconds");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getTransazioniStatefulTimerIntervalSeconds = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.stateful.seconds': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTransazioniStatefulTimerIntervalSeconds;
	}
	
	
	// Salvataggio
	
	private Integer getTransazioniCredenzialiMittenteMaxLength = null;
	public int getTransazioniCredenzialiMittenteMaxLength() throws CoreException {	
		if(this.getTransazioniCredenzialiMittenteMaxLength==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.credenzialiMittente.maxLength");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getTransazioniCredenzialiMittenteMaxLength = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.credenzialiMittente.maxLength': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTransazioniCredenzialiMittenteMaxLength;
	}
	
	private Boolean getTransazioniCredenzialiMittenteLifeSeconds_read = null;
	private Integer getTransazioniCredenzialiMittenteLifeSeconds = null;
	public Integer getTransazioniCredenzialiMittenteLifeSeconds() throws CoreException {	
		if(this.getTransazioniCredenzialiMittenteLifeSeconds_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.credenzialiMittente.updateAfterSeconds");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getTransazioniCredenzialiMittenteLifeSeconds = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.credenzialiMittente.updateAfterSeconds': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
			
			this.getTransazioniCredenzialiMittenteLifeSeconds_read = true;
		}

		return this.getTransazioniCredenzialiMittenteLifeSeconds;
	}
	
	private Boolean isTransazioniRegistrazioneTracceProtocolPropertiesEnabled = null;
	public boolean isTransazioniRegistrazioneTracceProtocolPropertiesEnabled() {	
		if(this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.protocolProperties.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.protocolProperties.enabled' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.protocolProperties.enabled', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled = false;
			}    
		}

		return this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled;
	}
	
	private Boolean isTransazioniRegistrazioneTracceHeaderRawEnabled = null;
	public boolean isTransazioniRegistrazioneTracceHeaderRawEnabled() {	
		if(this.isTransazioniRegistrazioneTracceHeaderRawEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.headerRaw.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.headerRaw.enabled' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isTransazioniRegistrazioneTracceHeaderRawEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.headerRaw.enabled', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniRegistrazioneTracceHeaderRawEnabled = false;
			}    
		}

		return this.isTransazioniRegistrazioneTracceHeaderRawEnabled;
	}
	
	private Boolean isTransazioniRegistrazioneTracceDigestEnabled = null;
	public boolean isTransazioniRegistrazioneTracceDigestEnabled() {	
		if(this.isTransazioniRegistrazioneTracceDigestEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.digest.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.digest.enabled' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isTransazioniRegistrazioneTracceDigestEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.digest.enabled', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniRegistrazioneTracceDigestEnabled = false;
			}    
		}

		return this.isTransazioniRegistrazioneTracceDigestEnabled;
	}
	
	private ISalvataggioTracceManager getTransazioniRegistrazioneTracceManager = null;
	private Boolean getTransazioniRegistrazioneTracceManager_read = null;
	public ISalvataggioTracceManager getTransazioniRegistrazioneTracceManager() throws CoreException {	
		return this.getTransazioniRegistrazioneTracceManager;
	}
	private ISalvataggioTracceManager _getTransazioniRegistrazioneTracceManager(ClassNameProperties className, Loader loader) throws CoreException {	
		if(this.getTransazioniRegistrazioneTracceManager_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.salvataggio");
				if(name!=null){
					name = name.trim();
					
					String classe = className.getSalvataggioTracceManager(name);
					if(classe == null) {
						throw new CoreException("Classe non trovata per il salvataggio delle tracce con tipo '"+name+"'");
					}
					
					this.getTransazioniRegistrazioneTracceManager = (ISalvataggioTracceManager) loader.newInstance(classe);
				}
				
				this.getTransazioniRegistrazioneTracceManager_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.salvataggio': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTransazioniRegistrazioneTracceManager;
	}
	
	private ISalvataggioDiagnosticiManager getTransazioniRegistrazioneDiagnosticiManager = null;
	private Boolean getTransazioniRegistrazioneDiagnosticiManager_read = null;
	public ISalvataggioDiagnosticiManager getTransazioniRegistrazioneDiagnosticiManager() throws CoreException {	
		return this.getTransazioniRegistrazioneDiagnosticiManager;
	}
	private ISalvataggioDiagnosticiManager _getTransazioniRegistrazioneDiagnosticiManager(ClassNameProperties className, Loader loader) throws CoreException {	
		if(this.getTransazioniRegistrazioneDiagnosticiManager_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.diagnostici.salvataggio");
				if(name!=null){
					name = name.trim();
					
					String classe = className.getSalvataggioDiagnosticiManager(name);
					if(classe == null) {
						throw new CoreException("Classe non trovata per il salvataggio dei diagnostici con tipo '"+name+"'");
					}
					
					this.getTransazioniRegistrazioneDiagnosticiManager = (ISalvataggioDiagnosticiManager) loader.newInstance(classe);
				}
				
				this.getTransazioniRegistrazioneDiagnosticiManager_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.diagnostici.salvataggio': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTransazioniRegistrazioneDiagnosticiManager;
	}
	
	private Boolean isTransazioniRegistrazioneDumpHeadersCompactEnabled = null;
	public boolean isTransazioniRegistrazioneDumpHeadersCompactEnabled() {	
		if(this.isTransazioniRegistrazioneDumpHeadersCompactEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.dump.headers.compact.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dump.headers.compact.enabled' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isTransazioniRegistrazioneDumpHeadersCompactEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dump.headers.compact.enabled', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniRegistrazioneDumpHeadersCompactEnabled = false;
			}    
		}

		return this.isTransazioniRegistrazioneDumpHeadersCompactEnabled;
	}
	
	// Trace su File
	
	private Boolean isTransazioniFileTraceEnabled = null;
	public boolean isTransazioniFileTraceEnabled() {	
		if(this.isTransazioniFileTraceEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniFileTraceEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniFileTraceEnabled = false;
			}    
		}

		return this.isTransazioniFileTraceEnabled;
	}
	
	private Boolean isTransazioniFileTraceDumpBinarioPDEnabled = null;
	public boolean isTransazioniFileTraceDumpBinarioPDEnabled() {	
		if(this.isTransazioniFileTraceDumpBinarioPDEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioPDEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioPDEnabled = false;
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioPDEnabled;
	}
	private Boolean isTransazioniFileTraceDumpBinarioPDPayloadEnabled = null;
	public boolean isTransazioniFileTraceDumpBinarioPDPayloadEnabled() {	
		if(this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.payload.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null || "".equals(name)){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPDEnabled()));
					name=""+isTransazioniFileTraceDumpBinarioPDEnabled();
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPDEnabled()+" : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled = isTransazioniFileTraceDumpBinarioPDEnabled();
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled;
	}
	private Boolean isTransazioniFileTraceDumpBinarioPDHeadersEnabled = null;
	public boolean isTransazioniFileTraceDumpBinarioPDHeadersEnabled() {	
		if(this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.headers.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null || "".equals(name)){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPDEnabled()));
					name=""+isTransazioniFileTraceDumpBinarioPDEnabled();
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPDEnabled()+" : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled = isTransazioniFileTraceDumpBinarioPDEnabled();
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled;
	}
	
	private Boolean isTransazioniFileTraceDumpBinarioPDConnettoreEnabled = null;
	public boolean isTransazioniFileTraceDumpBinarioPDConnettoreEnabled() {	
		if(this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.connettore.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled = false;
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled;
	}
	private Boolean isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled = null;
	public boolean isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled() {	
		if(this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.connettore.payload.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null || "".equals(name)){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()));
					name=""+isTransazioniFileTraceDumpBinarioPDConnettoreEnabled();
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()+" : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled = isTransazioniFileTraceDumpBinarioPDConnettoreEnabled();
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled;
	}
	private Boolean isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled = null;
	public boolean isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled() {	
		if(this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.connettore.headers.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null || "".equals(name)){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()));
					name=""+isTransazioniFileTraceDumpBinarioPDConnettoreEnabled();
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()+" : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled = isTransazioniFileTraceDumpBinarioPDConnettoreEnabled();
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled;
	}
	
	private Boolean isTransazioniFileTraceDumpBinarioPAEnabled = null;
	public boolean isTransazioniFileTraceDumpBinarioPAEnabled() {	
		if(this.isTransazioniFileTraceDumpBinarioPAEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioPAEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioPAEnabled = false;
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioPAEnabled;
	}
	private Boolean isTransazioniFileTraceDumpBinarioPAPayloadEnabled = null;
	public boolean isTransazioniFileTraceDumpBinarioPAPayloadEnabled() {	
		if(this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.payload.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null || "".equals(name)){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPAEnabled()));
					name=""+isTransazioniFileTraceDumpBinarioPAEnabled();
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPAEnabled()+" : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled = isTransazioniFileTraceDumpBinarioPAEnabled();
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled;
	}
	private Boolean isTransazioniFileTraceDumpBinarioPAHeadersEnabled = null;
	public boolean isTransazioniFileTraceDumpBinarioPAHeadersEnabled() {	
		if(this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.headers.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null || "".equals(name)){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPAEnabled()));
					name=""+isTransazioniFileTraceDumpBinarioPAEnabled();
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPAEnabled()+" : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled = isTransazioniFileTraceDumpBinarioPAEnabled();
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled;
	}

	
	private Boolean isTransazioniFileTraceDumpBinarioPAConnettoreEnabled = null;
	public boolean isTransazioniFileTraceDumpBinarioPAConnettoreEnabled() {	
		if(this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.connettore.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled = false;
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled;
	}
	private Boolean isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled = null;
	public boolean isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled() {	
		if(this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.connettore.payload.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null || "".equals(name)){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()));
					name=""+isTransazioniFileTraceDumpBinarioPAConnettoreEnabled();
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()+" : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled = isTransazioniFileTraceDumpBinarioPAConnettoreEnabled();
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled;
	}
	private Boolean isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled = null;
	public boolean isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled() {	
		if(this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.connettore.headers.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null || "".equals(name)){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()));
					name=""+isTransazioniFileTraceDumpBinarioPAConnettoreEnabled();
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()+" : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled = isTransazioniFileTraceDumpBinarioPAConnettoreEnabled();
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled;
	}
	
	private Boolean isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase = null;
	public boolean isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase() {	
		if(this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinario.releaseInLastTrackingPhase";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null || "".equals(name)){
					this.logDebug(getMessaggioProprietaNonImpostata(pName,true));
					name=""+true;
				}
				name = name.trim();
				this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+true+" : "+e.getMessage(),e);
				this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase = true;
			}    
		}

		return this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase;
	}

	private File getTransazioniFileTraceConfig = null;
	public File getTransazioniFileTraceConfig() throws CoreException {	
		if(this.getTransazioniFileTraceConfig==null){
			String pName = "org.openspcoop2.pdd.transazioni.fileTrace.config";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				
				this.getTransazioniFileTraceConfig = ConfigurazioneTracciamento.toFileTraceConfig(name, this.getRootDirectory(), false);
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getTransazioniFileTraceConfig;
	}
	
	public FileTraceGovWayState getFileTraceGovWayState() {
		FileTraceGovWayState state = new FileTraceGovWayState();
		state.setEnabled(this.isTransazioniFileTraceEnabled());
		if(state.isEnabled()) {
			try {
				state.setPath(this.getTransazioniFileTraceConfig().getAbsolutePath());
			}catch(Exception e) {
				state.setPath("ERROR: "+e.getMessage());
			}
			state.setEnabledInErogazione(this.isTransazioniFileTraceDumpBinarioPAEnabled());
			if(this.isTransazioniFileTraceDumpBinarioPAEnabled()) {
				state.setEnabledInErogazione_headers(this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled());
				state.setEnabledInErogazione_payload(this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled());
			}
			
			state.setEnabledOutErogazione(this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled());
			if(this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()) {
				state.setEnabledOutErogazione_headers(this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled());
				state.setEnabledOutErogazione_payload(this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled());
			}
			
			state.setEnabledInFruizione(this.isTransazioniFileTraceDumpBinarioPDEnabled());
			if(this.isTransazioniFileTraceDumpBinarioPDEnabled()) {
				state.setEnabledInFruizione_headers(this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled());
				state.setEnabledInFruizione_payload(this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled());
			}
			
			state.setEnabledOutFruizione(this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled());
			if(this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()) {
				state.setEnabledOutFruizione_headers(this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled());
				state.setEnabledOutFruizione_payload(this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled());
			}
		}
		return state;
	}
	
	
	/* ------------- Testsuite ---------------------*/
	
	private String getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit = null;
	private Boolean getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommitRead = null;
	public String getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit() throws CoreException {	
		if(this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommitRead==null){
			String pName = "org.openspcoop2.pdd.transazioni.testsuite.manuallyFaultHeader.db.beforeCommit";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit = name;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
			this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommitRead=true;
		}

		return this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit;
	}
	
	private String getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog = null;
	private Boolean getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLogRead = null;
	public String getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog() throws CoreException {	
		if(this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLogRead==null){
			String pName = "org.openspcoop2.pdd.transazioni.testsuite.manuallyFaultHeader.fileTrace.beforeLog";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null){
					name = name.trim();
					this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog = name;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
			this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLogRead=true;
		}

		return this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog;
	}
	
	/* ------------- Eventi ---------------------*/
	
	private Boolean isEventiEnabled = null;
	public boolean isEventiEnabled() {	
		if(this.isEventiEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isEventiEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isEventiEnabled = true;
			}    
		}

		return this.isEventiEnabled;
	}
	
	private Boolean isEventiDebug = null;
	public boolean isEventiDebug() {	
		if(this.isEventiDebug==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.debug");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.debug' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isEventiDebug = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.debug', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isEventiDebug = true;
			}    
		}

		return this.isEventiDebug;
	}
	
	private Boolean isEventiRegistrazioneStatoPorta = null;
	public boolean isEventiRegistrazioneStatoPorta() {	
		if(this.isEventiRegistrazioneStatoPorta==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.registraStatoPorta");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.registraStatoPorta' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isEventiRegistrazioneStatoPorta = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.registraStatoPorta', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isEventiRegistrazioneStatoPorta = true;
			}    
		}

		return this.isEventiRegistrazioneStatoPorta;
	}
	
	private Boolean isEventiTimerEnabled = null;
	public boolean isEventiTimerEnabled() {	
		if(this.isEventiTimerEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.timer.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.timer.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isEventiTimerEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.timer.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isEventiTimerEnabled = true;
			}    
		}

		return this.isEventiTimerEnabled;
	}
	
	private Integer getEventiTimerIntervalSeconds = null;
	public int getEventiTimerIntervalSeconds() throws CoreException {	
		if(this.getEventiTimerIntervalSeconds==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.timer.seconds");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getEventiTimerIntervalSeconds = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.timer.seconds': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getEventiTimerIntervalSeconds;
	}
	
	private Integer getEventiTimerIntervalConnectionTimeoutEveryXTimes = null;
	public int getEventiTimerIntervalConnectionTimeoutEveryXTimes() throws CoreException {	
		if(this.getEventiTimerIntervalConnectionTimeoutEveryXTimes==null){
			String pName = "org.openspcoop2.pdd.eventi.timer.connectionTimeout.everyXtimes";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getEventiTimerIntervalConnectionTimeoutEveryXTimes = Integer.valueOf(name);
				if(this.getEventiTimerIntervalConnectionTimeoutEveryXTimes<=0) {
					this.getEventiTimerIntervalConnectionTimeoutEveryXTimes = 1;
				}
			} catch(java.lang.Exception e) {
				this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+5+" : "+e.getMessage(),e);
				this.getEventiTimerIntervalConnectionTimeoutEveryXTimes = 5;
			}    
		}

		return this.getEventiTimerIntervalConnectionTimeoutEveryXTimes;
	}
	
	private Integer getEventiTimerIntervalRequestReadTimeoutEveryXTimes = null;
	public int getEventiTimerIntervalRequestReadTimeoutEveryXTimes() throws CoreException {	
		if(this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes==null){
			String pName = "org.openspcoop2.pdd.eventi.timer.requestReadTimeout.everyXtimes";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes = Integer.valueOf(name);
				if(this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes<=0) {
					this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes = 1;
				}
			} catch(java.lang.Exception e) {
				this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=5 : "+e.getMessage(),e);
				this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes = 5;
			}    
		}

		return this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes;
	}
	
	private Integer getEventiTimerIntervalReadTimeoutEveryXTimes = null;
	public int getEventiTimerIntervalReadTimeoutEveryXTimes() throws CoreException {	
		if(this.getEventiTimerIntervalReadTimeoutEveryXTimes==null){
			String pName = "org.openspcoop2.pdd.eventi.timer.readTimeout.everyXtimes";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getEventiTimerIntervalReadTimeoutEveryXTimes = Integer.valueOf(name);
				if(this.getEventiTimerIntervalReadTimeoutEveryXTimes<=0) {
					this.getEventiTimerIntervalReadTimeoutEveryXTimes = 1;
				}
			} catch(java.lang.Exception e) {
				this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=5 : "+e.getMessage(),e);
				this.getEventiTimerIntervalReadTimeoutEveryXTimes = 5;
			}    
		}

		return this.getEventiTimerIntervalReadTimeoutEveryXTimes;
	}
	
	
	
	
	/* ------------- Repository ---------------------*/
	
	private File getFileSystemRecoveryRepository = null;
	public File getFileSystemRecoveryRepository() throws CoreException {	
		if(this.getFileSystemRecoveryRepository==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.repository");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getFileSystemRecoveryRepository = new File(name);
				checkFileSystemRecoveryRepository();
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.repository': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getFileSystemRecoveryRepository;
	}
	private void checkFileSystemRecoveryRepository() throws CoreException {
		if(this.getFileSystemRecoveryRepository.exists()) {
			if(!this.getFileSystemRecoveryRepository.isDirectory()) {
				throw newCoreExceptionNotDir(this.getFileSystemRecoveryRepository,true);
			}
			if(!this.getFileSystemRecoveryRepository.canRead()) {
				throw newCoreExceptionCannotRead(this.getFileSystemRecoveryRepository,true);
			}
			if(!this.getFileSystemRecoveryRepository.canWrite()) {
				throw newCoreExceptionCannotWrite(this.getFileSystemRecoveryRepository,true);
			}
		}
		else {
			// viene creata automaticamente
		}
	}
	
	private Boolean isFileSystemRecoveryDebug = null;
	public boolean isFileSystemRecoveryDebug() {	
		if(this.isFileSystemRecoveryDebug==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.debug");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.debug' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isFileSystemRecoveryDebug = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.debug', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isFileSystemRecoveryDebug = true;
			}    
		}

		return this.isFileSystemRecoveryDebug;
	}
	
	private Boolean isFileSystemRecoveryTimerEnabled = null;
	public boolean isFileSystemRecoveryTimerEnabled() {	
		if(this.isFileSystemRecoveryTimerEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isFileSystemRecoveryTimerEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isFileSystemRecoveryTimerEnabled = true;
			}    
		}

		return this.isFileSystemRecoveryTimerEnabled;
	}
	
	private Integer getFileSystemRecoveryTimerIntervalSeconds = null;
	public int getFileSystemRecoveryTimerIntervalSeconds() throws CoreException {	
		if(this.getFileSystemRecoveryTimerIntervalSeconds==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.timeout");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getFileSystemRecoveryTimerIntervalSeconds = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.timeout': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getFileSystemRecoveryTimerIntervalSeconds;
	}
		
	private Integer getFileSystemRecoveryTimerMaxAttempts = null;
	public int getFileSystemRecoveryMaxAttempts() throws CoreException {	
		if(this.getFileSystemRecoveryTimerMaxAttempts==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.maxAttempts");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getFileSystemRecoveryTimerMaxAttempts = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.maxAttempts': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getFileSystemRecoveryTimerMaxAttempts;
	}
	
	private Boolean isFileSystemRecoveryTimerEventEnabled = null;
	public boolean isFileSystemRecoveryTimerEventEnabled() {	
		if(this.isFileSystemRecoveryTimerEventEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.events.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.events.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isFileSystemRecoveryTimerEventEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.events.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isFileSystemRecoveryTimerEventEnabled = true;
			}    
		}

		return this.isFileSystemRecoveryTimerEventEnabled;
	}
	
	private Boolean isFileSystemRecoveryTimerTransactionEnabled = null;
	public boolean isFileSystemRecoveryTimerTransactionEnabled() {	
		if(this.isFileSystemRecoveryTimerTransactionEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.transaction.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.transaction.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isFileSystemRecoveryTimerTransactionEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.transaction.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isFileSystemRecoveryTimerTransactionEnabled = true;
			}    
		}

		return this.isFileSystemRecoveryTimerTransactionEnabled;
	}
	
	private Long getFileSystemRecoveryEventsProcessingFileAfterMs = null;
	public long getFileSystemRecoveryEventsProcessingFileAfterMs() throws CoreException {	
		if(this.getFileSystemRecoveryEventsProcessingFileAfterMs==null){
			String pName = "org.openspcoop2.pdd.resources.fileSystemRecovery.events.processingFileAfterMs";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getFileSystemRecoveryEventsProcessingFileAfterMs = Long.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getFileSystemRecoveryEventsProcessingFileAfterMs;
	}
	
	private Long getFileSystemRecoveryTransactionProcessingFileAfterMs = null;
	public long getFileSystemRecoveryTransactionProcessingFileAfterMs() throws CoreException {	
		if(this.getFileSystemRecoveryTransactionProcessingFileAfterMs==null){
			String pName = "org.openspcoop2.pdd.resources.fileSystemRecovery.transaction.processingFileAfterMs";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getFileSystemRecoveryTransactionProcessingFileAfterMs = Long.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getFileSystemRecoveryTransactionProcessingFileAfterMs;
	}
	
	
	
	
	
	/* ------------- Controllo Traffico ---------------------*/
	
	private Boolean isControlloTrafficoEnabled = null;
	public boolean isControlloTrafficoEnabled() {	
		if(this.isControlloTrafficoEnabled==null){
			try{ 
				if(CostantiConfigurazione.CONFIGURAZIONE_XML.equalsIgnoreCase(getTipoConfigurazionePDD())){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.enabled' ignorata. Il controllo del traffico e' disabilitato sulla configurazione xml");
					this.isControlloTrafficoEnabled = false;
				}
				else {
					String name = null;
					name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.enabled");
					if(name==null){
						this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.enabled' non impostata, viene utilizzato il default=true");
						name="true";
					}
					name = name.trim();
					this.isControlloTrafficoEnabled = Boolean.parseBoolean(name);
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isControlloTrafficoEnabled = true;
			}    
		}

		return this.isControlloTrafficoEnabled;
	}
	
	private Boolean isControlloTrafficoDebug = null;
	public boolean isControlloTrafficoDebug() {	
		if(this.isControlloTrafficoDebug==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.debug");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.debug' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isControlloTrafficoDebug = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.debug', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isControlloTrafficoDebug = true;
			}    
		}

		return this.isControlloTrafficoDebug;
	}
	
	private Boolean isControlloTrafficoViolazioneGenerazioneErroreGenerico = null;
	private boolean isControlloTrafficoViolazioneGenerazioneErroreGenerico() {	
		if(this.isControlloTrafficoViolazioneGenerazioneErroreGenerico==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.erroreGenerico");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.erroreGenerico' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isControlloTrafficoViolazioneGenerazioneErroreGenerico = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.erroreGenerico', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isControlloTrafficoViolazioneGenerazioneErroreGenerico = true;
			}    
		}

		return this.isControlloTrafficoViolazioneGenerazioneErroreGenerico;
	}
	
	private Boolean isControlloTrafficoPolicyLetturaDaCacheDinamica = null;
	private boolean isControlloTrafficoPolicyLetturaDaCacheDinamica() {	
		if(this.isControlloTrafficoPolicyLetturaDaCacheDinamica==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.policy.readWithDynamicCache");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.policy.readWithDynamicCache' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isControlloTrafficoPolicyLetturaDaCacheDinamica = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.policy.readWithDynamicCache', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isControlloTrafficoPolicyLetturaDaCacheDinamica = true;
			}    
		}

		return this.isControlloTrafficoPolicyLetturaDaCacheDinamica;
	}
	
	private Map<String, int[]> getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata = new HashMap<>();
	private int[] getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata(String protocollo) throws CoreException{
		if(!this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.containsKey(protocollo)){
			EsitiProperties esitiProperties = null;
			try{
				esitiProperties =EsitiProperties.getInstanceFromProtocolName(this.log,protocollo);
			}catch(Exception e) {
				throw new CoreException(e.getMessage(),e);
			}
			try{
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaDelegata.esitiConsiderati");
				if(value!=null){
					value = value.trim();
					String [] split = value.split(",");
					List<Integer> lInt = new ArrayList<>();
					for (int i = 0; i < split.length; i++) {
						String s = split[i].trim();
						int e = -1;
						try{
							e = Integer.parseInt(s);
						}catch(Exception eParse){
							throw new CoreException("Valore ["+s+"] non riconosciuto come esito valido: "+eParse.getMessage(),eParse);
						}
						if(esitiProperties.existsEsitoCode(e)==false){
							continue; // non supportato dal protocollo
						}
						lInt.add(e);
					}
					if(lInt.isEmpty()) {
						throw new CoreException("Nessun valore è utilizzabile per il protocollo '"+protocollo+"'");
					}
					int [] tmp = new int[lInt.size()];
					for (int i = 0; i < lInt.size(); i++) {
						tmp[i] = lInt.get(i);
					}
					this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.put(protocollo, tmp);
				}
				else{
					// default
					int defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
					this.logWarn("Proprieta' non presente [org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaDelegata.esitiConsiderati] (Uso il default '"+EsitoTransazioneName.OK+"="+defaultEsito+"')");
					int [] tmp = new int[1];
					tmp[0] = defaultEsito;
					this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.put(protocollo, tmp);
				}

			}catch(Exception e){
				// default
				int defaultEsito = -1;
				try{
					defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
				}catch(Exception eEsito) {
					throw new CoreException(eEsito.getMessage(),eEsito);
				}
				this.logError("Errore durante la lettura della proprieta' [org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaDelegata.esitiConsideratii] (Uso il default '"+EsitoTransazioneName.OK+"="+defaultEsito+"'): "+e.getMessage(),e);
				int [] tmp = new int[1];
				tmp[0] = defaultEsito;
				this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.put(protocollo, tmp);
			}
		}
		return this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.get(protocollo);
	}
	
	private Map<String, int[]> getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa = new HashMap<>();
	private int[] getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa(String protocollo) throws CoreException{
		if(!this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.containsKey(protocollo)){
			EsitiProperties esitiProperties = null;
			try{
				esitiProperties = EsitiProperties.getInstanceFromProtocolName(this.log,protocollo);
			}catch(Exception e) {
				throw new CoreException(e.getMessage(),e);
			}
			try{
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaApplicativa.esitiConsiderati");
				if(value!=null){
					value = value.trim();
					String [] split = value.split(",");
					List<Integer> lInt = new ArrayList<>();
					for (int i = 0; i < split.length; i++) {
						String s = split[i].trim();
						int e = -1;
						try{
							e = Integer.parseInt(s);
						}catch(Exception eParse){
							throw new CoreException("Valore ["+s+"] non riconosciuto come esito valido: "+eParse.getMessage(),eParse);
						}
						if(esitiProperties.existsEsitoCode(e)==false){
							continue; // non supportato dal protocollo
						}
						lInt.add(e);
					}
					if(lInt.isEmpty()) {
						throw new CoreException("Nessun valore è utilizzabile per il protocollo '"+protocollo+"'");
					}
					int [] tmp = new int[lInt.size()];
					for (int i = 0; i < lInt.size(); i++) {
						tmp[i] = lInt.get(i);
					}
					this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.put(protocollo, tmp);
				}
				else{
					// default
					int defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
					this.logWarn("Proprieta' non presente [org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaApplicativa.esitiConsiderati] (Uso il default '"+EsitoTransazioneName.OK+"="+defaultEsito+"')");
					int [] tmp = new int[1];
					tmp[0] = defaultEsito;
					this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.put(protocollo, tmp);
				}

			}catch(Exception e){
				// default
				int defaultEsito = -1;
				try{
					defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
				}catch(Exception eEsito) {
					throw new CoreException(eEsito.getMessage(),eEsito);
				}
				this.logError("Errore durante la lettura della proprieta' [org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaApplicativa.esitiConsideratii] (Uso il default '"+EsitoTransazioneName.OK+"="+defaultEsito+"'): "+e.getMessage(),e);
				int [] tmp = new int[1];
				tmp[0] = defaultEsito;
				this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.put(protocollo, tmp);
			}
		}
		return this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.get(protocollo);
	}
	
	private Boolean isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo = null;
	private boolean isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo() {	
		if(this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.statistiche.finestraScorrevole.gestioneUltimoIntervallo");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.statistiche.finestraScorrevole.gestioneUltimoIntervallo' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.statistiche.finestraScorrevole.gestioneUltimoIntervallo', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo = true;
			}    
		}

		return this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo;
	}
	
	private Boolean isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere = null;
	private boolean isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere() {	
		if(this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.statistiche.distribuzioneSettimanale.usaStatisticheGiornaliere";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere = true;
			}    
		}

		return this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere;
	}
	
	private Boolean isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere = null;
	private boolean isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere() {	
		if(this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.statistiche.distribuzioneMensile.usaStatisticheGiornaliere";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere = true;
			}    
		}

		return this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere;
	}
	
	private Boolean isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata = null;
	private boolean isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata() {	
		if(this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.statistiche.distribuzioneSettimanaleMensile.usaStatisticheGiornaliere.latenza.mediaPesata";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata = true;
			}    
		}

		return this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata;
	}
	
	private Map<String, int[]> getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy = new HashMap<>();
	private int[] getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy(String protocollo) throws CoreException{
		if(!this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.containsKey(protocollo)){
			EsitiProperties esitiProperties = null;
			try{
				esitiProperties = EsitiProperties.getInstanceFromProtocolName(this.log, protocollo);
			}catch(Exception e) {
				throw new CoreException(e.getMessage(),e);
			}
			try{
				String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.violazionePolicy.esitiConsiderati");
				if(value!=null){
					value = value.trim();
					String [] split = value.split(",");
					int [] tmp = new int[split.length];
					for (int i = 0; i < split.length; i++) {
						String s = split[i].trim();
						int e = -1;
						try{
							e = Integer.parseInt(s);
						}catch(Exception eParse){
							throw new CoreException("Valore ["+s+"] non riconosciuto come esito valido: "+eParse.getMessage(),eParse);
						}
						if(!esitiProperties.existsEsitoCode(e)){
							throw new CoreException("Valore ["+s+"] non riconosciuto come esito valido");
						}
						tmp[i] = e;
					}
					this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.put(protocollo, tmp);
				}
				else{
					// default
					int defaultEsito =  esitiProperties.convertoToCode(EsitoTransazioneName.CONTROLLO_TRAFFICO_POLICY_VIOLATA);
					this.logWarn("Proprieta' non presente [org.openspcoop2.pdd.controlloTraffico.violazionePolicy.esitiConsiderati] (Uso il default '"+defaultEsito+"')");
					int [] tmp = new int[1];
					tmp[0] = defaultEsito;
					this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.put(protocollo, tmp);
				}

			}catch(Exception e){
				// default
				int defaultEsito = -1;
				try {
					defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.CONTROLLO_TRAFFICO_POLICY_VIOLATA);
				}catch(Exception eEsito) {
					throw new CoreException(eEsito.getMessage(),eEsito);
				}
				this.logError("Errore durante la lettura della proprieta' [org.openspcoop2.pdd.controlloTraffico.violazionePolicy.esitiConsiderati] (Uso il default '"+defaultEsito+"'): "+e.getMessage(),e);
				int [] tmp = new int[1];
				tmp[0] = defaultEsito;
				this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.put(protocollo, tmp);
			}
		}
		return this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.get(protocollo);
	}
	
	private Boolean isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile = null;
	private boolean isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile() {	
		if(this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.realtime.incrementaSoloPolicyApplicabile");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.realtime.incrementaSoloPolicyApplicabile' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.realtime.incrementaSoloPolicyApplicabile', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile = false;
			}    
		}

		return this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile;
	}
	
	private ConfigurazioneGatewayControlloTraffico controlloTrafficoConfigurazione = null;
	public void initConfigurazioneControlloTraffico(Loader loaderOpenSPCoop, List<String> protocolli) throws CoreException{
		if(this.controlloTrafficoConfigurazione==null){
			
			this.controlloTrafficoConfigurazione = new ConfigurazioneGatewayControlloTraffico();
						
			AccessoConfigurazionePdD config = null;
			try {
				config = this.getAccessoConfigurazionePdD();
			}catch(Exception e) {
				throw new CoreException(e.getMessage(),e);
			}
			this.controlloTrafficoConfigurazione.setTipoDatabaseConfig(config.getTipoDatabase());
			
			this.controlloTrafficoConfigurazione.setDebug(this.isControlloTrafficoDebug());
			
			this.controlloTrafficoConfigurazione.setErroreGenerico(this.isControlloTrafficoViolazioneGenerazioneErroreGenerico());
			
			this.controlloTrafficoConfigurazione.setPolicyReadedWithDynamicCache(this.isControlloTrafficoPolicyLetturaDaCacheDinamica());
			
			for (String protocollo : protocolli) {
				getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata(protocollo);
				getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa(protocollo);
			}
			this.controlloTrafficoConfigurazione.setCalcoloLatenzaPortaDelegataEsitiConsiderati(this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata);
			this.controlloTrafficoConfigurazione.setCalcoloLatenzaPortaApplicativaEsitiConsiderati(this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa);
			
			this.controlloTrafficoConfigurazione.setElaborazioneStatistica_finestraScorrevole_gestioneIntervalloCorrente(this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo());
			
			this.controlloTrafficoConfigurazione.setElaborazioneStatistica_distribuzioneSettimanale_usaStatisticheGiornaliere(this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere());
			this.controlloTrafficoConfigurazione.setElaborazioneStatistica_distribuzioneMensile_usaStatisticheGiornaliere(this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere());
			this.controlloTrafficoConfigurazione.setElaborazioneStatistica_distribuzioneSettimanaleMensile_usaStatisticheGiornaliere_latenza_mediaPesata(this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata());
						
			INotify notifier = this.getControlloTrafficoNotifyImpl(loaderOpenSPCoop);
			this.controlloTrafficoConfigurazione.setNotifierEnabled(notifier!=null);
			this.controlloTrafficoConfigurazione.setNotifier(notifier);
			
			for (String protocollo : protocolli) {
				getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy(protocollo);
			}
			this.controlloTrafficoConfigurazione.setEsitiPolicyViolate(this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy);
			
			this.controlloTrafficoConfigurazione.setElaborazioneRealtime_incrementaSoloPolicyApplicabile(this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile());
		}
	}
	public ConfigurazioneGatewayControlloTraffico getConfigurazioneControlloTraffico(){
		return this.controlloTrafficoConfigurazione;
	}
	
	
	private TipoGestorePolicy isControlloTrafficoGestorePolicyTipo = null;
	public TipoGestorePolicy getControlloTrafficoGestorePolicyTipo() {	
		if(this.isControlloTrafficoGestorePolicyTipo==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.gestorePolicy.tipo");
				if(name==null){
					TipoGestorePolicy gestoreDefault = TipoGestorePolicy.IN_MEMORY;
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.tipo' non impostata, viene utilizzato il default="+gestoreDefault);
					this.isControlloTrafficoGestorePolicyTipo = gestoreDefault;
				}
				else {
					name = name.trim();
					this.isControlloTrafficoGestorePolicyTipo = TipoGestorePolicy.toEnumConstant(name, true);
				}
			} catch(java.lang.Exception e) {
				TipoGestorePolicy gestoreDefault = TipoGestorePolicy.IN_MEMORY;
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.tipo', viene utilizzato il default="+gestoreDefault+" : "+e.getMessage(),e);
				this.isControlloTrafficoGestorePolicyTipo = gestoreDefault;
			}    
		}

		return this.isControlloTrafficoGestorePolicyTipo;
	}
	
	private PolicyGroupByActiveThreadsType getControlloTrafficoGestorePolicyInMemoryType = null;
	public PolicyGroupByActiveThreadsType getControlloTrafficoGestorePolicyInMemoryType() throws CoreException {	
		if(this.getControlloTrafficoGestorePolicyInMemoryType==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.tipo");
				if(name==null){
					this.getControlloTrafficoGestorePolicyInMemoryType = PolicyGroupByActiveThreadsType.LOCAL;
					this.logWarn("Proprieta' 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.tipo' non impostata; viene usato il default: "+this.getControlloTrafficoGestorePolicyInMemoryType);
				}
				else {
					name = name.trim();
					this.getControlloTrafficoGestorePolicyInMemoryType = PolicyGroupByActiveThreadsType.valueOf(name);
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.tipo': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoGestorePolicyInMemoryType;
	}
	
	private Map<PolicyGroupByActiveThreadsType, Boolean> getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization = null;
	public boolean isControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization(PolicyGroupByActiveThreadsType type) throws CoreException {	
		if(this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization==null){
			this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization = new HashMap<PolicyGroupByActiveThreadsType, Boolean>();
			for (PolicyGroupByActiveThreadsType initType : PolicyGroupByActiveThreadsType.values()) {
				String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory."+initType.name()+".lazyInitialization";
				try{ 
					String name = this.reader.getValueConvertEnvProperties(pName);
					if(name==null){
						this.logWarn("Proprieta' '"+pName+"' non impostata; viene usato il default: "+true);
						this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization.put(initType, true);
					}
					else {
						name = name.trim();
						Boolean v = Boolean.valueOf(name);
						this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization.put(initType, v);
					}
				} catch(java.lang.Exception e) {
					this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default: "+true+". Errore: "+e.getMessage(),e);
					this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization.put(initType, true);
				}    		
			}
		}

		return this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization.get(type);
	}
	
	private Boolean isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock = null;
	public boolean isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock(){
		String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.counters.useLocalLock";
		if(this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock = false;
			}
		}
		return this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock;
	}
	
	private Boolean isControlloTrafficoGestioneCluster_remaining_zeroValue = null;
	public boolean isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodes_remaining_zeroValue(){
		String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.LOCAL_DIVIDED_BY_NODES.remaining.zeroValue";
		if(this.isControlloTrafficoGestioneCluster_remaining_zeroValue==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isControlloTrafficoGestioneCluster_remaining_zeroValue = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isControlloTrafficoGestioneCluster_remaining_zeroValue = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isControlloTrafficoGestioneCluster_remaining_zeroValue = false;
			}
		}
		return this.isControlloTrafficoGestioneCluster_remaining_zeroValue;
	}
	
	private Boolean isControlloTrafficoGestioneCluster_limit_roundingDown = null;
	public boolean isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodes_limit_roundingDown(){
		String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.LOCAL_DIVIDED_BY_NODES.limit.roundingDown";
		if(this.isControlloTrafficoGestioneCluster_limit_roundingDown==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isControlloTrafficoGestioneCluster_limit_roundingDown = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.isControlloTrafficoGestioneCluster_limit_roundingDown = true;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.isControlloTrafficoGestioneCluster_limit_roundingDown = true;
			}
		}
		return this.isControlloTrafficoGestioneCluster_limit_roundingDown;
	}
	
	private Boolean isControlloTrafficoGestioneCluster_limit_normalizedQuota = null;
	public boolean isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodes_limit_normalizedQuota(){
		String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.LOCAL_DIVIDED_BY_NODES.limit.normalizedQuota";
		if(this.isControlloTrafficoGestioneCluster_limit_normalizedQuota==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isControlloTrafficoGestioneCluster_limit_normalizedQuota = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isControlloTrafficoGestioneCluster_limit_normalizedQuota = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isControlloTrafficoGestioneCluster_limit_normalizedQuota = false;
			}
		}
		return this.isControlloTrafficoGestioneCluster_limit_normalizedQuota;
	}
	
	private Boolean getControlloTrafficoGestorePolicyInMemoryDatabase_useTransaction = null;
	public boolean isControlloTrafficoGestorePolicyInMemoryDatabase_useTransaction() {
		if(this.getControlloTrafficoGestorePolicyInMemoryDatabase_useTransaction==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.DATABASE.useTransaction";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if (name != null) {
					name = name.trim();
					this.getControlloTrafficoGestorePolicyInMemoryDatabase_useTransaction = Boolean.valueOf(name);
				} else {
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					this.getControlloTrafficoGestorePolicyInMemoryDatabase_useTransaction =  true;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
				this.getControlloTrafficoGestorePolicyInMemoryDatabase_useTransaction = true;
			}   
		}

		return this.getControlloTrafficoGestorePolicyInMemoryDatabase_useTransaction;
	}
	
	private Long getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_AttesaAttiva = null;
	public long getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_AttesaAttiva() {	
		if(this.getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_AttesaAttiva==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.DATABASE.serializable.attesaAttiva";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if (name != null) {
					name = name.trim();
					long time = java.lang.Long.parseLong(name);
					this.getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_AttesaAttiva = time*1000;
				} else {
					this.logWarn(getMessaggioProprietaNonImpostata(pName,Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA));
					this.getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_AttesaAttiva =  Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA),e);
				this.getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_AttesaAttiva = Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA;
			}   
		}

		return this.getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_AttesaAttiva;
	}

	private Integer getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_CheckInterval = null;
	public int getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_CheckInterval() {	
		if(this.getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_CheckInterval==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.DATABASE.serializable.check";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if (name != null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_CheckInterval = time;
				} else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL));
					this.getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_CheckInterval = Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL),e);
				this.getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_CheckInterval = Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL;
			}    
		}

		return this.getControlloTrafficoGestorePolicyInMemoryDatabase_serializableDB_CheckInterval;
	}

	private Boolean isHazelcastEngineEnabled = null;
	public boolean isHazelcastEngineEnabled() {	
		if(this.isHazelcastEngineEnabled==null){
			String pName = "org.openspcoop2.pdd.hazelcast.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isHazelcastEngineEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isHazelcastEngineEnabled = true;
			}    
		}

		return this.isHazelcastEngineEnabled;
	}
	
	
	private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath_read = null;
	private String getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath = null;
	public String getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath() throws CoreException {
		
		if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath_read==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_MAP.config";

			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath = value;
				}
				
				this.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath_read = true;
				
			}catch(java.lang.Exception e) {
				String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
				this.logError(msgError,e);
				throw new CoreException(msgError,e);
			}
		}

		return this.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath;		
	}
	
	
	private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath_read = null;
	private String getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath = null;
	public String getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath() throws CoreException {
		
		if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath_read==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_PNCOUNTER.config";

			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath = value;
				}
				
				this.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath_read = true;
				
			}catch(java.lang.Exception e) {
				String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
				this.logError(msgError,e);
				throw new CoreException(msgError,e);
			}
		}

		return this.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath;		
	}
	
	
	private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath_read = null;
	private String getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath = null;
	public String getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath() throws CoreException {
		
		if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath_read==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_ATOMIC_LONG.config";

			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath = value;
				}
				
				this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath_read = true;
				
			}catch(java.lang.Exception e) {
				String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
				this.logError(msgError,e);
				throw new CoreException(msgError,e);
			}
		}

		return this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath;		
	}
	
	
	
	private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath_read = null;
	private String getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath = null;
	public String getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath() throws CoreException {
		
		if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath_read==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_ATOMIC_LONG_ASYNC.config";

			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath = value;
				}
				
				this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath_read = true;
				
			}catch(java.lang.Exception e) {
				String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
				this.logError(msgError,e);
				throw new CoreException(msgError,e);
			}
		}

		return this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath;		
	}
	
	
		
	private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath_read = null;
	private String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath = null;
	public String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath() throws CoreException {
		
		if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath_read==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_NEAR_CACHE.config";

			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath = value;
				}

				this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath_read = true;
				
			}catch(java.lang.Exception e) {
				String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
				this.logError(msgError,e);
				throw new CoreException(msgError,e);
			}
		}

		return this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath;		
	}
	
	private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath_read = null;
	private String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath = null;
	public String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath() throws CoreException {
		
		if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath_read==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_NEAR_CACHE_UNSAFE_SYNC_MAP.config";

			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath = value;
				}

				this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath_read = true;
				
			}catch(java.lang.Exception e) {
				String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
				this.logError(msgError,e);
				throw new CoreException(msgError,e);
			}
		}

		return this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath;		
	}
	
	private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath_read = null;
	private String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath = null;
	public String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath() throws CoreException {
		
		if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath_read==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_NEAR_CACHE_UNSAFE_ASYNC_MAP.config";

			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath = value;
				}

				this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath_read = true;
				
			}catch(java.lang.Exception e) {
				String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
				this.logError(msgError,e);
				throw new CoreException(msgError,e);
			}
		}

		return this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath;		
	}
	
	private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath_read = null;
	private String getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath = null;
	public String getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath() throws CoreException {
		
		if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath_read==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_REPLICATED_MAP.config";

			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath = value;
				}

				this.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath_read = true;
				
			}catch(java.lang.Exception e) {
				String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
				this.logError(msgError,e);
				throw new CoreException(msgError,e);
			}
		}

		return this.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath;		
	}
	
	
	private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastLocalConfigPath_read = null;
	private String getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath = null;
	public String getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath() throws CoreException {
		
		if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalConfigPath_read==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_LOCAL_CACHE.config";

			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if (value != null){
					value = value.trim();
					this.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath = value;
				}

				this.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalConfigPath_read = true;
				
			}catch(java.lang.Exception e) {
				String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
				this.logError(msgError,e);
				throw new CoreException(msgError,e);
			}
		}

		return this.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath;		
	}
	
	private Boolean isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy = null;
	public Boolean isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy() {
		String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST.oneMapForeachPolicy";
		
		if(this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy = false;
			}
		}
		
		return this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy;
	}
	
	private String getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId = null;
	public String getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId() {
		String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST.group_id";
		if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null) {
					throw new CoreException(NON_DEFINITA);
				}
				else if(name!=null){
					name = name.trim();
					this.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId = name;
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				this.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId = null;
			}  
		}

		return this.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId;
	}
	
	private File getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig = null;
	private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig_read = null;
	public File getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig() throws CoreException {
		String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST.sharedConfig";
		if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name!=null) {
					name = name.trim();
					this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig = new File(name);
					if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig.exists()) {
						if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig.isFile()==false) {
							throw newCoreExceptionNotFile(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig,false);
						}
						if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig.canRead()==false) {
							throw newCoreExceptionCannotRead(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig,false);
						}
					}
					else {
						this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig=null;
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}
			this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig_read = true;
		}

		return this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig;
	}

	private Integer getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval = null;	
	public Integer getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheTimerUpdate() {
		if(this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval==null){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_LOCAL_CACHE.updateInterval";
			
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if (name != null) {
					name = name.trim();
					this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval = Integer.valueOf(name);
				} else {
					this.logWarn(getMessaggioProprietaNonImpostata(pName,5));
					this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval =  5;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,5),e);
				this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval = 5;
			}   
		}

		return this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval;
	}

	
	private Boolean isRedisEngineEnabled = null;
	public boolean isRedisEngineEnabled() {	
		if(this.isRedisEngineEnabled==null){
			String pName = "org.openspcoop2.pdd.redis.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isRedisEngineEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isRedisEngineEnabled = true;
			}    
		}

		return this.isRedisEngineEnabled;
	}
	
	private List<String> getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl = null;
	private boolean getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrlRead = false;
	public List<String> getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl() throws CoreException {	
		if(this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrlRead == false){
			String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.REDIS.connectionUrl";
			try{ 

				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException(NON_DEFINITA);
				}else{
					String [] r = name.trim().split(",");
					List<String> l = new ArrayList<>();
					for(int i=0; i<r.length; i++){
						r[i] = r[i].trim();
						l.add(r[i]);
					}
					
					if(!l.isEmpty()) {
						this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl = new ArrayList<>();
						this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl.addAll(l);
					}
					else {
						throw new CoreException(NON_DEFINITA);
					}
				}
			}catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
			}  
			this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrlRead = true;
		}

		return this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl;
	}
	
	private Boolean isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy = null;
	public Boolean isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy() {
		String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.REDIS.oneMapForeachPolicy";
		
		if(this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy = false;
			}
		}
		
		return this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy;
	}
	
	private Boolean isControlloTrafficoGestorePolicyInMemoryRedis_throwExceptionIfRedisNotReady = null;
	public Boolean isControlloTrafficoGestorePolicyInMemoryRedis_throwExceptionIfRedisNotReady() {
		String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.REDIS.startupGovWay.throwExceptionIfRedisNotReady";
		
		if(this.isControlloTrafficoGestorePolicyInMemoryRedis_throwExceptionIfRedisNotReady==null){
			try{  
				String value = this.reader.getValueConvertEnvProperties(pName); 

				if(value!=null){
					value = value.trim();
					this.isControlloTrafficoGestorePolicyInMemoryRedis_throwExceptionIfRedisNotReady = Boolean.parseBoolean(value);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					this.isControlloTrafficoGestorePolicyInMemoryRedis_throwExceptionIfRedisNotReady = false;
				}

			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
				this.isControlloTrafficoGestorePolicyInMemoryRedis_throwExceptionIfRedisNotReady = false;
			}
		}
		
		return this.isControlloTrafficoGestorePolicyInMemoryRedis_throwExceptionIfRedisNotReady;
	}
	
	
	private String getControlloTrafficoGestorePolicyWSUrl = null;
	public String getControlloTrafficoGestorePolicyWSUrl() throws CoreException {	
		if(this.getControlloTrafficoGestorePolicyWSUrl==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.gestorePolicy.ws.url");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				else {
					name = name.trim();
					@SuppressWarnings("unused")
					String s = (new URL(name)).toString();
					this.getControlloTrafficoGestorePolicyWSUrl = name;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.ws.url': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoGestorePolicyWSUrl;
	}
		
	private Boolean getControlloTrafficoNotifyImpl_read = null;
	private INotify getControlloTrafficoNotifyImpl = null;
	public INotify getControlloTrafficoNotifyImpl(Loader loaderOpenSPCoop) throws CoreException {	
		if(this.getControlloTrafficoNotifyImpl_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.notifier.implementation");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNotifyImpl = (INotify) loaderOpenSPCoop.newInstance(name);
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.notifier.implementation': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}  
			this.getControlloTrafficoNotifyImpl_read = true;
		}

		return this.getControlloTrafficoNotifyImpl;
	}
	
	private File getControlloTrafficoGestorePolicyFileSystemRecoveryRepository = null;
	public File getControlloTrafficoGestorePolicyFileSystemRecoveryRepository() throws CoreException {	
		if(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.gestorePolicy.fileSystemRecovery.repository");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository = new File(name);
					if(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository.exists()) {
						if(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository.isDirectory()==false) {
							throw newCoreExceptionNotDir(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository, true);
						}
						if(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository.canRead()==false) {
							throw newCoreExceptionCannotRead(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository, true);
						}
						if(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository.canWrite()==false) {
							throw newCoreExceptionCannotWrite(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository, true);
						}
					}
					else {
						// viene creata automaticamente
					}
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.fileSystemRecovery.repository': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository;
	}
	
	
	
	
	
	// Limit
	
	private String [] getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit = null;
	private Boolean getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit_read = null;
	public String [] getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteSimultanee.header.limit");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit.length; i++) {
						this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteSimultanee.header.limit': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit;
	}
	
	private String [] getControlloTrafficoNumeroRichiesteHeaderLimit = null;
	private Boolean getControlloTrafficoNumeroRichiesteHeaderLimit_read = null;
	public String [] getControlloTrafficoNumeroRichiesteHeaderLimit() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteHeaderLimit_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteHeaderLimit = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteHeaderLimit.length; i++) {
						this.getControlloTrafficoNumeroRichiesteHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteHeaderLimit[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteHeaderLimit_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteHeaderLimit;
	}
	
	private String [] getControlloTrafficoOccupazioneBandaHeaderLimit = null;
	private Boolean getControlloTrafficoOccupazioneBandaHeaderLimit_read = null;
	public String [] getControlloTrafficoOccupazioneBandaHeaderLimit() throws CoreException {	
		if(this.getControlloTrafficoOccupazioneBandaHeaderLimit_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.limit");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoOccupazioneBandaHeaderLimit = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoOccupazioneBandaHeaderLimit.length; i++) {
						this.getControlloTrafficoOccupazioneBandaHeaderLimit[i]=this.getControlloTrafficoOccupazioneBandaHeaderLimit[i].trim();
					}
				}
				
				this.getControlloTrafficoOccupazioneBandaHeaderLimit_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.limit': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoOccupazioneBandaHeaderLimit;
	}
	
	private String [] getControlloTrafficoTempoComplessivoRispostaHeaderLimit = null;
	private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderLimit_read = null;
	public String [] getControlloTrafficoTempoComplessivoRispostaHeaderLimit() throws CoreException {	
		if(this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.limit");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit.length; i++) {
						this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit[i]=this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit[i].trim();
					}
				}
				
				this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.limit': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit;
	}
	
	private String [] getControlloTrafficoTempoMedioRispostaHeaderLimit = null;
	private Boolean getControlloTrafficoTempoMedioRispostaHeaderLimit_read = null;
	public String [] getControlloTrafficoTempoMedioRispostaHeaderLimit() throws CoreException {	
		if(this.getControlloTrafficoTempoMedioRispostaHeaderLimit_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.limit");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoTempoMedioRispostaHeaderLimit = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoTempoMedioRispostaHeaderLimit.length; i++) {
						this.getControlloTrafficoTempoMedioRispostaHeaderLimit[i]=this.getControlloTrafficoTempoMedioRispostaHeaderLimit[i].trim();
					}
				}
				
				this.getControlloTrafficoTempoMedioRispostaHeaderLimit_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.limit': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoTempoMedioRispostaHeaderLimit;
	}
	
	private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit = null;
	private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit_read = null;
	public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.limit");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit.length; i++) {
						this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.limit': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit;
	}
	
	private String [] getControlloTrafficoNumeroRichiesteFalliteHeaderLimit = null;
	private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderLimit_read = null;
	public String [] getControlloTrafficoNumeroRichiesteFalliteHeaderLimit() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.limit");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit.length; i++) {
						this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.limit': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit;
	}
	
	private String [] getControlloTrafficoNumeroFaultApplicativiHeaderLimit = null;
	private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderLimit_read = null;
	public String [] getControlloTrafficoNumeroFaultApplicativiHeaderLimit() throws CoreException {	
		if(this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.limit");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit.length; i++) {
						this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit[i]=this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.limit': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit;
	}
	
	private String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit = null;
	private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit_read = null;
	public String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.limit");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit.length; i++) {
						this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.limit': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit;
	}	
	
	
	
	// Windows
	
	private Boolean getControlloTrafficoNumeroRichiesteHeaderLimitWindows = null;
	private Boolean getControlloTrafficoNumeroRichiesteHeaderLimitWindows_read = null;
	public Boolean getControlloTrafficoNumeroRichiesteHeaderLimitWindows() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteHeaderLimitWindows_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit.windows");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteHeaderLimitWindows = Boolean.valueOf(name);
				}
				
				this.getControlloTrafficoNumeroRichiesteHeaderLimitWindows_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit.windows': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteHeaderLimitWindows;
	}
	
	private Boolean getControlloTrafficoOccupazioneBandaHeaderLimitWindows = null;
	private Boolean getControlloTrafficoOccupazioneBandaHeaderLimitWindows_read = null;
	public Boolean getControlloTrafficoOccupazioneBandaHeaderLimitWindows() throws CoreException {	
		if(this.getControlloTrafficoOccupazioneBandaHeaderLimitWindows_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.limit.windows");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoOccupazioneBandaHeaderLimitWindows = Boolean.valueOf(name);
				}
				
				this.getControlloTrafficoOccupazioneBandaHeaderLimitWindows_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.limit.windows': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoOccupazioneBandaHeaderLimitWindows;
	}
	
	private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows = null;
	private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows_read = null;
	public Boolean getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows() throws CoreException {	
		if(this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.limit.windows");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows = Boolean.valueOf(name);
				}
				
				this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.limit.windows': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows;
	}
	
	private Boolean getControlloTrafficoTempoMedioRispostaHeaderLimitWindows = null;
	private Boolean getControlloTrafficoTempoMedioRispostaHeaderLimitWindows_read = null;
	public Boolean getControlloTrafficoTempoMedioRispostaHeaderLimitWindows() throws CoreException {	
		if(this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindows_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.limit.windows");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindows = Boolean.valueOf(name);
				}
				
				this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindows_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.limit.windows': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindows;
	}
	
	private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows = null;
	private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows_read = null;
	public Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.limit.windows");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows = Boolean.valueOf(name);
				}
				
				this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.limit.windows': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows;
	}
	
	private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows = null;
	private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows_read = null;
	public Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.limit.windows");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows = Boolean.valueOf(name);
				}
				
				this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.limit.windows': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows;
	}
	
	private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows = null;
	private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows_read = null;
	public Boolean getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows() throws CoreException {	
		if(this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.limit.windows");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows = Boolean.valueOf(name);
				}
				
				this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.limit.windows': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows;
	}
	
	private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows = null;
	private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows_read = null;
	public Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.limit.windows");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows = Boolean.valueOf(name);
				}
				
				this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.limit.windows': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows;
	}	
	

	
	// Remaining
	
	private String [] getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining = null;
	private Boolean getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining_read = null;
	public String [] getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteSimultanee.header.remaining");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining.length; i++) {
						this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteSimultanee.header.remaining': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining;
	}
	
	private String [] getControlloTrafficoNumeroRichiesteHeaderRemaining = null;
	private Boolean getControlloTrafficoNumeroRichiesteHeaderRemaining_read = null;
	public String [] getControlloTrafficoNumeroRichiesteHeaderRemaining() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteHeaderRemaining_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.remaining");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteHeaderRemaining = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteHeaderRemaining.length; i++) {
						this.getControlloTrafficoNumeroRichiesteHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteHeaderRemaining[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteHeaderRemaining_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.remaining': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteHeaderRemaining;
	}
	
	private String [] getControlloTrafficoOccupazioneBandaHeaderRemaining = null;
	private Boolean getControlloTrafficoOccupazioneBandaHeaderRemaining_read = null;
	public String [] getControlloTrafficoOccupazioneBandaHeaderRemaining() throws CoreException {	
		if(this.getControlloTrafficoOccupazioneBandaHeaderRemaining_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.remaining");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoOccupazioneBandaHeaderRemaining = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoOccupazioneBandaHeaderRemaining.length; i++) {
						this.getControlloTrafficoOccupazioneBandaHeaderRemaining[i]=this.getControlloTrafficoOccupazioneBandaHeaderRemaining[i].trim();
					}
				}
				
				this.getControlloTrafficoOccupazioneBandaHeaderRemaining_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.remaining': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoOccupazioneBandaHeaderRemaining;
	}
	
	private String [] getControlloTrafficoTempoComplessivoRispostaHeaderRemaining = null;
	private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderRemaining_read = null;
	public String [] getControlloTrafficoTempoComplessivoRispostaHeaderRemaining() throws CoreException {	
		if(this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.remaining");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining.length; i++) {
						this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining[i]=this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining[i].trim();
					}
				}
				
				this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.remaining': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining;
	}
		
	private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining = null;
	private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining_read = null;
	public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.remaining");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining.length; i++) {
						this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.remaining': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining;
	}
	
	private String [] getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining = null;
	private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining_read = null;
	public String [] getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.remaining");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining.length; i++) {
						this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.remaining': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining;
	}
	
	private String [] getControlloTrafficoNumeroFaultApplicativiHeaderRemaining = null;
	private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderRemaining_read = null;
	public String [] getControlloTrafficoNumeroFaultApplicativiHeaderRemaining() throws CoreException {	
		if(this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.remaining");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining.length; i++) {
						this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining[i]=this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.remaining': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining;
	}
	
	private String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining = null;
	private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining_read = null;
	public String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.remaining");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining.length; i++) {
						this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteNonCompletateConSuccesso.header.remaining': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining;
	}
	

	
	
	
	// Reset
	
	private String [] getControlloTrafficoNumeroRichiesteHeaderReset = null;
	private Boolean getControlloTrafficoNumeroRichiesteHeaderReset_read = null;
	public String [] getControlloTrafficoNumeroRichiesteHeaderReset() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteHeaderReset_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.reset");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteHeaderReset = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteHeaderReset.length; i++) {
						this.getControlloTrafficoNumeroRichiesteHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteHeaderReset[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteHeaderReset_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.reset': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteHeaderReset;
	}
	
	private String [] getControlloTrafficoOccupazioneBandaHeaderReset = null;
	private Boolean getControlloTrafficoOccupazioneBandaHeaderReset_read = null;
	public String [] getControlloTrafficoOccupazioneBandaHeaderReset() throws CoreException {	
		if(this.getControlloTrafficoOccupazioneBandaHeaderReset_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.reset");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoOccupazioneBandaHeaderReset = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoOccupazioneBandaHeaderReset.length; i++) {
						this.getControlloTrafficoOccupazioneBandaHeaderReset[i]=this.getControlloTrafficoOccupazioneBandaHeaderReset[i].trim();
					}
				}
				
				this.getControlloTrafficoOccupazioneBandaHeaderReset_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.reset': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoOccupazioneBandaHeaderReset;
	}
	
	private String [] getControlloTrafficoTempoComplessivoRispostaHeaderReset = null;
	private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderReset_read = null;
	public String [] getControlloTrafficoTempoComplessivoRispostaHeaderReset() throws CoreException {	
		if(this.getControlloTrafficoTempoComplessivoRispostaHeaderReset_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.reset");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoTempoComplessivoRispostaHeaderReset = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoTempoComplessivoRispostaHeaderReset.length; i++) {
						this.getControlloTrafficoTempoComplessivoRispostaHeaderReset[i]=this.getControlloTrafficoTempoComplessivoRispostaHeaderReset[i].trim();
					}
				}
				
				this.getControlloTrafficoTempoComplessivoRispostaHeaderReset_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.reset': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoTempoComplessivoRispostaHeaderReset;
	}
	
	private String [] getControlloTrafficoTempoMedioRispostaHeaderReset = null;
	private Boolean getControlloTrafficoTempoMedioRispostaHeaderReset_read = null;
	public String [] getControlloTrafficoTempoMedioRispostaHeaderReset() throws CoreException {	
		if(this.getControlloTrafficoTempoMedioRispostaHeaderReset_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.reset");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoTempoMedioRispostaHeaderReset = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoTempoMedioRispostaHeaderReset.length; i++) {
						this.getControlloTrafficoTempoMedioRispostaHeaderReset[i]=this.getControlloTrafficoTempoMedioRispostaHeaderReset[i].trim();
					}
				}
				
				this.getControlloTrafficoTempoMedioRispostaHeaderReset_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.reset': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoTempoMedioRispostaHeaderReset;
	}
	
	private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset = null;
	private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset_read = null;
	public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.reset");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset.length; i++) {
						this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.reset': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset;
	}
	
	private String [] getControlloTrafficoNumeroRichiesteFalliteHeaderReset = null;
	private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderReset_read = null;
	public String [] getControlloTrafficoNumeroRichiesteFalliteHeaderReset() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.reset");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset.length; i++) {
						this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.reset': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset;
	}
	
	private String [] getControlloTrafficoNumeroFaultApplicativiHeaderReset = null;
	private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderReset_read = null;
	public String [] getControlloTrafficoNumeroFaultApplicativiHeaderReset() throws CoreException {	
		if(this.getControlloTrafficoNumeroFaultApplicativiHeaderReset_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.reset");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroFaultApplicativiHeaderReset = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroFaultApplicativiHeaderReset.length; i++) {
						this.getControlloTrafficoNumeroFaultApplicativiHeaderReset[i]=this.getControlloTrafficoNumeroFaultApplicativiHeaderReset[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroFaultApplicativiHeaderReset_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.reset': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroFaultApplicativiHeaderReset;
	}
	
	private String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset = null;
	private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset_read = null;
	public String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset() throws CoreException {	
		if(this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.reset");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset.length; i++) {
						this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset[i].trim();
					}
				}
				
				this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.reset': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset;
	}	
	
	
	
	// Header Retry After
	
	private String [] getControlloTrafficoRetryAfterHeader = null;
	private Boolean getControlloTrafficoRetryAfterHeader_read = null;
	public String [] getControlloTrafficoRetryAfterHeader() throws CoreException {	
		if(this.getControlloTrafficoRetryAfterHeader_read==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.policyViolate.retryAfter");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoRetryAfterHeader = name.split(",");
					for (int i = 0; i < this.getControlloTrafficoRetryAfterHeader.length; i++) {
						this.getControlloTrafficoRetryAfterHeader[i]=this.getControlloTrafficoRetryAfterHeader[i].trim();
					}
				}
				
				this.getControlloTrafficoRetryAfterHeader_read = true;
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getControlloTrafficoRetryAfterHeader;
	}
		
	private Integer getControlloTrafficoRetryAfterHeader_randomBackoff = null;
	public Integer getControlloTrafficoRetryAfterHeader_randomBackoff() {	
		if(this.getControlloTrafficoRetryAfterHeader_randomBackoff==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.policyViolate.retryAfter.randomBackoff.seconds");
				if(name!=null){
					name = name.trim();
					this.getControlloTrafficoRetryAfterHeader_randomBackoff = Integer.parseInt(name);
				}
				else {
					this.getControlloTrafficoRetryAfterHeader_randomBackoff = 0;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.policyViolate.retryAfter.randomBackoff.seconds': "+e.getMessage(),e);
				this.getControlloTrafficoRetryAfterHeader_randomBackoff = 0;
			}    
		}

		return this.getControlloTrafficoRetryAfterHeader_randomBackoff;
	}
	
	
	
	/* ------------- Allarmi ---------------------*/
	
	private Boolean isAllarmiEnabled = null;
	public boolean isAllarmiEnabled() {	
		if(this.isAllarmiEnabled==null){
			try{ 
				if(CostantiConfigurazione.CONFIGURAZIONE_XML.equalsIgnoreCase(getTipoConfigurazionePDD())){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.enabled' ignorata. La segnalazione degli allarmi è disabilitata sulla configurazione xml");
					this.isAllarmiEnabled = false;
				}
				else {
					String name = null;
					name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.allarmi.enabled");
					if(name==null){
						this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.enabled' non impostata, viene utilizzato il default=false");
						name="false";
					}
					name = name.trim();
					this.isAllarmiEnabled = Boolean.parseBoolean(name);
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.enabled', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isAllarmiEnabled = true;
			}    
		}

		return this.isAllarmiEnabled;
	}
	
	private Boolean isAllarmiDebug = null;
	public boolean isAllarmiDebug() {	
		if(this.isAllarmiDebug==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.allarmi.debug");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.debug' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isAllarmiDebug = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.debug', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isAllarmiDebug = true;
			}    
		}

		return this.isAllarmiDebug;
	}
	
	
	
	
	/* ------------- Service Unavailable ---------------------*/
	
	private Integer getServiceUnavailableRetryAfterSeconds_pd = null;
	public Integer getServiceUnavailableRetryAfterSeconds_pd() {	
		if(this.getServiceUnavailableRetryAfterSeconds_pd==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.seconds");
				if(name!=null){
					name = name.trim();
					this.getServiceUnavailableRetryAfterSeconds_pd = Integer.parseInt(name);
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.seconds', default:60 : "+e.getMessage(),e);
				this.getServiceUnavailableRetryAfterSeconds_pd = 60;
			}    
		}

		return this.getServiceUnavailableRetryAfterSeconds_pd;
	}
	
	private Integer getServiceUnavailableRetryAfterSeconds_randomBackoff_pd = null;
	public Integer getServiceUnavailableRetryAfterSeconds_randomBackoff_pd() {	
		if(this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.randomBackoff.seconds");
				if(name!=null){
					name = name.trim();
					this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd = Integer.parseInt(name);
				}
				else {
					this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd = 0;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.randomBackoff.seconds': "+e.getMessage(),e);
				this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd = 0;
			}    
		}

		return this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd;
	}
	
	private Integer getServiceUnavailableRetryAfterSeconds_pa = null;
	public Integer getServiceUnavailableRetryAfterSeconds_pa() {	
		if(this.getServiceUnavailableRetryAfterSeconds_pa==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.seconds");
				if(name!=null){
					name = name.trim();
					this.getServiceUnavailableRetryAfterSeconds_pa = Integer.parseInt(name);
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.seconds', default:60 : "+e.getMessage(),e);
				this.getServiceUnavailableRetryAfterSeconds_pa = 60;
			}    
		}

		return this.getServiceUnavailableRetryAfterSeconds_pa;
	}
	
	private Integer getServiceUnavailableRetryAfterSeconds_randomBackoff_pa = null;
	public Integer getServiceUnavailableRetryAfterSeconds_randomBackoff_pa() {	
		if(this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.randomBackoff.seconds");
				if(name!=null){
					name = name.trim();
					this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa = Integer.parseInt(name);
				}
				else {
					this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa = 0;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.randomBackoff.seconds': "+e.getMessage(),e);
				this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa = 0;
			}    
		}

		return this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa;
	}
	
	
	
	private Boolean isEnabledServiceUnavailableRetryAfter_pd_suspend = null;
	public boolean isEnabledServiceUnavailableRetryAfter_pd_suspend() {	
		if(this.isEnabledServiceUnavailableRetryAfter_pd_suspend==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isEnabledServiceUnavailableRetryAfter_pd_suspend = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isEnabledServiceUnavailableRetryAfter_pd_suspend = true;
			}    
		}

		return this.isEnabledServiceUnavailableRetryAfter_pd_suspend;
	}
	
	private Integer getServiceUnavailableRetryAfterSeconds_pd_suspend = null;
	public Integer getServiceUnavailableRetryAfterSeconds_pd_suspend() {	
		if(this.getServiceUnavailableRetryAfterSeconds_pd_suspend==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.seconds");
				if(name!=null){
					name = name.trim();
					this.getServiceUnavailableRetryAfterSeconds_pd_suspend = Integer.parseInt(name);
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.seconds', default:60 : "+e.getMessage(),e);
				this.getServiceUnavailableRetryAfterSeconds_pd_suspend = 60;
			}    
		}

		return this.getServiceUnavailableRetryAfterSeconds_pd_suspend;
	}
	
	private Integer getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_suspend = null;
	public Integer getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_suspend() {	
		if(this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_suspend==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.randomBackoff.seconds");
				if(name!=null){
					name = name.trim();
					this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_suspend = Integer.parseInt(name);
				}
				else {
					this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_suspend = 0;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.randomBackoff.seconds': "+e.getMessage(),e);
				this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_suspend = 0;
			}    
		}

		return this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_suspend;
	}
	
	private Boolean isEnabledServiceUnavailableRetryAfter_pa_suspend = null;
	public boolean isEnabledServiceUnavailableRetryAfter_pa_suspend() {	
		if(this.isEnabledServiceUnavailableRetryAfter_pa_suspend==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isEnabledServiceUnavailableRetryAfter_pa_suspend = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isEnabledServiceUnavailableRetryAfter_pa_suspend = true;
			}    
		}

		return this.isEnabledServiceUnavailableRetryAfter_pa_suspend;
	}
	
	private Integer getServiceUnavailableRetryAfterSeconds_pa_suspend = null;
	public Integer getServiceUnavailableRetryAfterSeconds_pa_suspend() {	
		if(this.getServiceUnavailableRetryAfterSeconds_pa_suspend==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.seconds");
				if(name!=null){
					name = name.trim();
					this.getServiceUnavailableRetryAfterSeconds_pa_suspend = Integer.parseInt(name);
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.seconds', default:60 : "+e.getMessage(),e);
				this.getServiceUnavailableRetryAfterSeconds_pa_suspend = 60;
			}    
		}

		return this.getServiceUnavailableRetryAfterSeconds_pa_suspend;
	}
	
	private Integer getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_suspend = null;
	public Integer getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_suspend() {	
		if(this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_suspend==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.randomBackoff.seconds");
				if(name!=null){
					name = name.trim();
					this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_suspend = Integer.parseInt(name);
				}
				else {
					this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_suspend = 0;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.randomBackoff.seconds': "+e.getMessage(),e);
				this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_suspend = 0;
			}    
		}

		return this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_suspend;
	}
	
	private Boolean isEnabledServiceUnavailableRetryAfter_pd_connectionFailed = null;
	public boolean isEnabledServiceUnavailableRetryAfter_pd_connectionFailed() {	
		if(this.isEnabledServiceUnavailableRetryAfter_pd_connectionFailed==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isEnabledServiceUnavailableRetryAfter_pd_connectionFailed = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isEnabledServiceUnavailableRetryAfter_pd_connectionFailed = true;
			}    
		}

		return this.isEnabledServiceUnavailableRetryAfter_pd_connectionFailed;
	}
	
	private Integer getServiceUnavailableRetryAfterSeconds_pd_connectionFailed = null;
	public Integer getServiceUnavailableRetryAfterSeconds_pd_connectionFailed() {	
		if(this.getServiceUnavailableRetryAfterSeconds_pd_connectionFailed==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.seconds");
				if(name!=null){
					name = name.trim();
					this.getServiceUnavailableRetryAfterSeconds_pd_connectionFailed = Integer.parseInt(name);
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.seconds', default:60 : "+e.getMessage(),e);
				this.getServiceUnavailableRetryAfterSeconds_pd_connectionFailed = 60;
			}    
		}

		return this.getServiceUnavailableRetryAfterSeconds_pd_connectionFailed;
	}
	
	private Integer getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_connectionFailed = null;
	public Integer getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_connectionFailed() {	
		if(this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_connectionFailed==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.randomBackoff.seconds");
				if(name!=null){
					name = name.trim();
					this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_connectionFailed = Integer.parseInt(name);
				}
				else {
					this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_connectionFailed = 0;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.randomBackoff.seconds': "+e.getMessage(),e);
				this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_connectionFailed = 0;
			}    
		}

		return this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pd_connectionFailed;
	}
	
	private Boolean isEnabledServiceUnavailableRetryAfter_pa_connectionFailed = null;
	public boolean isEnabledServiceUnavailableRetryAfter_pa_connectionFailed() {	
		if(this.isEnabledServiceUnavailableRetryAfter_pa_connectionFailed==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isEnabledServiceUnavailableRetryAfter_pa_connectionFailed = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isEnabledServiceUnavailableRetryAfter_pa_connectionFailed = true;
			}    
		}

		return this.isEnabledServiceUnavailableRetryAfter_pa_connectionFailed;
	}
	
	private Integer getServiceUnavailableRetryAfterSeconds_pa_connectionFailed = null;
	public Integer getServiceUnavailableRetryAfterSeconds_pa_connectionFailed() {	
		if(this.getServiceUnavailableRetryAfterSeconds_pa_connectionFailed==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.seconds");
				if(name!=null){
					name = name.trim();
					this.getServiceUnavailableRetryAfterSeconds_pa_connectionFailed = Integer.parseInt(name);
				}
				else {
					throw new CoreException(PROPRIETA_NON_DEFINITA);
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.seconds', default:60 : "+e.getMessage(),e);
				this.getServiceUnavailableRetryAfterSeconds_pa_connectionFailed = 60;
			}    
		}

		return this.getServiceUnavailableRetryAfterSeconds_pa_connectionFailed;
	}
	
	private Integer getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_connectionFailed = null;
	public Integer getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_connectionFailed() {	
		if(this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_connectionFailed==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.randomBackoff.seconds");
				if(name!=null){
					name = name.trim();
					this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_connectionFailed = Integer.parseInt(name);
				}
				else {
					this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_connectionFailed = 0;
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.randomBackoff.seconds': "+e.getMessage(),e);
				this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_connectionFailed = 0;
			}    
		}

		return this.getServiceUnavailableRetryAfterSeconds_randomBackoff_pa_connectionFailed;
	}
	
	
	private List<String> isReadTimedOut = null;
	public boolean isServiceUnavailable_ReadTimedOut(String msg) {	
		if(this.isReadTimedOut==null){
			try{ 
				Properties p = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.readTimedOut.");
				this.isReadTimedOut = new ArrayList<>();
				if(p!=null && !p.isEmpty()) {
					Iterator<Object> it = p.values().iterator();
					while (it.hasNext()) {
						Object o = it.next();
						if(o instanceof String) {
							String s = (String) o;
							this.isReadTimedOut.add(s);
						}
					}
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.error.': "+e.getMessage(),e);
				this.isReadTimedOut = new ArrayList<>();
			}    
		}

		if(!this.isReadTimedOut.isEmpty()) {
			for (String s : this.isReadTimedOut) {
				if(msg.contains(s)) {
					return true;
				}
			}
		}
		
		return false;
	}
	
	
	/* ------------- Statistiche ---------------------*/
	
	private Boolean isStatisticheGenerazioneEnabled = null;
	public boolean isStatisticheGenerazioneEnabled() {	
		if(this.isStatisticheGenerazioneEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheGenerazioneEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheGenerazioneEnabled = true;
			}    
		}

		return this.isStatisticheGenerazioneEnabled;
	}
	
	
	private Boolean isStatisticheUsePddRuntimeDatasource = null;
	public boolean isStatisticheUsePddRuntimeDatasource() {	
		if(this.isStatisticheUsePddRuntimeDatasource==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.dataSource.usePddRuntime");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource.usePddRuntime' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheUsePddRuntimeDatasource = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource.usePddRuntime', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isStatisticheUsePddRuntimeDatasource = false;
			}    
		}

		return this.isStatisticheUsePddRuntimeDatasource;
	}
	
	private Boolean isStatisticheUseTransazioniDatasource = null;
	public boolean isStatisticheUseTransazioniDatasource() {	
		if(this.isStatisticheUseTransazioniDatasource==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.dataSource.useTransazioni");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource.useTransazioni' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheUseTransazioniDatasource = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource.useTransazioni', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheUseTransazioniDatasource = true;
			}    
		}

		return this.isStatisticheUseTransazioniDatasource;
	}
	
	private String getStatisticheDatasource = null;
	public String getStatisticheDatasource() throws CoreException {	
		if(this.getStatisticheDatasource==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.dataSource");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getStatisticheDatasource = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getStatisticheDatasource;
	}
	
	private Properties getStatisticheDatasourceJndiContext = null;
	public Properties getStatisticheDatasourceJndiContext() throws CoreException {	
		if(this.getStatisticheDatasourceJndiContext==null){
			try{ 
				this.getStatisticheDatasourceJndiContext = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.statistiche.dataSource.property.");
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource.property.*': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getStatisticheDatasourceJndiContext;
	}
	
	private Boolean isStatisticheDatasourceUseDBUtils = null;
	public boolean isStatisticheDatasourceUseDBUtils() {	
		if(this.isStatisticheDatasourceUseDBUtils==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.datasource.useDSUtils");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.datasource.useDSUtils' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheDatasourceUseDBUtils = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.datasource.useDSUtils', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheDatasourceUseDBUtils = true;
			}    
		}

		return this.isStatisticheDatasourceUseDBUtils;
	}

	private Boolean isStatisticheGenerazioneUseUnionForLatency = null;
	public boolean isStatisticheGenerazioneUseUnionForLatency() {	
		if(this.isStatisticheGenerazioneUseUnionForLatency==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.useUnionForLatency");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.useUnionForLatency' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheGenerazioneUseUnionForLatency = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.useUnionForLatency', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheGenerazioneUseUnionForLatency = true;
			}    
		}

		return this.isStatisticheGenerazioneUseUnionForLatency;
	}
	
	private Boolean isStatisticheGenerazioneCustomEnabled = null;
	public boolean isStatisticheGenerazioneCustomEnabled() {	
		if(this.isStatisticheGenerazioneCustomEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.custom.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.custom.enabled' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isStatisticheGenerazioneCustomEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.custom.enabled', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isStatisticheGenerazioneCustomEnabled = false;
			}    
		}

		return this.isStatisticheGenerazioneCustomEnabled;
	}
	
	private Boolean isStatisticheGenerazioneCustomSdkEnabled = null;
	public boolean isStatisticheGenerazioneCustomSdkEnabled() {	
		if(this.isStatisticheGenerazioneCustomSdkEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.custom.transazioniSdk.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.custom.transazioniSdk.enabled' non impostata, viene utilizzato il default=false");
					name="false";
				}
				name = name.trim();
				this.isStatisticheGenerazioneCustomSdkEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.custom.transazioniSdk.enabled', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isStatisticheGenerazioneCustomSdkEnabled = false;
			}    
		}

		return this.isStatisticheGenerazioneCustomSdkEnabled;
	}
	
	private Boolean isStatisticheGenerazioneDebug = null;
	public boolean isStatisticheGenerazioneDebug() {	
		if(this.isStatisticheGenerazioneDebug==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.debug");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.debug' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheGenerazioneDebug = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.debug', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheGenerazioneDebug = true;
			}    
		}

		return this.isStatisticheGenerazioneDebug;
	}
	
	private Integer getStatisticheOrarieGenerazioneTimerIntervalSeconds = null;
	public int getStatisticheOrarieGenerazioneTimerIntervalSeconds() throws CoreException {	
		if(this.getStatisticheOrarieGenerazioneTimerIntervalSeconds==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseOraria.timer.intervalloSecondi");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getStatisticheOrarieGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseOraria.timer.intervalloSecondi': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getStatisticheOrarieGenerazioneTimerIntervalSeconds;
	}
	
	private Integer getStatisticheGiornaliereGenerazioneTimerIntervalSeconds = null;
	public int getStatisticheGiornaliereGenerazioneTimerIntervalSeconds() throws CoreException {	
		if(this.getStatisticheGiornaliereGenerazioneTimerIntervalSeconds==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.timer.intervalloSecondi");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getStatisticheGiornaliereGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.timer.intervalloSecondi': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getStatisticheGiornaliereGenerazioneTimerIntervalSeconds;
	}
	
	private Integer getStatisticheSettimanaliGenerazioneTimerIntervalSeconds = null;
	public int getStatisticheSettimanaliGenerazioneTimerIntervalSeconds() throws CoreException {	
		if(this.getStatisticheSettimanaliGenerazioneTimerIntervalSeconds==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.timer.intervalloSecondi");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getStatisticheSettimanaliGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.timer.intervalloSecondi': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getStatisticheSettimanaliGenerazioneTimerIntervalSeconds;
	}
	
	private Integer getStatisticheMensiliGenerazioneTimerIntervalSeconds = null;
	public int getStatisticheMensiliGenerazioneTimerIntervalSeconds() throws CoreException {	
		if(this.getStatisticheMensiliGenerazioneTimerIntervalSeconds==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseMensile.timer.intervalloSecondi");
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getStatisticheMensiliGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseMensile.timer.intervalloSecondi': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getStatisticheMensiliGenerazioneTimerIntervalSeconds;
	}
	
	private Integer getStatisticheGenerazioneTimerLockMaxLife = null;
	public int getStatisticheGenerazioneTimerLockMaxLife() {	
		if(this.getStatisticheGenerazioneTimerLockMaxLife==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.timer.lock.maxLife");

				if(name!=null){
					name = name.trim();
					this.getStatisticheGenerazioneTimerLockMaxLife = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.timer.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
					this.getStatisticheGenerazioneTimerLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.timer.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE+", errore:"+e.getMessage(),e);
				this.getStatisticheGenerazioneTimerLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
			}
			if(this.getStatisticheGenerazioneTimerLockMaxLife!=null && this.getStatisticheGenerazioneTimerLockMaxLife>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getStatisticheGenerazioneTimerLockMaxLife = this.getStatisticheGenerazioneTimerLockMaxLife *1000;
			}
		}

		return this.getStatisticheGenerazioneTimerLockMaxLife;
	}
	
	private Integer getStatisticheGenerazioneTimerLockIdleTime = null;
	public int getStatisticheGenerazioneTimerLockIdleTime() {	
		if(this.getStatisticheGenerazioneTimerLockIdleTime==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.timer.lock.idleTime");

				if(name!=null){
					name = name.trim();
					this.getStatisticheGenerazioneTimerLockIdleTime = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.timer.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
					this.getStatisticheGenerazioneTimerLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.timer.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME+", errore:"+e.getMessage(),e);
				this.getStatisticheGenerazioneTimerLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
			}
			if(this.getStatisticheGenerazioneTimerLockIdleTime!=null && this.getStatisticheGenerazioneTimerLockIdleTime>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getStatisticheGenerazioneTimerLockIdleTime = this.getStatisticheGenerazioneTimerLockIdleTime *1000;
			}
		}

		return this.getStatisticheGenerazioneTimerLockIdleTime;
	}
	
	private Long getStatisticheGenerazioneTimerLockAttesaAttiva = null;
	public long getStatisticheGenerazioneTimerLockAttesaAttiva() {	
		if(this.getStatisticheGenerazioneTimerLockAttesaAttiva==null){
			String pName = "org.openspcoop2.pdd.statistiche.generazione.timer.lock.attesaAttiva";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					long time = java.lang.Long.parseLong(name);
					this.getStatisticheGenerazioneTimerLockAttesaAttiva = time*1000;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
					this.getStatisticheGenerazioneTimerLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.getStatisticheGenerazioneTimerLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
			}    
		}

		return this.getStatisticheGenerazioneTimerLockAttesaAttiva;
	}

	private Integer getStatisticheGenerazioneTimerLockCheckInterval = null;
	public int getStatisticheGenerazioneTimerLockCheckInterval() {	
		if(this.getStatisticheGenerazioneTimerLockCheckInterval==null){
			String pName = "org.openspcoop2.pdd.statistiche.generazione.timer.lock.check";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.getStatisticheGenerazioneTimerLockCheckInterval = time;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
					this.getStatisticheGenerazioneTimerLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.getStatisticheGenerazioneTimerLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
			}  
		}

		return this.getStatisticheGenerazioneTimerLockCheckInterval;
	}
	
	private Boolean isStatisticheGenerazioneBaseOrariaEnabled = null;
	public boolean isStatisticheGenerazioneBaseOrariaEnabled() {	
		if(this.isStatisticheGenerazioneBaseOrariaEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseOraria.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseOraria.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheGenerazioneBaseOrariaEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseOraria.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheGenerazioneBaseOrariaEnabled = true;
			}    
		}

		return this.isStatisticheGenerazioneBaseOrariaEnabled;
	}
	
	private Boolean isStatisticheGenerazioneBaseGiornalieraEnabled = null;
	public boolean isStatisticheGenerazioneBaseGiornalieraEnabled() {	
		if(this.isStatisticheGenerazioneBaseGiornalieraEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheGenerazioneBaseGiornalieraEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheGenerazioneBaseGiornalieraEnabled = true;
			}    
		}

		return this.isStatisticheGenerazioneBaseGiornalieraEnabled;
	}
	
	private Boolean isStatisticheGenerazioneBaseSettimanaleEnabled = null;
	public boolean isStatisticheGenerazioneBaseSettimanaleEnabled() {	
		if(this.isStatisticheGenerazioneBaseSettimanaleEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheGenerazioneBaseSettimanaleEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheGenerazioneBaseSettimanaleEnabled = true;
			}    
		}

		return this.isStatisticheGenerazioneBaseSettimanaleEnabled;
	}
	
	private Boolean isStatisticheGenerazioneBaseMensileEnabled = null;
	public boolean isStatisticheGenerazioneBaseMensileEnabled() {	
		if(this.isStatisticheGenerazioneBaseMensileEnabled==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseMensile.enabled");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseMensile.enabled' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheGenerazioneBaseMensileEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseMensile.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheGenerazioneBaseMensileEnabled = true;
			}    
		}

		return this.isStatisticheGenerazioneBaseMensileEnabled;
	}
	
	
	private Boolean isStatisticheGenerazioneBaseOrariaEnabledUltimaOra = null;
	public boolean isStatisticheGenerazioneBaseOrariaEnabledUltimaOra() {	
		if(this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseOraria.gestioneUltimaOra");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseOraria.gestioneUltimaOra' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseOraria.gestioneUltimaOra', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra = true;
			}    
		}

		return this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra;
	}
	
	private Boolean isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno = null;
	public boolean isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno() {	
		if(this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.gestioneUltimoGiorno");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.gestioneUltimoGiorno' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.gestioneUltimoGiorno', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno = true;
			}    
		}

		return this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno;
	}
	
	private Boolean isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana = null;
	public boolean isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana() {	
		if(this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.gestioneUltimaSettimana");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.gestioneUltimaSettimana' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.gestioneUltimaSettimana', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana = true;
			}    
		}

		return this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana;
	}
	
	private Boolean isStatisticheGenerazioneBaseMensileEnabledUltimoMese = null;
	public boolean isStatisticheGenerazioneBaseMensileEnabledUltimoMese() {	
		if(this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese==null){
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseMensile.gestioneUltimoMese");
				if(name==null){
					this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseMensile.gestioneUltimoMese' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseMensile.gestioneUltimoMese', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese = true;
			}    
		}

		return this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese;
	}
	
	private Boolean isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie = null;
	public boolean isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie() {	
		if(this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie==null){
			String pName = "org.openspcoop2.pdd.statistiche.generazione.attendiCompletamentoTransazioniInFasiIntermedie";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=true");
					name="true";
				}
				name = name.trim();
				this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie = true;
			}    
		}

		return this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie;
	}
	
	private Long getStatisticheGenerazioneTradeOffMs = null;
	public long getStatisticheGenerazioneTradeOffMs() {	
		if(this.getStatisticheGenerazioneTradeOffMs==null){
			String pName = "org.openspcoop2.pdd.statistiche.generazione.tradeOffSeconds";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata");
					name="-1";
				}
				name = name.trim();
				this.getStatisticheGenerazioneTradeOffMs = Long.parseLong(name);
				if(this.getStatisticheGenerazioneTradeOffMs>0) {
					this.getStatisticheGenerazioneTradeOffMs = this.getStatisticheGenerazioneTradeOffMs * 1000l; // traduco in ms
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=300 : "+e.getMessage(),e);
				this.getStatisticheGenerazioneTradeOffMs = 300l * 1000l;  // traduco in ms
			}    
		}

		return this.getStatisticheGenerazioneTradeOffMs;
	}

	// NOTA: DEVE ESSERE RILETTO TUTTE LE VOLTE CHE VIENE CHIAMATO!!!!!!!
	public StatisticsForceIndexConfig getStatisticheGenerazioneExternalForceIndexRepository() throws CoreException {	
		try{ 
			String name = null;
			name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.forceIndex.repository");
			if(name!=null){
				name = name.trim();
				return readStatisticsForceIndexConfig(name);
			}
			
			return null;
			
		} catch(java.lang.Exception e) {
			this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.forceIndex.repository': "+e.getMessage(),e);
			throw new CoreException(e.getMessage(),e);
		}    
		
	}
	private StatisticsForceIndexConfig readStatisticsForceIndexConfig(String name) throws CoreException, IOException {
		File f = new File(name);
		if(f.exists()) {
			if(f.isDirectory()) {
				throw newCoreExceptionNotFile(f,false);
			}
			if(!f.canRead()) {
				throw newCoreExceptionCannotRead(f, false);
			}
		}
		else {
			// provo a cercarlo nel classpath
		}
		try (InputStream is = f.exists() ? new FileInputStream(f) : OpenSPCoop2Properties.class.getResourceAsStream(name);){
			if(is!=null) {
				Properties p = new Properties();
				p.load(is);
				return new StatisticsForceIndexConfig(p);
			}
		}
		return null;
	}
	
	
	
	
	
	
	/* ------------- Gestore Chiavi PDND ---------------------*/
	
	private Boolean isGestoreChiaviPDNDEnabled = null;
	public boolean isGestoreChiaviPDNDEnabled() {	
		if(this.isGestoreChiaviPDNDEnabled==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
					name="false";
				}
				name = name.trim();
				this.isGestoreChiaviPDNDEnabled = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
				this.isGestoreChiaviPDNDEnabled = false;
			}    
		}

		return this.isGestoreChiaviPDNDEnabled;
	}
	
	private Boolean isGestoreChiaviPDNDDebug = null;
	public boolean isGestoreChiaviPDNDDebug() {	
		if(this.isGestoreChiaviPDNDDebug==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.debug";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isGestoreChiaviPDNDDebug = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isGestoreChiaviPDNDDebug = true;
			}    
		}

		return this.isGestoreChiaviPDNDDebug;
	}
	
	private Boolean isGestoreChiaviPDNDEventiAdd = null;
	public boolean isGestoreChiaviPDNDEventiAdd() {	
		if(this.isGestoreChiaviPDNDEventiAdd==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.eventi.add";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isGestoreChiaviPDNDEventiAdd = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isGestoreChiaviPDNDEventiAdd = true;
			}    
		}

		return this.isGestoreChiaviPDNDEventiAdd;
	}
	
	private Boolean isGestoreChiaviPDNDEventiUpdate = null;
	public boolean isGestoreChiaviPDNDEventiUpdate() {	
		if(this.isGestoreChiaviPDNDEventiUpdate==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.eventi.update";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isGestoreChiaviPDNDEventiUpdate = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isGestoreChiaviPDNDEventiUpdate = true;
			}    
		}

		return this.isGestoreChiaviPDNDEventiUpdate;
	}
	
	private Boolean isGestoreChiaviPDNDEventiDelete = null;
	public boolean isGestoreChiaviPDNDEventiDelete() {	
		if(this.isGestoreChiaviPDNDEventiDelete==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.eventi.delete";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
					name="true";
				}
				name = name.trim();
				this.isGestoreChiaviPDNDEventiDelete = Boolean.parseBoolean(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
				this.isGestoreChiaviPDNDEventiDelete = true;
			}    
		}

		return this.isGestoreChiaviPDNDEventiDelete;
	}
	
	private String getGestoreChiaviPDNDRemoteStoreName = null;
	public String getGestoreChiaviPDNDRemoteStoreName() throws CoreException {	
		if(this.getGestoreChiaviPDNDRemoteStoreName==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.remoteStore.name";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getGestoreChiaviPDNDRemoteStoreName = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getGestoreChiaviPDNDRemoteStoreName;
	}
	
	private Integer getGestoreChiaviPDNDkeysMaxLifeMinutes = null;
	public int getGestoreChiaviPDNDkeysMaxLifeMinutes() {	
		if(this.getGestoreChiaviPDNDkeysMaxLifeMinutes==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.keys.maxLifeMinutes";
			int defaultValue = 43200;
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
					name=defaultValue+"";
				}
				name = name.trim();
				this.getGestoreChiaviPDNDkeysMaxLifeMinutes = Integer.valueOf(name);
				/**if(this.getGestoreChiaviPDNDkeysMaxLifeMinutes<=0) {
					throw new CoreException("Atteso un limite maggiore di zero");
				}*/ // Se la proprietà viene valorizzata con un valore <=0 le informazioni hanno vita infinita
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
				this.getGestoreChiaviPDNDkeysMaxLifeMinutes = defaultValue;
			}    
		}

		return this.getGestoreChiaviPDNDkeysMaxLifeMinutes;
	}
		
	private String getGestoreChiaviPDNDkeysPath = null;
	public String getGestoreChiaviPDNDkeysPath() throws CoreException {	
		if(this.getGestoreChiaviPDNDkeysPath==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.keys.path";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getGestoreChiaviPDNDkeysPath = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getGestoreChiaviPDNDkeysPath;
	}
	
	private String getGestoreChiaviPDNDeventsKeysPath = null;
	public String getGestoreChiaviPDNDeventsKeysPath() throws CoreException {	
		if(this.getGestoreChiaviPDNDeventsKeysPath==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.path";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getGestoreChiaviPDNDeventsKeysPath = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getGestoreChiaviPDNDeventsKeysPath;
	}
	
	private String getGestoreChiaviPDNDeventsKeysParameterLastEventId = null;
	public String getGestoreChiaviPDNDeventsKeysParameterLastEventId() throws CoreException {	
		if(this.getGestoreChiaviPDNDeventsKeysParameterLastEventId==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.parameter.lastEventId";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getGestoreChiaviPDNDeventsKeysParameterLastEventId = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getGestoreChiaviPDNDeventsKeysParameterLastEventId;
	}
	
	private String getGestoreChiaviPDNDeventsKeysParameterLimit = null;
	public String getGestoreChiaviPDNDeventsKeysParameterLimit() throws CoreException {	
		if(this.getGestoreChiaviPDNDeventsKeysParameterLimit==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.parameter.limit";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getGestoreChiaviPDNDeventsKeysParameterLimit = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getGestoreChiaviPDNDeventsKeysParameterLimit;
	}

	private Integer getGestoreChiaviPDNDeventsKeysLimit = null;
	public int getGestoreChiaviPDNDeventsKeysLimit() {	
		if(this.getGestoreChiaviPDNDeventsKeysLimit==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.limit";
			int defaultValue = 100;
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
					name=defaultValue+"";
				}
				name = name.trim();
				this.getGestoreChiaviPDNDeventsKeysLimit = Integer.valueOf(name);
				if(this.getGestoreChiaviPDNDeventsKeysLimit<=0) {
					throw new CoreException("Atteso un limite maggiore di zero");
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
				this.getGestoreChiaviPDNDeventsKeysLimit = defaultValue;
			}    
		}

		return this.getGestoreChiaviPDNDeventsKeysLimit;
	}

	private Long getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi = null;
	public long getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi() {	
		if(this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.intervalloSecondi";
			long defaultValue = 3600;
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
					name=defaultValue+"";
				}
				name = name.trim();
				this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi = Long.valueOf(name);
				if(this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi<=0) {
					throw new CoreException("Atteso un intervallo maggiore di zero");
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
				this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi = defaultValue;
			}    
		}

		return this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi;
	}
	
	private Long getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi = null;
	public long getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi() {	
		if(this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.cache.keys.timer.intervalloSecondi";
			long defaultValue = 300;
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
					name=defaultValue+"";
				}
				name = name.trim();
				this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi = Long.valueOf(name);
				if(this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi<=0) {
					throw new CoreException("Atteso un intervallo maggiore di zero");
				}
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
				this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi = defaultValue;
			}    
		}

		return this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi;
	}
	
	private Integer getGestoreChiaviPDNDTimerLockMaxLife = null;
	public int getGestoreChiaviPDNDTimerLockMaxLife() {	
		if(this.getGestoreChiaviPDNDTimerLockMaxLife==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.lock.maxLife";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					this.getGestoreChiaviPDNDTimerLockMaxLife = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.TIMER_LOCK_MAX_LIFE));
					this.getGestoreChiaviPDNDTimerLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.TIMER_LOCK_MAX_LIFE),e);
				this.getGestoreChiaviPDNDTimerLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
			}
			if(this.getGestoreChiaviPDNDTimerLockMaxLife!=null && this.getGestoreChiaviPDNDTimerLockMaxLife>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getGestoreChiaviPDNDTimerLockMaxLife = this.getGestoreChiaviPDNDTimerLockMaxLife *1000;
			}
		}

		return this.getGestoreChiaviPDNDTimerLockMaxLife;
	}
	
	private Integer getGestoreChiaviPDNDTimerLockIdleTime = null;
	public int getGestoreChiaviPDNDTimerLockIdleTime() {	
		if(this.getGestoreChiaviPDNDTimerLockIdleTime==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.lock.idleTime";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					this.getGestoreChiaviPDNDTimerLockIdleTime = java.lang.Integer.parseInt(name);
				}else{
					this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.TIMER_LOCK_IDLE_TIME));
					this.getGestoreChiaviPDNDTimerLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
				}
			}catch(java.lang.Exception e) {
				this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.TIMER_LOCK_IDLE_TIME),e);
				this.getGestoreChiaviPDNDTimerLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
			}
			if(this.getGestoreChiaviPDNDTimerLockIdleTime!=null && this.getGestoreChiaviPDNDTimerLockIdleTime>0) {
				// trasformo in millisecondi l'informazione fornita in secondi
				this.getGestoreChiaviPDNDTimerLockIdleTime = this.getGestoreChiaviPDNDTimerLockIdleTime *1000;
			}
		}

		return this.getGestoreChiaviPDNDTimerLockIdleTime;
	}
	
	private Long getGestoreChiaviPDNDTimerLockAttesaAttiva = null;
	public long getGestoreChiaviPDNDTimerLockAttesaAttiva() {	
		if(this.getGestoreChiaviPDNDTimerLockAttesaAttiva==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.lock.attesaAttiva";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					long time = java.lang.Long.parseLong(name);
					this.getGestoreChiaviPDNDTimerLockAttesaAttiva = time*1000;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
					this.getGestoreChiaviPDNDTimerLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
				}

			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA+", errore:"+e.getMessage(),e);
				this.getGestoreChiaviPDNDTimerLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
			}    
		}

		return this.getGestoreChiaviPDNDTimerLockAttesaAttiva;
	}

	private Integer getGestoreChiaviPDNDTimerLockCheckInterval = null;
	public int getGestoreChiaviPDNDTimerLockCheckInterval() {	
		if(this.getGestoreChiaviPDNDTimerLockCheckInterval==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.lock.check";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);

				if(name!=null){
					name = name.trim();
					int time = java.lang.Integer.parseInt(name);
					this.getGestoreChiaviPDNDTimerLockCheckInterval = time;
				}else{
					this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
					this.getGestoreChiaviPDNDTimerLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
				}
			}catch(java.lang.Exception e) {
				this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
				this.getGestoreChiaviPDNDTimerLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
			}  
		}

		return this.getGestoreChiaviPDNDTimerLockCheckInterval;
	}
	
	private String getGestoreChiaviPDNDclientsPath = null;
	public String getGestoreChiaviPDNDclientsPath() throws CoreException {	
		if(this.getGestoreChiaviPDNDclientsPath==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.clients.path";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getGestoreChiaviPDNDclientsPath = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getGestoreChiaviPDNDclientsPath;
	}
		
	private String getGestoreChiaviPDNDclientsOrganizationJsonPath = null;
	public String getGestoreChiaviPDNDclientsOrganizationJsonPath() throws CoreException {	
		if(this.getGestoreChiaviPDNDclientsOrganizationJsonPath==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.clients.organizationJsonPath";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getGestoreChiaviPDNDclientsOrganizationJsonPath = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getGestoreChiaviPDNDclientsOrganizationJsonPath;
	}
	
	private String getGestoreChiaviPDNDorganizationsPath = null;
	public String getGestoreChiaviPDNDorganizationsPath() throws CoreException {	
		if(this.getGestoreChiaviPDNDorganizationsPath==null){
			String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.organizations.path";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.getGestoreChiaviPDNDorganizationsPath = name;
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.getGestoreChiaviPDNDorganizationsPath;
	}
	
	
	
	private Boolean isGestoreChiaviPDNDclientInfoEnabled = null;
	public boolean isGestoreChiaviPDNDclientInfoEnabled() throws CoreException {	
		if(this.isGestoreChiaviPDNDclientInfoEnabled==null){
			String pName = "org.openspcoop2.pdd.gestorePDND.clientInfo.enabled";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.isGestoreChiaviPDNDclientInfoEnabled = Boolean.valueOf(name);
				
				if(this.isGestoreChiaviPDNDclientInfoEnabled.booleanValue() && !this.isGestoreChiaviPDNDEnabled()) {
					throw new CoreException("per abilitare la proprietà è richiesto che sia abilitata la gestione delle chiavi PDND");
				}
				
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.isGestoreChiaviPDNDclientInfoEnabled;
	}
	
	private Integer getGestoreChiaviPDNDclientInfoMaxLifeMinutes = null;
	public int getGestoreChiaviPDNDclientInfoMaxLifeMinutes() {	
		if(this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes==null){
			String pName = "org.openspcoop2.pdd.gestorePDND.clientInfo.maxLifeMinutes";
			int defaultValue = 43200;
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
					name=defaultValue+"";
				}
				name = name.trim();
				this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes = Integer.valueOf(name);
				/**if(this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes<=0) {
					throw new CoreException("Atteso un limite maggiore di zero");
				}*/ // Se la proprietà viene valorizzata con un valore <=0 le informazioni hanno vita infinita
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
				this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes = defaultValue;
			}    
		}

		return this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes;
	}
		
	private Boolean isGestoreChiaviPDNDclientsErrorAbortTransaction = null;
	public boolean isGestoreChiaviPDNDclientsErrorAbortTransaction() throws CoreException {	
		if(this.isGestoreChiaviPDNDclientsErrorAbortTransaction==null){
			String pName = "org.openspcoop2.pdd.gestorePDND.clients.error.abortTransaction";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.isGestoreChiaviPDNDclientsErrorAbortTransaction = Boolean.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.isGestoreChiaviPDNDclientsErrorAbortTransaction;
	}
	
	private Boolean isGestoreChiaviPDNDorganizationsErrorAbortTransaction = null;
	public boolean isGestoreChiaviPDNDorganizationsErrorAbortTransaction() throws CoreException {	
		if(this.isGestoreChiaviPDNDorganizationsErrorAbortTransaction==null){
			String pName = "org.openspcoop2.pdd.gestorePDND.organizations.error.abortTransaction";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.isGestoreChiaviPDNDorganizationsErrorAbortTransaction = Boolean.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.isGestoreChiaviPDNDorganizationsErrorAbortTransaction;
	}
	
	private Boolean isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation = null;
	public boolean isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation() throws CoreException {	
		if(this.isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation==null){
			String pName = "org.openspcoop2.pdd.gestorePDND.clientInfo.retrieveAfterVoucherPDNDValidation";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation = Boolean.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation;
	}
	
	private Boolean isGestoreChiaviPDNDclientsTraceJsonResponse = null;
	public boolean isGestoreChiaviPDNDclientsTraceJsonResponse() throws CoreException {	
		if(this.isGestoreChiaviPDNDclientsTraceJsonResponse==null){
			String pName = "org.openspcoop2.pdd.gestorePDND.clients.traceJsonResponse";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.isGestoreChiaviPDNDclientsTraceJsonResponse = Boolean.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.isGestoreChiaviPDNDclientsTraceJsonResponse;
	}
	
	private Boolean isGestoreChiaviPDNDorganizationsTraceJsonResponse = null;
	public boolean isGestoreChiaviPDNDorganizationsTraceJsonResponse() throws CoreException {	
		if(this.isGestoreChiaviPDNDorganizationsTraceJsonResponse==null){
			String pName = "org.openspcoop2.pdd.gestorePDND.organizations.traceJsonResponse";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.isGestoreChiaviPDNDorganizationsTraceJsonResponse = Boolean.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.isGestoreChiaviPDNDorganizationsTraceJsonResponse;
	}
	
	private Boolean isGestoreChiaviPDNDorganizationsTraceName = null;
	public boolean isGestoreChiaviPDNDorganizationsTraceName() throws CoreException {	
		if(this.isGestoreChiaviPDNDorganizationsTraceName==null){
			String pName = "org.openspcoop2.pdd.gestorePDND.organizations.traceName";
			try{ 
				String name = null;
				name = this.reader.getValueConvertEnvProperties(pName);
				if(name==null){
					throw new CoreException("Proprieta' non impostata");
				}
				name = name.trim();
				this.isGestoreChiaviPDNDorganizationsTraceName = Boolean.valueOf(name);
			} catch(java.lang.Exception e) {
				this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
				throw new CoreException(e.getMessage(),e);
			}    
		}

		return this.isGestoreChiaviPDNDorganizationsTraceName;
	}
	
}