OpenSPCoop2Properties.java

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



  23. package org.openspcoop2.pdd.config;


  26. import java.io.File;
  27. import java.io.FileInputStream;
  28. import java.io.IOException;
  29. import java.io.InputStream;
  30. import java.lang.reflect.Constructor;
  31. import java.net.URL;
  32. import java.security.MessageDigest;
  33. import java.sql.Connection;
  34. import java.text.ParseException;
  35. import java.text.SimpleDateFormat;
  36. import java.util.ArrayList;
  37. import java.util.Collections;
  38. import java.util.Date;
  39. import java.util.Enumeration;
  40. import java.util.HashMap;
  41. import java.util.Iterator;
  42. import java.util.List;
  43. import java.util.Locale;
  44. import java.util.Map;
  45. import java.util.Properties;

  47. import org.apache.commons.lang.StringUtils;
  48. import org.openspcoop2.core.commons.CoreException;
  49. import org.openspcoop2.core.commons.DBUtils;
  50. import org.openspcoop2.core.commons.IExtendedInfo;
  51. import org.openspcoop2.core.config.AccessoConfigurazionePdD;
  52. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  53. import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
  54. import org.openspcoop2.core.config.constants.TipoAutenticazionePrincipal;
  55. import org.openspcoop2.core.constants.TransferLengthModes;
  56. import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
  57. import org.openspcoop2.core.id.IDSoggetto;
  58. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  59. import org.openspcoop2.message.AttachmentsProcessingMode;
  60. import org.openspcoop2.message.ForwardConfig;
  61. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  62. import org.openspcoop2.message.utils.WWWAuthenticateErrorCode;
  63. import org.openspcoop2.monitor.engine.statistic.StatisticsForceIndexConfig;
  64. import org.openspcoop2.pdd.core.CostantiPdD;
  65. import org.openspcoop2.pdd.core.autenticazione.WWWAuthenticateConfig;
  66. import org.openspcoop2.pdd.core.autorizzazione.container.IAutorizzazioneSecurityContainer;
  67. import org.openspcoop2.pdd.core.autorizzazione.pa.IAutorizzazionePortaApplicativa;
  68. import org.openspcoop2.pdd.core.controllo_traffico.ConfigurazioneGatewayControlloTraffico;
  69. import org.openspcoop2.pdd.core.controllo_traffico.INotify;
  70. import org.openspcoop2.pdd.core.controllo_traffico.policy.driver.TipoGestorePolicy;
  71. import org.openspcoop2.pdd.core.credenziali.IGestoreCredenziali;
  72. import org.openspcoop2.pdd.core.credenziali.IGestoreCredenzialiIM;
  73. import org.openspcoop2.pdd.core.dynamic.InformazioniIntegrazioneCodifica;
  74. import org.openspcoop2.pdd.core.dynamic.InformazioniIntegrazioneSorgente;
  75. import org.openspcoop2.pdd.core.handlers.ExitHandler;
  76. import org.openspcoop2.pdd.core.handlers.InRequestHandler;
  77. import org.openspcoop2.pdd.core.handlers.InRequestProtocolHandler;
  78. import org.openspcoop2.pdd.core.handlers.InResponseHandler;
  79. import org.openspcoop2.pdd.core.handlers.InitHandler;
  80. import org.openspcoop2.pdd.core.handlers.IntegrationManagerRequestHandler;
  81. import org.openspcoop2.pdd.core.handlers.IntegrationManagerResponseHandler;
  82. import org.openspcoop2.pdd.core.handlers.OutRequestHandler;
  83. import org.openspcoop2.pdd.core.handlers.OutResponseHandler;
  84. import org.openspcoop2.pdd.core.handlers.PostOutRequestHandler;
  85. import org.openspcoop2.pdd.core.handlers.PostOutResponseHandler;
  86. import org.openspcoop2.pdd.core.handlers.PreInRequestHandler;
  87. import org.openspcoop2.pdd.core.handlers.PreInResponseHandler;
  88. import org.openspcoop2.pdd.core.handlers.notifier.INotifierCallback;
  89. import org.openspcoop2.pdd.core.handlers.transazioni.ISalvataggioDiagnosticiManager;
  90. import org.openspcoop2.pdd.core.handlers.transazioni.ISalvataggioTracceManager;
  91. import org.openspcoop2.pdd.core.integrazione.IGestoreIntegrazionePA;
  92. import org.openspcoop2.pdd.core.integrazione.IGestoreIntegrazionePD;
  93. import org.openspcoop2.pdd.core.integrazione.UtilitiesTemplate;
  94. import org.openspcoop2.pdd.core.integrazione.peer.PeerHeaderDescriptor;
  95. import org.openspcoop2.pdd.core.integrazione.peer.RegexpPeerHeaderDescriptor;
  96. import org.openspcoop2.pdd.core.integrazione.peer.StringPeerHeaderDescriptor;
  97. import org.openspcoop2.pdd.core.node.INodeReceiver;
  98. import org.openspcoop2.pdd.core.node.INodeSender;
  99. import org.openspcoop2.pdd.core.threshold.IThreshold;
  100. import org.openspcoop2.pdd.core.trasformazioni.TipoTrasformazione;
  101. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  102. import org.openspcoop2.pdd.logger.filetrace.FileTraceGovWayState;
  103. import org.openspcoop2.pdd.logger.transazioni.ConfigurazioneTracciamento;
  104. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  105. import org.openspcoop2.pdd.mdb.Imbustamento;
  106. import org.openspcoop2.pdd.mdb.ImbustamentoRisposte;
  107. import org.openspcoop2.pdd.mdb.InoltroBuste;
  108. import org.openspcoop2.pdd.mdb.InoltroRisposte;
  109. import org.openspcoop2.pdd.mdb.Sbustamento;
  110. import org.openspcoop2.pdd.mdb.SbustamentoRisposte;
  111. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  112. import org.openspcoop2.pdd.services.core.RicezioneBuste;
  113. import org.openspcoop2.pdd.services.core.RicezioneContenutiApplicativi;
  114. import org.openspcoop2.pdd.timers.TimerGestoreBusteNonRiscontrate;
  115. import org.openspcoop2.pdd.timers.TimerGestoreMessaggi;
  116. import org.openspcoop2.pdd.timers.TimerGestorePuliziaMessaggiAnomali;
  117. import org.openspcoop2.pdd.timers.TimerGestoreRepositoryBuste;
  118. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  119. import org.openspcoop2.protocol.engine.constants.Costanti;
  120. import org.openspcoop2.protocol.engine.driver.IFiltroDuplicati;
  121. import org.openspcoop2.protocol.engine.driver.repository.GestoreRepositoryFactory;
  122. import org.openspcoop2.protocol.engine.driver.repository.IGestoreRepository;
  123. import org.openspcoop2.protocol.sdk.BypassMustUnderstandCheck;
  124. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  125. import org.openspcoop2.protocol.sdk.ProtocolException;
  126. import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
  127. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  128. import org.openspcoop2.protocol.sdk.config.IProtocolConfiguration;
  129. import org.openspcoop2.protocol.sdk.config.IProtocolManager;
  130. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  131. import org.openspcoop2.protocol.sdk.constants.FaultIntegrationGenericInfoMode;
  132. import org.openspcoop2.protocol.sdk.constants.IDService;
  133. import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
  134. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  135. import org.openspcoop2.protocol.sdk.state.FunctionContextCustom;
  136. import org.openspcoop2.protocol.sdk.state.FunctionContextsCustom;
  137. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  138. import org.openspcoop2.protocol.utils.EsitiProperties;
  139. import org.openspcoop2.security.message.MessageSecurityContext;
  140. import org.openspcoop2.security.message.engine.MessageSecurityFactory;
  141. import org.openspcoop2.utils.BooleanNullable;
  142. import org.openspcoop2.utils.LoggerWrapperFactory;
  143. import org.openspcoop2.utils.MapKey;
  144. import org.openspcoop2.utils.NameValue;
  145. import org.openspcoop2.utils.Semaphore;
  146. import org.openspcoop2.utils.SemaphoreType;
  147. import org.openspcoop2.utils.TipiDatabase;
  148. import org.openspcoop2.utils.Utilities;
  149. import org.openspcoop2.utils.UtilsException;
  150. import org.openspcoop2.utils.VersionUtilities;
  151. import org.openspcoop2.utils.cache.CacheType;
  152. import org.openspcoop2.utils.certificate.KeystoreType;
  153. import org.openspcoop2.utils.crypt.CryptConfig;
  154. import org.openspcoop2.utils.date.DateEngineType;
  155. import org.openspcoop2.utils.date.DateUtils;
  156. import org.openspcoop2.utils.date.IDate;
  157. import org.openspcoop2.utils.digest.IDigestReader;
  158. import org.openspcoop2.utils.id.IUniqueIdentifierGenerator;
  159. import org.openspcoop2.utils.io.ArchiveType;
  160. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  161. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  162. import org.openspcoop2.utils.json.JsonSchemaValidatorConfig.ADDITIONAL;
  163. import org.openspcoop2.utils.json.JsonValidatorAPI.ApiName;
  164. import org.openspcoop2.utils.openapi.validator.OpenAPILibrary;
  165. import org.openspcoop2.utils.resources.Charset;
  166. import org.openspcoop2.utils.resources.FileSystemMkdirConfig;
  167. import org.openspcoop2.utils.resources.FileSystemUtilities;
  168. import org.openspcoop2.utils.resources.Loader;
  169. import org.openspcoop2.utils.security.CertificateValidityCheck;
  170. import org.openspcoop2.utils.sql.ISQLQueryObject;
  171. import org.openspcoop2.utils.transport.http.HttpConstants;
  172. import org.openspcoop2.utils.transport.http.RFC2047Encoding;
  173. import org.slf4j.Logger;

  175. /**
  176.  * Contiene un lettore del file di proprieta' di OpenSPCoop.
  177.  *
  178.  * @author Poli Andrea (apoli@link.it)
  179.  * @author Tommaso Burlon (tommaso.burlon@link.it)
  180.  * @author $Author$
  181.  * @version $Rev$, $Date$
  182.  */


  185. public class OpenSPCoop2Properties {    

  187.     /** Logger utilizzato per errori eventuali. */
  188.     private Logger log = null;
  189.     private void logError(String msg) {
  190.         if(this.log!=null) {
  191.             this.log.error(msg);
  192.         }
  193.     }
  194.     private void logError(String msg, Exception e) {
  195.         if(this.log!=null) {
  196.             this.log.error(msg,e);
  197.         }
  198.     }
  199.     private void logWarn(String msg) {
  200.         if(this.log!=null) {
  201.             this.log.warn(msg);
  202.         }
  203.     }
  204.     private void logWarn(String msg, Exception e) {
  205.         if(this.log!=null) {
  206.             this.log.warn(msg,e);
  207.         }
  208.     }
  209.     private void logInfo(String msg) {
  210.         if(this.log!=null) {
  211.             this.log.info(msg);
  212.         }
  213.     }
  214.     private void logDebug(String msg) {
  215.         if(this.log!=null) {
  216.             this.log.debug(msg);
  217.         }
  218.     }
  219.     
  220.     private String getMessaggioProprietaNonImpostata(String pName, int defaultValue){
  221.         return getMessaggioProprietaNonImpostata(pName, defaultValue+"");
  222.     }
  223.     private String getMessaggioProprietaNonImpostata(String pName, long defaultValue){
  224.         return getMessaggioProprietaNonImpostata(pName, defaultValue+"");
  225.     }
  226.     private String getMessaggioProprietaNonImpostata(String pName, boolean defaultValue){
  227.         return getMessaggioProprietaNonImpostata(pName, defaultValue+"");
  228.     }
  229.     private String getMessaggioProprietaNonImpostata(String pName, String defaultValue){
  230.         return "Proprietà di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+defaultValue;
  231.     }
  232.     
  233.     private String getMessaggioProprietaNonImpostata(String pName, Exception e, int defaultValue){
  234.         return getMessaggioProprietaNonImpostata(pName, e, defaultValue+"");
  235.     }
  236.     private String getMessaggioProprietaNonImpostata(String pName, Exception e, long defaultValue){
  237.         return getMessaggioProprietaNonImpostata(pName, e, defaultValue+"");
  238.     }
  239.     private String getMessaggioProprietaNonImpostata(String pName, Exception e, boolean defaultValue){
  240.         return getMessaggioProprietaNonImpostata(pName, e, defaultValue+"");
  241.     }
  242.     private String getMessaggioProprietaNonImpostata(String pName, Exception e, String defaultValue){
  243.         return "Proprietà di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+defaultValue+"; errore:"+e.getMessage();
  244.     }
  245.     
  246.     private static final String HEADER_INTEGRAZIONE_SCONOSCIUTO = "L'header di integrazione indicato non esiste nelle classi registrate in GovWay";
  247.     private static final String TIPO_SCONOSCIUTO = "Il tipo non esiste nelle classi registrate in GovWay";
  248.     private String getMessaggioClasseSconosciuta(Exception e) {
  249.         return "La classe non esiste: "+e.getMessage();
  250.     }
  251.     private static final String OGGETTO_NEW_INSTANCE_NON_CREATO = "Oggetto non creato dopo aver chiamato la newInstance";
  252.     
  253.     private static final String NON_DEFINITA = "non definita";
  254.     
  255.     private static final String VALORE_NON_CORRETTO_ABILITATO_DISABILITATO = "Valore non corretto (abilitato/disabilitato): ";
  256.     
  257.     private static final String PROPERTY_START_SUFFIX_ERRORE = ".*': ";

  259.     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 [";
  260.     
  261.     private static final String PROPRIETA_NON_DEFINITA = "Proprietà non definita";
  262.     
  263.     private static final String ATTESO_UN_CARATTERE_TROVATI = "Atteso un carattere, trovati ";
  264.     
  265.     private static final String VALORE_NON_VALIDO = "Valore fornito non valido: ";
  266.     
  267.     private String getPrefixFile(File f, boolean expectedDir) {
  268.         return (expectedDir ? "Dir ":"")+"["+f.getAbsolutePath()+"] ";
  269.     }
  270.     private CoreException newCoreExceptionNotDir(File f, boolean expectedDir){
  271.         return new CoreException(getPrefixFile(f, expectedDir)+"isn't dir");
  272.     }
  273.     private CoreException newCoreExceptionNotFile(File f, boolean expectedDir){
  274.         return new CoreException(getPrefixFile(f, expectedDir)+"isn't file");
  275.     }
  276.     private CoreException newCoreExceptionCannotRead(File f, boolean expectedDir){
  277.         return new CoreException(getPrefixFile(f, expectedDir)+"cannot read");
  278.     }
  279.     private CoreException newCoreExceptionCannotWrite(File f, boolean expectedDir){
  280.         return new CoreException(getPrefixFile(f, expectedDir)+"cannot write");
  281.     }
  282.     /**private CoreException newCoreExceptionNotExists(File f, boolean expectedDir){
  283.         return new CoreException(getPrefixFile(f, expectedDir)+"not exists");
  284.     }*/
  285.     

  287.     private static void initSplitValues(List<String> l, String value, boolean addEmpty) {
  288.         if(value.contains(",")) {
  289.             String [] tmp = value.split(",");
  290.             if(tmp!=null && tmp.length>0) {
  291.                 for (String s : tmp) {
  292.                     if(s!=null && (!"".equals(s.trim()) || addEmpty) ) {
  293.                         l.add(s.trim());
  294.                     }
  295.                 }
  296.             }
  297.         }
  298.         else {
  299.             l.add(value);
  300.         }
  301.     }
  302.     
  303.     /** Copia Statica */
  304.     private static OpenSPCoop2Properties openspcoopProperties = null;




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

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





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

  321.     /**
  322.      * Viene chiamato in causa per istanziare il properties reader
  323.      *
  324.      * 
  325.      */
  326.     public OpenSPCoop2Properties(Properties localProperties) throws CoreException{
  327.         this(localProperties, "/govway.properties");
  328.     }
  329.     public OpenSPCoop2Properties(Properties localProperties, String path) throws CoreException{

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

  336.         /* ---- Lettura del cammino del file di configurazione ---- */
  337.         Properties propertiesReader = new Properties();
  338.         java.io.InputStream properties = null;
  339.         try{ 
  340.             properties = OpenSPCoop2Properties.class.getResourceAsStream(path);
  341.             if(properties==null){
  342.                 File f = new File(path);
  343.                 if(f.exists()) {
  344.                     properties = new FileInputStream(f);
  345.                 }
  346.                 else {
  347.                     throw new CoreException("File '"+path+"' not found");
  348.                 }
  349.             }
  350.             propertiesReader.load(properties);
  351.         }catch(Exception e) {
  352.             this.logError("Riscontrato errore durante la lettura del file '"+path+"': \n\n"+e.getMessage(),e);
  353.             throw new CoreException("OpenSPCoopProperties initialize error: "+e.getMessage(),e);
  354.         }finally{
  355.             try{
  356.                 if(properties!=null)
  357.                     properties.close();
  358.             }catch(Exception er){
  359.                 // close
  360.             }
  361.         }
  362.         try {
  363.             this.reader = new OpenSPCoop2InstanceProperties(propertiesReader, this.log, localProperties);
  364.         }catch(Exception e) {
  365.             throw new CoreException(e.getMessage(),e);
  366.         }

  368.     }

  370.     /**
  371.      * Il Metodo si occupa di inizializzare il propertiesReader 
  372.      *
  373.      * 
  374.      */
  375.     public static boolean initialize(Properties localProperties){
  376.         try {
  377.             OpenSPCoop2Properties.openspcoopProperties = new OpenSPCoop2Properties(localProperties);    
  378.             return true;
  379.         }
  380.         catch(Exception e) {
  381.             return false;
  382.         }
  383.     }
  384.     public static boolean initialize(Properties localProperties, String path){
  385.         try {
  386.             OpenSPCoop2Properties.openspcoopProperties = new OpenSPCoop2Properties(localProperties, path);  
  387.             return true;
  388.         }
  389.         catch(Exception e) {
  390.             return false;
  391.         }
  392.     }

  394.     /**
  395.      * Ritorna l'istanza di questa classe
  396.      *
  397.      * @return Istanza di OpenSPCoopProperties
  398.      * 
  399.      */
  400.     public static OpenSPCoop2Properties getInstance(){
  401.         return OpenSPCoop2Properties.openspcoopProperties;
  402.     }


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












  420.     /* ********  VALIDATORE FILE PROPERTY  ******** */

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

  432.             // root Directory
  433.             if (getRootDirectory() == null)     
  434.                 return false;
  435.             if( (new File(getRootDirectory())).exists() == false ){
  436.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.confDirectory'. \n La directory indicata non esiste ["+getRootDirectory()+"].");
  437.                 return false;
  438.             }
  439.             
  440.             // Tipo server
  441.             Boolean serverJ2EEtest = isServerJ2EE();
  442.             if(serverJ2EEtest==null){
  443.                 return false;
  444.             }
  445.             
  446.             // Attachment
  447.             getAttachmentsProcessingMode();
  448.             // warning, default false.
  449.             if(this.isFileCacheEnable()){
  450.                 // Se abilitato, deve essere specificato il repository
  451.                 this.getAttachmentRepoDir();
  452.             }
  453.             // warning, default 1024
  454.             this.getFileThreshold();        
  455.             
  456.             // Versione
  457.             this.getVersione();
  458.             this.getDetails();
  459.             // openspcoop home
  460.             this.getCheckOpenSPCoopHome();

  462.             // Loader
  463.             Loader loaderOpenSPCoop = null;
  464.             if(loader!=null){
  465.                 loaderOpenSPCoop = Loader.getInstance(); // gia inizializzato nello startup
  466.             }else{
  467.                 String loaderOP = this.getClassLoader();
  468.                 if(loaderOP!=null){
  469.                     try{
  470.                         Class<?> c = Class.forName(loaderOP);
  471.                         Constructor<?> constructor = c.getConstructor(java.lang.ClassLoader.class);
  472.                         java.lang.ClassLoader test = (java.lang.ClassLoader) constructor.newInstance(this.getClass().getClassLoader());
  473.                         test.toString();
  474.                         loaderOpenSPCoop = new Loader(loader);
  475.                     }catch(Exception e){
  476.                         this.logError("Riscontrato errore durante la lettura del class loader indicato nella proprieta' di openspcoop 'org.openspcoop2.pdd.classLoader': "+e.getMessage(),e);
  477.                         return false;
  478.                     }
  479.                 }else{
  480.                     loaderOpenSPCoop = Loader.getInstance();
  481.                 }
  482.             }
  483.             
  484.             // Non posso inizializzarli durante la validazione poich' il ProtocolFactoryManager non e' ancora stato inizializzato
  485. //          // EsitiProperties
  486. /**         EsitiProperties.initialize(getRootDirectory(), this.log, loaderOpenSPCoop); */
  487.             
  488.             // Repository
  489.             String tipoRepository = getRepositoryType();
  490.             if(CostantiConfigurazione.REPOSITORY_FILE_SYSTEM.equals(tipoRepository)){
  491.                 if (getRepositoryDirectory() == null)   {                       
  492.                     return false;
  493.                 }
  494.                 // Verra' creata se non esiste in openspcoop startup
  495. /**             if( (new File(getRepositoryDirectory())).exists() == false ){
  496. //                  this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.directory'. \n La directory indicata non esiste ["+getRepositoryDirectory()+"].");
  497. //                  return false;
  498. //              }*/
  499.             }else if(CostantiConfigurazione.REPOSITORY_DB.equals(tipoRepository)){
  500.                 if (getRepositoryJDBCAdapter() == null) {                       
  501.                     return false;
  502.                 }
  503.                 String jdbcAdapter = this.getRepositoryJDBCAdapter();
  504.                 if(this.getDatabaseType()!=null && TipiDatabase.DEFAULT.equals(jdbcAdapter)){
  505.                     try{
  506.                         IJDBCAdapter adapter = JDBCAdapterFactory.createJDBCAdapter(OpenSPCoop2Properties.openspcoopProperties.getDatabaseType());
  507.                         adapter.toString();                 
  508.                     }catch(Exception e){
  509.                         this.logError(PREFIX_JDBC_ADAPTER_NOT_EXISTS+getRepositoryJDBCAdapter()+"]: "+e.getMessage(),e);
  510.                         return false;
  511.                     }
  512.                 }
  513.                 else{
  514.                     //  Ricerco connettore
  515.                     String adapterClass = className.getJDBCAdapter(jdbcAdapter);
  516.                     if(adapterClass == null){
  517.                         this.logError(PREFIX_JDBC_ADAPTER_NOT_EXISTS+getRepositoryJDBCAdapter()+"] nelle classi registrate in OpenSPCoop");
  518.                         return false;
  519.                     }
  520.                     try{
  521.                         IJDBCAdapter adapter = (IJDBCAdapter) loaderOpenSPCoop.newInstance(adapterClass);
  522.                         adapter.toString();
  523.                     }catch(Exception e){
  524.                         this.logError(PREFIX_JDBC_ADAPTER_NOT_EXISTS+getRepositoryJDBCAdapter()+"]: "+e.getMessage(),e);
  525.                         return false;
  526.                     }
  527.                 }
  528.             }else{
  529.                 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()+"].");
  530.                 return false;
  531.             }
  532.             // warning
  533.             this.isRepositoryOnFS();
  534.             this.isCondivisioneConfigurazioneRegistroDB();

  536.             // SoapBuffer
  537.             if(this.useSoapMessageReader()) {
  538.                 this.getSoapMessageReaderBufferThresholdKb();
  539.                 this.useSoapMessageReaderHeaderOptimization();
  540.             }
  541.             
  542.             this.useSoapMessagePassthrough();
  543.             
  544.             this.getSoapMessageSaajSaxParserPoolSize();
  545.             // AlternativeContentTypeSoap12
  546.             this.getAlternativeContentTypeSoap12();
  547.             
  548.             // Multipart
  549.             this.useRestMultipartLazy();
  550.             
  551.             // EliminatoreMessaggi in Repository
  552.             long intervalloEliminazione = getRepositoryIntervalloEliminazioneMessaggi();
  553.             if(intervalloEliminazione<=0){
  554.                 if(intervalloEliminazione!=-1){
  555.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.timer'. \n Valore non valido ["+intervalloEliminazione+"].");          
  556.                 }
  557.                 return false;
  558.             }
  559.             long intervalloScadenza = getRepositoryIntervalloScadenzaMessaggi();
  560.             if(intervalloScadenza<=0){
  561.                 if(intervalloScadenza!=-1){
  562.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.scadenzaMessaggio'. \n Valore non valido ["+intervalloScadenza+"].");          
  563.                 }
  564.                 return false;
  565.             }
  566.             this.isRepositoryBusteFiltraBusteScaduteRispettoOraRegistrazione();

  568.             // EliminatoreCorrelazioniApplicative in Repository
  569.             long intervalloScadenzaCorrelazioneApplicativa = getRepositoryIntervalloScadenzaCorrelazioneApplicativa();
  570.             if(intervalloScadenzaCorrelazioneApplicativa<=0){
  571.                 if(intervalloScadenzaCorrelazioneApplicativa!=-1){
  572.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa'. \n Valore non valido ["+intervalloScadenzaCorrelazioneApplicativa+"].");         
  573.                 }
  574.                 return false;
  575.             }
  576.             this.getMaxLengthCorrelazioneApplicativa();
  577.             this.isMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate();
  578.             this.getMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate();
  579.             this.isMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate();
  580.             this.getMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate();
  581.             this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione();
  582.             this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata();
  583.             this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore();
  584.             this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore();
  585.             this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore();
  586.             this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore();
  587.             this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca();
  588.             this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca();
  589.             
  590.             // Msg gia Processati (Warning)
  591.             this.getMsgGiaInProcessamentoAttesaAttiva();
  592.             this.getMsgGiaInProcessamentoCheckInterval();
  593.             this.isMsgGiaInProcessamentoUseLock();

  595.             // Threshold per il Repository
  596.             List<String> tipiThreshold = this.getRepositoryThresholdTypes();
  597.             if(tipiThreshold!=null){
  598.                 // CheckInterval in Repository
  599.                 long intervalloCheck = this.getRepositoryThresholdCheckInterval();
  600.                 if(intervalloCheck<=0){
  601.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.threshold.checkInterval', valore non impostato/valido.");          
  602.                     return false;
  603.                 }
  604.                 for(int i=0; i<tipiThreshold.size();i++){
  605.                     if(this.getRepositoryThresholdParameters(tipiThreshold.get(i))==null)
  606.                         return false;
  607.                     //  Ricerco connettore
  608.                     String tipoClass = className.getThreshold(tipiThreshold.get(i));
  609.                     if(tipoClass == null){
  610.                         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");
  611.                         return false;
  612.                     }
  613.                     try{
  614.                         IThreshold t = (IThreshold) loaderOpenSPCoop.newInstance(tipoClass);
  615.                         t.toString();
  616.                     }catch(Exception e){
  617.                         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);
  618.                         return false;
  619.                     }
  620.                 }
  621.             }

  623.             // Check validazioneSemantica: warning
  624.             this.isValidazioneSemanticaRegistroServiziStartupXML();
  625.             this.isValidazioneSemanticaConfigurazioneStartupXML();
  626.             this.isValidazioneSemanticaRegistroServiziStartup();
  627.             this.isValidazioneSemanticaConfigurazioneStartup();
  628.             this.isValidazioneSemanticaRegistroServiziCheckURI();
  629.             
  630.             // Controllo risorse
  631.             if( this.isAbilitatoControlloRisorseConfigurazione() ||
  632.                     this.isAbilitatoControlloValidazioneSemanticaConfigurazione() ||
  633.                     this.isAbilitatoControlloRisorseDB() ||
  634.                     this.isAbilitatoControlloRisorseJMS() ||
  635.                     this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati() || 
  636.                     this.isAbilitatoControlloRisorseRegistriServizi() ||
  637.                     this.isAbilitatoControlloValidazioneSemanticaRegistriServizi() ||
  638.                     this.isAbilitatoControlloRisorseTracciamentiPersonalizzati()){
  639.                 // CheckInterval 
  640.                 long intervalloCheck = this.getControlloRisorseCheckInterval();
  641.                 if(intervalloCheck<=0){
  642.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.risorse.checkInterval', valore non impostato/valido.");           
  643.                     return false;
  644.                 }
  645.                 // Warning
  646.                 this.isControlloRisorseRegistriRaggiungibilitaTotale();
  647.                 this.isControlloRisorseRegistrazioneEvento();
  648.                 if(this.isAbilitatoControlloRisorseDB()) {
  649.                     this.getNumeroIterazioniFalliteControlloRisorseDB();
  650.                     this.getIterazioniFalliteCheckIntervalControlloRisorseDB();
  651.                 }
  652.                 if(this.isAbilitatoControlloRisorseJMS()) {
  653.                     this.getNumeroIterazioniFalliteControlloRisorseJMS();
  654.                     this.getIterazioniFalliteCheckIntervalControlloRisorseJMS();
  655.                 }
  656.                 if(this.isAbilitatoControlloRisorseTracciamentiPersonalizzati()) {
  657.                     this.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati();
  658.                     this.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati();
  659.                 }
  660.                 if(this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati()) {
  661.                     this.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati();
  662.                     this.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati();
  663.                 }
  664.                 if(this.isAbilitatoControlloRisorseConfigurazione()) {
  665.                     this.getNumeroIterazioniFalliteControlloRisorseConfigurazione();
  666.                     this.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione();
  667.                 }
  668.                 if(this.isAbilitatoControlloRisorseRegistriServizi()) {
  669.                     this.getNumeroIterazioniFalliteControlloRisorseRegistriServizi();
  670.                     this.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi();
  671.                 }
  672.             }


  675.             // Tipo di Configurazione
  676.             
  677.             this.getConfigPreLoadingLocale();
  678.             
  679.             if (getTipoConfigurazionePDD() == null){        
  680.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.config.tipo'. Proprieta' non impostata");
  681.                 return false;
  682.             }
  683.             if( (CostantiConfigurazione.CONFIGURAZIONE_XML.equalsIgnoreCase(getTipoConfigurazionePDD()) == false) &&
  684.                     (CostantiConfigurazione.CONFIGURAZIONE_DB.equalsIgnoreCase(getTipoConfigurazionePDD()) == false) ){
  685.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.config.tipo'. Tipo non Supportato");
  686.                 return false;
  687.             }
  688.             if( CostantiConfigurazione.CONFIGURAZIONE_DB.equalsIgnoreCase(getTipoConfigurazionePDD()) ){
  689.                 // Il tipo del DB e' obbligatorio.
  690.                 // Controllo che vi sia o
  691.                 // - come prefisso del datasource: tipoDatabase@datasource
  692.                 // - come tipo di database della porta di dominio.
  693.                 if(this.getPathConfigurazionePDD().indexOf("@")!=-1){
  694.                     // estrazione tipo database
  695.                     try{
  696.                         DBUtils.estraiTipoDatabaseFromLocation(this.getPathConfigurazionePDD());
  697.                     }catch(Exception e){
  698.                         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);
  699.                         return false;
  700.                     }
  701.                 }else{
  702.                     if(this.getDatabaseType()==null){
  703.                         this.logError("La configurazione della porta di dominio di tipo ["+getTipoConfigurazionePDD()
  704.                                 +"] richiede la definizione del tipo di database indicato o come prefisso della location (tipoDB@datasource) o attraverso la proprieta' 'org.openspcoop2.pdd.repository.tipoDatabase'");
  705.                     }
  706.                 }
  707.             }


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

  717.                 String path = getPathConfigurazionePDD();
  718.                 if( (!path.startsWith("http://")) && (!path.startsWith("file://")) ){
  719.                     if( !(new File(path)).exists() ){
  720.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.config.location'. \n Il file indicato non esiste ["+path+"].");
  721.                         return false;
  722.                     }
  723.                 }else{
  724.                     // validazione url
  725.                     try{
  726.                         URL v  = new URL(path);
  727.                         v.toString();
  728.                     }catch(Exception e){
  729.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.config.location'. \n La url indicata non e' corretta ["+path+"].");
  730.                         return false;
  731.                     }
  732.                 }
  733.             }
  734.             else if( !CostantiConfigurazione.CONFIGURAZIONE_DB.equalsIgnoreCase(getTipoConfigurazionePDD())){       
  735.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.config.tipo'. \n Tipo non supportato ["+getTipoConfigurazionePDD()+"].");
  736.                 return false;
  737.             }

  739.             // (warning)
  740.             this.isConfigurazioneDinamica();
  741.             this.isConfigurazioneCache_ConfigPrefill();
  742.             this.isConfigurazioneCache_RegistryPrefill();
  743.             this.isConfigurazioneCache_accessiSynchronized();
  744.             this.isConfigurazioneCache_transactionContext_accessiSynchronized();
  745.             
  746.             this.getCacheTypeConfig();
  747.             this.getCacheTypeRegistry();
  748.             this.getCacheTypeAuthentication();
  749.             this.getCacheTypeAuthorization();
  750.             this.getCacheTypeResponseCaching();
  751.             this.getCacheTypeToken();
  752.             this.getCacheTypeAttributeAuthority();
  753.             this.getCacheTypeKeystore();
  754.             this.getCacheTypeLoadBalancer();
  755.             this.getCacheTypeTrafficControl();
  756.             this.getCacheTypeMessage();
  757.             this.getCacheTypeRequestManager();
  758.             
  759.             this.isConfigurazioneCacheDebug();
  760.             
  761.             this.isConfigurazioneCacheRequestManagerUseCache();
  762.             
  763.             this.isConfigurazioneCacheRequestManagerExternalResourceSaveInCache();
  764.             this.isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache();
  765.             this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache();
  766.             
  767.             this.isConfigurazioneKeystoreJksPasswordRequired();
  768.             this.isConfigurazioneKeystoreJksKeyPasswordRequired();
  769.             this.isConfigurazioneKeystorePkcs12PasswordRequired();
  770.             this.isConfigurazioneKeystorePkcs12KeyPasswordRequired();
  771.             this.isConfigurazioneTruststoreJksPasswordRequired();
  772.             this.isConfigurazioneTruststorePkcs12PasswordRequired();
  773.             
  774.             if(this.isConfigurazionePluginsEnabled()) {
  775.                 this.isConfigurazionePluginsDebug();
  776.                 this.getConfigurazionePluginsSeconds();
  777.             }

  779.             // DataSource
  780.             if (getJNDIName_DataSource() == null){      
  781.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.dataSource'. Proprieta' non impostata");
  782.                 return false;
  783.             }
  784.             if (getJNDIContext_DataSource() == null){       
  785.                 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?");
  786.                 return false;
  787.             }

  789.             // Comunicazioni infrastrutturali
  790.             if( this.getNodeReceiver()==null ){
  791.                 return false;
  792.             }else{
  793.                 //  Ricerco connettore
  794.                 String tipoClass = className.getNodeReceiver(this.getNodeReceiver());
  795.                 if(tipoClass == null){
  796.                     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");
  797.                     return false;
  798.                 }
  799.                 try{
  800.                     INodeReceiver nodeReceiverTest = (INodeReceiver) loaderOpenSPCoop.newInstance(tipoClass);
  801.                     nodeReceiverTest.toString();
  802.                 }catch(Exception e){
  803.                     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);
  804.                     return false;
  805.                 }
  806.             }
  807.             // warning
  808.             this.getNodeReceiverTimeout();
  809.             this.getNodeReceiverTimeoutRicezioneContenutiApplicativi();
  810.             this.getNodeReceiverTimeoutRicezioneBuste();
  811.             this.getNodeReceiverCheckInterval();
  812.             this.getNodeReceiverCheckDBInterval();
  813.             this.singleConnectionNodeReceiver();

  815.             if( this.getNodeSender()==null ){
  816.                 return false;
  817.             }else{
  818.                 //  Ricerco connettore
  819.                 String tipoClass = className.getNodeSender(this.getNodeSender());
  820.                 if(tipoClass == null){
  821.                     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");
  822.                     return false;
  823.                 }
  824.                 try{
  825.                     INodeSender nodeSenderTest = (INodeSender) loaderOpenSPCoop.newInstance(tipoClass);
  826.                     nodeSenderTest.toString();
  827.                 }catch(Exception e){
  828.                     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);
  829.                     return false;
  830.                 }


  833.                 if(CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_DB.equals(this.getNodeSender())){
  834.                     if (getRepositoryJDBCAdapter() == null) {   
  835.                         this.logError("Un JDBCAdapter deve essere definito in caso di NodeSender=db");
  836.                         return false;
  837.                     }
  838.                     //  Ricerco connettore
  839.                     String jdbcAdapter = this.getRepositoryJDBCAdapter();
  840.                     if(this.getDatabaseType()!=null && TipiDatabase.DEFAULT.equals(jdbcAdapter)){
  841.                         try{
  842.                             IJDBCAdapter adapter = JDBCAdapterFactory.createJDBCAdapter(OpenSPCoop2Properties.openspcoopProperties.getDatabaseType());
  843.                             adapter.toString();
  844.                         }catch(Exception e){
  845.                             this.logError(PREFIX_JDBC_ADAPTER_NOT_EXISTS+getRepositoryJDBCAdapter()+"]: "+e.getMessage(),e);
  846.                             return false;
  847.                         }
  848.                     }
  849.                     else{
  850.                         String adapterClass = className.getJDBCAdapter(jdbcAdapter);
  851.                         if(adapterClass == null){
  852.                             this.logError(PREFIX_JDBC_ADAPTER_NOT_EXISTS+getRepositoryJDBCAdapter()+"] nelle classi registrate in OpenSPCoop");
  853.                             return false;
  854.                         }
  855.                         try{
  856.                             IJDBCAdapter adapter = (IJDBCAdapter) loaderOpenSPCoop.newInstance(tipoClass);
  857.                             adapter.toString();
  858.                         }catch(Exception e){
  859.                             this.logError(PREFIX_JDBC_ADAPTER_NOT_EXISTS+getRepositoryJDBCAdapter()+"]: "+e.getMessage(),e);
  860.                             return false;
  861.                         }
  862.                     }
  863.                 }
  864.             }

  866.             
  867.             // Servizi HTTP: warning
  868.             isHttpDisableKeepAlive();
  869.             isServiceRequestHttpMethodPatchEnabled();
  870.             isServiceRequestHttpMethodLinkEnabled();
  871.             isServiceRequestHttpMethodUnlinkEnabled();
  872.             TransferLengthModes modeConsegna = this.getTransferLengthModes_consegnaContenutiApplicativi();
  873.             if(TransferLengthModes.TRANSFER_ENCODING_CHUNKED.equals(modeConsegna)){
  874.                 this.getChunkLength_consegnaContenutiApplicativi();
  875.             }
  876.             TransferLengthModes modeInoltro = this.getTransferLengthModes_inoltroBuste();
  877.             if(TransferLengthModes.TRANSFER_ENCODING_CHUNKED.equals(modeInoltro)){
  878.                 this.getChunkLength_inoltroBuste();
  879.             }
  880.             this.getTransferLengthModes_ricezioneBuste();
  881.             this.getTransferLengthModes_ricezioneContenutiApplicativi();
  882.             
  883.             this.isFollowRedirects_consegnaContenutiApplicativi_soap();
  884.             this.isFollowRedirects_consegnaContenutiApplicativi_rest();
  885.             this.isFollowRedirects_inoltroBuste_soap();
  886.             this.isFollowRedirects_inoltroBuste_rest();
  887.             this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi();
  888.             this.getFollowRedirectsMaxHop_inoltroBuste();
  889.             this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi();
  890.             this.isAcceptOnlyReturnCode_200_202_inoltroBuste();
  891.             this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi();
  892.             this.isAcceptOnlyReturnCode_307_inoltroBuste();
  893.             
  894.             this.checkSoapActionQuotedString_ricezioneContenutiApplicativi();
  895.             this.checkSoapActionQuotedString_ricezioneBuste();
  896.             
  897.             this.isControlloContentTypeAbilitatoRicezioneContenutiApplicativi();
  898.             this.isControlloContentTypeAbilitatoRicezioneBuste();
  899.             this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap();
  900.             this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest();
  901.             this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap();
  902.             this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest();
  903.             this.isPrintInfoCertificate();
  904.             
  905.             if(this.isGestoreCredenzialiPortaDelegataEnabled()) {
  906.                 getGestoreCredenzialiPortaDelegataProperties();
  907.             }
  908.             if(this.isGestoreCredenzialiPortaApplicativaEnabled()) {
  909.                 getGestoreCredenzialiPortaApplicativaProperties();
  910.             }
  911.             
  912.             this.getEnvMapConfig();
  913.             this.isEnvMapConfigRequired();
  914.             
  915.             this.getHSMConfig();
  916.             this.isHSMConfigRequired();
  917.             this.isHSMConfigUniqueProviderInstance();
  918.             
  919.             this.getOCSPConfig();
  920.             this.isOCSPConfigRequired();
  921.             this.isOCSPConfigLoadDefault();
  922.             
  923.             this.getBYOKConfig();
  924.             this.isBYOKConfigRequired();
  925.             this.isBYOKJmxWrapEnbled();
  926.             this.isBYOKJmxUnwrapEnbled();
  927.             this.getBYOKEnvSecretsConfig();
  928.             this.isBYOKEnvSecretsConfigRequired();
  929.             
  930.             this.getHttpUserAgent();
  931.             this.getHttpServer();
  932.             this.getHttpXPdDDetails();
  933.             
  934.             if(this.isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi()){
  935.                 this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi();
  936.                 this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi();
  937.             }
  938.             if(this.isEnabledEncodingRFC2047HeaderValueRicezioneBuste()){
  939.                 this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste();
  940.                 this.getEncodingRFC2047HeaderValueRicezioneBuste();
  941.             }
  942.             if(this.isEnabledEncodingRFC2047HeaderValueInoltroBuste()){
  943.                 this.getCharsetEncodingRFC2047HeaderValueInoltroBuste();
  944.                 this.getEncodingRFC2047HeaderValueInoltroBuste();
  945.             }
  946.             if(this.isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi()){
  947.                 this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi();
  948.                 this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi();
  949.             }
  950.             
  951.             this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi();
  952.             this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste();
  953.             this.isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste();
  954.             this.isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi();
  955.             
  956.             this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi();
  957.             this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi();
  958.             this.getGestioneCORS_returnCode_ricezioneBuste();
  959.             this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste();
  960.             
  961.             this. getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType();
  962.             
  963.             

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

  977.                 // Code Interne
  978.                 if(this.getJNDIQueueName( (CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(this.getNodeReceiver())),
  979.                         (CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(this.getNodeSender())))==null){
  980.                     // log stampato dentro il metodo
  981.                     return false;
  982.                 }
  983.                 if (getJNDIContext_CodeInterne() == null){      
  984.                     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?");
  985.                     return false;
  986.                 }
  987.                 // warning
  988.                 this.getAcknowledgeModeSessioneConnectionFactory();

  990.                 // TransactionManager (Warning)
  991.                 this.getTransactionManagerAttesaAttiva();
  992.                 this.getTransactionManagerCheckDBInterval();
  993.                 this.getTransactionManagerCheckInterval();
  994.                 this.singleConnectionTransactionManager();
  995.             }

  997.             //  Timer EJB
  998.             if(this.getJNDITimerEJBName()==null){
  999.                 // log stampato dentro il metodo
  1000.                 return false;
  1001.             }
  1002.             if (getJNDIContext_TimerEJB() == null){     
  1003.                 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?");
  1004.                 return false;
  1005.             }
  1006.             // warning
  1007.             this.getTimerEJBDeployTimeout();
  1008.             this.getTimerEJBDeployCheckInterval();
  1009.             this.isTimerAutoStart_StopTimer();
  1010.             
  1011.             this.isTimerGestoreRiscontriRicevuteAbilitato();
  1012.             this.isTimerGestoreRiscontriRicevuteAbilitatoLog();
  1013.             this.getTimerGestoreRiscontriRicevuteLimit();
  1014.             if(this.isTimerLockByDatabase()) {
  1015.                 this.getTimerGestoreRiscontriRicevuteLockMaxLife();
  1016.                 this.getTimerGestoreRiscontriRicevuteLockIdleTime();
  1017.             }
  1018.             this.getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva();
  1019.             this.getTimerGestoreRiscontriRicevuteGetLockCheckInterval();
  1020.             
  1021.             this.isTimerGestoreMessaggiAbilitato();
  1022.             this.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata();
  1023.             this.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata();
  1024.             this.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata();
  1025.             this.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata();
  1026.             this.isTimerGestoreMessaggiAbilitatoOrderBy();
  1027.             this.isTimerGestoreMessaggiAbilitatoLog();
  1028.             this.getTimerGestoreMessaggiLimit();
  1029.             this.isTimerGestoreMessaggiVerificaConnessioniAttive();
  1030.             if(this.isTimerLockByDatabase()) {
  1031.                 this.getTimerGestoreMessaggiLockMaxLife();
  1032.                 this.getTimerGestoreMessaggiLockIdleTime();
  1033.             }
  1034.             this.getTimerGestoreMessaggi_getLockAttesaAttiva();
  1035.             this.getTimerGestoreMessaggi_getLockCheckInterval();
  1036.             
  1037.             this.isTimerGestorePuliziaMessaggiAnomaliAbilitato();
  1038.             this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy();
  1039.             this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog();
  1040.             this.getTimerGestorePuliziaMessaggiAnomaliLimit();
  1041.             if(this.isTimerLockByDatabase()) {
  1042.                 this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife();
  1043.                 this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime();
  1044.             }
  1045.             this.getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva();
  1046.             this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval();
  1047.             
  1048.             this.isTimerGestoreRepositoryBusteAbilitato();
  1049.             this.isTimerGestoreRepositoryBusteAbilitatoInitialState();
  1050.             this.isTimerGestoreRepositoryBusteAbilitatoOrderBy();
  1051.             this.isTimerGestoreRepositoryBusteAbilitatoLog();
  1052.             this.getTimerGestoreRepositoryBusteLimit();
  1053.             if(this.isTimerLockByDatabase()) {
  1054.                 this.getTimerGestoreRepositoryBusteLockMaxLife();
  1055.                 this.getTimerGestoreRepositoryBusteLockIdleTime();
  1056.             }
  1057.             this.getTimerGestoreRepositoryBuste_getLockAttesaAttiva();
  1058.             this.getTimerGestoreRepositoryBuste_getLockCheckInterval();
  1059.             
  1060.             this.isTimerConsegnaContenutiApplicativiAbilitato();
  1061.             this.isTimerConsegnaContenutiApplicativiSchedulingDebug();
  1062.             this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica();
  1063.             this.isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare();
  1064.             List<String> code = getTimerConsegnaContenutiApplicativiCode();
  1065.             if(code==null) {
  1066.                 return false;
  1067.             }
  1068.             for (String coda : code) {
  1069.                 ConfigurazioneCoda conf = getTimerConsegnaContenutiApplicativiConfigurazioneCoda(coda);
  1070.                 if(conf==null) {
  1071.                     return false;
  1072.                 }
  1073.             }
  1074.             List<String> priorita = getTimerConsegnaContenutiApplicativiPriorita();
  1075.             if(priorita==null) {
  1076.                 return false;
  1077.             }
  1078.             int sommaPercentuale = 0;
  1079.             for (int i = 0; i < priorita.size(); i++) {
  1080.                 String prior = priorita.get(i);
  1081.                 ConfigurazionePriorita conf = getTimerConsegnaContenutiApplicativiConfigurazionePriorita(prior);
  1082.                 if(conf==null) {
  1083.                     return false;
  1084.                 }
  1085.                 if(!conf.isNessunaPriorita()) {
  1086.                     sommaPercentuale = sommaPercentuale + conf.getPercentuale();
  1087.                 }
  1088.                 if(i==(priorita.size()-1)) {
  1089.                     if(!conf.isNessunaPriorita()) {
  1090.                         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()+")");
  1091.                         return false;
  1092.                     }
  1093.                 }
  1094.             }
  1095.             if(sommaPercentuale>100) {
  1096.                 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+")");
  1097.                 return false;
  1098.             }
  1099.             this.isLoadBalancerDebug();
  1100.             if(this.isTimerLockByDatabase()) {
  1101.                 this.getTimerConsegnaContenutiApplicativiLockMaxLife();
  1102.                 this.getTimerConsegnaContenutiApplicativiLockIdleTime();
  1103.             }
  1104.             this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife();
  1105.             this.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva();
  1106.             this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval();
  1107.             if(!isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager()){
  1108.                 getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource();   
  1109.                 getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSourceJndiContext();
  1110.                 isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils();
  1111.             }
  1112.             if(!isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager()){
  1113.                 getTimerConsegnaContenutiApplicativi_runtime_dataSource();  
  1114.                 getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext();
  1115.                 isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils();
  1116.             }
  1117.             if(!isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager()){
  1118.                 getTimerConsegnaContenutiApplicativi_transazioni_dataSource();  
  1119.                 getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext();
  1120.                 isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils();
  1121.             }
  1122.                 
  1123.             
  1124.             
  1125.             // Gestione Serializable DB (Warning)
  1126.             this.getGestioneSerializableDBAttesaAttiva();
  1127.             this.getGestioneSerializableDBCheckInterval();
  1128.             this.isJdbcCloseConnectionCheckIsClosed();
  1129.             this.isJdbcCloseConnectionCheckAutocommit();

  1131.             // GestioneErrore
  1132.             ProprietaErroreApplicativo paError = getProprietaGestioneErrorePD_engine(null,true);
  1133.             if( paError == null  ){
  1134.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.erroreApplicativo'.");
  1135.                 return false;
  1136.             }
  1137.             getLocaleSOAPFaultString();
  1138.             
  1139.             // Errori http
  1140.             getErroriHttpHeaderGovWayStatus();
  1141.             getErroriHttpHeaderGovWayType();
  1142.             getErroriHttpHeaderGovWayCode();
  1143.             
  1144.             // Errori soap
  1145.             this.isErroriSoapUseGovWayStatusAsFaultCode();
  1146.             this.isErroriSoapHttpHeaderGovWayCodeEnabled();
  1147.             
  1148.             // Errori           
  1149.             this.isErroriGovWayStatusEnabled();
  1150.             this.isErroriGovWayInstanceEnabled();
  1151.             this.isErroriGovWayForceSpecificDetails();
  1152.             this.isErroriGovWayFaultDetailsWithProblemRFC7807();
  1153.             
  1154.             // Problem RFC 7807
  1155.             this.isProblemRFC7807_enrichTitleAsGovWayType();
  1156.             this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode();
  1157.             this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim();
  1158.             this.getProblemRFC7807_transactionId_claim();
  1159.             this.getProblemRFC7807_code_claim();
  1160.             this.getProblemRFC7807_type_claim();
  1161.             
  1162.             // Risposta Errore
  1163.             this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta(Costanti.TRASPARENTE_PROTOCOL_NAME);

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

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

  1194.                 // Check tipi registrati
  1195.                 for(int i=0; i<tipiIntegrazionePD.length;i++){
  1196.                     String tipoClass = className.getIntegrazionePortaDelegata(tipiIntegrazionePD[i]);
  1197.                     if(tipoClass == null){
  1198.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pd="+tipiIntegrazionePD[i]+
  1199.                                 "'"+"\n"+HEADER_INTEGRAZIONE_SCONOSCIUTO);
  1200.                         return false;
  1201.                     }
  1202.                     try{
  1203.                         IGestoreIntegrazionePD gestore = (IGestoreIntegrazionePD) loaderOpenSPCoop.newInstance(tipoClass);
  1204.                         if(gestore==null){
  1205.                             throw new CoreException(OGGETTO_NEW_INSTANCE_NON_CREATO);
  1206.                         }
  1207.                         gestore.toString();
  1208.                     }catch(Exception e){
  1209.                         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);
  1210.                         return false;
  1211.                     }
  1212.                 }

  1214.                 if(checkTipiIntegrazione(tipiIntegrazionePD)==false)
  1215.                     return false;
  1216.             }
  1217.             
  1218.             Properties integrazioneProtocolPD = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pd.");
  1219.             Enumeration<?> keys = integrazioneProtocolPD.keys();
  1220.             while (keys.hasMoreElements()) {
  1221.                 String protocollo = (String) keys.nextElement();
  1222.                 
  1223.                 if(this.getTipoIntegrazionePD(protocollo)!=null){
  1224.                     
  1225.                     String[] tipiIntegrazionePDprotocollo = this.getTipoIntegrazionePD(protocollo);

  1227.                     // Check tipi registrati
  1228.                     for(int i=0; i<tipiIntegrazionePDprotocollo.length;i++){
  1229.                         String tipoClass = className.getIntegrazionePortaDelegata(tipiIntegrazionePDprotocollo[i]);
  1230.                         if(tipoClass == null){
  1231.                             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pd."+protocollo+"="+tipiIntegrazionePDprotocollo[i]+
  1232.                                     "'"+"\n"+HEADER_INTEGRAZIONE_SCONOSCIUTO);
  1233.                             return false;
  1234.                         }
  1235.                         try{
  1236.                             IGestoreIntegrazionePD gestore = (IGestoreIntegrazionePD) loaderOpenSPCoop.newInstance(tipoClass);
  1237.                             if(gestore==null){
  1238.                                 throw new CoreException(OGGETTO_NEW_INSTANCE_NON_CREATO);
  1239.                             }
  1240.                             gestore.toString();
  1241.                         }catch(Exception e){
  1242.                             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);
  1243.                             return false;
  1244.                         }
  1245.                     }

  1247.                     if(!checkTipiIntegrazione(tipiIntegrazionePDprotocollo))
  1248.                         return false;
  1249.                 }
  1250.             }

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

  1256.                 // Check tipi registrati
  1257.                 for(int i=0; i<tipiIntegrazionePA.length;i++){
  1258.                     String tipoClass = className.getIntegrazionePortaApplicativa(tipiIntegrazionePA[i]);
  1259.                     if(tipoClass == null){
  1260.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pa="+tipiIntegrazionePA[i]+
  1261.                                 "'"+"\n"+HEADER_INTEGRAZIONE_SCONOSCIUTO);
  1262.                         return false;
  1263.                     }
  1264.                     try{
  1265.                         IGestoreIntegrazionePA gestore = (IGestoreIntegrazionePA) loaderOpenSPCoop.newInstance(tipoClass);
  1266.                         if(gestore==null){
  1267.                             throw new CoreException(OGGETTO_NEW_INSTANCE_NON_CREATO);
  1268.                         }
  1269.                         gestore.toString();
  1270.                     }catch(Exception e){
  1271.                         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);
  1272.                         return false;
  1273.                     }
  1274.                 }

  1276.                 if(checkTipiIntegrazione(tipiIntegrazionePA)==false)
  1277.                     return false;
  1278.             }
  1279.             
  1280.             Properties integrazioneProtocolPA = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pa.");
  1281.             keys = integrazioneProtocolPA.keys();
  1282.             while (keys.hasMoreElements()) {
  1283.                 String protocollo = (String) keys.nextElement();
  1284.                 
  1285.                 if(this.getTipoIntegrazionePA(protocollo)!=null){
  1286.                     
  1287.                     String[] tipiIntegrazionePAprotocollo = this.getTipoIntegrazionePA(protocollo);

  1289.                     // Check tipi registrati
  1290.                     for(int i=0; i<tipiIntegrazionePAprotocollo.length;i++){
  1291.                         String tipoClass = className.getIntegrazionePortaApplicativa(tipiIntegrazionePAprotocollo[i]);
  1292.                         if(tipoClass == null){
  1293.                             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.tipo.pa."+protocollo+"="+tipiIntegrazionePAprotocollo[i]+
  1294.                                     "'"+"\n"+HEADER_INTEGRAZIONE_SCONOSCIUTO);
  1295.                             return false;
  1296.                         }
  1297.                         try{
  1298.                             IGestoreIntegrazionePA gestore = (IGestoreIntegrazionePA) loaderOpenSPCoop.newInstance(tipoClass);
  1299.                             if(gestore==null){
  1300.                                 throw new CoreException(OGGETTO_NEW_INSTANCE_NON_CREATO);
  1301.                             }
  1302.                             gestore.toString();
  1303.                         }catch(Exception e){
  1304.                             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);
  1305.                             return false;
  1306.                         }
  1307.                     }

  1309.                     if(!checkTipiIntegrazione(tipiIntegrazionePAprotocollo))
  1310.                         return false;
  1311.                 }
  1312.             }
  1313.             
  1314.             // Integrazione Dynamic Info
  1315.             this.isIntegrazioneDynamicInfoEnabled();
  1316.             if(this.getIntegrazioneDynamicInfoType()==null) {
  1317.                 return false;
  1318.             }
  1319.             if(this.getIntegrazioneDynamicInfoName()==null) {
  1320.                 return false;
  1321.             }
  1322.             if(this.getIntegrazioneDynamicInfoEncodeType()==null) {
  1323.                 return false;
  1324.             }
  1325.             this.isIntegrazioneDynamicInfoRequired();
  1326.             
  1327.             // Integrazione Response Dynamic Info
  1328.             this.isIntegrazioneResponseDynamicInfoEnabled();
  1329.             if(this.getIntegrazioneResponseDynamicInfoName()==null) {
  1330.                 return false;
  1331.             }
  1332.             if(this.getIntegrazioneResponseDynamicInfoEncodeType()==null) {
  1333.                 return false;
  1334.             }
  1335.             this.isIntegrazioneResponseDynamicInfoRequired();
  1336.             
  1337.             // Integrazione Template
  1338.             if(this.getIntegrazioneTemplateRequestPropertyTipo()==null) {
  1339.                 return false;
  1340.             }
  1341.             if(this.getIntegrazioneTemplateRequestPropertyFile()==null) {
  1342.                 return false;
  1343.             }
  1344.             if(this.getIntegrazioneTemplateResponsePropertyTipo()==null) {
  1345.                 return false;
  1346.             }
  1347.             if(this.getIntegrazioneTemplateResponsePropertyFile()==null) {
  1348.                 return false;
  1349.             }
  1350.             getIntegrazioneTemplatePortaDelegataRequestTipo();
  1351.             getIntegrazioneTemplatePortaDelegataRequestFile();
  1352.             getIntegrazioneTemplatePortaDelegataResponseTipo();
  1353.             getIntegrazioneTemplatePortaDelegataResponseFile();
  1354.             getIntegrazioneTemplatePortaApplicativaRequestTipo();
  1355.             getIntegrazioneTemplatePortaApplicativaRequestFile();
  1356.             getIntegrazioneTemplatePortaApplicativaResponseTipo();
  1357.             getIntegrazioneTemplatePortaApplicativaResponseFile();
  1358.             
  1359.             getIntegrazioneAutenticazionePortaDelegataRequestHeaders();
  1360.             getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap();
  1361.             getIntegrazioneAutenticazionePortaApplicativaRequestHeaders();
  1362.             getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap();
  1363.             if(this.getIntegrazioneAutenticazionePropertyHeaders()==null) {
  1364.                 return false;
  1365.             }
  1366.             if(this.getIntegrazioneAutenticazionePropertyHeaderPrefix()==null) {
  1367.                 return false;
  1368.             }           
  1369.             
  1370.             // Warning
  1371.             this.isIntegrazioneAsincroniConIdCollaborazioneEnabled();
  1372.             this.getNewOldMapping_backward_compatibility_trasparente_soggetto();
  1373.             this.getNewOldMapping_backward_compatibility_trasparente_servizio();
  1374.             this.getNewOldMapping_backward_compatibility_spcoop_soggetto();
  1375.             this.getNewOldMapping_backward_compatibility_spcoop_servizio();
  1376.             this.getNewOldMapping_backward_compatibility_sdi_soggetto();
  1377.             this.getNewOldMapping_backward_compatibility_sdi_servizio();
  1378.             this.getHeaderIntegrazioneSOAPPdDVersione();
  1379.             this.getHeaderIntegrazioneSOAPPdDDetails();
  1380.             this.deleteHeaderIntegrazioneRequestPD();
  1381.             this.deleteHeaderIntegrazioneResponsePD();
  1382.             this.processHeaderIntegrazionePDResponse(false);
  1383.             this.deleteHeaderIntegrazioneRequestPA();
  1384.             this.deleteHeaderIntegrazioneResponsePA();
  1385.             this.processHeaderIntegrazionePARequest(false);

  1387.             //  TipoAutorizzazioneBuste
  1388.             String tipoNonEsistente = "tipoNonEsistente";
  1389.             getAutorizzazioneLockPermits();
  1390.             getAutorizzazioneLockPermits(tipoNonEsistente);
  1391.             if( this.getTipoAutorizzazioneBuste()==null ){
  1392.                 return false;
  1393.             }else{
  1394.                 if(!CostantiConfigurazione.AUTORIZZAZIONE_NONE.equals(this.getTipoAutorizzazioneBuste())){
  1395.                     //  Ricerco connettore
  1396.                     String tipoClass = className.getAutorizzazionePortaApplicativa(this.getTipoAutorizzazioneBuste());
  1397.                     if(tipoClass == null){
  1398.                         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");
  1399.                         return false;
  1400.                     }
  1401.                     try{
  1402.                         IAutorizzazionePortaApplicativa auth = (IAutorizzazionePortaApplicativa) loaderOpenSPCoop.newInstance(tipoClass);
  1403.                         auth.toString();
  1404.                     }catch(Exception e){
  1405.                         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);
  1406.                         return false;
  1407.                     }
  1408.                 }
  1409.             }
  1410.             isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta();
  1411.             
  1412.             //  TipoAutorizzazioneContenuti
  1413.             getAutorizzazioneContenutiLockPermits();
  1414.             getAutorizzazioneContenutiLockPermits(tipoNonEsistente);

  1416.             // ByPass
  1417.             // Controllo spostato sotto, in attesa che venga inizializzato il ProtocolFactoryManager
  1418.             /**protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
  1419.             while (protocolli.hasMoreElements()) {
  1420.                 String protocollo = (String) protocolli.nextElement();
  1421.                 getBypassFilterMustUnderstandProperties(protocollo);
  1422.             }*/
  1423.             
  1424.             // GestoreRepositoryBuste
  1425.             if( this.getGestoreRepositoryBuste() == null  ){
  1426.                 return false;
  1427.             }else{
  1428.                 //  Ricerco
  1429.                 if(this.getDatabaseType()!=null){
  1430.                     try{
  1431.                         IGestoreRepository repository = GestoreRepositoryFactory.createRepositoryBuste(this.getDatabaseType());
  1432.                         repository.toString();
  1433.                     }catch(Exception e){
  1434.                         this.logError("Riscontrato errore durante l'inizializzazione del gestore del repository buste associato dalla factory al tipo di database ["+this.getDatabaseType()+"]: "+e.getMessage(),e);
  1435.                         return false;
  1436.                     }
  1437.                 }
  1438.                 else{
  1439.                     String tipoClass = className.getRepositoryBuste(this.getGestoreRepositoryBuste());
  1440.                     if(tipoClass == null){
  1441.                         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");
  1442.                         return false;
  1443.                     }
  1444.                     try{
  1445.                         IGestoreRepository repository = (IGestoreRepository) loaderOpenSPCoop.newInstance(tipoClass);
  1446.                         repository.toString();
  1447.                     }catch(Exception e){
  1448.                         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);
  1449.                         return false;
  1450.                     }
  1451.                 }
  1452.             }

  1454.             // Filtro duplicati (warning)
  1455.             // Ricerco
  1456.             String tipoClassFiltroDuplicati = className.getFiltroDuplicati(this.getGestoreFiltroDuplicatiRepositoryBuste());
  1457.             if(tipoClassFiltroDuplicati == null){
  1458.                 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");
  1459.                 return false;
  1460.             }
  1461.             try{
  1462.                 IFiltroDuplicati duplicati = (IFiltroDuplicati) loaderOpenSPCoop.newInstance(tipoClassFiltroDuplicati);
  1463.                 duplicati.toString();
  1464.             }catch(Exception e){
  1465.                 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);
  1466.                 return false;
  1467.             }
  1468.             
  1469.             // SQLQueryObject
  1470.             if(this.getDatabaseType()!=null){
  1471.                 if ( ! TipiDatabase.isAMember(this.getDatabaseType())){
  1472.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.repository.tipoDatabase', tipo di database non gestito");
  1473.                     return false;
  1474.                 }
  1475.                 // Ricerco
  1476.                 String tipoClass = className.getSQLQueryObject(this.getDatabaseType());
  1477.                 if(tipoClass == null){
  1478.                     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");
  1479.                     return false;
  1480.                 }
  1481.                 try{
  1482.                     ISQLQueryObject sqlQuery = (ISQLQueryObject) loaderOpenSPCoop.newInstance(tipoClass,TipiDatabase.DEFAULT);
  1483.                     sqlQuery.toString();
  1484.                 }catch(Exception e){
  1485.                     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);
  1486.                     return false;
  1487.                 }
  1488.             }

  1490.             // Connettore (Warning)
  1491.             if(this.isConnettoriUseLimitedInputStream()) {
  1492.                 this.getLimitedInputStreamThresholdKb();
  1493.                 this.isLimitedInputStreamUseContentLength();
  1494.                 this.isLimitedInputStreamUseContentLengthAcceptZeroValue();
  1495.             }
  1496.             this.isConnettoriUseTimeoutInputStream();
  1497.             this.getConnectionTimeout_consegnaContenutiApplicativi();
  1498.             this.getConnectionTimeout_inoltroBuste();
  1499.             this.getReadConnectionTimeout_consegnaContenutiApplicativi();
  1500.             this.getReadConnectionTimeout_inoltroBuste();
  1501.             this.getConnectionLife_consegnaContenutiApplicativi();
  1502.             this.getConnectionLife_inoltroBuste();
  1503.             this.getReadConnectionTimeout_ricezioneContenutiApplicativi();
  1504.             this.getReadConnectionTimeout_ricezioneBuste();
  1505.             
  1506.             this.isConnettoriUseDiagnosticInputStream_inoltroBuste();
  1507.             this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi();
  1508.             this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi();
  1509.             this.isConnettoriUseDiagnosticInputStream_ricezioneBuste();
  1510.             this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream();
  1511.             
  1512.             // Connettore https
  1513.             this.getConnettoreHttps_secureRandomAlgo();
  1514.             this.isConnettoreHttps_useSecureRandom();
  1515.             
  1516.             // Connettore http (url https)
  1517.             if(this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste()) {
  1518.                 this.getConnettoreHttp_urlHttps_repository_inoltroBuste();
  1519.             }
  1520.             if(this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi()) {
  1521.                 this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi();
  1522.             }
  1523.             if(this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste() ||
  1524.                     this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi()) {
  1525.                 if(this.isConnettoreHttp_urlHttps_cacheEnabled()) {
  1526.                     this.getConnettoreHttp_urlHttps_cacheSize();
  1527.                 }
  1528.             }

  1530.             // Contatore esponenziale per consegna
  1531.             if(this.isRitardoConsegnaAbilitato()){
  1532.                 if( this.getRitardoConsegnaEsponenziale() <= 0 ){
  1533.                     return false;
  1534.                 }else if(this.getRitardoConsegnaEsponenziale() > 0){
  1535.                     try{
  1536.                         this.isRitardoConsegnaEsponenzialeConMoltiplicazione();
  1537.                     }catch(Exception e){
  1538.                         return false;
  1539.                     }
  1540.                     if( this.getRitardoConsegnaEsponenzialeLimite() <= 0 ){
  1541.                         return false;
  1542.                     }
  1543.                 }
  1544.             }

  1546.             // Cache per gestore Messaggi
  1547.             try{
  1548.                 if(this.isAbilitataCacheGestoreMessaggi()){
  1549.                     String algoritmo = this.getAlgoritmoCacheGestoreMessaggi();
  1550.                     if(algoritmo!=null &&
  1551.                             !CostantiConfigurazione.CACHE_LRU.equals(algoritmo) && 
  1552.                             !CostantiConfigurazione.CACHE_MRU.equals(algoritmo)){
  1553.                         this.logError("Algoritmo utilizzato con la cache (Gestore Messaggi) non conosciuto: "+algoritmo);
  1554.                         throw new CoreException("Algoritmo Cache (Gestore Messaggi) non conosciuto");
  1555.                     }
  1556.                     this.getDimensioneCacheGestoreMessaggi();
  1557.                     this.getItemIdleTimeCacheGestoreMessaggi();
  1558.                     this.getItemLifeSecondCacheGestoreMessaggi();
  1559.                 }
  1560.             }catch(Exception e){
  1561.                 // Il motivo dell'errore viene loggato dentro i metodi
  1562.                 return false;
  1563.             }

  1565.             // Gestione JMX
  1566.             this.isRisorseJMXAbilitate();
  1567.             this.getJNDIName_MBeanServer();
  1568.             this.getJNDIContext_MBeanServer();

  1570.             // DateManager
  1571.             if(this.getTipoDateManager()==null)
  1572.                 return false;
  1573.             if(getTipoDateTimeFormat()==null) {
  1574.                 return false;
  1575.             }
  1576.             String tipoDateManger = className.getDateManager(this.getTipoDateManager());
  1577.             if(tipoDateManger == null){
  1578.                 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");
  1579.                 return false;
  1580.             }
  1581.             try{
  1582.                 IDate date = (IDate) loaderOpenSPCoop.newInstance(tipoDateManger);
  1583.                 date.toString();
  1584.             }catch(Exception e){
  1585.                 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);
  1586.                 return false;
  1587.             }
  1588.             if (this.getDateManagerProperties() == null){       
  1589.                 this.logError("Riscontrato errore durante la lettura della proprieta' del DataManager: 'org.openspcoop2.pdd.date.property.*'. Proprieta' definite in maniera errata?");
  1590.                 return false;
  1591.             }
  1592.             // Warning
  1593.             this.getTipoTempoBusta(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);

  1595.             // IntegrationManager
  1596.             if(this.isIntegrationManagerEnabled()) {
  1597.                 this.isIntegrationManagerIdWithDate();
  1598.                 this.getIntegrationManagerIdsLimit();
  1599.             }
  1600.             // IntegrationManager (Warning)
  1601.             this.integrationManager_readInformazioniTrasporto();
  1602.             this.integrationManager_isNomePortaDelegataUrlBased();
  1603.             if(this.isIntegrationManagerEnabled()) {
  1604.                 if(!isIntegrationManager_runtime_useRuntimeManager() && !isIntegrationManager_runtime_useConsegnePreseInCaricoManager()){
  1605.                     getIntegrationManager_runtime_dataSource(); 
  1606.                     getIntegrationManager_runtime_dataSourceJndiContext();
  1607.                     isIntegrationManager_runtime_dataSource_useDBUtils();
  1608.                 }
  1609.                 if(!isIntegrationManager_transazioni_useTransactionManager() && !isIntegrationManager_transazioni_useConsegnePreseInCaricoManager()){
  1610.                     getIntegrationManager_transazioni_dataSource(); 
  1611.                     getIntegrationManager_transazioni_dataSourceJndiContext();
  1612.                     isIntegrationManager_transazioni_dataSource_useDBUtils();
  1613.                 }
  1614.             }

  1616.             // Gestione Attachments (Warning)
  1617.             this.isDeleteInstructionTargetMachineXml();
  1618.             this.isTunnelSOAP_loadMailcap();
  1619.             this.getTunnelSOAPKeyWord_headerTrasporto();
  1620.             this.getTunnelSOAPKeyWordMimeType_headerTrasporto();
  1621.             this.getTunnelSOAPKeyWord_urlBased();
  1622.             this.getTunnelSOAPKeyWordMimeType_urlBased();

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

  1627.             // Autenticazione
  1628.             this.getAutenticazioneLockPermits();
  1629.             this.getAutenticazioneLockPermits(tipoNonEsistente);
  1630.             this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed();
  1631.             if(this.getCryptConfigAutenticazioneApplicativi()==null) {
  1632.                 return false;
  1633.             }
  1634.             if(this.getCryptConfigAutenticazioneSoggetti()==null) {
  1635.                 return false;
  1636.             }
  1637.             
  1638.             this.isAutenticazioneBasicLogPassword();
  1639.             this.getRealmAutenticazioneBasicWWWAuthenticateConfig();
  1640.             
  1641.             this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig();
  1642.             
  1643.             this.isAutenticazioneHttpsPortaDelegataValidityCheck();
  1644.             if(this.getAutenticazioneHttpsPortaDelegataTruststorePath()!=null) {
  1645.                 this.getAutenticazioneHttpsPortaDelegataTruststoreType();
  1646.                 this.getAutenticazioneHttpsPortaDelegataTruststorePassword();
  1647.                 this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs();
  1648.                 this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy();
  1649.             }
  1650.             this.isAutenticazioneHttpsPortaApplicativaValidityCheck();
  1651.             if(this.getAutenticazioneHttpsPortaApplicativaTruststorePath()!=null) {
  1652.                 this.getAutenticazioneHttpsPortaApplicativaTruststoreType();
  1653.                 this.getAutenticazioneHttpsPortaApplicativaTruststorePassword();
  1654.                 this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs();
  1655.                 this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy();
  1656.             }
  1657.             this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari();
  1658.             this.getRealmAutenticazioneHttpsWWWAuthenticateConfig();
  1659.             
  1660.             this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari();
  1661.             TipoAutenticazionePrincipal [] tipiPrincipale = TipoAutenticazionePrincipal.values();
  1662.             for (TipoAutenticazionePrincipal tipoAutenticazionePrincipal : tipiPrincipale) {
  1663.                 this.getRealmAutenticazionePrincipalWWWAuthenticateConfig(tipoAutenticazionePrincipal); 
  1664.             }
  1665.             
  1666.             this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari();
  1667.             
  1668.             // Gestori Credenziali PD
  1669.             String [] gestoriCredenzialiPD = this.getTipoGestoreCredenzialiPD();
  1670.             if(gestoriCredenzialiPD!=null){
  1671.                 for(int i=0; i<gestoriCredenzialiPD.length;i++){
  1672.                     //  Ricerco
  1673.                     String tipoClass = className.getGestoreCredenziali(gestoriCredenzialiPD[i]);
  1674.                     if(tipoClass == null){
  1675.                         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");
  1676.                         return false;
  1677.                     }
  1678.                     try{
  1679.                         IGestoreCredenziali g = (IGestoreCredenziali) loaderOpenSPCoop.newInstance(tipoClass);
  1680.                         g.toString();
  1681.                     }catch(Exception e){
  1682.                         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);
  1683.                         return false;
  1684.                     }
  1685.                 }
  1686.             }
  1687.             
  1688.             // Gestori Credenziali PA
  1689.             String [] gestoriCredenzialiPA = this.getTipoGestoreCredenzialiPA();
  1690.             if(gestoriCredenzialiPA!=null){
  1691.                 for(int i=0; i<gestoriCredenzialiPA.length;i++){
  1692.                     //  Ricerco
  1693.                     String tipoClass = className.getGestoreCredenziali(gestoriCredenzialiPA[i]);
  1694.                     if(tipoClass == null){
  1695.                         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");
  1696.                         return false;
  1697.                     }
  1698.                     try{
  1699.                         IGestoreCredenziali g = (IGestoreCredenziali) loaderOpenSPCoop.newInstance(tipoClass);
  1700.                         g.toString();
  1701.                     }catch(Exception e){
  1702.                         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);
  1703.                         return false;
  1704.                     }
  1705.                 }
  1706.             }
  1707.             
  1708.             // Gestori Credenziali IntegrationManager
  1709.             String [] gestoriCredenzialiIM = this.getTipoGestoreCredenzialiIM();
  1710.             if(gestoriCredenzialiIM!=null){
  1711.                 for(int i=0; i<gestoriCredenzialiIM.length;i++){
  1712.                     //  Ricerco
  1713.                     String tipoClass = className.getGestoreCredenzialiIM(gestoriCredenzialiIM[i]);
  1714.                     if(tipoClass == null){
  1715.                         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");
  1716.                         return false;
  1717.                     }
  1718.                     try{
  1719.                         IGestoreCredenzialiIM g = (IGestoreCredenzialiIM) loaderOpenSPCoop.newInstance(tipoClass);
  1720.                         g.toString();
  1721.                     }catch(Exception e){
  1722.                         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);
  1723.                         return false;
  1724.                     }
  1725.                 }
  1726.             }
  1727.             
  1728.             // warning Risposta Asincrona
  1729.             this.getTimeoutBustaRispostaAsincrona();
  1730.             this.getCheckIntervalBustaRispostaAsincrona();

  1732.             // Configurazione Cluster
  1733.             this.getClusterId(false);
  1734.             this.getClusterIdNumerico();
  1735.             if(this.isClusterDinamico()) {
  1736.                 if(this.getClusterId(true)==null) {
  1737.                     return false;
  1738.                 }
  1739.                 this.getClusterDinamicoRefreshSecondsInterval();
  1740.                 this.getClusterHostname();
  1741.                 if(this.getGroupId(false)==null) {
  1742.                     return false;
  1743.                 }
  1744.                 if(this.getClusterDinamicoIdNumericoCifre(false)<0) {
  1745.                     return false;
  1746.                 }
  1747.                 this.isUseHashClusterId();
  1748.             }
  1749.             if(this.isTimerLockByDatabase()) {
  1750.                 this.isTimerLockByDatabaseNotifyLogEnabled();
  1751.             }
  1752.             this.getPddContextSerializer();
  1753.             
  1754.             // Warning
  1755.             this.isGenerazioneAttributiAsincroni(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1756.             this.isGenerazioneListaTrasmissioni(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1757.             this.isGenerazioneErroreProtocolloFiltroDuplicati(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1758.             this.isCheckFromRegistroFiltroDuplicatiAbilitato(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1759.             this.isCheckFromRegistroConfermaRicezioneAbilitato(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1760.             this.isCheckFromRegistroConsegnaInOrdineAbilitato(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1761.             this.isGestioneConsegnaInOrdine(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1762.             this.isGestioneElementoCollaborazione(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1763.             this.isGestioneRiscontri(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1764.             this.ignoraEccezioniNonGraviValidazione();
  1765.             this.isForceSoapPrefixCompatibilitaOpenSPCoopV1();
  1766.             this.isReadQualifiedAttribute(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1767.             this.isValidazioneIDBustaCompleta(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);

  1769.             // Stateless
  1770.             if(this.getStatelessOneWay()==null)
  1771.                 return false;
  1772.             if(this.getStatelessSincrono()==null)
  1773.                 return false;
  1774.             if(this.getStatelessAsincroni()==null)
  1775.                 return false;
  1776.             if(this.getStatelessRouting()==null)
  1777.                 return false;

  1779.             // Warning
  1780.             this.isGestioneOnewayStateful_1_1();
  1781.             this.isRinegoziamentoConnessione();

  1783.             // Handlers
  1784.             this.isMergeHandlerBuiltInAndHandlerUser();
  1785.             
  1786.             // Handlers BuiltIn
  1787.             this.isPrintInfoHandlerBuiltIn();
  1788.             if(this.validateHandlersBuiltInEngine(className, loaderOpenSPCoop)==false) {
  1789.                 return false;
  1790.             }
  1791.             
  1792.             // Handlers
  1793.             this.isPrintInfoHandler();
  1794.             if(this.validateHandlersEngine(className, loaderOpenSPCoop)==false) {
  1795.                 return false;
  1796.             }
  1797.             
  1798.             // MessageSecurity
  1799.             this.isLoadApacheXMLDSig();
  1800.             this.isLoadBouncyCastle();
  1801.             this.getBouncyCastleSecureRandomAlgorithm();
  1802.             this.isUseBouncyCastleProviderForCertificate();
  1803.             this.isUseBouncyCastleProviderForMessageDigest();
  1804.             this.isUseBouncyCastleProviderForWss4jCryptoMerlin();
  1805.             this.getSecurityEgd();
  1806.             this.isGenerazioneActorDefault(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1807.             this.getActorDefault(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1808.             this.getPrefixWsuId();
  1809.             this.getWsuIdSecureRandomAlgorithm();
  1810.             this.getExternalPWCallbackPropertyFile();
  1811.             this.isAbilitataCacheMessageSecurityKeystore();
  1812.             this.getDimensioneCacheMessageSecurityKeystore();
  1813.             this.getItemLifeSecondCacheMessageSecurityKeystore();

  1815.             // Accesso registro servizi
  1816.             this.isReadObjectStatoBozza();
  1817.             
  1818.             // Tracce
  1819.             this.isTracciaturaFallita_BloccaCooperazioneInCorso();
  1820.             this.isTracciaturaFallita_BloccoServiziPdD();
  1821.             
  1822.             // Diagnostici
  1823.             this.isRegistrazioneDiagnosticaFile_intestazione_formatValues();
  1824.             this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD();
  1825.             this.isLoggerSaajDisabilitato();
  1826.             
  1827.             // Dump
  1828.             this.getDumpBufferImpl();
  1829.             this.isDumpAllAttachments();
  1830.             this.isDumpFallitoBloccaCooperazioneInCorso();
  1831.             this.isDumpFallitoBloccoServiziPdD();
  1832.             
  1833.             this.getDumpHeaderWhiteList();
  1834.             this.getDumpHeaderBlackList();
  1835.             
  1836.             this.getDumpHeaderErogazioniWhiteList();
  1837.             this.getDumpHeaderErogazioniBlackList();
  1838.             this.getDumpHeaderFruizioniWhiteList();
  1839.             this.getDumpHeaderFruizioniBlackList();
  1840.             
  1841.             this.getDumpHeaderErogazioniRichiestaIngressoWhiteList();
  1842.             this.getDumpHeaderErogazioniRichiestaIngressoBlackList();
  1843.             this.getDumpHeaderErogazioniRichiestaUscitaWhiteList();
  1844.             this.getDumpHeaderErogazioniRichiestaUscitaBlackList();
  1845.             this.getDumpHeaderErogazioniRispostaIngressoWhiteList();
  1846.             this.getDumpHeaderErogazioniRispostaIngressoBlackList();
  1847.             this.getDumpHeaderErogazioniRispostaUscitaWhiteList();
  1848.             this.getDumpHeaderErogazioniRispostaUscitaBlackList();
  1849.             
  1850.             this.getDumpHeaderFruizioniRichiestaIngressoWhiteList();
  1851.             this.getDumpHeaderFruizioniRichiestaIngressoBlackList();
  1852.             this.getDumpHeaderFruizioniRichiestaUscitaWhiteList();
  1853.             this.getDumpHeaderFruizioniRichiestaUscitaBlackList();
  1854.             this.getDumpHeaderFruizioniRispostaIngressoWhiteList();
  1855.             this.getDumpHeaderFruizioniRispostaIngressoBlackList();
  1856.             this.getDumpHeaderFruizioniRispostaUscitaWhiteList();
  1857.             this.getDumpHeaderFruizioniRispostaUscitaBlackList();
  1858.             
  1859.             this.isDumpEmitDiagnostic();
  1860.             
  1861.             // DumpBinario
  1862.             this.isDumpBinarioRegistrazioneDatabase();
  1863.             this.getDumpBinarioInMemoryThreshold();
  1864.             this.getDumpBinarioRepository();

  1866.             // DumpNotRealtime
  1867.             this.getDumpNonRealtimeInMemoryThreshold();
  1868.             this.getDumpNonRealtimeMode();
  1869.             if(this.isDumpNonRealtimeFileSystemMode()) {
  1870.                 this.getDumpNonRealtimeRepository();
  1871.             }
  1872.             this.isDumpNonRealtimeThrowStreamingHandlerException();
  1873.             
  1874.             // Generatore di ID
  1875.             String tipoIDGenerator = this.getTipoIDManager();
  1876.             if(CostantiConfigurazione.NONE.equals(tipoIDGenerator)==false){
  1877.                 String tipoIdManger = className.getUniqueIdentifier(tipoIDGenerator);
  1878.                 if(tipoIdManger == null){
  1879.                     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");
  1880.                     return false;
  1881.                 }
  1882.                 useIDManagerWithThreadLocal();
  1883.                 getIDManagerParameters();
  1884.                 getIDManagerBufferSize();
  1885.                 try{
  1886.                     IUniqueIdentifierGenerator uniqueIdentifier = (IUniqueIdentifierGenerator) loaderOpenSPCoop.newInstance(tipoIdManger);
  1887.                     uniqueIdentifier.toString();
  1888.                 }catch(Exception e){
  1889.                     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);
  1890.                     return false;
  1891.                 }
  1892.             }
  1893.             
  1894.             // InitOpenSPCoop2MessageFactory
  1895.             if ( this.getOpenspcoop2MessageFactory() != null ){
  1896.                 String tipo = this.getOpenspcoop2MessageFactory();
  1897.                 // Check tipi registrati
  1898.                 String tipoClass = className.getOpenSPCoop2MessageFactory(tipo);
  1899.                 if(tipoClass == null){
  1900.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.messagefactory'=...,"+tipo+
  1901.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  1902.                     return false;
  1903.                 }
  1904.                 try{
  1905.                     OpenSPCoop2MessageFactory test = (OpenSPCoop2MessageFactory) loaderOpenSPCoop.newInstance(tipoClass);
  1906.                     test.toString();
  1907.                 }catch(Exception e){
  1908.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.messagefactory'=...,"+tipoClass+
  1909.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  1910.                     return false;
  1911.                 } 
  1912.             }
  1913.             
  1914.             // InitOpenSPCoop2MessageFactory
  1915.             if ( this.getMessageSecurityContext() != null ){
  1916.                 String tipo = this.getMessageSecurityContext();
  1917.                 // Check tipi registrati
  1918.                 String tipoClass = className.getMessageSecurityContext(tipo);
  1919.                 if(tipoClass == null){
  1920.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.messageSecurity.context'=...,"+tipo+
  1921.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  1922.                     return false;
  1923.                 }
  1924.                 try{
  1925.                     MessageSecurityContext test = (MessageSecurityContext) loaderOpenSPCoop.newInstance(tipoClass);
  1926.                     test.toString();
  1927.                 }catch(Exception e){
  1928.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.messageSecurity.context'=...,"+tipoClass+
  1929.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  1930.                     return false;
  1931.                 } 
  1932.             }
  1933.             if ( this.getMessageSecurityDigestReader() != null ){
  1934.                 String tipo = this.getMessageSecurityDigestReader();
  1935.                 // Check tipi registrati
  1936.                 String tipoClass = className.getMessageSecurityDigestReader(tipo);
  1937.                 if(tipoClass == null){
  1938.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.messageSecurity.digestReader'=...,"+tipo+
  1939.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  1940.                     return false;
  1941.                 }
  1942.                 try{
  1943.                     IDigestReader test = (IDigestReader) loaderOpenSPCoop.newInstance(tipoClass);
  1944.                     test.toString();
  1945.                 }catch(Exception e){
  1946.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.messageSecurity.digestReader'=...,"+tipoClass+
  1947.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  1948.                     return false;
  1949.                 } 
  1950.             }
  1951.             
  1952.             // test warning
  1953.             isPrintInfoFactory();
  1954.             isPrintInfoMessageSecurity();
  1955.             
  1956.             // FreeMemoryLog
  1957.             this.getFreeMemoryLog();
  1958.             
  1959.             // DefaultProtocol
  1960.             this.getDefaultProtocolName();
  1961.                         
  1962.             // SoggettiVirtuali
  1963.             this.isSoggettiVirtualiEnabled();
  1964.             
  1965.             // Informazioni generazione errori
  1966.             this.isGenerazioneErroreProtocolloNonSupportato();
  1967.             this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled();
  1968.             this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled();
  1969.             this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled();
  1970.             this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled();
  1971.             this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled();
  1972.             this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled();
  1973.             
  1974.             // Informazioni generazione WSDL
  1975.             this.isGenerazioneWsdlPortaDelegataEnabled();
  1976.             this.isGenerazioneWsdlPortaApplicativaEnabled();
  1977.             this.isGenerazioneWsdlIntegrationManagerEnabled();
  1978.             
  1979.             // Check
  1980.             if(this.isCheckEnabled()) {
  1981.                 if(this.isCheckHealthCheckApiRestEnabled() &&
  1982.                     this.getCheckHealthCheckApiRestEndpoint()==null) {
  1983.                     return false;
  1984.                 }
  1985.                 if(this.isCheckHealthCheckApiSoapEnabled() &&
  1986.                     this.getCheckHealthCheckApiSoapEndpoint()==null) {
  1987.                     return false;
  1988.                 }
  1989.                 this.isCheckHealthCheckStatsEnabled(); // le verifiche sotto vengono fatte lo stesso poichè la verifica della statistica può essere fatta on demand
  1990.                 if(this.isCheckHealthCheckStatsHourlyEnabled() &&
  1991.                     this.getCheckHealthCheckStatsHourlyThreshold()<0) {
  1992.                     return false;
  1993.                 }
  1994.                 if(this.isCheckHealthCheckStatsDailyEnabled() &&
  1995.                     this.getCheckHealthCheckStatsDailyThreshold()<0) {
  1996.                     return false;
  1997.                 }
  1998.                 if(this.isCheckHealthCheckStatsWeeklyEnabled() &&
  1999.                     this.getCheckHealthCheckStatsWeeklyThreshold()<0) {
  2000.                     return false;
  2001.                 }
  2002.                 if(this.isCheckHealthCheckStatsMonthlyEnabled() &&
  2003.                     this.getCheckHealthCheckStatsMonthlyThreshold()<0) {
  2004.                     return false;
  2005.                 }
  2006.             }
  2007.             this.isCheckReadJMXResourcesEnabled();
  2008.             this.getCheckReadJMXResourcesUsername();
  2009.             this.getCheckReadJMXResourcesPassword();
  2010.             if(this.isProxyReadJMXResourcesEnabled()) {
  2011.                 
  2012.                 if(this.isProxyReadJMXResourcesAsyncProcessByTimer()) {
  2013.                     this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass();
  2014.                     this.isProxyReadJMXResourcesAsyncProcessByTimerDebug();
  2015.                     this.getProxyReadJMXResourcesAsyncProcessByTimerSchema();
  2016.                     this.getProxyReadJMXResourcesAsyncProcessByTimerHostname();
  2017.                     this.getProxyReadJMXResourcesAsyncProcessByTimerPort();
  2018.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval();
  2019.                     this.getProxyReadJMXResourcesAsyncProcessByTimerLimit();
  2020.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval();
  2021.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes();
  2022.                 }
  2023.                 
  2024.                 this.getProxyReadJMXResourcesSchema();
  2025.                 this.getProxyReadJMXResourcesPort();
  2026.                 if(this.isProxyReadJMXResourcesHttpsEnabled()) {
  2027.                     this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName();
  2028.                     if(this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer()) {
  2029.                         if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath()==null) {
  2030.                             return false;
  2031.                         }
  2032.                         if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType()==null) {
  2033.                             return false;
  2034.                         }
  2035.                         if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword()==null) {
  2036.                             return false;
  2037.                         }
  2038.                     }
  2039.                 }
  2040.                 this.getProxyReadJMXResourcesUsername();
  2041.                 this.getProxyReadJMXResourcesPassword();
  2042.                 this.getProxyReadJMXResourcesConnectionTimeout();
  2043.                 this.getProxyReadJMXResourcesReadTimeout();
  2044.             }
  2045.                         
  2046.             // Datasource Wrapped
  2047.             this.isDSOp2UtilsEnabled();
  2048.             
  2049.             // Datasource getConnection
  2050.             this.isDataSourceGetConnectionCheckAutoCommitDisabled();
  2051.             if(this.isDataSourceGetConnectionCheckTransactionIsolationLevel()) {
  2052.                 this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected();
  2053.             }
  2054.             
  2055.             // NotifierInputStreamEnabled
  2056.             if(this.isNotifierInputStreamEnabled()) {
  2057.                 String notifierClass = null;
  2058.                 try{
  2059.                     notifierClass = this.getNotifierInputStreamCallback();
  2060.                 }catch(Exception e){
  2061.                     return false; // log registrato nel metodo
  2062.                 }
  2063.                 if(notifierClass!=null){
  2064.                     String tipoClass = className.getNotifierCallback(notifierClass);
  2065.                     if(tipoClass == null){
  2066.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.notifierCallback'=...,"+notifierClass+
  2067.                         "'"+"\n"+TIPO_SCONOSCIUTO);
  2068.                         return false;
  2069.                     }
  2070.                     try{
  2071.                         INotifierCallback test = (INotifierCallback) loaderOpenSPCoop.newInstance(tipoClass);
  2072.                         test.toString();
  2073.                     }catch(Exception e){
  2074.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.notifierCallback'=...,"+tipoClass+
  2075.                                 "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2076.                         return false;
  2077.                     } 
  2078.                 }
  2079.             }
  2080.             
  2081.             // PipedUnblockedVersion
  2082.             try{
  2083.                 this.getPipedUnblockedStreamClassName();
  2084.             }catch(Exception e){
  2085.                 return false; // log registrato nel metodo
  2086.             }
  2087.             
  2088.             // FormUrlEncodedFilter
  2089.             this.isFormUrlEncodedFilterEnabled();
  2090.             
  2091.             // semaphore
  2092.             this.getSemaphoreTimeoutMS();
  2093.             this.getSemaphoreHoldTimeoutMS();
  2094.             this.isSemaphoreDebug();
  2095.             this.getSemaphoreType();
  2096.             this.isSemaphoreFair();
  2097.             
  2098.             // JminixConsole
  2099.             this.getPortJminixConsole();
  2100.             
  2101.             // Custom Contexts
  2102.             this.isEnabledFunctionPD();
  2103.             this.isEnabledFunctionPDtoSOAP();
  2104.             this.isEnabledFunctionPA();
  2105.             this.getCustomContexts();
  2106.             
  2107.             // Custom Container
  2108.             if ( this.getRealContainerCustom() != null ){
  2109.                 String tipo = this.getRealContainerCustom();
  2110.                 // Check tipi registrati
  2111.                 String tipoClass = className.getRealmContainerCustom(tipo);
  2112.                 if(tipoClass == null){
  2113.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.realmContainer.custom'="+tipo+
  2114.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  2115.                     return false;
  2116.                 }
  2117.                 try{
  2118.                     IAutorizzazioneSecurityContainer test = (IAutorizzazioneSecurityContainer) loaderOpenSPCoop.newInstance(tipoClass);
  2119.                     test.toString();
  2120.                 }catch(Exception e){
  2121.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.realmContainer.custom'="+tipoClass+
  2122.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2123.                     return false;
  2124.                 } 
  2125.             }
  2126.             
  2127.             // govway_configurazioneSistema.log
  2128.             this.isConfigurazioneSistema_javaProperties_showPassword();
  2129.             
  2130.             // govway startup
  2131.             this.getStartupRichiesteIngressoTimeoutSecondi();
  2132.             this.getStartupRichiesteIngressoCheckMs();
  2133.             this.getStartupLockMaxLife();
  2134.             this.getStartupLockIdleTime();
  2135.             
  2136.             // ExtendedInfo (Configurazione)
  2137.             String extendedInfoConfigurazioneTest = null;
  2138.             try{
  2139.                 extendedInfoConfigurazioneTest = this.getExtendedInfoConfigurazione();
  2140.             }catch(Exception e){
  2141.                 return false; // log registrato nel metodo
  2142.             }
  2143.             if(extendedInfoConfigurazioneTest!=null){
  2144.                 try{
  2145.                     IExtendedInfo test = (IExtendedInfo) loaderOpenSPCoop.newInstance(extendedInfoConfigurazioneTest);
  2146.                     test.toString();
  2147.                 }catch(Exception e){
  2148.                     this.logError("La classe ["+extendedInfoConfigurazioneTest+"], indicata nella proprieta' 'org.openspcoop2.pdd.config.extendedInfo.configurazione', non esiste: "+e.getMessage(),e);
  2149.                     return false;
  2150.                 } 
  2151.             }
  2152.             
  2153.             // ExtendedInfo (PortaDelegata)
  2154.             String extendedInfoPortaDelegataTest = null;
  2155.             try{
  2156.                 extendedInfoPortaDelegataTest = this.getExtendedInfoPortaDelegata();
  2157.             }catch(Exception e){
  2158.                 return false; // log registrato nel metodo
  2159.             }
  2160.             if(extendedInfoPortaDelegataTest!=null){
  2161.                 try{
  2162.                     IExtendedInfo test = (IExtendedInfo) loaderOpenSPCoop.newInstance(extendedInfoPortaDelegataTest);
  2163.                     test.toString();
  2164.                 }catch(Exception e){
  2165.                     this.logError("La classe ["+extendedInfoPortaDelegataTest+"], indicata nella proprieta' 'org.openspcoop2.pdd.config.extendedInfo.portaDelegata', non esiste: "+e.getMessage(),e);
  2166.                     return false;
  2167.                 } 
  2168.             }
  2169.             
  2170.             // ExtendedInfo (PortaApplicativa)
  2171.             String extendedInfoPortaApplicativaTest = null;
  2172.             try{
  2173.                 extendedInfoPortaApplicativaTest = this.getExtendedInfoPortaApplicativa();
  2174.             }catch(Exception e){
  2175.                 return false; // log registrato nel metodo
  2176.             }
  2177.             if(extendedInfoPortaApplicativaTest!=null){
  2178.                 try{
  2179.                     IExtendedInfo test = (IExtendedInfo) loaderOpenSPCoop.newInstance(extendedInfoPortaApplicativaTest);
  2180.                     test.toString();
  2181.                 }catch(Exception e){
  2182.                     this.logError("La classe ["+extendedInfoPortaApplicativaTest+"], indicata nella proprieta' 'org.openspcoop2.pdd.config.extendedInfo.portaApplicativa', non esiste: "+e.getMessage(),e);
  2183.                     return false;
  2184.                 } 
  2185.             }
  2186.             
  2187.             // ValidazioneContenutiApplicativi
  2188.             this.isValidazioneContenutiApplicativiDebug();
  2189.             this.isValidazioneContenutiApplicativiBufferContentRead();
  2190.             this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione();
  2191.             this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione();
  2192.             this.isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists();
  2193.             this.isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists();
  2194.             this.isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists();
  2195.             this.isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified();
  2196.             this.isValidazioneContenutiApplicativiCheckSoapAction();
  2197.             this.getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties();
  2198.             this.getValidazioneContenutiApplicativiOpenApiJsonValidator();
  2199.             this.getValidazioneContenutiApplicativiOpenApiLibrary();
  2200.             this.isValidazioneContenutiApplicativiOpenApiValidateAPISpec();
  2201.             this.isValidazioneContenutiApplicativiOpenApiValidateRequestPath();
  2202.             this.isValidazioneContenutiApplicativiOpenApiValidateRequestQuery();
  2203.             this.isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam();
  2204.             this.isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders();
  2205.             this.isValidazioneContenutiApplicativiOpenApiValidateRequestCookie();
  2206.             this.isValidazioneContenutiApplicativiOpenApiValidateRequestBody();
  2207.             this.isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders();
  2208.             this.isValidazioneContenutiApplicativiOpenApiValidateResponseBody();
  2209.             this.isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson();
  2210.             this.isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization();
  2211.             this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse();
  2212.             this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec();
  2213.             this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values();
  2214.             this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl();
  2215.             this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ();
  2216.             this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator();
  2217.             
  2218.             // XML
  2219.             this.isXmlFactoryDTDsEnabled();
  2220.             this.isXsltProcessAsDOMSource();
  2221.             
  2222.             // YAML
  2223.             this.getYamlSnakeLimits();
  2224.             
  2225.             // XPath Json Path
  2226.             this.isJsonPathCacheEnabled();
  2227.             this.isReadByPathBufferEnabled();
  2228.             
  2229.             // CachingResponse
  2230.             this.getCachingResponseDigestAlgorithm();
  2231.             this.getCachingResponseHeaderCacheKey();
  2232.             
  2233.             // Gestione Token
  2234.             this.isGestioneTokenDynamicDiscoveryDebug();
  2235.             this.isGestioneTokenIntrospectionDebug();
  2236.             this.isGestioneTokenUserInfoDebug();
  2237.             this.getGestioneTokenDynamicDiscoveryLockPermits();
  2238.             this.getGestioneTokenValidazioneJWTLockPermits();
  2239.             this.getGestioneTokenIntrospectionLockPermits();
  2240.             this.getGestioneTokenUserInfoLockPermits();
  2241.             this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken();
  2242.             this.isGestioneTokenDynamicDiscoveryUseCacheConfig();
  2243.             this.isGestioneTokenIatRequired();
  2244.             this.isGestioneTokenIatRequired(true);
  2245.             this.isGestioneTokenIatRequired(false);
  2246.             this.getGestioneTokenIatTimeCheckMilliseconds();
  2247.             this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds();
  2248.             this.isGestioneTokenExpRequired();
  2249.             this.isGestioneTokenExpRequired(true);
  2250.             this.isGestioneTokenExpRequired(false);
  2251.             this.isGestioneTokenExpTimeCheck();
  2252.             this.getGestioneTokenExpTimeCheckToleranceMilliseconds();
  2253.             this.isGestioneTokenNbfRequired();
  2254.             this.isGestioneTokenNbfRequired(true);
  2255.             this.isGestioneTokenNbfRequired(false);     
  2256.             this.getGestioneTokenNbfTimeCheckToleranceMilliseconds();
  2257.             this.getGestioneTokenValidityCheck();
  2258.             this.isGestioneTokenSaveSourceTokenInfo();
  2259.             this.isGestioneTokenSaveTokenInfoValidationFailed();
  2260.             this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature();
  2261.             this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed();
  2262.             this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed();
  2263.             this.getGestioneTokenFormatDate();
  2264.             this.getGestioneTokenHeaderTrasportoJSON();
  2265.             this.getGestioneTokenHeaderTrasportoJWT();
  2266.             if(!this.checkTipiIntegrazioneGestioneToken()) {
  2267.                 return false;
  2268.             }
  2269.             List<String> listCustomClaims = getCustomClaimsKeysGestioneTokenForward();
  2270.             if(listCustomClaims!=null && !listCustomClaims.isEmpty()) {
  2271.                 for (String claim : listCustomClaims) {
  2272.                     // in caso non siano presenti viene sollevata una eccezione
  2273.                     this.getCustomClaimsNameGestioneTokenHeaderIntegrazione(claim);
  2274.                     this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto(claim);
  2275.                     this.getCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(claim);
  2276.                     this.getCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(claim);
  2277.                     this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson(claim);
  2278.                     this.getCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(claim);
  2279.                     this.getCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(claim);
  2280.                 }
  2281.             }
  2282.             this.getGestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator();
  2283.             this.getGestioneTokenHeaderIntegrazioneTrasportoScopeSeparator();
  2284.             this.getGestioneTokenHeaderIntegrazioneTrasportoRoleSeparator();
  2285.             
  2286.             // Gestione RetrieveToken
  2287.             this.getGestioneRetrieveTokenDebug();
  2288.             this.getGestioneRetrieveTokenLockPermits();
  2289.             if(!this.validateGestioneRetrieveTokenRefreshTokenBeforeExpire()) {
  2290.                 return false;
  2291.             }
  2292.             this.isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials();
  2293.             this.isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword();
  2294.             this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509();
  2295.             this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret();
  2296.             this.isGestioneRetrieveTokenRefreshTokenGrantTypeCustom();
  2297.             this.isGestioneRetrieveTokenSaveAsTokenInfo();
  2298.             this.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature();
  2299.             this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest();
  2300.             this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate();
  2301.             this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate();
  2302.             this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature();
  2303.             this.isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed();
  2304.             this.initGestioneRetrieveTokenCacheKey();
  2305.             // dovrebbe venire chiamato solo per ModI
  2306.             // può essere usato con il profilo trasparente nella testsuite
  2307.             this.getGestioneRetrieveTokenPdndUrlPatternMatch(Costanti.MODIPA_PROTOCOL_NAME);
  2308.             this.isGestioneRetrieveTokenPdndPayloadClientId(Costanti.MODIPA_PROTOCOL_NAME);
  2309.             this.isGestioneRetrieveTokenPdndPayloadNbf(Costanti.MODIPA_PROTOCOL_NAME);
  2310.             this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientId(Costanti.MODIPA_PROTOCOL_NAME);
  2311.                         
  2312.             // Gestione AttributeAuthority
  2313.             this.isGestioneAttributeAuthorityDebug();
  2314.             this.getGestioneAttributeAuthorityLockPermits();
  2315.             this.isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo();
  2316.             this.isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate();
  2317.             this.getGestioneAttributeAuthorityValidityCheck();
  2318.             
  2319.             // Statistiche via jmx Console
  2320.             this.isStatisticheViaJmx();
  2321.             
  2322.             // Forward Proxy
  2323.             this.isForwardProxyEnable();
  2324.             this.getForwardProxyConfigurazioneDefault();
  2325.             this.getForwardProxyConfigurazioneTokenDefault();
  2326.             
  2327.             // Trasformazioni
  2328.             this.isTrasformazioni_readCharsetFromContentType();
  2329.             this.getTrasformazioni_backwardCompatibility();
  2330.             
  2331.             // Trasporto REST / SOAP
  2332.             
  2333.             this.getSOAPServicesUrlParametersForwardConfig();
  2334.             this.getSOAPServicesHeadersForwardConfig(true);
  2335.             this.getSOAPServicesHeadersForwardConfig(false);
  2336.             
  2337.             // Location
  2338.             this.isSOAPServices_inoltroBuste_proxyPassReverse();
  2339.             this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse();
  2340.             this.getSOAPServices_inoltroBuste_proxyPassReverse_headers();
  2341.             this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers();
  2342.             // SetCookie
  2343.             this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
  2344.             this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  2345.             this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path();
  2346.             this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path();
  2347.             this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain();
  2348.             this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain();
  2349.             this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers();
  2350.             this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers();
  2351.             // useProtocolPrefix
  2352.             this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix();
  2353.             this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix();
  2354.             // securityHeaders
  2355.             if(this.isSOAPServices_inoltroBuste_response_securityHeaders()) {
  2356.                 this.getSOAPServices_inoltroBuste_response_securityHeaders();
  2357.             }
  2358.             if(this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders()) {
  2359.                 this.getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders();
  2360.             }
  2361.             
  2362.             this.getRESTServicesUrlParametersForwardConfig();
  2363.             this.getRESTServicesHeadersForwardConfig(true);
  2364.             this.getRESTServicesHeadersForwardConfig(false);
  2365.             
  2366.             // Location
  2367.             this.isRESTServices_inoltroBuste_proxyPassReverse();
  2368.             this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse();
  2369.             this.getRESTServices_inoltroBuste_proxyPassReverse_headers();
  2370.             this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers();
  2371.             // SetCookie
  2372.             this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
  2373.             this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  2374.             this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path();
  2375.             this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path();
  2376.             this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain();
  2377.             this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain();
  2378.             this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers();
  2379.             this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers();
  2380.             // useProtocolPrefix
  2381.             this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix();
  2382.             this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix();
  2383.             // securityHeaders
  2384.             if(this.isRESTServices_inoltroBuste_response_securityHeaders()) {
  2385.                 this.getRESTServices_inoltroBuste_response_securityHeaders();
  2386.             }
  2387.             if(this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders()) {
  2388.                 this.getRESTServices_consegnaContenutiApplicativi_response_securityHeaders();
  2389.             }
  2390.                                 
  2391.             // Transazioni
  2392.             if(this.isTransazioniEnabled()) {
  2393.                 this.isTransazioniDebug();
  2394.                 if(!this.isTransazioniUsePddRuntimeDatasource()) {
  2395.                     this.getTransazioniDatasource();
  2396.                     this.getTransazioniDatasourceJndiContext();
  2397.                     this.isTransazioniDatasourceUseDBUtils();
  2398.                 }
  2399.                 this.isTransazioniSaveTracceInUniqueTransaction();
  2400.                 this.isTransazioniSaveDiagnosticiInUniqueTransaction();
  2401.                 this.isTransazioniSaveDumpInUniqueTransaction();
  2402.                 this.isTransazioniValorizzaDataIngressoConDataAccettazione();
  2403.                 this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent();
  2404.                 this.isTransazioniFaultPrettyPrint();
  2405.                 
  2406.                 this._isTransazioniFiltroDuplicatiSaveDateEnabled();
  2407.                 if(this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled()) {
  2408.                     this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection();
  2409.                     this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex();
  2410.                 }
  2411.                 
  2412.                 if(this.isTransazioniStatefulEnabled()) {
  2413.                     this.isTransazioniStatefulDebug();
  2414.                     this.getTransazioniStatefulTimerIntervalSeconds();
  2415.                 }
  2416.                 
  2417.                 this.getTransazioniCredenzialiMittenteMaxLength();
  2418.                 this.getTransazioniCredenzialiMittenteLifeSeconds();
  2419.                 this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled();
  2420.                 this.isTransazioniRegistrazioneTracceHeaderRawEnabled();
  2421.                 this.isTransazioniRegistrazioneTracceDigestEnabled();
  2422.                 this._getTransazioniRegistrazioneTracceManager(className, loaderOpenSPCoop);
  2423.                 this._getTransazioniRegistrazioneDiagnosticiManager(className, loaderOpenSPCoop);
  2424.                 this.isTransazioniRegistrazioneDumpHeadersCompactEnabled();
  2425.                 
  2426.                 this.isTransazioniHttpStatusAsEvent_inResponseCode();
  2427.                 this.isTransazioniHttpStatusAsEvent_outResponseCode();
  2428.                 this.isTransazioniTipoApiAsEvent();
  2429.                 this.isTransazioniConnettoriMultipliAsEvent();
  2430.                 this.isTransazioniUpdateUseDayInterval();
  2431.                 
  2432.                 if(this.isTransazioniRegistrazioneSlowLog()) {
  2433.                     this.getTransazioniRegistrazioneSlowLogThresholdMs();
  2434.                     this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails();
  2435.                     this.isTransazioniRegistrazioneSlowLogRateLimitingDetails();
  2436.                     this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails();
  2437.                     this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails();
  2438.                 }
  2439.                 
  2440.                 this.isTransazioniTracciamentoDBOutRequestThrowRequestException();
  2441.                 this.isTransazioniTracciamentoDBOutResponseThrowRequestException();
  2442.                 this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException();
  2443.                 this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException();

  2445.                 this.isTransazioniFileTraceEnabled();
  2446.                 if(this.isTransazioniFileTraceDumpBinarioPDEnabled()) {
  2447.                     this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled();
  2448.                     this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled();
  2449.                 }
  2450.                 if(this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()) {
  2451.                     this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled();
  2452.                     this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled();
  2453.                 }
  2454.                 if(this.isTransazioniFileTraceDumpBinarioPAEnabled()) {
  2455.                     this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled();
  2456.                     this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled();
  2457.                 }
  2458.                 if(this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()) {
  2459.                     this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled();
  2460.                     this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled();
  2461.                 }
  2462.                 this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase();
  2463.                 this.getTransazioniFileTraceConfig();
  2464.                 
  2465.                 this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit();
  2466.                 this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog();
  2467.             }
  2468.             
  2469.             // Eventi
  2470.             if(this.isEventiEnabled()) {
  2471.                 this.isEventiDebug();
  2472.                 this.isEventiRegistrazioneStatoPorta();
  2473.                 if(this.isEventiTimerEnabled()) {
  2474.                     this.getEventiTimerIntervalSeconds();
  2475.                     this.getEventiTimerIntervalConnectionTimeoutEveryXTimes();
  2476.                     this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes();
  2477.                     this.getEventiTimerIntervalReadTimeoutEveryXTimes();
  2478.                 }
  2479.             }
  2480.             
  2481.             // FileSystemRecovery
  2482.             this.getFileSystemRecoveryRepository();
  2483.             this.isFileSystemRecoveryDebug();
  2484.             if(this.isFileSystemRecoveryTimerEnabled()) {
  2485.                 this.getFileSystemRecoveryTimerIntervalSeconds();
  2486.                 this.getFileSystemRecoveryMaxAttempts();
  2487.                 this.isFileSystemRecoveryTimerEventEnabled();
  2488.                 this.isFileSystemRecoveryTimerTransactionEnabled();
  2489.                 this.getFileSystemRecoveryEventsProcessingFileAfterMs();
  2490.                 this.getFileSystemRecoveryTransactionProcessingFileAfterMs();
  2491.             }
  2492.             
  2493.             // ControlloTraffico
  2494.             if(this.isControlloTrafficoEnabled()) {
  2495.                 //this.initConfigurazioneControlloTraffico(loaderOpenSPCoop); invocato da OpenSPcoop2Startup
  2496.                 TipoGestorePolicy tipo = this.getControlloTrafficoGestorePolicyTipo();
  2497.                 if(TipoGestorePolicy.WS.equals(tipo)) {
  2498.                     this.getControlloTrafficoGestorePolicyWSUrl();
  2499.                 }
  2500.                 else if(TipoGestorePolicy.IN_MEMORY.equals(tipo)) {
  2501.                     @SuppressWarnings("unused")
  2502.                     PolicyGroupByActiveThreadsType type = this.getControlloTrafficoGestorePolicyInMemoryType();
  2503.                     
  2504.                     this.isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodesRemainingZeroValue();
  2505.                     this.isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodesLimitRoundingDown();
  2506.                     this.isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodesLimitNormalizedQuota();

  2508.                     isControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction();
  2509.                     getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva();
  2510.                     getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval();
  2511.                     
  2512.                     //case HAZELCAST:
  2513.                     if(isHazelcastEngineEnabled()) {
  2514.                         //case HAZELCAST_MAP:
  2515.                         getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath();
  2516.                         //case HAZELCAST_NEAR_CACHE:
  2517.                         getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath();
  2518.                         //case HAZELCAST_NEAR_CACHE_UNSAFE_SYNC_MAP:
  2519.                         getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath();
  2520.                         //case HAZELCAST_NEAR_CACHE_UNSAFE_ASYNC_MAP:
  2521.                         getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath();
  2522.                         // case HAZELCAST_REPLICATED_MAP
  2523.                         getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath();
  2524.                         //case HAZELCAST_LOCAL_CACHE:
  2525.                         getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath();
  2526.                         getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheTimerUpdate();

  2528.                         getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId();
  2529.                         getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig();
  2530.                         isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy();
  2531.                         
  2532.                         getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath();
  2533.                         getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath();
  2534.                         getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath();
  2535.                         
  2536.                         isHazelcastSecurityRecommendationsEnabled();
  2537.                         if(isHazelcastDiagnosticsEnabled()) {
  2538.                             getHazelcastDiagnosticsDirectory();
  2539.                             getHazelcastDiagnosticsMaxRolledFileCount();
  2540.                             getHazelcastDiagnosticsMaxFileSizeMb();
  2541.                         }
  2542.                         getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover();
  2543.                         getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs();
  2544.                     }
  2545.                     
  2546.                     // case REDIS
  2547.                     if(isRedisEngineEnabled()) {
  2548.                         getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl();
  2549.                         isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy();
  2550.                         isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady();
  2551.                     }
  2552.                     
  2553.                     if(isHazelcastEngineEnabled() || isRedisEngineEnabled()) {
  2554.                         isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock();
  2555.                     }
  2556.                     
  2557.                 }
  2558.                 this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository();
  2559.                 
  2560.                 // header limit
  2561.                 this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit();
  2562.                 this.getControlloTrafficoNumeroRichiesteHeaderLimit();
  2563.                 this.getControlloTrafficoOccupazioneBandaHeaderLimit();
  2564.                 this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit();
  2565.                 this.getControlloTrafficoTempoMedioRispostaHeaderLimit();
  2566.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit();
  2567.                 this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit();
  2568.                 this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit();
  2569.                 this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit();
  2570.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit();
  2571.                 
  2572.                 // header limit windows
  2573.                 this.getControlloTrafficoNumeroRichiesteHeaderLimitWindows();
  2574.                 this.getControlloTrafficoOccupazioneBandaHeaderLimitWindows();
  2575.                 this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows();
  2576.                 this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindows();
  2577.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows();
  2578.                 this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows();
  2579.                 this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows();
  2580.                 this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows();
  2581.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindows();
  2582.                 
  2583.                 // header remaining
  2584.                 this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining();
  2585.                 this.getControlloTrafficoNumeroRichiesteHeaderRemaining();
  2586.                 this.getControlloTrafficoOccupazioneBandaHeaderRemaining();
  2587.                 this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining();
  2588.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining();
  2589.                 this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining();
  2590.                 this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining();
  2591.                 this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining();
  2592.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining();
  2593.                 
  2594.                 // header reset
  2595.                 this.getControlloTrafficoNumeroRichiesteHeaderReset();
  2596.                 this.getControlloTrafficoOccupazioneBandaHeaderReset();
  2597.                 this.getControlloTrafficoTempoComplessivoRispostaHeaderReset();
  2598.                 this.getControlloTrafficoTempoMedioRispostaHeaderReset();
  2599.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset();
  2600.                 this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset();
  2601.                 this.getControlloTrafficoNumeroFaultApplicativiHeaderReset();
  2602.                 this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset();
  2603.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset();
  2604.                 
  2605.                 this.getControlloTrafficoRetryAfterHeader();
  2606.                 this.getControlloTrafficoRetryAfterHeaderRandomBackoff();
  2607.             }
  2608.             
  2609.             // Allarmi
  2610.             if(this.isAllarmiEnabled()) {
  2611.                 this.isAllarmiDebug();
  2612.             }
  2613.             
  2614.             // Service Unavailable
  2615.             this.getServiceUnavailableRetryAfterSecondsPD();
  2616.             this.getServiceUnavailableRetryAfterSecondsRandomBackoffPD();
  2617.             this.getServiceUnavailableRetryAfterSecondsPA();
  2618.             this.getServiceUnavailableRetryAfterSecondsRandomBackoffPA();
  2619.             if(this.isEnabledServiceUnavailableRetryAfterPDSuspend()) {
  2620.                 this.getServiceUnavailableRetryAfterSecondsPDSuspend();
  2621.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend();
  2622.             }
  2623.             if(this.isEnabledServiceUnavailableRetryAfterPASuspend()) {
  2624.                 this.getServiceUnavailableRetryAfterSecondsPASuspend();
  2625.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend();
  2626.             }
  2627.             if(this.isEnabledServiceUnavailableRetryAfterPDConnectionFailed()) {
  2628.                 this.getServiceUnavailableRetryAfterSecondsPDConnectionFailed();
  2629.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed();
  2630.             }
  2631.             if(this.isEnabledServiceUnavailableRetryAfterPAConnectionFailed()) {
  2632.                 this.getServiceUnavailableRetryAfterSecondsPAConnectionFailed();
  2633.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed();
  2634.             }
  2635.             this.isServiceUnavailableReadTimedOut("");
  2636.             
  2637.             // Statistiche
  2638.             if(this.isStatisticheGenerazioneEnabled()) {
  2639.                 if(!this.isStatisticheUsePddRuntimeDatasource() &&
  2640.                         !this.isStatisticheUseTransazioniDatasource()) {
  2641.                     this.getStatisticheDatasource();
  2642.                     this.getStatisticheDatasourceJndiContext();
  2643.                     this.isStatisticheDatasourceUseDBUtils();
  2644.                 }
  2645.                 this.isStatisticheGenerazioneUseUnionForLatency();
  2646.                 if(this.isStatisticheGenerazioneCustomEnabled()) {
  2647.                     this.isStatisticheGenerazioneCustomSdkEnabled();
  2648.                 }
  2649.                 if(this.isStatisticheGenerazioneBaseOrariaEnabled()) {
  2650.                     this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra();
  2651.                 }
  2652.                 if(this.isStatisticheGenerazioneBaseGiornalieraEnabled()) {
  2653.                     this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno();
  2654.                 }
  2655.                 if(this.isStatisticheGenerazioneBaseSettimanaleEnabled()) {
  2656.                     this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana();
  2657.                 }
  2658.                 if(this.isStatisticheGenerazioneBaseMensileEnabled()) {
  2659.                     this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese();
  2660.                 }
  2661.                 this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie();
  2662.                 this.getStatisticheGenerazioneTradeOffMs();
  2663.                 this.getStatisticheOrarieGenerazioneTimerIntervalSeconds();
  2664.                 this.getStatisticheGiornaliereGenerazioneTimerIntervalSeconds();
  2665.                 this.getStatisticheSettimanaliGenerazioneTimerIntervalSeconds();
  2666.                 this.getStatisticheMensiliGenerazioneTimerIntervalSeconds();
  2667.                 this.getStatisticheGenerazioneTimerLockMaxLife();
  2668.                 this.getStatisticheGenerazioneTimerLockIdleTime();
  2669.                 this.getStatisticheGenerazioneTimerLockAttesaAttiva();
  2670.                 this.getStatisticheGenerazioneTimerLockCheckInterval();
  2671.                 this.getStatisticheGenerazioneExternalForceIndexRepository();
  2672.             }
  2673.             
  2674.             if(this.isGestoreChiaviPDNDEnabled()) {
  2675.                 isGestoreChiaviPDNDDebug();
  2676.                 isGestoreChiaviPDNDEventiAdd();
  2677.                 isGestoreChiaviPDNDEventiUpdate();
  2678.                 isGestoreChiaviPDNDEventiDelete();
  2679.                 getGestoreChiaviPDNDRemoteStoreName();
  2680.                 isGestoreChiaviPDNDEventiCheckAllStores();
  2681.                 getGestoreChiaviPDNDkeysMaxLifeMinutes();
  2682.                 getGestoreChiaviPDNDkeysPath();
  2683.                 getGestoreChiaviPDNDeventsKeysPath();
  2684.                 getGestoreChiaviPDNDeventsKeysParameterLastEventId();
  2685.                 getGestoreChiaviPDNDeventsKeysParameterLimit();
  2686.                 getGestoreChiaviPDNDeventsKeysLimit();
  2687.                 getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi();
  2688.                 getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi();
  2689.                 getGestoreChiaviPDNDTimerLockMaxLife();
  2690.                 getGestoreChiaviPDNDTimerLockIdleTime();
  2691.                 getGestoreChiaviPDNDTimerLockAttesaAttiva();
  2692.                 getGestoreChiaviPDNDTimerLockCheckInterval();
  2693.                 getGestoreChiaviPDNDclientsPath();
  2694.                 getGestoreChiaviPDNDclientsOrganizationJsonPath();
  2695.                 getGestoreChiaviPDNDorganizationsPath();
  2696.                 
  2697.                 isGestoreChiaviPDNDclientInfoEnabled();
  2698.                 getGestoreChiaviPDNDclientInfoMaxLifeMinutes();
  2699.                 isGestoreChiaviPDNDclientsErrorAbortTransaction();
  2700.                 isGestoreChiaviPDNDorganizationsErrorAbortTransaction();
  2701.                 isGestoreChiaviPDNDRateLimitingInfoNotAvailableAbortTransaction();
  2702.                 isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation();
  2703.                 isGestoreChiaviPDNDclientsTraceJsonResponse();
  2704.                 isGestoreChiaviPDNDorganizationsTraceJsonResponse();
  2705.                 isGestoreChiaviPDNDorganizationsTraceName();
  2706.             }
  2707.             
  2708.             getHeadersPeerRegexpCacheSize();
  2709.             getHeadersPeer();
  2710.             
  2711.             return true;

  2713.         }catch(java.lang.Exception e) {
  2714.             this.logError("Riscontrato errore durante la validazione lettura della proprieta' di openspcoop: "+e.getMessage(),e);
  2715.             return false;
  2716.         }
  2717.     }
  2718.     
  2719.     public boolean validaConfigurazioneDopoInizializzazioneProtocolManager(java.lang.ClassLoader loader) {  
  2720.         try{  
  2721.             
  2722.             if(loader!=null) {
  2723.                 // nop
  2724.             }
  2725.             
  2726.             // IdentitaPdD
  2727.             Enumeration<String> protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
  2728.             while (protocolli.hasMoreElements()) {
  2729.                 String protocollo = protocolli.nextElement();
  2730.                 getIdentitaPortaDefault(protocollo, null);
  2731.             }   
  2732.             
  2733.             // ByPass
  2734.             protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
  2735.             while (protocolli.hasMoreElements()) {
  2736.                 String protocollo = protocolli.nextElement();
  2737.                 getBypassFilterMustUnderstandProperties(protocollo);
  2738.             }
  2739.             
  2740.             // ControlliToken
  2741.             protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
  2742.             while (protocolli.hasMoreElements()) {
  2743.                 String protocollo = protocolli.nextElement();
  2744.                 isGestioneTokenIatRequired(true, protocollo);
  2745.                 isGestioneTokenIatRequired(false, protocollo);
  2746.                 isGestioneTokenExpRequired(true, protocollo);
  2747.                 isGestioneTokenExpRequired(false, protocollo);
  2748.                 isGestioneTokenNbfRequired(true, protocollo);
  2749.                 isGestioneTokenNbfRequired(false, protocollo);
  2750.                 if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo)) {
  2751.                     isGestioneTokenIatPdndRequired();
  2752.                     isGestioneTokenExpPdndRequired();
  2753.                     isGestioneTokenNbfPdndRequired();
  2754.                 }
  2755.             }
  2756.             
  2757.             return true;
  2758.             
  2759.         }catch(java.lang.Exception e) {
  2760.             this.logError("Riscontrato errore durante la validazione lettura della proprieta' di openspcoop: "+e.getMessage(),e);
  2761.             return false;
  2762.         }
  2763.     }

  2765.     private boolean validateHandlersBuiltInEngine(ClassNameProperties className, Loader loaderOpenSPCoop) {
  2766.         // InitHandlerBuiltIn
  2767.         if ( this.getInitHandlerBuiltIn() != null ){
  2768.             String[] tipiHandlerBuiltIn = this.getInitHandlerBuiltIn();
  2769.             // Check tipi registrati
  2770.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  2771.                 String tipoClass = className.getInitHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  2772.                 if(tipoClass == null){
  2773.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.init'=...,"+tipiHandlerBuiltIn[i]+
  2774.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  2775.                     return false;
  2776.                 }
  2777.                 try{
  2778.                     InitHandler handler = (InitHandler) loaderOpenSPCoop.newInstance(tipoClass);
  2779.                     handler.toString();
  2780.                 }catch(Exception e){
  2781.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.init'=...,"+tipiHandlerBuiltIn[i]+
  2782.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2783.                     return false;
  2784.                 }
  2785.             }
  2786.         }
  2787.         
  2788.         // ExitHandlerBuiltIn
  2789.         if ( this.getExitHandlerBuiltIn() != null ){
  2790.             String[] tipiHandlerBuiltIn = this.getExitHandlerBuiltIn();
  2791.             // Check tipi registrati
  2792.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  2793.                 String tipoClass = className.getExitHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  2794.                 if(tipoClass == null){
  2795.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.exit'=...,"+tipiHandlerBuiltIn[i]+
  2796.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  2797.                     return false;
  2798.                 }
  2799.                 try{
  2800.                     ExitHandler handler = (ExitHandler) loaderOpenSPCoop.newInstance(tipoClass);
  2801.                     handler.toString();
  2802.                 }catch(Exception e){
  2803.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.exit'=...,"+tipiHandlerBuiltIn[i]+
  2804.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2805.                     return false;
  2806.                 }
  2807.             }
  2808.         }
  2809.         
  2810.         // PreInRequestHandlerBuiltIn
  2811.         if ( this.getPreInRequestHandlerBuiltIn() != null ){
  2812.             String[] tipiHandlerBuiltIn = this.getPreInRequestHandlerBuiltIn();
  2813.             // Check tipi registrati
  2814.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  2815.                 String tipoClass = className.getPreInRequestHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  2816.                 if(tipoClass == null){
  2817.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.pre-in-request'=...,"+tipiHandlerBuiltIn[i]+
  2818.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  2819.                     return false;
  2820.                 }
  2821.                 try{
  2822.                     PreInRequestHandler handler = (PreInRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
  2823.                     handler.toString();
  2824.                 }catch(Exception e){
  2825.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.pre-in-request'=...,"+tipiHandlerBuiltIn[i]+
  2826.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2827.                     return false;
  2828.                 }
  2829.             }
  2830.         }
  2831.         // InRequestHandlerBuiltIn
  2832.         if ( this.getInRequestHandlerBuiltIn() != null ){
  2833.             String[] tipiHandlerBuiltIn = this.getInRequestHandlerBuiltIn();
  2834.             // Check tipi registrati
  2835.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  2836.                 String tipoClass = className.getInRequestHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  2837.                 if(tipoClass == null){
  2838.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.in-request'=...,"+tipiHandlerBuiltIn[i]+
  2839.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  2840.                     return false;
  2841.                 }
  2842.                 try{
  2843.                     InRequestHandler handler = (InRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
  2844.                     handler.toString();
  2845.                 }catch(Exception e){
  2846.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.in-request'=...,"+tipiHandlerBuiltIn[i]+
  2847.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2848.                     return false;
  2849.                 }
  2850.             }
  2851.         }
  2852.         // InRequestProtocolHandlerBuiltIn
  2853.         if ( this.getInRequestProtocolHandlerBuiltIn() != null ){
  2854.             String[] tipiHandlerBuiltIn = this.getInRequestProtocolHandlerBuiltIn();
  2855.             // Check tipi registrati
  2856.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  2857.                 String tipoClass = className.getInRequestProtocolHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  2858.                 if(tipoClass == null){
  2859.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.in-protocol-request'=...,"+tipiHandlerBuiltIn[i]+
  2860.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  2861.                     return false;
  2862.                 }
  2863.                 try{
  2864.                     InRequestProtocolHandler handler = (InRequestProtocolHandler) loaderOpenSPCoop.newInstance(tipoClass);
  2865.                     handler.toString();
  2866.                 }catch(Exception e){
  2867.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.in-protocol-request'=...,"+tipiHandlerBuiltIn[i]+
  2868.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2869.                     return false;
  2870.                 }
  2871.             }
  2872.         }
  2873.         // OutRequestHandlerBuiltIn
  2874.         if ( this.getOutRequestHandlerBuiltIn() != null ){
  2875.             String[] tipiHandlerBuiltIn = this.getOutRequestHandlerBuiltIn();
  2876.             // Check tipi registrati
  2877.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  2878.                 String tipoClass = className.getOutRequestHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  2879.                 if(tipoClass == null){
  2880.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.out-request'=...,"+tipiHandlerBuiltIn[i]+
  2881.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  2882.                     return false;
  2883.                 }
  2884.                 try{
  2885.                     OutRequestHandler handler = (OutRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
  2886.                     handler.toString();
  2887.                 }catch(Exception e){
  2888.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.out-request'=...,"+tipiHandlerBuiltIn[i]+
  2889.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2890.                     return false;
  2891.                 }
  2892.             }
  2893.         }
  2894.         // PostOutRequestHandlerBuiltIn
  2895.         if ( this.getPostOutRequestHandlerBuiltIn() != null ){
  2896.             String[] tipiHandlerBuiltIn = this.getPostOutRequestHandlerBuiltIn();
  2897.             // Check tipi registrati
  2898.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  2899.                 String tipoClass = className.getPostOutRequestHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  2900.                 if(tipoClass == null){
  2901.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.post-out-request'=...,"+tipiHandlerBuiltIn[i]+
  2902.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  2903.                     return false;
  2904.                 }
  2905.                 try{
  2906.                     PostOutRequestHandler handler = (PostOutRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
  2907.                     handler.toString();
  2908.                 }catch(Exception e){
  2909.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.post-out-request'=...,"+tipiHandlerBuiltIn[i]+
  2910.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2911.                     return false;
  2912.                 }
  2913.             }
  2914.         }
  2915.         // PreInResponseHandlerBuiltIn
  2916.         if ( this.getPreInResponseHandlerBuiltIn() != null ){
  2917.             String[] tipiHandlerBuiltIn = this.getPreInResponseHandlerBuiltIn();
  2918.             // Check tipi registrati
  2919.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  2920.                 String tipoClass = className.getPreInResponseHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  2921.                 if(tipoClass == null){
  2922.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.pre-in-response'=...,"+tipiHandlerBuiltIn[i]+
  2923.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  2924.                     return false;
  2925.                 }
  2926.                 try{
  2927.                     PreInResponseHandler handler = (PreInResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
  2928.                     handler.toString();
  2929.                 }catch(Exception e){
  2930.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.pre-in-response'=...,"+tipiHandlerBuiltIn[i]+
  2931.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2932.                     return false;
  2933.                 }
  2934.             }
  2935.         }
  2936.         // InResponseHandlerBuiltIn
  2937.         if ( this.getInResponseHandlerBuiltIn() != null ){
  2938.             String[] tipiHandlerBuiltIn = this.getInResponseHandlerBuiltIn();
  2939.             // Check tipi registrati
  2940.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  2941.                 String tipoClass = className.getInResponseHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  2942.                 if(tipoClass == null){
  2943.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.in-response'=...,"+tipiHandlerBuiltIn[i]+
  2944.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  2945.                     return false;
  2946.                 }
  2947.                 try{
  2948.                     InResponseHandler handler = (InResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
  2949.                     handler.toString();
  2950.                 }catch(Exception e){
  2951.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.in-response'=...,"+tipiHandlerBuiltIn[i]+
  2952.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2953.                     return false;
  2954.                 }
  2955.             }
  2956.         }
  2957.         // OutResponseHandlerBuiltIn
  2958.         if ( this.getOutResponseHandlerBuiltIn() != null ){
  2959.             String[] tipiHandlerBuiltIn = this.getOutResponseHandlerBuiltIn();
  2960.             // Check tipi registrati
  2961.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  2962.                 String tipoClass = className.getOutResponseHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  2963.                 if(tipoClass == null){
  2964.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.out-response'=...,"+tipiHandlerBuiltIn[i]+
  2965.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  2966.                     return false;
  2967.                 }
  2968.                 try{
  2969.                     OutResponseHandler handler = (OutResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
  2970.                     handler.toString();
  2971.                 }catch(Exception e){
  2972.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.out-response'=...,"+tipiHandlerBuiltIn[i]+
  2973.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2974.                     return false;
  2975.                 }
  2976.             }
  2977.         }
  2978.         // PostOutResponseHandlerBuiltIn
  2979.         if ( this.getPostOutResponseHandlerBuiltIn() != null ){
  2980.             String[] tipiHandlerBuiltIn = this.getPostOutResponseHandlerBuiltIn();
  2981.             // Check tipi registrati
  2982.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  2983.                 String tipoClass = className.getPostOutResponseHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  2984.                 if(tipoClass == null){
  2985.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.post-out-response'=...,"+tipiHandlerBuiltIn[i]+
  2986.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  2987.                     return false;
  2988.                 }
  2989.                 try{
  2990.                     PostOutResponseHandler handler = (PostOutResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
  2991.                     handler.toString();
  2992.                 }catch(Exception e){
  2993.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.built-in.post-out-response'=...,"+tipiHandlerBuiltIn[i]+
  2994.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  2995.                     return false;
  2996.                 }
  2997.             }
  2998.         }
  2999.         // IntegrationManagerRequestHandlerBuiltIn
  3000.         if ( this.getIntegrationManagerRequestHandlerBuiltIn() != null ){
  3001.             String[] tipiHandlerBuiltIn = this.getIntegrationManagerRequestHandlerBuiltIn();
  3002.             // Check tipi registrati
  3003.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  3004.                 String tipoClass = className.getIntegrationManagerRequestHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  3005.                 if(tipoClass == null){
  3006.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.built-in.request'=...,"+tipiHandlerBuiltIn[i]+
  3007.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3008.                     return false;
  3009.                 }
  3010.                 try{
  3011.                     IntegrationManagerRequestHandler handler = (IntegrationManagerRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3012.                     handler.toString();
  3013.                 }catch(Exception e){
  3014.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.built-in.request'=...,"+tipiHandlerBuiltIn[i]+
  3015.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3016.                     return false;
  3017.                 }
  3018.             }
  3019.         }
  3020.         // IntegrationManagerResponseHandlerBuiltIn
  3021.         if ( this.getIntegrationManagerResponseHandlerBuiltIn() != null ){
  3022.             String[] tipiHandlerBuiltIn = this.getIntegrationManagerResponseHandlerBuiltIn();
  3023.             // Check tipi registrati
  3024.             for(int i=0; i<tipiHandlerBuiltIn.length;i++){
  3025.                 String tipoClass = className.getIntegrationManagerResponseHandlerBuiltIn(tipiHandlerBuiltIn[i]);
  3026.                 if(tipoClass == null){
  3027.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.built-in.response'=...,"+tipiHandlerBuiltIn[i]+
  3028.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3029.                     return false;
  3030.                 }
  3031.                 try{
  3032.                     IntegrationManagerResponseHandler handler = (IntegrationManagerResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3033.                     handler.toString();
  3034.                 }catch(Exception e){
  3035.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.built-in.response'=...,"+tipiHandlerBuiltIn[i]+
  3036.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3037.                     return false;
  3038.                 }
  3039.             }
  3040.         }
  3041.         return true;
  3042.     }
  3043.     
  3044.     
  3045.     private boolean validateHandlersEngine(ClassNameProperties className, Loader loaderOpenSPCoop) {
  3046.         // InitHandler
  3047.         if ( this.getInitHandler() != null ){
  3048.             String[] tipiHandler = this.getInitHandler();
  3049.             // Check tipi registrati
  3050.             for(int i=0; i<tipiHandler.length;i++){
  3051.                 String tipoClass = className.getInitHandler(tipiHandler[i]);
  3052.                 if(tipoClass == null){
  3053.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.init'=...,"+tipiHandler[i]+
  3054.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3055.                     return false;
  3056.                 }
  3057.                 try{
  3058.                     InitHandler handler = (InitHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3059.                     handler.toString();
  3060.                 }catch(Exception e){
  3061.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.init'=...,"+tipiHandler[i]+
  3062.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3063.                     return false;
  3064.                 }
  3065.             }
  3066.         }
  3067.         
  3068.         // ExitHandler
  3069.         if ( this.getExitHandler() != null ){
  3070.             String[] tipiHandler = this.getExitHandler();
  3071.             // Check tipi registrati
  3072.             for(int i=0; i<tipiHandler.length;i++){
  3073.                 String tipoClass = className.getExitHandler(tipiHandler[i]);
  3074.                 if(tipoClass == null){
  3075.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.exit'=...,"+tipiHandler[i]+
  3076.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3077.                     return false;
  3078.                 }
  3079.                 try{
  3080.                     ExitHandler handler = (ExitHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3081.                     handler.toString();
  3082.                 }catch(Exception e){
  3083.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.exit'=...,"+tipiHandler[i]+
  3084.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3085.                     return false;
  3086.                 }
  3087.             }
  3088.         }
  3089.         
  3090.         // PreInRequestHandler
  3091.         if ( this.getPreInRequestHandler() != null ){
  3092.             String[] tipiHandler = this.getPreInRequestHandler();
  3093.             // Check tipi registrati
  3094.             for(int i=0; i<tipiHandler.length;i++){
  3095.                 String tipoClass = className.getPreInRequestHandler(tipiHandler[i]);
  3096.                 if(tipoClass == null){
  3097.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.pre-in-request'=...,"+tipiHandler[i]+
  3098.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3099.                     return false;
  3100.                 }
  3101.                 try{
  3102.                     PreInRequestHandler handler = (PreInRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3103.                     handler.toString();
  3104.                 }catch(Exception e){
  3105.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.pre-in-request'=...,"+tipiHandler[i]+
  3106.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3107.                     return false;
  3108.                 }
  3109.             }
  3110.         }
  3111.         // InRequestHandler
  3112.         if ( this.getInRequestHandler() != null ){
  3113.             String[] tipiHandler = this.getInRequestHandler();
  3114.             // Check tipi registrati
  3115.             for(int i=0; i<tipiHandler.length;i++){
  3116.                 String tipoClass = className.getInRequestHandler(tipiHandler[i]);
  3117.                 if(tipoClass == null){
  3118.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.in-request'=...,"+tipiHandler[i]+
  3119.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3120.                     return false;
  3121.                 }
  3122.                 try{
  3123.                     InRequestHandler handler = (InRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3124.                     handler.toString();
  3125.                 }catch(Exception e){
  3126.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.in-request'=...,"+tipiHandler[i]+
  3127.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3128.                     return false;
  3129.                 }
  3130.             }
  3131.         }
  3132.         // InRequestProtocolHandler
  3133.         if ( this.getInRequestProtocolHandler() != null ){
  3134.             String[] tipiHandler = this.getInRequestProtocolHandler();
  3135.             // Check tipi registrati
  3136.             for(int i=0; i<tipiHandler.length;i++){
  3137.                 String tipoClass = className.getInRequestProtocolHandler(tipiHandler[i]);
  3138.                 if(tipoClass == null){
  3139.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.in-protocol-request'=...,"+tipiHandler[i]+
  3140.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3141.                     return false;
  3142.                 }
  3143.                 try{
  3144.                     InRequestProtocolHandler handler = (InRequestProtocolHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3145.                     handler.toString();
  3146.                 }catch(Exception e){
  3147.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.in-protocol-request'=...,"+tipiHandler[i]+
  3148.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3149.                     return false;
  3150.                 }
  3151.             }
  3152.         }
  3153.         // OutRequestHandler
  3154.         if ( this.getOutRequestHandler() != null ){
  3155.             String[] tipiHandler = this.getOutRequestHandler();
  3156.             // Check tipi registrati
  3157.             for(int i=0; i<tipiHandler.length;i++){
  3158.                 String tipoClass = className.getOutRequestHandler(tipiHandler[i]);
  3159.                 if(tipoClass == null){
  3160.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.out-request'=...,"+tipiHandler[i]+
  3161.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3162.                     return false;
  3163.                 }
  3164.                 try{
  3165.                     OutRequestHandler handler = (OutRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3166.                     handler.toString();
  3167.                 }catch(Exception e){
  3168.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.out-request'=...,"+tipiHandler[i]+
  3169.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3170.                     return false;
  3171.                 }
  3172.             }
  3173.         }
  3174.         // PostOutRequestHandler
  3175.         if ( this.getPostOutRequestHandler() != null ){
  3176.             String[] tipiHandler = this.getPostOutRequestHandler();
  3177.             // Check tipi registrati
  3178.             for(int i=0; i<tipiHandler.length;i++){
  3179.                 String tipoClass = className.getPostOutRequestHandler(tipiHandler[i]);
  3180.                 if(tipoClass == null){
  3181.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.post-out-request'=...,"+tipiHandler[i]+
  3182.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3183.                     return false;
  3184.                 }
  3185.                 try{
  3186.                     PostOutRequestHandler handler = (PostOutRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3187.                     handler.toString();
  3188.                 }catch(Exception e){
  3189.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.post-out-request'=...,"+tipiHandler[i]+
  3190.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3191.                     return false;
  3192.                 }
  3193.             }
  3194.         }
  3195.         // PreInResponseHandler
  3196.         if ( this.getPreInResponseHandler() != null ){
  3197.             String[] tipiHandler = this.getPreInResponseHandler();
  3198.             // Check tipi registrati
  3199.             for(int i=0; i<tipiHandler.length;i++){
  3200.                 String tipoClass = className.getPreInResponseHandler(tipiHandler[i]);
  3201.                 if(tipoClass == null){
  3202.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.pre-in-response'=...,"+tipiHandler[i]+
  3203.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3204.                     return false;
  3205.                 }
  3206.                 try{
  3207.                     PreInResponseHandler handler = (PreInResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3208.                     handler.toString();
  3209.                 }catch(Exception e){
  3210.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.pre-in-response'=...,"+tipiHandler[i]+
  3211.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3212.                     return false;
  3213.                 }
  3214.             }
  3215.         }
  3216.         // InResponseHandler
  3217.         if ( this.getInResponseHandler() != null ){
  3218.             String[] tipiHandler = this.getInResponseHandler();
  3219.             // Check tipi registrati
  3220.             for(int i=0; i<tipiHandler.length;i++){
  3221.                 String tipoClass = className.getInResponseHandler(tipiHandler[i]);
  3222.                 if(tipoClass == null){
  3223.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.in-response'=...,"+tipiHandler[i]+
  3224.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3225.                     return false;
  3226.                 }
  3227.                 try{
  3228.                     InResponseHandler handler = (InResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3229.                     handler.toString();
  3230.                 }catch(Exception e){
  3231.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.in-response'=...,"+tipiHandler[i]+
  3232.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3233.                     return false;
  3234.                 }
  3235.             }
  3236.         }
  3237.         // OutResponseHandler
  3238.         if ( this.getOutResponseHandler() != null ){
  3239.             String[] tipiHandler = this.getOutResponseHandler();
  3240.             // Check tipi registrati
  3241.             for(int i=0; i<tipiHandler.length;i++){
  3242.                 String tipoClass = className.getOutResponseHandler(tipiHandler[i]);
  3243.                 if(tipoClass == null){
  3244.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.out-response'=...,"+tipiHandler[i]+
  3245.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3246.                     return false;
  3247.                 }
  3248.                 try{
  3249.                     OutResponseHandler handler = (OutResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3250.                     handler.toString();
  3251.                 }catch(Exception e){
  3252.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.out-response'=...,"+tipiHandler[i]+
  3253.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3254.                     return false;
  3255.                 }
  3256.             }
  3257.         }
  3258.         // PostOutResponseHandler
  3259.         if ( this.getPostOutResponseHandler() != null ){
  3260.             String[] tipiHandler = this.getPostOutResponseHandler();
  3261.             // Check tipi registrati
  3262.             for(int i=0; i<tipiHandler.length;i++){
  3263.                 String tipoClass = className.getPostOutResponseHandler(tipiHandler[i]);
  3264.                 if(tipoClass == null){
  3265.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.post-out-response'=...,"+tipiHandler[i]+
  3266.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3267.                     return false;
  3268.                 }
  3269.                 try{
  3270.                     PostOutResponseHandler handler = (PostOutResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3271.                     handler.toString();
  3272.                 }catch(Exception e){
  3273.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.handler.post-out-response'=...,"+tipiHandler[i]+
  3274.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3275.                     return false;
  3276.                 }
  3277.             }
  3278.         }
  3279.         // IntegrationManagerRequestHandler
  3280.         if ( this.getIntegrationManagerRequestHandler() != null ){
  3281.             String[] tipiHandler = this.getIntegrationManagerRequestHandler();
  3282.             // Check tipi registrati
  3283.             for(int i=0; i<tipiHandler.length;i++){
  3284.                 String tipoClass = className.getIntegrationManagerRequestHandler(tipiHandler[i]);
  3285.                 if(tipoClass == null){
  3286.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.request'=...,"+tipiHandler[i]+
  3287.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3288.                     return false;
  3289.                 }
  3290.                 try{
  3291.                     IntegrationManagerRequestHandler handler = (IntegrationManagerRequestHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3292.                     handler.toString();
  3293.                 }catch(Exception e){
  3294.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.request'=...,"+tipiHandler[i]+
  3295.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3296.                     return false;
  3297.                 }
  3298.             }
  3299.         }
  3300.         // IntegrationManagerResponseHandler
  3301.         if ( this.getIntegrationManagerResponseHandler() != null ){
  3302.             String[] tipiHandler = this.getIntegrationManagerResponseHandler();
  3303.             // Check tipi registrati
  3304.             for(int i=0; i<tipiHandler.length;i++){
  3305.                 String tipoClass = className.getIntegrationManagerResponseHandler(tipiHandler[i]);
  3306.                 if(tipoClass == null){
  3307.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.response'=...,"+tipiHandler[i]+
  3308.                     "'"+"\n"+TIPO_SCONOSCIUTO);
  3309.                     return false;
  3310.                 }
  3311.                 try{
  3312.                     IntegrationManagerResponseHandler handler = (IntegrationManagerResponseHandler) loaderOpenSPCoop.newInstance(tipoClass);
  3313.                     handler.toString();
  3314.                 }catch(Exception e){
  3315.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrationManager.handler.response'=...,"+tipiHandler[i]+
  3316.                             "'"+"\n"+getMessaggioClasseSconosciuta(e),e);
  3317.                     return false;
  3318.                 }
  3319.             }
  3320.         }
  3321.         return true;
  3322.     }


  3325.     public List<String> getKeywordsIntegrazioneGestioneToken(){
  3326.         List<String> keywords = new ArrayList<>();
  3327.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PROCESS_TIME);
  3328.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ISSUER);
  3329.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SUBJECT);
  3330.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_USERNAME);
  3331.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_AUDIENCE);
  3332.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_CLIENT_ID);
  3333.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ISSUED_AT);
  3334.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_EXPIRED);
  3335.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_NBF);
  3336.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ROLES);
  3337.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SCOPES);
  3338.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FULL_NAME);
  3339.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FIRST_NAME);
  3340.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_MIDDLE_NAME);
  3341.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FAMILY_NAME);
  3342.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_EMAIL);
  3343.         return keywords;
  3344.     }

  3346.     private boolean checkTipiIntegrazioneGestioneToken(){
  3347.         
  3348.         Map<?,?> prop = this.getKeyValueGestioneTokenHeaderIntegrazioneTrasporto();
  3349.         if ( prop == null ){
  3350.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.keyword.*'.");
  3351.             return false;
  3352.         }
  3353.         
  3354.         Map<String, Boolean> propSetPDtrasporto = null;
  3355.         try {
  3356.             propSetPDtrasporto = this.getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto();
  3357.         }catch(Exception e) {
  3358.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled.*'.");
  3359.             return false;
  3360.         }
  3361.         
  3362.         Map<String, Boolean> propSetPDjson = null;
  3363.         try {
  3364.             propSetPDjson = this.getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson();
  3365.         }catch(Exception e) {
  3366.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled.*'.");
  3367.             return false;
  3368.         }
  3369.         
  3370.         Map<String, Boolean> propSetPAtrasporto = null;
  3371.         try {
  3372.             propSetPAtrasporto = this.getKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto();
  3373.         }catch(Exception e) {
  3374.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled.*'.");
  3375.             return false;
  3376.         }
  3377.         
  3378.         Map<String, Boolean> propSetPAjson = null;
  3379.         try {
  3380.             propSetPAjson = this.getKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson();
  3381.         }catch(Exception e) {
  3382.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled.*'.");
  3383.             return false;
  3384.         }
  3385.         
  3386.         List<String> keywords = this.getKeywordsIntegrazioneGestioneToken();
  3387.         for (String keyword : keywords) {
  3388.             if( prop.get(keyword) == null){
  3389.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.keyword."+
  3390.                         keyword+"'.");
  3391.                 return false;
  3392.             }
  3393.             if( !propSetPDtrasporto.containsKey(keyword)){
  3394.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled."+
  3395.                         keyword+"'.");
  3396.                 return false;
  3397.             }
  3398.             if( !propSetPDjson.containsKey(keyword)){
  3399.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled."+
  3400.                         keyword+"'.");
  3401.                 return false;
  3402.             }
  3403.             if( !propSetPAtrasporto.containsKey(keyword)){
  3404.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled."+
  3405.                         keyword+"'.");
  3406.                 return false;
  3407.             }
  3408.             if( !propSetPAjson.containsKey(keyword)){
  3409.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled."+
  3410.                         keyword+"'.");
  3411.                 return false;
  3412.             }
  3413.         }
  3414.                 

  3416.         return true;
  3417.     }

  3419.     public List<MapKey<String>> getKeywordsIntegrazione(){
  3420.         return getKeywordsIntegrazioneEngine(false);
  3421.     }
  3422.     private List<MapKey<String>> getKeywordsIntegrazioneEngine(boolean all){
  3423.         List<MapKey<String>> keywords = new ArrayList<>();
  3424.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_MITTENTE);
  3425.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_MITTENTE);
  3426.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_DESTINATARIO);
  3427.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_DESTINATARIO);
  3428.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_SERVIZIO);
  3429.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_SERVIZIO);
  3430.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_VERSIONE_SERVIZIO);
  3431.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_AZIONE);
  3432.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_ID_MESSAGGIO);
  3433.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_RIFERIMENTO_MESSAGGIO);
  3434.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_COLLABORAZIONE);
  3435.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_ID_APPLICATIVO);
  3436.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_SERVIZIO_APPLICATIVO);
  3437.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_MITTENTE_TOKEN);
  3438.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_MITTENTE_TOKEN);
  3439.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_SERVIZIO_APPLICATIVO_TOKEN);
  3440.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_ID_TRANSAZIONE);
  3441.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_PROTOCOL_INFO);
  3442.         if(all) {
  3443.             keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_INFO);
  3444.             keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_USER_AGENT);
  3445.         }
  3446.         return keywords;
  3447.     }

  3449.     private boolean checkTipiIntegrazione(String[] tipiIntegrazione){
  3450.         // Check KeyWord per tipi 'trasporto' e 'urlBased' e 'soap'
  3451.         for(int i=0; i<tipiIntegrazione.length;i++){
  3452.             if(CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO.equals(tipiIntegrazione[i]) ||
  3453.                     CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED.equals(tipiIntegrazione[i]) ||
  3454.                             CostantiConfigurazione.HEADER_INTEGRAZIONE_SOAP.equals(tipiIntegrazione[i]) ){
  3455.                 
  3456.                 Map<MapKey<String>,String> propGovWay = null;
  3457.                 Map<MapKey<String>,String> propOpenSPCoop2 = null;
  3458.                 Map<MapKey<String>,String> propOpenSPCoop1 = null;
  3459.                 Map<MapKey<String>, Boolean> propSetRequestPD = null;
  3460.                 Map<MapKey<String>, Boolean> propSetResponsePD = null;
  3461.                 Map<MapKey<String>, Boolean> propReadPD = null;
  3462.                 Map<MapKey<String>, Boolean> propSetRequestPA = null;
  3463.                 Map<MapKey<String>, Boolean> propSetResponsePA = null;
  3464.                 Map<MapKey<String>, Boolean> propReadPA = null;
  3465.                 String tipo = "";
  3466.                 if(CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO.equals(tipiIntegrazione[i])){
  3467.                     if ( this.getKeyValue_HeaderIntegrazioneTrasporto() == null ){
  3468.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.keyword.*'.");
  3469.                         return false;
  3470.                     }
  3471.                     propGovWay = this.getKeyValue_HeaderIntegrazioneTrasporto();
  3472.                     propOpenSPCoop2 = this.getKeyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2();
  3473.                     propOpenSPCoop1 = this.getKeyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1();
  3474.                     try {
  3475.                         propSetRequestPD = this.getKeyPDSetEnabled_HeaderIntegrazioneTrasporto(true);
  3476.                     }catch(Exception e) {
  3477.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.pd.set.request.enabled.*'.");
  3478.                         return false;
  3479.                     }
  3480.                     try {
  3481.                         propSetResponsePD = this.getKeyPDSetEnabled_HeaderIntegrazioneTrasporto(false);
  3482.                     }catch(Exception e) {
  3483.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.pd.set.response.enabled.*'.");
  3484.                         return false;
  3485.                     }
  3486.                     try {
  3487.                         propReadPD = this.getKeyPDReadEnabled_HeaderIntegrazioneTrasporto();
  3488.                     }catch(Exception e) {
  3489.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.pd.read.enabled.*'.");
  3490.                         return false;
  3491.                     }
  3492.                     try {
  3493.                         propSetRequestPA = this.getKeyPASetEnabled_HeaderIntegrazioneTrasporto(true);
  3494.                     }catch(Exception e) {
  3495.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.pa.set.request.enabled.*'.");
  3496.                         return false;
  3497.                     }
  3498.                     try {
  3499.                         propSetResponsePA = this.getKeyPASetEnabled_HeaderIntegrazioneTrasporto(false);
  3500.                     }catch(Exception e) {
  3501.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.pa.set.response.enabled.*'.");
  3502.                         return false;
  3503.                     }
  3504.                     try {
  3505.                         propReadPA = this.getKeyPAReadEnabled_HeaderIntegrazioneTrasporto();
  3506.                     }catch(Exception e) {
  3507.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.trasporto.pa.read.enabled.*'.");
  3508.                         return false;
  3509.                     }
  3510.                     tipo=CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO;
  3511.                 }else if(CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED.equals(tipiIntegrazione[i])){
  3512.                     if ( this.getKeyValue_HeaderIntegrazioneUrlBased() == null ){
  3513.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.urlBased.keyword.*'.");
  3514.                         return false;
  3515.                     }
  3516.                     propGovWay = this.getKeyValue_HeaderIntegrazioneUrlBased();
  3517.                     propOpenSPCoop2 = this.getKeyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2();
  3518.                     propOpenSPCoop1 = this.getKeyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1();
  3519.                     try {
  3520.                         propSetRequestPD = this.getKeyPDSetEnabled_HeaderIntegrazioneUrlBased();
  3521.                     }catch(Exception e) {
  3522.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.urlBased.pd.set.enabled.*'.");
  3523.                         return false;
  3524.                     }
  3525.                     try {
  3526.                         propReadPD = this.getKeyPDReadEnabled_HeaderIntegrazioneUrlBased();
  3527.                     }catch(Exception e) {
  3528.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.urlBased.pd.read.enabled.*'.");
  3529.                         return false;
  3530.                     }
  3531.                     try {
  3532.                         propSetRequestPA = this.getKeyPASetEnabled_HeaderIntegrazioneUrlBased();
  3533.                     }catch(Exception e) {
  3534.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.urlBased.pa.set.enabled.*'.");
  3535.                         return false;
  3536.                     }
  3537.                     try {
  3538.                         propReadPA = this.getKeyPAReadEnabled_HeaderIntegrazioneUrlBased();
  3539.                     }catch(Exception e) {
  3540.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.urlBased.pa.read.enabled.*'.");
  3541.                         return false;
  3542.                     }
  3543.                     tipo=CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED;
  3544.                 }else if(CostantiConfigurazione.HEADER_INTEGRAZIONE_SOAP.equals(tipiIntegrazione[i])){
  3545.                     if ( this.getKeyValue_HeaderIntegrazioneSoap() == null ){
  3546.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.keyword.*'.");
  3547.                         return false;
  3548.                     }
  3549.                     propGovWay = this.getKeyValue_HeaderIntegrazioneSoap();
  3550.                     propOpenSPCoop2 = this.getKeyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2();
  3551.                     propOpenSPCoop1 = this.getKeyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1();
  3552.                     try {
  3553.                         propSetRequestPD = this.getKeyPDSetEnabled_HeaderIntegrazioneSoap(true);
  3554.                     }catch(Exception e) {
  3555.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pd.set.request.enabled.*'.");
  3556.                         return false;
  3557.                     }
  3558.                     try {
  3559.                         propSetResponsePD = this.getKeyPDSetEnabled_HeaderIntegrazioneSoap(false);
  3560.                     }catch(Exception e) {
  3561.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pd.set.response.enabled.*'.");
  3562.                         return false;
  3563.                     }
  3564.                     try {
  3565.                         propReadPD = this.getKeyPDReadEnabled_HeaderIntegrazioneSoap();
  3566.                     }catch(Exception e) {
  3567.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pd.read.enabled.*'.");
  3568.                         return false;
  3569.                     }
  3570.                     try {
  3571.                         propSetRequestPA = this.getKeyPASetEnabled_HeaderIntegrazioneSoap(true);
  3572.                     }catch(Exception e) {
  3573.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pa.set.request.enabled.*'.");
  3574.                         return false;
  3575.                     }
  3576.                     try {
  3577.                         propSetResponsePA = this.getKeyPASetEnabled_HeaderIntegrazioneSoap(false);
  3578.                     }catch(Exception e) {
  3579.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pa.set.response.enabled.*'.");
  3580.                         return false;
  3581.                     }
  3582.                     try {
  3583.                         propReadPA = this.getKeyPAReadEnabled_HeaderIntegrazioneSoap();
  3584.                     }catch(Exception e) {
  3585.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pa.read.enabled.*'.");
  3586.                         return false;
  3587.                     }
  3588.                     tipo=CostantiConfigurazione.HEADER_INTEGRAZIONE_SOAP;
  3589.                 }
  3590.                 
  3591.                 if(propSetRequestPD==null) {
  3592.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.soap.pd.set.request.enabled.*'. Set is null");
  3593.                     return false;
  3594.                 }
  3595.                 
  3596.                 List<MapKey<String>> keywords = this.getKeywordsIntegrazione();
  3597.                 for (MapKey<String> mapkey : keywords) {
  3598.                     
  3599.                     if(CostantiPdD.HEADER_INTEGRAZIONE_PROTOCOL_INFO.equals(mapkey)) {
  3600.                         continue; // gestito sotto come caso eccezionale
  3601.                     }
  3602.                     
  3603.                     if( propGovWay.get(mapkey) == null){
  3604.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".keyword."+
  3605.                                 mapkey+"'.");
  3606.                         return false;
  3607.                     }
  3608.                     if( propOpenSPCoop2.get(mapkey) == null){
  3609.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop2."+tipo+".keyword."+
  3610.                                 mapkey+"'.");
  3611.                         return false;
  3612.                     }
  3613.                     if( propOpenSPCoop1.get(mapkey) == null){
  3614.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione.backward_compatibility.openspcoop1."+tipo+".keyword."+
  3615.                                 mapkey.toString()+"'.");
  3616.                         return false;
  3617.                     }
  3618.                     if(CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED.equals(tipiIntegrazione[i])){
  3619.                         if( !propSetRequestPD.containsKey(mapkey)){
  3620.                             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.enabled."+
  3621.                                     mapkey+"'.");
  3622.                             return false;
  3623.                         }
  3624.                     }
  3625.                     else {
  3626.                         if( !propSetRequestPD.containsKey(mapkey)){
  3627.                             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.request.enabled."+
  3628.                                     mapkey+"'.");
  3629.                             return false;
  3630.                         }
  3631.                         if( propSetResponsePD==null || !propSetResponsePD.containsKey(mapkey)){
  3632.                             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.response.enabled."+
  3633.                                     mapkey+"'.");
  3634.                             return false;
  3635.                         }
  3636.                     }
  3637.                     if( !propReadPD.containsKey(mapkey)){
  3638.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.read.enabled."+
  3639.                                 mapkey+"'.");
  3640.                         return false;
  3641.                     }
  3642.                     if(CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED.equals(tipiIntegrazione[i])){
  3643.                         if( !propSetRequestPA.containsKey(mapkey)){
  3644.                             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.enabled."+
  3645.                                     mapkey+"'.");
  3646.                             return false;
  3647.                         }
  3648.                     }
  3649.                     else {
  3650.                         if( !propSetRequestPA.containsKey(mapkey)){
  3651.                             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.request.enabled."+
  3652.                                     mapkey+"'.");
  3653.                             return false;
  3654.                         }
  3655.                         if( !propSetResponsePA.containsKey(mapkey)){
  3656.                             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.response.enabled."+
  3657.                                     mapkey+"'.");
  3658.                             return false;
  3659.                         }
  3660.                     }
  3661.                     if( !propReadPA.containsKey(mapkey)){
  3662.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.read.enabled."+
  3663.                                 mapkey+"'.");
  3664.                         return false;
  3665.                     }
  3666.                 }
  3667.                 
  3668.                 MapKey<String> mapkey = CostantiPdD.HEADER_INTEGRAZIONE_INFO;
  3669.                 if(CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED.equals(tipiIntegrazione[i])){
  3670.                     if( !propSetRequestPD.containsKey(mapkey)){
  3671.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.enabled."+
  3672.                                 mapkey+"'.");
  3673.                         return false;
  3674.                     }
  3675.                     if( !propSetRequestPA.containsKey(mapkey)){
  3676.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.enabled."+
  3677.                                 mapkey+"'.");
  3678.                         return false;
  3679.                     }
  3680.                 }
  3681.                 else {
  3682.                     if( !propSetRequestPD.containsKey(mapkey)){
  3683.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.request.enabled."+
  3684.                                 mapkey+"'.");
  3685.                         return false;
  3686.                     }
  3687.                     if( propSetResponsePD==null || !propSetResponsePD.containsKey(mapkey)){
  3688.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.response.enabled."+
  3689.                                 mapkey+"'.");
  3690.                         return false;
  3691.                     }
  3692.                     if( !propSetRequestPA.containsKey(mapkey)){
  3693.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.request.enabled."+
  3694.                                 mapkey+"'.");
  3695.                         return false;
  3696.                     }
  3697.                     if( !propSetResponsePA.containsKey(mapkey)){
  3698.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.response.enabled."+
  3699.                                 mapkey+"'.");
  3700.                         return false;
  3701.                     }
  3702.                 }
  3703.                 
  3704.                 if(CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO.equals(tipo)) {
  3705.                     mapkey = CostantiPdD.HEADER_INTEGRAZIONE_USER_AGENT;
  3706.                     if( !propSetRequestPD.containsKey(mapkey)){
  3707.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.request.enabled."+
  3708.                                 mapkey+"'.");
  3709.                         return false;
  3710.                     }
  3711.                     if( propSetResponsePD==null || !propSetResponsePD.containsKey(mapkey)){
  3712.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.response.enabled."+
  3713.                                 mapkey+"'.");
  3714.                         return false;
  3715.                     }
  3716.                     if( !propSetRequestPA.containsKey(mapkey)){
  3717.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.request.enabled."+
  3718.                                 mapkey+"'.");
  3719.                         return false;
  3720.                     }
  3721.                     if( !propSetResponsePA.containsKey(mapkey)){
  3722.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.response.enabled."+
  3723.                                 mapkey+"'.");
  3724.                         return false;
  3725.                     }
  3726.                 }
  3727.                 
  3728.                 mapkey = CostantiPdD.HEADER_INTEGRAZIONE_PROTOCOL_INFO;
  3729.                 if(CostantiConfigurazione.HEADER_INTEGRAZIONE_URL_BASED.equals(tipiIntegrazione[i])){
  3730.                     if( !propSetRequestPD.containsKey(mapkey)){
  3731.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.enabled."+
  3732.                                 mapkey+"'.");
  3733.                         return false;
  3734.                     }
  3735.                     if( !propSetRequestPA.containsKey(mapkey)){
  3736.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.enabled."+
  3737.                                 mapkey+"'.");
  3738.                         return false;
  3739.                     }
  3740.                 }
  3741.                 else {
  3742.                     if( !propSetRequestPD.containsKey(mapkey)){
  3743.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.request.enabled."+
  3744.                                 mapkey+"'.");
  3745.                         return false;
  3746.                     }
  3747.                     if( propSetResponsePD==null || !propSetResponsePD.containsKey(mapkey)){
  3748.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pd.set.response.enabled."+
  3749.                                 mapkey+"'.");
  3750.                         return false;
  3751.                     }
  3752.                     if( !propSetRequestPA.containsKey(mapkey)){
  3753.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.request.enabled."+
  3754.                                 mapkey+"'.");
  3755.                         return false;
  3756.                     }
  3757.                     if( !propSetResponsePA.containsKey(mapkey)){
  3758.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.integrazione."+tipo+".pa.set.response.enabled."+
  3759.                                 mapkey+"'.");
  3760.                         return false;
  3761.                     }
  3762.                 }
  3763.                 
  3764.             }
  3765.             
  3766.             
  3767.             if(CostantiConfigurazione.HEADER_INTEGRAZIONE_SOAP.equals(tipiIntegrazione[i])){
  3768.                 if ( this.getHeaderSoapNameIntegrazione() == null ){
  3769.                     return false;
  3770.                 }
  3771.                 if ( this.getHeaderSoapNameIntegrazione_backwardCompatibility_openspcoop2() == null ){
  3772.                     return false;
  3773.                 }
  3774.                 if ( this.getHeaderSoapNameIntegrazione_backwardCompatibility_openspcoop1() == null ){
  3775.                     return false;
  3776.                 }
  3777.                 
  3778.                 if ( this.getHeaderSoapActorIntegrazione() == null ){
  3779.                     return false;
  3780.                 }
  3781.                 if ( this.getHeaderSoapActorIntegrazione_backwardCompatibility_openspcoop2() == null ){
  3782.                     return false;
  3783.                 }
  3784.                 if ( this.getHeaderSoapActorIntegrazione_backwardCompatibility_openspcoop1() == null ){
  3785.                     return false;
  3786.                 }
  3787.                 
  3788.                 if ( this.getHeaderSoapPrefixIntegrazione() == null ){
  3789.                     return false;
  3790.                 }
  3791.                 if ( this.getHeaderSoapPrefixIntegrazione_backwardCompatibility_openspcoop2() == null ){
  3792.                     return false;
  3793.                 }
  3794.                 if ( this.getHeaderSoapPrefixIntegrazione_backwardCompatibility_openspcoop1() == null ){
  3795.                     return false;
  3796.                 }
  3797.                 
  3798.                 if ( this.getHeaderSoapExtProtocolInfoNomeElementoIntegrazione() == null ){
  3799.                     return false;
  3800.                 }
  3801.                 if ( this.getHeaderSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2() == null ){
  3802.                     return false;
  3803.                 }
  3804.                 if ( this.getHeaderSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1() == null ){
  3805.                     return false;
  3806.                 }
  3807.                 
  3808.                 if ( this.getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione() == null ){
  3809.                     return false;
  3810.                 }
  3811.                 if ( this.getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2() == null ){
  3812.                     return false;
  3813.                 }
  3814.                 if ( this.getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1() == null ){
  3815.                     return false;
  3816.                 }
  3817.             }
  3818.             
  3819.         }
  3820.         return true;
  3821.     }














  3836.     /* ********  CONF DIRECTORY  ******** */

  3838.     /**
  3839.      * Restituisce la directory di configurazione di OpenSPCoop.
  3840.      *
  3841.      * @return la directory di configurazione di OpenSPCoop.
  3842.      * 
  3843.      */
  3844.     private String rootDirectory = null;
  3845.     public String getRootDirectory() {  
  3846.         if(this.rootDirectory==null){
  3847.             try{ 
  3848.                 String root = null;
  3849.                 root = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.confDirectory");

  3851.                 if(root==null)
  3852.                     throw new CoreException(NON_DEFINITA);

  3854.                 root = root.trim();

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

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

  3866.         return this.rootDirectory;
  3867.     }

  3869.     /**
  3870.      * Restituisce L'indicazione se il server è un server J2EE o WEB
  3871.      *
  3872.      * @return indicazione se il server è un server J2EE o WEB
  3873.      * 
  3874.      */
  3875.     private Boolean serverJ2EE = null;
  3876.     public Boolean isServerJ2EE() { 
  3877.         if(this.serverJ2EE==null){
  3878.             try{ 
  3879.                 String server = null;
  3880.                 server = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.server");

  3882.                 if(server==null)
  3883.                     throw new CoreException(NON_DEFINITA);

  3885.                 server = server.trim();

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

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

  3901.         return this.serverJ2EE;
  3902.     }

  3904.     private Boolean getClassLoaderRead = null;
  3905.     private String getClassLoader = null;
  3906.     public String getClassLoader(){

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

  3912.                 if (value != null){
  3913.                     value = value.trim();
  3914.                     this.getClassLoader = value;
  3915.                 }

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

  3923.         return this.getClassLoader;
  3924.     }

  3926.     private String productName = null;
  3927.     public String getProductName() {    
  3928.         if(this.productName==null){
  3929.             try{ 
  3930.                 String v = null;
  3931.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.productName");
  3932.                 if(v!=null){
  3933.                     v = v.trim();
  3934.                     this.productName = v;
  3935.                 }else{
  3936.                     this.productName = CostantiPdD.OPENSPCOOP2_PRODUCT;
  3937.                 }
  3938.             }catch(java.lang.Exception e) {
  3939.                 this.productName = CostantiPdD.OPENSPCOOP2_PRODUCT;
  3940.             }    
  3941.         }
  3942.         return this.productName;
  3943.     }
  3944.     
  3945.     private String versione = null;
  3946.     public String getVersione() {   
  3947.         if(this.versione==null){
  3948.             try{ 
  3949.                 String v = null;
  3950.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.versione");
  3951.                 if(v!=null){
  3952.                     v = v.trim();
  3953.                     this.versione = v;
  3954.                 }else{
  3955.                     this.versione = getVersionePdD(null);
  3956.                 }
  3957.             }catch(java.lang.Exception e) {
  3958.                 this.versione = CostantiPdD.OPENSPCOOP2_PRODUCT_VERSION;
  3959.             }    
  3960.         }
  3961.         return this.versione;
  3962.     }
  3963.     public static String getVersionePdD(OpenSPCoop2Properties properties) {
  3964.         String versione = CostantiPdD.OPENSPCOOP2_PRODUCT_VERSION;
  3965.         if(properties!=null){
  3966.             versione = properties.getPddDetailsForServices();
  3967.         }
  3968.         
  3969.         try {
  3970.             String version = VersionUtilities.readVersion();
  3971.             if(version!=null && !StringUtils.isEmpty(version)) {
  3972.                 versione = version;
  3973.             }
  3974.         }catch(Exception e) {
  3975.             // ignore
  3976.         }
  3977.         
  3978.         String buildVersion = null;
  3979.         try {
  3980.             buildVersion = VersionUtilities.readBuildVersion();
  3981.         }catch(Exception e) {
  3982.             // ignore
  3983.         }
  3984.         if(buildVersion!=null) {
  3985.             versione = versione + " (build "+buildVersion+")";
  3986.         }
  3987.         return versione;
  3988.     }
  3989.     
  3990.     private String details = null;
  3991.     public String getDetails() {    
  3992.         if(this.details==null){
  3993.             try{ 
  3994.                 String v = null;
  3995.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.details");
  3996.                 if(v!=null){
  3997.                     v = v.trim();
  3998.                     this.details = v;
  3999.                 }else{
  4000.                     this.details = CostantiPdD.OPENSPCOOP2_DETAILS;
  4001.                 }
  4002.             }catch(java.lang.Exception e) {
  4003.                 this.details = CostantiPdD.OPENSPCOOP2_DETAILS;
  4004.             }    
  4005.         }
  4006.         return this.details;
  4007.     }
  4008.     
  4009.     private String getPddDetailsForLog = null;
  4010.     public String getPddDetailsForLog() {   
  4011.         if(this.getPddDetailsForLog==null){
  4012.             try{ 
  4013.                 String v = null;
  4014.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.log.details");
  4015.                 if(v!=null){
  4016.                     v = v.trim();
  4017.                     this.getPddDetailsForLog = v;
  4018.                 }else{
  4019.                     this.getPddDetailsForLog = getDefaultLogVersionDetails();
  4020.                 }
  4021.             }catch(java.lang.Exception e) {
  4022.                 this.getPddDetailsForLog = getDefaultLogVersionDetails();
  4023.             }    
  4024.         }
  4025.         return this.getPddDetailsForLog;
  4026.     }
  4027.     
  4028.     private String getDefaultLogVersionDetails() {
  4029.         String d = this.getDetails();
  4030.         if(d!=null && !"".equals(d))
  4031.             return this.getVersione()+" ("+d+")";
  4032.         else
  4033.             return this.getVersione();
  4034.     }

  4036.     private String getPddDetailsForServices = null;
  4037.     public String getPddDetailsForServices() {  
  4038.         if(this.getPddDetailsForServices==null){
  4039.             try{ 
  4040.                 String v = null;
  4041.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.details");
  4042.                 if(v!=null){
  4043.                     v = v.trim();
  4044.                     this.getPddDetailsForServices = v;
  4045.                 }else{
  4046.                     this.getPddDetailsForServices = this.getVersione();
  4047.                 }
  4048.             }catch(java.lang.Exception e) {
  4049.                 this.getPddDetailsForServices = this.getVersione();
  4050.             }    
  4051.         }
  4052.         return this.getPddDetailsForServices;
  4053.     }
  4054.     
  4055.     private StatoFunzionalitaConWarning getCheckOpenSPCoopHome = null;
  4056.     public StatoFunzionalitaConWarning getCheckOpenSPCoopHome() {   
  4057.         if(this.getCheckOpenSPCoopHome==null){
  4058.             try{ 
  4059.                 String v = null;
  4060.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.checkHomeProperty");
  4061.                 if(v!=null){
  4062.                     v = v.trim();
  4063.                     this.getCheckOpenSPCoopHome = (StatoFunzionalitaConWarning) StatoFunzionalitaConWarning.toEnumConstantFromString(v);
  4064.                     if(this.getCheckOpenSPCoopHome==null){
  4065.                         throw new CoreException("Valore inatteso: "+v);
  4066.                     }
  4067.                 }else{
  4068.                     this.getCheckOpenSPCoopHome = StatoFunzionalitaConWarning.DISABILITATO;
  4069.                 }
  4070.             }catch(java.lang.Exception e) {
  4071.                 e.printStackTrace(System.out);
  4072.                 this.getCheckOpenSPCoopHome = StatoFunzionalitaConWarning.DISABILITATO;
  4073.             }    
  4074.         }
  4075.         return this.getCheckOpenSPCoopHome;
  4076.     }
  4077.     
  4078.     public void checkOpenSPCoopHome() throws CoreException{
  4079.         if(!StatoFunzionalitaConWarning.DISABILITATO.equals(this.getCheckOpenSPCoopHome())){
  4080.             Exception e = null;
  4081.             boolean foundSystem = false;
  4082.             try{
  4083.                 String dir = System.getProperty(CostantiPdD.OPENSPCOOP2_LOCAL_HOME);
  4084.                 if(dir==null || "".equals(dir)){
  4085.                     throw new CoreException("Variabile java ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non trovata");
  4086.                 }
  4087.                 foundSystem = true;
  4088.                 File fDir = new File(dir);
  4089.                 if(!fDir.exists()){
  4090.                     throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile java ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non esiste");
  4091.                 }
  4092.                 if(!fDir.isDirectory()){
  4093.                     throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile java ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non è una directory");
  4094.                 }
  4095.                 if(!fDir.canRead()){
  4096.                     throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile java ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non è accessibile in lettura");
  4097.                 }
  4098.             }catch(Exception eTh){
  4099.                 e = eTh;
  4100.             }
  4101.             try{
  4102.                 // NOTA: nel caricamento la variabile di sistema vince sulla variabile java
  4103.                 String dir = System.getenv(CostantiPdD.OPENSPCOOP2_LOCAL_HOME);
  4104.                 if(dir==null || "".equals(dir)){
  4105.                     if(!foundSystem){
  4106.                         throw new CoreException("Ne variabile java ne variabile di sistema ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] trovata");
  4107.                     }
  4108.                 }
  4109.                 else{
  4110.                     File fDir = new File(dir);
  4111.                     if(!fDir.exists()){
  4112.                         throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile di sistema ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non esiste");
  4113.                     }
  4114.                     if(!fDir.isDirectory()){
  4115.                         throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile di sistema ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non è una directory");
  4116.                     }
  4117.                     if(!fDir.canRead()){
  4118.                         throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile di sistema ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non è accessibile in lettura");
  4119.                     }
  4120.                     // trovata.
  4121.                     // annullo una eventuale eccezione di sistema
  4122.                     e = null;
  4123.                 }
  4124.             }catch(Exception eTh){
  4125.                 if(e==null)
  4126.                     e = eTh;
  4127.                 else{
  4128.                     e = new Exception(e.getMessage()+" - "+eTh.getMessage(),eTh);
  4129.                 }
  4130.             }
  4131.             if(e!=null){
  4132.                 throw new CoreException(e.getMessage(),e);
  4133.             }
  4134.         }
  4135.     }
  4136.     
  4137.     




  4142.     /* ********  CONFIGURAZIONE DI OPENSPCOOP  ******** */

  4144.     /**
  4145.      * Restituisce la location della configurazione della porta di dominio di OpenSPCoop,
  4146.      *
  4147.      * @return il path del file di configurazione della porta di dominio in caso di ricerca con successo, null altrimenti.
  4148.      * 
  4149.      */
  4150.     private String pathConfigurazionePDD = null;
  4151.     public String getPathConfigurazionePDD() {  
  4152.         if(this.pathConfigurazionePDD==null){
  4153.             try{  
  4154.                 String indirizzo = this.reader.getValue("org.openspcoop2.pdd.config.location"); 
  4155.                 if(indirizzo==null)
  4156.                     throw new CoreException(NON_DEFINITA);

  4158.                 indirizzo = indirizzo.trim();

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

  4162.                     if( (!indirizzo.startsWith("http://")) && (!indirizzo.startsWith("file://")) ){
  4163.                         if(!indirizzo.startsWith("${")){
  4164.                             String root = getRootDirectory();
  4165.                             indirizzo = root+indirizzo;
  4166.                         }
  4167.                         while (indirizzo.indexOf("${")!=-1){
  4168.                             int indexStart = indirizzo.indexOf("${");
  4169.                             int indexEnd = indirizzo.indexOf("}");
  4170.                             if(indexEnd==-1){
  4171.                                 throw new CoreException("errore durante l'interpretazione del path ["+indirizzo+"]: ${ utilizzato senza la rispettiva chiusura }");
  4172.                             }
  4173.                             String nameSystemProperty = indirizzo.substring(indexStart+"${".length(),indexEnd);
  4174.                             String valueSystemProperty = System.getProperty(nameSystemProperty);
  4175.                             if(valueSystemProperty==null){
  4176.                                 throw new CoreException("errore durante l'interpretazione del path ["+indirizzo+"]: variabile di sistema ${"+nameSystemProperty+"} non esistente");
  4177.                             }
  4178.                             indirizzo = indirizzo.replace("${"+nameSystemProperty+"}", valueSystemProperty);
  4179.                         }
  4180.                     }

  4182.                 }

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

  4191.         return this.pathConfigurazionePDD;
  4192.     } 

  4194.     private List<byte[]> configPreLoadingLocale = null;
  4195.     private Boolean configPreLoadingLocaleRead = null;
  4196.     public List<byte[]> getConfigPreLoadingLocale() {   
  4197.         if(this.configPreLoadingLocaleRead==null){
  4198.             try{ 
  4199.                 String resourceTmp = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.config.preLoading.locale");
  4200.                 if(resourceTmp!=null){
  4201.                     resourceTmp = resourceTmp.trim();
  4202.                     
  4203.                     List<String> lResources = new ArrayList<>();
  4204.                     initSplitValues(lResources, resourceTmp, false);
  4205.                     
  4206.                     this.configPreLoadingLocale = new ArrayList<>();
  4207.                     
  4208.                     for (String resource : lResources) {
  4209.                         File f = new File(resource);
  4210.                         if(f.exists()) {
  4211.                             this.configPreLoadingLocale.add(FileSystemUtilities.readBytesFromFile(f));
  4212.                         }
  4213.                         else {
  4214.                             if(!resource.startsWith("/")) {
  4215.                                 resource = "/" + resource;
  4216.                             }
  4217.                             InputStream is = OpenSPCoop2Properties.class.getResourceAsStream(resource);
  4218.                             if(is!=null) {
  4219.                                 try {
  4220.                                     this.configPreLoadingLocale.add(Utilities.getAsByteArray(is));
  4221.                                 }finally {
  4222.                                     try {
  4223.                                         is.close();
  4224.                                     }catch(Exception eClose) {
  4225.                                         // close
  4226.                                     }
  4227.                                 }
  4228.                             }
  4229.                         }   
  4230.                     }
  4231.                     
  4232.                 }

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

  4242.         return this.configPreLoadingLocale;
  4243.     }
  4244.     
  4245.     /**
  4246.      * Restituisce il tipo di configurazione della porta di dominio di OpenSPCoop.
  4247.      *
  4248.      * @return il tipo di configurazione della porta di dominio, null altrimenti.
  4249.      * 
  4250.      */
  4251.     private String tipoConfigurazionePDD = null;
  4252.     public String getTipoConfigurazionePDD() {  
  4253.         if(this.tipoConfigurazionePDD==null){
  4254.             try{ 
  4255.                 String tipo = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.config.tipo");
  4256.                 if(tipo==null)
  4257.                     throw new CoreException(NON_DEFINITA);
  4258.                 tipo = tipo.trim();

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

  4267.         return this.tipoConfigurazionePDD;
  4268.     }

  4270.     /**
  4271.      * Restituisce l'indicazione Se si desidera condividere i due database config e regserv
  4272.      *
  4273.      * @return l'indicazione Se si desidera condividere i due database config e regserv
  4274.      * 
  4275.      */
  4276.     private Boolean isCondivisioneConfigurazioneRegistroDB = null;
  4277.     public boolean isCondivisioneConfigurazioneRegistroDB() {   
  4278.         if(this.isCondivisioneConfigurazioneRegistroDB==null){
  4279.             try{ 
  4280.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.config.db.condivisioneDBRegserv");
  4281.                 if(value==null)
  4282.                     this.isCondivisioneConfigurazioneRegistroDB = false;
  4283.                 else{
  4284.                     this.isCondivisioneConfigurazioneRegistroDB = Boolean.parseBoolean(value);
  4285.                 }
  4286.             }catch(java.lang.Exception e) {
  4287.                 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);
  4288.                 this.isCondivisioneConfigurazioneRegistroDB = false;
  4289.             }    
  4290.         }

  4292.         return this.isCondivisioneConfigurazioneRegistroDB;
  4293.     }

  4295.     /**
  4296.      * Restituisce le proprieta' da utilizzare con il contesto JNDI di lookup, se impostate.
  4297.      *
  4298.      * @return proprieta' da utilizzare con il contesto JNDI di lookup.
  4299.      * 
  4300.      */
  4301.     private java.util.Properties jndiContext_Configurazione = null;
  4302.     public java.util.Properties getJNDIContext_Configurazione() {   
  4303.         if(this.jndiContext_Configurazione==null){
  4304.             java.util.Properties prop = new java.util.Properties();
  4305.             try{ 

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

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

  4316.         return this.jndiContext_Configurazione;
  4317.     }

  4319.     
  4320.     private AccessoConfigurazionePdD accessoConfigurazionePdD = null;
  4321.     public AccessoConfigurazionePdD getAccessoConfigurazionePdD() throws OpenSPCoop2ConfigurationException{ 
  4322.         if(this.accessoConfigurazionePdD==null){
  4323.             try{  
  4324.                 AccessoConfigurazionePdD conf = new AccessoConfigurazionePdD();
  4325.                 conf.setTipo(this.getTipoConfigurazionePDD());
  4326.                 if(CostantiConfigurazione.CONFIGURAZIONE_DB.equalsIgnoreCase(this.getTipoConfigurazionePDD())){ 
  4327.                     String tipoDatabase = null;
  4328.                     String location = null;
  4329.                     if(this.getPathConfigurazionePDD().indexOf("@")!=-1){
  4330.                         // estrazione tipo database
  4331.                         tipoDatabase = DBUtils.estraiTipoDatabaseFromLocation(this.getPathConfigurazionePDD());
  4332.                         location = this.getPathConfigurazionePDD().substring(this.getPathConfigurazionePDD().indexOf("@")+1);
  4333.                     }else{
  4334.                         tipoDatabase = this.getDatabaseType();
  4335.                         location =this.getPathConfigurazionePDD();
  4336.                     }
  4337.                     conf.setLocation(location);
  4338.                     conf.setTipoDatabase(tipoDatabase);
  4339.                 }else{
  4340.                     conf.setLocation(this.getPathConfigurazionePDD());
  4341.                 }
  4342.                 conf.setContext(this.getJNDIContext_Configurazione());
  4343.                 conf.setCondivisioneDatabasePddRegistro(this.isCondivisioneConfigurazioneRegistroDB());
  4344.                 
  4345.                 this.accessoConfigurazionePdD = conf;
  4346.             }catch(java.lang.Exception e) {
  4347.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della modalita' di accesso alla configurazione della PdD OpenSPCoop",e);
  4348.             }
  4349.         }

  4351.         return this.accessoConfigurazionePdD;
  4352.     }

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

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

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

  4381.         return this.isConfigurazioneDinamica_value;
  4382.     }
  4383.     
  4384.     private Boolean isConfigurazioneCache_ConfigPrefill_value = null;
  4385.     public boolean isConfigurazioneCache_ConfigPrefill(){
  4386.         if(this.isConfigurazioneCache_ConfigPrefill_value==null){
  4387.             try{  
  4388.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cache.config.prefill"); 

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

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

  4404.         return this.isConfigurazioneCache_ConfigPrefill_value;
  4405.     }
  4406.     
  4407.     private Boolean isConfigurazioneCache_RegistryPrefill_value = null;
  4408.     public boolean isConfigurazioneCache_RegistryPrefill(){
  4409.         if(this.isConfigurazioneCache_RegistryPrefill_value==null){
  4410.             try{  
  4411.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cache.registry.prefill"); 

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

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

  4427.         return this.isConfigurazioneCache_RegistryPrefill_value;
  4428.     }
  4429.     
  4430.     private Boolean isConfigurazioneCache_accessiSynchronized = null;
  4431.     public boolean isConfigurazioneCache_accessiSynchronized(){
  4432.         if(this.isConfigurazioneCache_accessiSynchronized==null){
  4433.             try{  
  4434.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cache.get.synchronized"); 

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

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

  4450.         return this.isConfigurazioneCache_accessiSynchronized;
  4451.     }
  4452.     
  4453.     private Boolean isConfigurazioneCache_transactionContext_accessiSynchronized = null;
  4454.     public boolean isConfigurazioneCache_transactionContext_accessiSynchronized(){
  4455.         if(this.isConfigurazioneCache_transactionContext_accessiSynchronized==null){
  4456.             try{  
  4457.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cache.transactionContext.synchronized"); 

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

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

  4473.         return this.isConfigurazioneCache_transactionContext_accessiSynchronized;
  4474.     }

  4476.     private CacheType readCacheTypeConfig = null;
  4477.     public CacheType getCacheTypeConfig() {
  4478.         if(this.readCacheTypeConfig==null) {
  4479.             this.readCacheTypeConfig = readCacheType("org.openspcoop2.pdd.cache.impl.config");
  4480.         }
  4481.         return this.readCacheTypeConfig;
  4482.     }
  4483.     
  4484.     private CacheType readCacheTypeRegistry = null;
  4485.     public CacheType getCacheTypeRegistry() {
  4486.         if(this.readCacheTypeRegistry==null) {
  4487.             this.readCacheTypeRegistry = readCacheType("org.openspcoop2.pdd.cache.impl.registry");
  4488.         }
  4489.         return this.readCacheTypeRegistry;
  4490.     }
  4491.     
  4492.     private CacheType readCacheTypeAuthentication = null;
  4493.     public CacheType getCacheTypeAuthentication() {
  4494.         if(this.readCacheTypeAuthentication==null) {
  4495.             this.readCacheTypeAuthentication = readCacheType("org.openspcoop2.pdd.cache.impl.authentication");
  4496.         }
  4497.         return this.readCacheTypeAuthentication;
  4498.     }
  4499.     
  4500.     private CacheType readCacheTypeAuthorization = null;
  4501.     public CacheType getCacheTypeAuthorization() {
  4502.         if(this.readCacheTypeAuthorization==null) {
  4503.             this.readCacheTypeAuthorization = readCacheType("org.openspcoop2.pdd.cache.impl.authorization");
  4504.         }
  4505.         return this.readCacheTypeAuthorization;
  4506.     }
  4507.     
  4508.     private CacheType readCacheTypeResponseCaching = null;
  4509.     public CacheType getCacheTypeResponseCaching() {
  4510.         if(this.readCacheTypeResponseCaching==null) {
  4511.             this.readCacheTypeResponseCaching = readCacheType("org.openspcoop2.pdd.cache.impl.responseCaching");
  4512.         }
  4513.         return this.readCacheTypeResponseCaching;
  4514.     }

  4516.     private CacheType readCacheTypeToken = null;
  4517.     public CacheType getCacheTypeToken() {
  4518.         if(this.readCacheTypeToken==null) {
  4519.             this.readCacheTypeToken = readCacheType("org.openspcoop2.pdd.cache.impl.token");
  4520.         }
  4521.         return this.readCacheTypeToken;
  4522.     }
  4523.     
  4524.     private CacheType readCacheTypeAttributeAuthority = null;
  4525.     public CacheType getCacheTypeAttributeAuthority() {
  4526.         if(this.readCacheTypeAttributeAuthority==null) {
  4527.             this.readCacheTypeAttributeAuthority = readCacheType("org.openspcoop2.pdd.cache.impl.attributeAuthority");
  4528.         }
  4529.         return this.readCacheTypeAttributeAuthority;
  4530.     }
  4531.     
  4532.     private CacheType readCacheTypeKeystore = null;
  4533.     public CacheType getCacheTypeKeystore() {
  4534.         if(this.readCacheTypeKeystore==null) {
  4535.             this.readCacheTypeKeystore = readCacheType("org.openspcoop2.pdd.cache.impl.keystore");
  4536.         }
  4537.         return this.readCacheTypeKeystore;
  4538.     }
  4539.     
  4540.     private CacheType readCacheTypeLoadBalancer = null;
  4541.     public CacheType getCacheTypeLoadBalancer() {
  4542.         if(this.readCacheTypeLoadBalancer==null) {
  4543.             this.readCacheTypeLoadBalancer = readCacheType("org.openspcoop2.pdd.cache.impl.loadBalancer");
  4544.         }
  4545.         return this.readCacheTypeLoadBalancer;
  4546.     }
  4547.     
  4548.     private CacheType readCacheTypeTrafficControl = null;
  4549.     public CacheType getCacheTypeTrafficControl() {
  4550.         if(this.readCacheTypeTrafficControl==null) {
  4551.             this.readCacheTypeTrafficControl = readCacheType("org.openspcoop2.pdd.cache.impl.trafficControl");
  4552.         }
  4553.         return this.readCacheTypeTrafficControl;
  4554.     }
  4555.     
  4556.     private CacheType readCacheTypeMessage = null;
  4557.     public CacheType getCacheTypeMessage() {
  4558.         if(this.readCacheTypeMessage==null) {
  4559.             this.readCacheTypeMessage = readCacheType("org.openspcoop2.pdd.cache.impl.message");
  4560.         }
  4561.         return this.readCacheTypeMessage;
  4562.     }
  4563.     
  4564.     private CacheType readCacheTypeRequestManager = null;
  4565.     public CacheType getCacheTypeRequestManager() {
  4566.         if(this.readCacheTypeRequestManager==null) {
  4567.             this.readCacheTypeRequestManager = readCacheType("org.openspcoop2.pdd.cache.impl.requestManager");
  4568.         }
  4569.         return this.readCacheTypeRequestManager;
  4570.     }
  4571.     
  4572.     
  4573.     public CacheType readCacheType(String pName){
  4574.         try{  
  4575.             String value = this.reader.getValueConvertEnvProperties(pName); 

  4577.             if(value!=null){
  4578.                 value = value.trim();
  4579.                 return CacheType.valueOf(value);
  4580.             }else{
  4581.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,CacheType.JCS.toString()));
  4582.                 return CacheType.JCS;
  4583.             }

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

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

  4598.                 if(value!=null){
  4599.                     value = value.trim();
  4600.                     this.isConfigurazioneCacheDebug = Boolean.parseBoolean(value);
  4601.                 }else{
  4602.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  4603.                     this.isConfigurazioneCacheDebug = false;
  4604.                 }

  4606.             }catch(java.lang.Exception e) {
  4607.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  4608.                 this.isConfigurazioneCacheDebug = false;
  4609.             }
  4610.         }

  4612.         return this.isConfigurazioneCacheDebug;
  4613.     }
  4614.     
  4615.     private Boolean isConfigurazioneCacheRequestManagerUseCache = null;
  4616.     public boolean isConfigurazioneCacheRequestManagerUseCache(){
  4617.         if(this.isConfigurazioneCacheRequestManagerUseCache==null){
  4618.             String pName = "org.openspcoop2.pdd.cache.impl.requestManager.useCache";
  4619.             try{  
  4620.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  4622.                 if(value!=null){
  4623.                     value = value.trim();
  4624.                     this.isConfigurazioneCacheRequestManagerUseCache = Boolean.parseBoolean(value);
  4625.                 }else{
  4626.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4627.                     this.isConfigurazioneCacheRequestManagerUseCache = true;
  4628.                 }

  4630.             }catch(java.lang.Exception e) {
  4631.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  4632.                 this.isConfigurazioneCacheRequestManagerUseCache = true;
  4633.             }
  4634.         }

  4636.         return this.isConfigurazioneCacheRequestManagerUseCache;
  4637.     }
  4638.     
  4639.     private Boolean isConfigurazioneCacheRequestManagerExternalResourceSaveInCache = null;
  4640.     public boolean isConfigurazioneCacheRequestManagerExternalResourceSaveInCache() {   
  4641.         if(this.isConfigurazioneCacheRequestManagerExternalResourceSaveInCache==null){
  4642.             String pName = "org.openspcoop2.pdd.cache.impl.requestManager.externalResource.saveInCache";
  4643.             try{ 
  4644.                 String name = null;
  4645.                 name = this.reader.getValueConvertEnvProperties(pName);
  4646.                 if(name==null){
  4647.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  4648.                     name="false";
  4649.                 }
  4650.                 name = name.trim();
  4651.                 this.isConfigurazioneCacheRequestManagerExternalResourceSaveInCache = Boolean.parseBoolean(name);
  4652.             } catch(java.lang.Exception e) {
  4653.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  4654.                 this.isConfigurazioneCacheRequestManagerExternalResourceSaveInCache = false;
  4655.             }    
  4656.         }

  4658.         return this.isConfigurazioneCacheRequestManagerExternalResourceSaveInCache;
  4659.     }
  4660.     
  4661.     private Boolean isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache = null;
  4662.     public boolean isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache() {   
  4663.         if(this.isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache==null){
  4664.             String pName = "org.openspcoop2.pdd.cache.impl.requestManager.ocspResponse.saveInCache";
  4665.             try{ 
  4666.                 String name = null;
  4667.                 name = this.reader.getValueConvertEnvProperties(pName);
  4668.                 if(name==null){
  4669.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  4670.                     name="false";
  4671.                 }
  4672.                 name = name.trim();
  4673.                 this.isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache = Boolean.parseBoolean(name);
  4674.             } catch(java.lang.Exception e) {
  4675.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  4676.                 this.isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache = false;
  4677.             }    
  4678.         }

  4680.         return this.isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache;
  4681.     }
  4682.     
  4683.     private Boolean isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache = null;
  4684.     public boolean isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache() {    
  4685.         if(this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache==null){
  4686.             String pName = "org.openspcoop2.pdd.cache.impl.requestManager.remoteStore.saveInCache";
  4687.             try{ 
  4688.                 String name = null;
  4689.                 name = this.reader.getValueConvertEnvProperties(pName);
  4690.                 if(name==null){
  4691.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  4692.                     name="false";
  4693.                 }
  4694.                 name = name.trim();
  4695.                 this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache = Boolean.parseBoolean(name);
  4696.             } catch(java.lang.Exception e) {
  4697.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  4698.                 this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache = false;
  4699.             }    
  4700.         }

  4702.         return this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache;
  4703.     }
  4704.     
  4705.     
  4706.     
  4707.     private Boolean isConfigurazioneKeystoreJksPasswordRequired = null;
  4708.     public boolean isConfigurazioneKeystoreJksPasswordRequired() {  
  4709.         if(this.isConfigurazioneKeystoreJksPasswordRequired==null){
  4710.             String pName = "org.openspcoop2.pdd.keystore.jks.passwordRequired";
  4711.             try{ 
  4712.                 String name = null;
  4713.                 name = this.reader.getValueConvertEnvProperties(pName);
  4714.                 if(name==null){
  4715.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4716.                     name="true";
  4717.                 }
  4718.                 name = name.trim();
  4719.                 this.isConfigurazioneKeystoreJksPasswordRequired = Boolean.parseBoolean(name);
  4720.             } catch(java.lang.Exception e) {
  4721.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  4722.                 this.isConfigurazioneKeystoreJksPasswordRequired = true;
  4723.             }    
  4724.         }

  4726.         return this.isConfigurazioneKeystoreJksPasswordRequired;
  4727.     }
  4728.     private Boolean isConfigurazioneKeystoreJksKeyPasswordRequired = null;
  4729.     public boolean isConfigurazioneKeystoreJksKeyPasswordRequired() {   
  4730.         if(this.isConfigurazioneKeystoreJksKeyPasswordRequired==null){
  4731.             String pName = "org.openspcoop2.pdd.keystore.jks.key.passwordRequired";
  4732.             try{ 
  4733.                 String name = null;
  4734.                 name = this.reader.getValueConvertEnvProperties(pName);
  4735.                 if(name==null){
  4736.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4737.                     name="true";
  4738.                 }
  4739.                 name = name.trim();
  4740.                 this.isConfigurazioneKeystoreJksKeyPasswordRequired = Boolean.parseBoolean(name);
  4741.             } catch(java.lang.Exception e) {
  4742.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  4743.                 this.isConfigurazioneKeystoreJksKeyPasswordRequired = true;
  4744.             }    
  4745.         }

  4747.         return this.isConfigurazioneKeystoreJksKeyPasswordRequired;
  4748.     }
  4749.     private Boolean isConfigurazioneKeystorePkcs12PasswordRequired = null;
  4750.     public boolean isConfigurazioneKeystorePkcs12PasswordRequired() {   
  4751.         if(this.isConfigurazioneKeystorePkcs12PasswordRequired==null){
  4752.             String pName = "org.openspcoop2.pdd.keystore.pkcs12.passwordRequired";
  4753.             try{ 
  4754.                 String name = null;
  4755.                 name = this.reader.getValueConvertEnvProperties(pName);
  4756.                 if(name==null){
  4757.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4758.                     name="true";
  4759.                 }
  4760.                 name = name.trim();
  4761.                 this.isConfigurazioneKeystorePkcs12PasswordRequired = Boolean.parseBoolean(name);
  4762.             } catch(java.lang.Exception e) {
  4763.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  4764.                 this.isConfigurazioneKeystorePkcs12PasswordRequired = true;
  4765.             }    
  4766.         }

  4768.         return this.isConfigurazioneKeystorePkcs12PasswordRequired;
  4769.     }
  4770.     private Boolean isConfigurazioneKeystorePkcs12KeyPasswordRequired = null;
  4771.     public boolean isConfigurazioneKeystorePkcs12KeyPasswordRequired() {    
  4772.         if(this.isConfigurazioneKeystorePkcs12KeyPasswordRequired==null){
  4773.             String pName = "org.openspcoop2.pdd.keystore.pkcs12.key.passwordRequired";
  4774.             try{ 
  4775.                 String name = null;
  4776.                 name = this.reader.getValueConvertEnvProperties(pName);
  4777.                 if(name==null){
  4778.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4779.                     name="true";
  4780.                 }
  4781.                 name = name.trim();
  4782.                 this.isConfigurazioneKeystorePkcs12KeyPasswordRequired = Boolean.parseBoolean(name);
  4783.             } catch(java.lang.Exception e) {
  4784.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  4785.                 this.isConfigurazioneKeystorePkcs12KeyPasswordRequired = true;
  4786.             }    
  4787.         }

  4789.         return this.isConfigurazioneKeystorePkcs12KeyPasswordRequired;
  4790.     }
  4791.     
  4792.     private Boolean isConfigurazioneTruststoreJksPasswordRequired = null;
  4793.     public boolean isConfigurazioneTruststoreJksPasswordRequired() {    
  4794.         if(this.isConfigurazioneTruststoreJksPasswordRequired==null){
  4795.             String pName = "org.openspcoop2.pdd.truststore.jks.passwordRequired";
  4796.             try{ 
  4797.                 String name = null;
  4798.                 name = this.reader.getValueConvertEnvProperties(pName);
  4799.                 if(name==null){
  4800.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4801.                     name="true";
  4802.                 }
  4803.                 name = name.trim();
  4804.                 this.isConfigurazioneTruststoreJksPasswordRequired = Boolean.parseBoolean(name);
  4805.             } catch(java.lang.Exception e) {
  4806.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  4807.                 this.isConfigurazioneTruststoreJksPasswordRequired = true;
  4808.             }    
  4809.         }

  4811.         return this.isConfigurazioneTruststoreJksPasswordRequired;
  4812.     }
  4813.     private Boolean isConfigurazioneTruststorePkcs12PasswordRequired = null;
  4814.     public boolean isConfigurazioneTruststorePkcs12PasswordRequired() { 
  4815.         if(this.isConfigurazioneTruststorePkcs12PasswordRequired==null){
  4816.             String pName = "org.openspcoop2.pdd.truststore.pkcs12.passwordRequired";
  4817.             try{ 
  4818.                 String name = null;
  4819.                 name = this.reader.getValueConvertEnvProperties(pName);
  4820.                 if(name==null){
  4821.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4822.                     name="true";
  4823.                 }
  4824.                 name = name.trim();
  4825.                 this.isConfigurazioneTruststorePkcs12PasswordRequired = Boolean.parseBoolean(name);
  4826.             } catch(java.lang.Exception e) {
  4827.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  4828.                 this.isConfigurazioneTruststorePkcs12PasswordRequired = true;
  4829.             }    
  4830.         }

  4832.         return this.isConfigurazioneTruststorePkcs12PasswordRequired;
  4833.     }


  4836.     
  4837.     
  4838.     /* ********  CONFIGURAZIONE PLUGINS  ******** */
  4839.     
  4840.     private Boolean isConfigurazionePluginsEnabled = null;
  4841.     public boolean isConfigurazionePluginsEnabled(){
  4842.         
  4843.         String pName = "org.openspcoop2.pdd.config.plugins.enabled";
  4844.         if(this.isConfigurazionePluginsEnabled==null){
  4845.             try{  
  4846.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  4848.                 if(value!=null){
  4849.                     value = value.trim();
  4850.                     this.isConfigurazionePluginsEnabled = Boolean.parseBoolean(value);
  4851.                 }else{
  4852.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4853.                     this.isConfigurazionePluginsEnabled = true;
  4854.                 }

  4856.             }catch(java.lang.Exception e) {
  4857.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  4858.                 this.isConfigurazionePluginsEnabled = true;
  4859.             }
  4860.         }

  4862.         return this.isConfigurazionePluginsEnabled;
  4863.     }
  4864.     
  4865.     private Boolean isConfigurazionePluginsDebug = null;
  4866.     public boolean isConfigurazionePluginsDebug(){
  4867.         
  4868.         String pName = "org.openspcoop2.pdd.config.plugins.debug";
  4869.         if(this.isConfigurazionePluginsDebug==null){
  4870.             try{  
  4871.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  4873.                 if(value!=null){
  4874.                     value = value.trim();
  4875.                     this.isConfigurazionePluginsDebug = Boolean.parseBoolean(value);
  4876.                 }else{
  4877.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4878.                     this.isConfigurazionePluginsDebug = true;
  4879.                 }

  4881.             }catch(java.lang.Exception e) {
  4882.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  4883.                 this.isConfigurazionePluginsDebug = true;
  4884.             }
  4885.         }

  4887.         return this.isConfigurazionePluginsDebug;
  4888.     }
  4889.     
  4890.     private Integer getConfigurazionePluginsSeconds = null;
  4891.     public int getConfigurazionePluginsSeconds(){
  4892.         
  4893.         String pName = "org.openspcoop2.pdd.config.plugins.seconds";
  4894.         if(this.getConfigurazionePluginsSeconds==null){
  4895.             try{  
  4896.                 String value = this.reader.getValueConvertEnvProperties(pName); 

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

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

  4912.         return this.getConfigurazionePluginsSeconds;
  4913.     }






  4920.     /* ********  DATASOURCE DI OPENSPCOOP  ******** */

  4922.     /**
  4923.      * Restituisce il Nome JNDI del DataSource utilizzato da OpenSPCoop.
  4924.      *
  4925.      * @return il Nome JNDI del DataSource utilizzato da OpenSPCoop.
  4926.      * 
  4927.      */
  4928.     private String jndiNameDatasource = null;
  4929.     public String getJNDIName_DataSource() {    
  4930.         if(this.jndiNameDatasource==null){
  4931.             try{ 
  4932.                 String name = null;
  4933.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dataSource");
  4934.                 if(name==null)
  4935.                     throw new CoreException(NON_DEFINITA);
  4936.                 name = name.trim();

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

  4945.         return this.jndiNameDatasource;
  4946.     }

  4948.     /**
  4949.      * Restituisce le proprieta' da utilizzare con il contesto JNDI di lookup, se impostate.
  4950.      *
  4951.      * @return proprieta' da utilizzare con il contesto JNDI di lookup.
  4952.      * 
  4953.      */
  4954.     private java.util.Properties jndiContextDatasource = null;
  4955.     public java.util.Properties getJNDIContext_DataSource() {
  4956.         if(this.jndiContextDatasource == null){
  4957.             java.util.Properties prop = new java.util.Properties();
  4958.             try{ 

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

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

  4969.         return this.jndiContextDatasource;
  4970.     }











  4982.     /* ********  CONNECTION FACTORY DI OPENSPCOOP  ******** */

  4984.     /**
  4985.      * Restituisce il Nome JNDI del ConnectionFactory utilizzato da OpenSPCoop.
  4986.      *
  4987.      * @return il Nome JNDI del ConnectionFactory utilizzato da OpenSPCoop.
  4988.      * 
  4989.      */
  4990.     private String jndiNameConnectionFactory = null;
  4991.     public String getJNDIName_ConnectionFactory() { 
  4992.         if(this.jndiNameConnectionFactory==null){
  4993.             try{ 
  4994.                 String name = null;
  4995.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.queueConnectionFactory");
  4996.                 if(name==null)
  4997.                     throw new CoreException(NON_DEFINITA);
  4998.                 name = name.trim();

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

  5007.         return this.jndiNameConnectionFactory;
  5008.     }

  5010.     /**
  5011.      * Restituisce le proprieta' da utilizzare con il contesto JNDI di lookup, se impostate.
  5012.      *
  5013.      * @return proprieta' da utilizzare con il contesto JNDI di lookup.
  5014.      * 
  5015.      */
  5016.     private java.util.Properties jndiContextConnectionFactory = null;
  5017.     public java.util.Properties getJNDIContext_ConnectionFactory() {
  5018.         if(this.jndiContextConnectionFactory==null){
  5019.             java.util.Properties prop = new java.util.Properties();
  5020.             try{ 

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

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

  5031.         return this.jndiContextConnectionFactory;
  5032.     }

  5034.     /**
  5035.      * Restituisce acknowledgeMode della Sessione utilizzata da OpenSPCoop.
  5036.      *
  5037.      * @return acknowledgeMode della Sessione utilizzata da OpenSPCoop.
  5038.      * 
  5039.      */
  5040.     private int acknowledgeModeSessioneConnectionFactory = -1;
  5041.     public int getAcknowledgeModeSessioneConnectionFactory() {  
  5042.         if(this.acknowledgeModeSessioneConnectionFactory==-1){
  5043.             try{ 
  5044.                 String name = null;
  5045.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.queueConnectionFactory.session.AcknowledgeMode");

  5047.                 if(name!=null){
  5048.                     name = name.trim();
  5049.                     if(CostantiConfigurazione.AUTO_ACKNOWLEDGE.equals(name))
  5050.                         this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.AUTO_ACKNOWLEDGE;
  5051.                     else if(CostantiConfigurazione.CLIENT_ACKNOWLEDGE.equals(name))
  5052.                         this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.CLIENT_ACKNOWLEDGE;
  5053.                     else if(CostantiConfigurazione.DUPS_OK_ACKNOWLEDGE.equals(name))
  5054.                         this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.DUPS_OK_ACKNOWLEDGE;
  5055.                     else
  5056.                         throw new CoreException("Tipo di acknowledgeModeSessione non conosciuto (viene utilizzato il default:AUTO_ACKNOWLEDGE)");
  5057.                 }else{
  5058.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.queueConnectionFactory.session.AcknowledgeMode' non impostata, viene utilizzato il default=AUTO_ACKNOWLEDGE");
  5059.                     this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.AUTO_ACKNOWLEDGE; // Default
  5060.                 }

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

  5068.         return this.acknowledgeModeSessioneConnectionFactory;
  5069.     }








  5078.     /* ********  CODE JMS DI OPENSPCOOP  ******** */

  5080.     public java.util.Map<String,String> getJNDIQueueName(boolean receiverJMSActive,boolean senderJMSActive){
  5081.         java.util.Map<String,String> table = new java.util.HashMap<>();
  5082.         try{ 
  5083.             boolean ricezioneContenutiApplicativi = !receiverJMSActive;
  5084.             boolean ricezioneBuste = !receiverJMSActive;
  5085.             boolean consegnaContenutiApplicativi = !senderJMSActive;
  5086.             boolean inoltroBuste = !senderJMSActive;
  5087.             boolean inoltroRisposte = !senderJMSActive;
  5088.             boolean imbustamento = !senderJMSActive;
  5089.             boolean imbustamentoRisposte = !senderJMSActive;
  5090.             boolean sbustamento=!senderJMSActive;
  5091.             boolean sbustamentoRisposte=!senderJMSActive;
  5092.             java.util.Enumeration<?> en = this.reader.propertyNames();
  5093.             for (; en.hasMoreElements() ;) {
  5094.                 String property = (String) en.nextElement();
  5095.                 if(property.startsWith("org.openspcoop2.pdd.queue.")){
  5096.                     String key = (property.substring("org.openspcoop2.pdd.queue.".length()));
  5097.                     if(key != null)
  5098.                         key = key.trim();
  5099.                     String value = this.reader.getValueConvertEnvProperties(property);
  5100.                     if(value!=null)
  5101.                         value = value.trim();
  5102.                     if(receiverJMSActive){
  5103.                         if("ricezioneContenutiApplicativi".equals(key) && value!=null){
  5104.                             table.put(RicezioneContenutiApplicativi.ID_MODULO, value);
  5105.                             ricezioneContenutiApplicativi = true;
  5106.                         }else if("ricezioneBuste".equals(key) && value!=null){
  5107.                             table.put(RicezioneBuste.ID_MODULO, value);
  5108.                             ricezioneBuste = true;
  5109.                         }
  5110.                     }
  5111.                     if(senderJMSActive){
  5112.                         if("inoltroBuste".equals(key) && value!=null){
  5113.                             table.put(InoltroBuste.ID_MODULO, value);
  5114.                             inoltroBuste = true;
  5115.                         }else if("inoltroRisposte".equals(key) && value!=null){
  5116.                             table.put(InoltroRisposte.ID_MODULO, value);
  5117.                             inoltroRisposte = true;
  5118.                         }else if("consegnaContenutiApplicativi".equals(key) && value!=null){
  5119.                             table.put(ConsegnaContenutiApplicativi.ID_MODULO, value);
  5120.                             consegnaContenutiApplicativi = true;
  5121.                         }else if("imbustamento".equals(key) && value!=null){
  5122.                             table.put(Imbustamento.ID_MODULO, value);
  5123.                             imbustamento = true;
  5124.                         }else if("imbustamentoRisposte".equals(key) && value!=null){
  5125.                             table.put(ImbustamentoRisposte.ID_MODULO, value);
  5126.                             imbustamentoRisposte = true;
  5127.                         }else if("sbustamento".equals(key) && value!=null){
  5128.                             table.put(Sbustamento.ID_MODULO, value);
  5129.                             sbustamento = true;
  5130.                         }else if("sbustamentoRisposte".equals(key) && value!=null){
  5131.                             table.put(SbustamentoRisposte.ID_MODULO, value);
  5132.                             sbustamentoRisposte = true;
  5133.                         }
  5134.                     }
  5135.                 }
  5136.             }


  5139.             if(ricezioneContenutiApplicativi==false){
  5140.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.ricezioneContenutiApplicativi non definita");
  5141.                 return null;
  5142.             }
  5143.             if(ricezioneBuste==false){
  5144.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.ricezioneBuste non definita");
  5145.                 return null;
  5146.             }
  5147.             if(consegnaContenutiApplicativi==false){
  5148.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.consegnaContenutiApplicativi non definita");
  5149.                 return null;
  5150.             }
  5151.             if(inoltroBuste==false){
  5152.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.inoltroBuste non definita");
  5153.                 return null;
  5154.             }
  5155.             if(inoltroRisposte==false){
  5156.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.inoltroRisposte non definita");
  5157.                 return null;
  5158.             }
  5159.             if(imbustamento==false){
  5160.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.imbustamento non definita");
  5161.                 return null;
  5162.             }if(imbustamentoRisposte==false){
  5163.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.imbustamentoRisposte non definita");
  5164.                 return null;
  5165.             }else if(sbustamentoRisposte==false){
  5166.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.sbustamentoRisposte non definita");
  5167.                 return null;
  5168.             }
  5169.             if(sbustamento==false){
  5170.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.sbustamento non definita");
  5171.                 return null;
  5172.             }
  5173.             return table;

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

  5181.     /**
  5182.      * Restituisce le proprieta' da utilizzare nel contesto JNDI di lookup per localizzare le code.
  5183.      *
  5184.      * @return proprieta' da utilizzare con il contesto JNDI di lookup per localizzare le code.
  5185.      * 
  5186.      */
  5187.     private java.util.Properties jndiContext_CodeInterne = null;
  5188.     public java.util.Properties getJNDIContext_CodeInterne() {  
  5189.         if(this.jndiContext_CodeInterne==null){
  5190.             java.util.Properties prop = new java.util.Properties();
  5191.             try{ 

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

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

  5202.         return this.jndiContext_CodeInterne;
  5203.     }














  5218.     /* ********  Timer EJB DI OPENSPCOOP  ******** */

  5220.     public java.util.Map<String,String> getJNDITimerEJBName(){
  5221.         java.util.Map<String,String> table = new java.util.HashMap<>();
  5222.         try{ 
  5223.             boolean gestoreBusteNonRiscontrate = false;
  5224.             boolean gestoreMessaggi = false;
  5225.             boolean gestorePuliziaMessaggiAnomali = false;
  5226.             boolean gestoreRepositoryBuste = false;
  5227.             java.util.Enumeration<?> en = this.reader.propertyNames();
  5228.             for (; en.hasMoreElements() ;) {
  5229.                 String property = (String) en.nextElement();
  5230.                 if(property.startsWith("org.openspcoop2.pdd.timer.")){
  5231.                     String key = (property.substring("org.openspcoop2.pdd.timer.".length()));
  5232.                     if(key != null)
  5233.                         key = key.trim();
  5234.                     String value = this.reader.getValueConvertEnvProperties(property);
  5235.                     if(value!=null)
  5236.                         value = value.trim();
  5237.                     if("gestoreBusteNonRiscontrate".equals(key) && value!=null){
  5238.                         table.put(TimerGestoreBusteNonRiscontrate.ID_MODULO, value);
  5239.                         gestoreBusteNonRiscontrate = true;
  5240.                     }else if("gestoreMessaggi".equals(key) && value!=null){
  5241.                         table.put(TimerGestoreMessaggi.ID_MODULO, value);
  5242.                         gestoreMessaggi = true;
  5243.                     }else if("gestorePuliziaMessaggiAnomali".equals(key) && value!=null){
  5244.                         table.put(TimerGestorePuliziaMessaggiAnomali.ID_MODULO, value);
  5245.                         gestorePuliziaMessaggiAnomali = true;
  5246.                     }else if("gestoreRepositoryBuste".equals(key) && value!=null){
  5247.                         table.put(TimerGestoreRepositoryBuste.ID_MODULO, value);
  5248.                         gestoreRepositoryBuste = true;
  5249.                     }
  5250.                 }
  5251.             }


  5254.             if(gestoreBusteNonRiscontrate==false && this.isTimerGestoreRiscontriRicevuteAbilitato()){
  5255.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI dei timer openspcoop: timer org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate non definito");
  5256.                 return null;
  5257.             }
  5258.             if(gestoreMessaggi==false && this.isTimerGestoreMessaggiAbilitato()){
  5259.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI dei timer openspcoop: timer org.openspcoop2.pdd.timer.gestoreMessaggi non definito");
  5260.                 return null;
  5261.             }
  5262.             if(gestorePuliziaMessaggiAnomali==false && this.isTimerGestorePuliziaMessaggiAnomaliAbilitato()){
  5263.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI dei timer openspcoop: timer org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali non definito");
  5264.                 return null;
  5265.             }
  5266.             if(gestoreRepositoryBuste==false && this.isTimerGestoreRepositoryBusteAbilitato()){
  5267.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI dei timer openspcoop: timer org.openspcoop2.pdd.timer.gestoreRepositoryBuste  non definito");
  5268.                 return null;
  5269.             }
  5270.             return table;

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

  5278.     /**
  5279.      * Restituisce le proprieta' da utilizzare nel contesto JNDI di lookup per localizzare i timer.
  5280.      *
  5281.      * @return proprieta' da utilizzare con il contesto JNDI di lookup per localizzare i timer.
  5282.      * 
  5283.      */
  5284.     private java.util.Properties jndiContext_TimerEJB = null;
  5285.     public java.util.Properties getJNDIContext_TimerEJB() { 
  5286.         if(this.jndiContext_TimerEJB==null){
  5287.             java.util.Properties prop = new java.util.Properties();
  5288.             try{ 

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

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

  5299.         return this.jndiContext_TimerEJB;
  5300.     }
  5301.     
  5302.     private Boolean isTimerAutoStart_StopTimer = null;
  5303.     public boolean isTimerAutoStart_StopTimer(){
  5304.         if(this.isTimerAutoStart_StopTimer==null){
  5305.             try{  
  5306.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.autoStart.stop"); 

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

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

  5322.         return this.isTimerAutoStart_StopTimer;
  5323.     }
  5324.     
  5325.     
  5326.     

  5328.     
  5329.     // GestoreRiscontriRicevute
  5330.     
  5331.     /**
  5332.      * Restituisce l'indicazione se avviare il timer
  5333.      *
  5334.      * @return Restituisce indicazione se avviare il timer
  5335.      * 
  5336.      */
  5337.     private Boolean isTimerGestoreRiscontriRicevuteAbilitato = null;
  5338.     public boolean isTimerGestoreRiscontriRicevuteAbilitato(){
  5339.         if(this.isTimerGestoreRiscontriRicevuteAbilitato==null){
  5340.             try{  
  5341.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.enable"); 

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

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

  5357.         return this.isTimerGestoreRiscontriRicevuteAbilitato;
  5358.     }
  5359.     
  5360.     /**
  5361.      * Restituisce l'indicazione se registrare su log le queries
  5362.      *
  5363.      * @return Restituisce indicazione se registrare su log le queries
  5364.      * 
  5365.      */
  5366.     private Boolean isTimerGestoreRiscontriRicevuteAbilitatoLog = null;
  5367.     public boolean isTimerGestoreRiscontriRicevuteAbilitatoLog(){
  5368.         if(this.isTimerGestoreRiscontriRicevuteAbilitatoLog==null){
  5369.             try{  
  5370.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.logQuery"); 

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

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

  5386.         return this.isTimerGestoreRiscontriRicevuteAbilitatoLog;
  5387.     }
  5388.     
  5389.     /**
  5390.      * Restituisce l'indicazione sul numero di messaggi alla volta processati
  5391.      *
  5392.      * @return Restituisce indicazione sul numero di messaggi alla volta processati
  5393.      * 
  5394.      */
  5395.     private Integer getTimerGestoreRiscontriRicevuteLimit = null;
  5396.     public int getTimerGestoreRiscontriRicevuteLimit(){
  5397.         if(this.getTimerGestoreRiscontriRicevuteLimit==null){
  5398.             try{  
  5399.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.query.limit"); 

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

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

  5415.         return this.getTimerGestoreRiscontriRicevuteLimit;
  5416.     }
  5417.     
  5418.     private Integer getTimerGestoreRiscontriRicevuteLockMaxLife = null;
  5419.     public int getTimerGestoreRiscontriRicevuteLockMaxLife() {  
  5420.         if(this.getTimerGestoreRiscontriRicevuteLockMaxLife==null){
  5421.             try{ 
  5422.                 String name = null;
  5423.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.maxLife");

  5425.                 if(name!=null){
  5426.                     name = name.trim();
  5427.                     this.getTimerGestoreRiscontriRicevuteLockMaxLife = java.lang.Integer.parseInt(name);
  5428.                 }else{
  5429.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
  5430.                     this.getTimerGestoreRiscontriRicevuteLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  5431.                 }
  5432.             }catch(java.lang.Exception e) {
  5433.                 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);
  5434.                 this.getTimerGestoreRiscontriRicevuteLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  5435.             }  
  5436.             if(this.getTimerGestoreRiscontriRicevuteLockMaxLife!=null && this.getTimerGestoreRiscontriRicevuteLockMaxLife>0) {
  5437.                 // trasformo in millisecondi l'informazione fornita in secondi
  5438.                 this.getTimerGestoreRiscontriRicevuteLockMaxLife = this.getTimerGestoreRiscontriRicevuteLockMaxLife *1000;
  5439.             }
  5440.         }

  5442.         if(this.getTimerGestoreRiscontriRicevuteLockMaxLife!=null) {
  5443.             return this.getTimerGestoreRiscontriRicevuteLockMaxLife.intValue();
  5444.         }
  5445.         return -1;
  5446.     }
  5447.     
  5448.     private Integer getTimerGestoreRiscontriRicevuteLockIdleTime = null;
  5449.     public int getTimerGestoreRiscontriRicevuteLockIdleTime() { 
  5450.         if(this.getTimerGestoreRiscontriRicevuteLockIdleTime==null){
  5451.             try{ 
  5452.                 String name = null;
  5453.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.idleTime");

  5455.                 if(name!=null){
  5456.                     name = name.trim();
  5457.                     this.getTimerGestoreRiscontriRicevuteLockIdleTime = java.lang.Integer.parseInt(name);
  5458.                 }else{
  5459.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  5460.                     this.getTimerGestoreRiscontriRicevuteLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  5461.                 }
  5462.             }catch(java.lang.Exception e) {
  5463.                 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);
  5464.                 this.getTimerGestoreRiscontriRicevuteLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  5465.             } 
  5466.             if(this.getTimerGestoreRiscontriRicevuteLockIdleTime!=null && this.getTimerGestoreRiscontriRicevuteLockIdleTime>0) {
  5467.                 // trasformo in millisecondi l'informazione fornita in secondi
  5468.                 this.getTimerGestoreRiscontriRicevuteLockIdleTime = this.getTimerGestoreRiscontriRicevuteLockIdleTime *1000;
  5469.             }
  5470.         }

  5472.         if(this.getTimerGestoreRiscontriRicevuteLockIdleTime!=null) {
  5473.             return this.getTimerGestoreRiscontriRicevuteLockIdleTime.intValue();
  5474.         }
  5475.         return -1;
  5476.     }
  5477.     
  5478.     private Long getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva = null;
  5479.     public long getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva() { 
  5480.         if(this.getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva==null){
  5481.             String pName = "org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.attesaAttiva";
  5482.             try{ 
  5483.                 String name = null;
  5484.                 name = this.reader.getValueConvertEnvProperties(pName);

  5486.                 if(name!=null){
  5487.                     name = name.trim();
  5488.                     long time = java.lang.Long.parseLong(name);
  5489.                     this.getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva = time*1000;
  5490.                 }else{
  5491.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
  5492.                     this.getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
  5493.                 }

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

  5501.         return this.getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva;
  5502.     }

  5504.     private Integer getTimerGestoreRiscontriRicevuteGetLockCheckInterval = null;
  5505.     public int getTimerGestoreRiscontriRicevuteGetLockCheckInterval() { 
  5506.         if(this.getTimerGestoreRiscontriRicevuteGetLockCheckInterval==null){
  5507.             String pName = "org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.check";
  5508.             try{ 
  5509.                 String name = null;
  5510.                 name = this.reader.getValueConvertEnvProperties(pName);

  5512.                 if(name!=null){
  5513.                     name = name.trim();
  5514.                     int time = java.lang.Integer.parseInt(name);
  5515.                     this.getTimerGestoreRiscontriRicevuteGetLockCheckInterval = time;
  5516.                 }else{
  5517.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  5518.                     this.getTimerGestoreRiscontriRicevuteGetLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  5519.                 }
  5520.             }catch(java.lang.Exception e) {
  5521.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  5522.                 this.getTimerGestoreRiscontriRicevuteGetLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  5523.             }  
  5524.         }

  5526.         return this.getTimerGestoreRiscontriRicevuteGetLockCheckInterval;
  5527.     }
  5528.     
  5529.     
  5530.     
  5531.     
  5532.     // GestoreMessaggi
  5533.     
  5534.     /**
  5535.      * Restituisce l'indicazione se avviare il timer
  5536.      *
  5537.      * @return Restituisce indicazione se avviare il timer
  5538.      * 
  5539.      */
  5540.     private Boolean isTimerGestoreMessaggiAbilitato = null;
  5541.     public boolean isTimerGestoreMessaggiAbilitato(){
  5542.         if(this.isTimerGestoreMessaggiAbilitato==null){
  5543.             try{  
  5544.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.enable"); 

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

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

  5560.         return this.isTimerGestoreMessaggiAbilitato;
  5561.     }
  5562.     
  5563.     private Boolean isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata = null;
  5564.     public boolean isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata(){
  5565.         if(this.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata==null){
  5566.             try{  
  5567.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiEliminati.enable"); 

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

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

  5583.         return this.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata;
  5584.     }
  5585.     
  5586.     private Boolean isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata = null;
  5587.     public boolean isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata(){
  5588.         if(this.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata==null){
  5589.             try{  
  5590.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiScaduti.enable"); 

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

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

  5606.         return this.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata;
  5607.     }
  5608.     
  5609.     private Boolean isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata = null;
  5610.     public boolean isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata(){
  5611.         if(this.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata==null){
  5612.             try{  
  5613.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiNonGestiti.enable"); 

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

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

  5629.         return this.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata;
  5630.     }
  5631.     
  5632.     private Boolean isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata = null;
  5633.     public boolean isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata(){
  5634.         if(this.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata==null){
  5635.             try{  
  5636.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaCorrelazioneApplicativa.enable"); 

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

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

  5652.         return this.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata;
  5653.     }
  5654.     
  5655.     /**
  5656.      * Restituisce l'indicazione se usare l'order by nelle queries
  5657.      *
  5658.      * @return Restituisce indicazione se usare l'order by nelle queries
  5659.      * 
  5660.      */
  5661.     private Boolean isTimerGestoreMessaggiAbilitatoOrderBy = null;
  5662.     public boolean isTimerGestoreMessaggiAbilitatoOrderBy(){
  5663.         if(this.isTimerGestoreMessaggiAbilitatoOrderBy==null){
  5664.             try{  
  5665.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.orderBy"); 

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

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

  5681.         return this.isTimerGestoreMessaggiAbilitatoOrderBy;
  5682.     }
  5683.     
  5684.     /**
  5685.      * Restituisce l'indicazione se registrare su log le queries
  5686.      *
  5687.      * @return Restituisce indicazione se registrare su log le queries
  5688.      * 
  5689.      */
  5690.     private Boolean isTimerGestoreMessaggiAbilitatoLog = null;
  5691.     public boolean isTimerGestoreMessaggiAbilitatoLog(){
  5692.         if(this.isTimerGestoreMessaggiAbilitatoLog==null){
  5693.             try{  
  5694.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.logQuery"); 

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

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

  5710.         return this.isTimerGestoreMessaggiAbilitatoLog;
  5711.     }
  5712.     
  5713.     /**
  5714.      * Restituisce l'indicazione sul numero di messaggi alla volta processati
  5715.      *
  5716.      * @return Restituisce indicazione sul numero di messaggi alla volta processati
  5717.      * 
  5718.      */
  5719.     private Integer getTimerGestoreMessaggiLimit = null;
  5720.     public int getTimerGestoreMessaggiLimit(){
  5721.         if(this.getTimerGestoreMessaggiLimit==null){
  5722.             try{  
  5723.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.query.limit"); 

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

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

  5739.         return this.getTimerGestoreMessaggiLimit;
  5740.     }
  5741.     
  5742.     /**
  5743.      * Restituisce l'indicazione se devono essere verificate anche le connessioni rimaste attive
  5744.      *
  5745.      * @return Restituisce indicazione se devono essere verificate anche le connessioni rimaste attive
  5746.      * 
  5747.      */
  5748.     private Boolean isTimerGestoreMessaggiVerificaConnessioniAttive = null;
  5749.     public boolean isTimerGestoreMessaggiVerificaConnessioniAttive(){
  5750.         if(this.isTimerGestoreMessaggiVerificaConnessioniAttive==null){
  5751.             try{  
  5752.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.verificaConnessioniAttive"); 

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

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

  5768.         return this.isTimerGestoreMessaggiVerificaConnessioniAttive;
  5769.     }
  5770.         
  5771.     private Integer getTimerGestoreMessaggiLockMaxLife = null;
  5772.     public int getTimerGestoreMessaggiLockMaxLife() {   
  5773.         if(this.getTimerGestoreMessaggiLockMaxLife==null){
  5774.             try{ 
  5775.                 String name = null;
  5776.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.lock.maxLife");

  5778.                 if(name!=null){
  5779.                     name = name.trim();
  5780.                     this.getTimerGestoreMessaggiLockMaxLife = java.lang.Integer.parseInt(name);
  5781.                 }else{
  5782.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
  5783.                     this.getTimerGestoreMessaggiLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  5784.                 }
  5785.             }catch(java.lang.Exception e) {
  5786.                 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);
  5787.                 this.getTimerGestoreMessaggiLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  5788.             }
  5789.             if(this.getTimerGestoreMessaggiLockMaxLife!=null && this.getTimerGestoreMessaggiLockMaxLife>0) {
  5790.                 // trasformo in millisecondi l'informazione fornita in secondi
  5791.                 this.getTimerGestoreMessaggiLockMaxLife = this.getTimerGestoreMessaggiLockMaxLife *1000;
  5792.             }
  5793.         }

  5795.         if(this.getTimerGestoreMessaggiLockMaxLife!=null) {
  5796.             return this.getTimerGestoreMessaggiLockMaxLife.intValue();
  5797.         }
  5798.         return -1;
  5799.     }
  5800.     
  5801.     private Integer getTimerGestoreMessaggiLockIdleTime = null;
  5802.     public int getTimerGestoreMessaggiLockIdleTime() {  
  5803.         if(this.getTimerGestoreMessaggiLockIdleTime==null){
  5804.             try{ 
  5805.                 String name = null;
  5806.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.lock.idleTime");

  5808.                 if(name!=null){
  5809.                     name = name.trim();
  5810.                     this.getTimerGestoreMessaggiLockIdleTime = java.lang.Integer.parseInt(name);
  5811.                 }else{
  5812.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  5813.                     this.getTimerGestoreMessaggiLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  5814.                 }
  5815.             }catch(java.lang.Exception e) {
  5816.                 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);
  5817.                 this.getTimerGestoreMessaggiLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  5818.             }
  5819.             if(this.getTimerGestoreMessaggiLockIdleTime!=null && this.getTimerGestoreMessaggiLockIdleTime>0) {
  5820.                 // trasformo in millisecondi l'informazione fornita in secondi
  5821.                 this.getTimerGestoreMessaggiLockIdleTime = this.getTimerGestoreMessaggiLockIdleTime *1000;
  5822.             }
  5823.         }

  5825.         if(this.getTimerGestoreMessaggiLockIdleTime!=null) {
  5826.             return this.getTimerGestoreMessaggiLockIdleTime.intValue();
  5827.         }
  5828.         return -1;
  5829.     }
  5830.     
  5831.     private Long getTimerGestoreMessaggi_getLockAttesaAttiva = null;
  5832.     public long getTimerGestoreMessaggi_getLockAttesaAttiva() { 
  5833.         if(this.getTimerGestoreMessaggi_getLockAttesaAttiva==null){
  5834.             String pName = "org.openspcoop2.pdd.timer.gestoreMessaggi.lock.attesaAttiva";
  5835.             try{ 
  5836.                 String name = null;
  5837.                 name = this.reader.getValueConvertEnvProperties(pName);

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

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

  5854.         return this.getTimerGestoreMessaggi_getLockAttesaAttiva;
  5855.     }

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

  5865.                 if(name!=null){
  5866.                     name = name.trim();
  5867.                     int time = java.lang.Integer.parseInt(name);
  5868.                     this.getTimerGestoreMessaggi_getLockCheckInterval = time;
  5869.                 }else{
  5870.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  5871.                     this.getTimerGestoreMessaggi_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  5872.                 }
  5873.             }catch(java.lang.Exception e) {
  5874.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  5875.                 this.getTimerGestoreMessaggi_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  5876.             }  
  5877.         }

  5879.         return this.getTimerGestoreMessaggi_getLockCheckInterval;
  5880.     }
  5881.     
  5882.     
  5883.     
  5884.     
  5885.     // GestorePuliziaMessaggiAnomali
  5886.     
  5887.     /**
  5888.      * Restituisce l'indicazione se avviare il timer
  5889.      *
  5890.      * @return Restituisce indicazione se avviare il timer
  5891.      * 
  5892.      */
  5893.     private Boolean isTimerGestorePuliziaMessaggiAnomaliAbilitato = null;
  5894.     public boolean isTimerGestorePuliziaMessaggiAnomaliAbilitato(){
  5895.         if(this.isTimerGestorePuliziaMessaggiAnomaliAbilitato==null){
  5896.             try{  
  5897.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.enable"); 
  5898.                 if(value!=null){
  5899.                     value = value.trim();
  5900.                     this.isTimerGestorePuliziaMessaggiAnomaliAbilitato = Boolean.parseBoolean(value);
  5901.                 }else{
  5902.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.enable' non impostata, viene utilizzato il default=true");
  5903.                     this.isTimerGestorePuliziaMessaggiAnomaliAbilitato = true;
  5904.                 }

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

  5912.         return this.isTimerGestorePuliziaMessaggiAnomaliAbilitato;
  5913.     }
  5914.     
  5915.     /**
  5916.      * Restituisce l'indicazione se usare l'order by nelle queries
  5917.      *
  5918.      * @return Restituisce indicazione se usare l'order by nelle queries
  5919.      * 
  5920.      */
  5921.     private Boolean isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy = null;
  5922.     public boolean isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy(){
  5923.         if(this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy==null){
  5924.             try{  
  5925.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.orderBy"); 
  5926.                 if(value!=null){
  5927.                     value = value.trim();
  5928.                     this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy = Boolean.parseBoolean(value);
  5929.                 }else{
  5930.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.orderBy' non impostata, viene utilizzato il default=false");
  5931.                     this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy = false;
  5932.                 }

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

  5940.         return this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy;
  5941.     }
  5942.     
  5943.     /**
  5944.      * Restituisce l'indicazione se registrare su log le queries
  5945.      *
  5946.      * @return Restituisce indicazione se registrare su log le queries
  5947.      * 
  5948.      */
  5949.     private Boolean isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog = null;
  5950.     public boolean isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog(){
  5951.         if(this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog==null){
  5952.             try{  
  5953.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.logQuery"); 
  5954.                 if(value!=null){
  5955.                     value = value.trim();
  5956.                     this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog = Boolean.parseBoolean(value);
  5957.                 }else{
  5958.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.logQuery' non impostata, viene utilizzato il default=false");
  5959.                     this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog = false;
  5960.                 }

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

  5968.         return this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog;
  5969.     }

  5971.     /**
  5972.      * Restituisce l'indicazione sul numero di messaggi alla volta processati
  5973.      *
  5974.      * @return Restituisce indicazione sul numero di messaggi alla volta processati
  5975.      * 
  5976.      */
  5977.     private Integer getTimerGestorePuliziaMessaggiAnomaliLimit = null;
  5978.     public int getTimerGestorePuliziaMessaggiAnomaliLimit(){
  5979.         if(this.getTimerGestorePuliziaMessaggiAnomaliLimit==null){
  5980.             try{  
  5981.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.query.limit"); 

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

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

  5997.         return this.getTimerGestorePuliziaMessaggiAnomaliLimit;
  5998.     }
  5999.     
  6000.     private Integer getTimerGestorePuliziaMessaggiAnomaliLockMaxLife = null;
  6001.     public int getTimerGestorePuliziaMessaggiAnomaliLockMaxLife() { 
  6002.         if(this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife==null){
  6003.             try{ 
  6004.                 String name = null;
  6005.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.maxLife");

  6007.                 if(name!=null){
  6008.                     name = name.trim();
  6009.                     this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife = java.lang.Integer.parseInt(name);
  6010.                 }else{
  6011.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
  6012.                     this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  6013.                 }
  6014.             }catch(java.lang.Exception e) {
  6015.                 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);
  6016.                 this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  6017.             }  
  6018.             if(this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife!=null && this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife>0) {
  6019.                 // trasformo in millisecondi l'informazione fornita in secondi
  6020.                 this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife = this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife *1000;
  6021.             }
  6022.         }

  6024.         if(this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife!=null) {
  6025.             return this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife.intValue();
  6026.         }
  6027.         return -1;
  6028.     }
  6029.     
  6030.     private Integer getTimerGestorePuliziaMessaggiAnomaliLockIdleTime = null;
  6031.     public int getTimerGestorePuliziaMessaggiAnomaliLockIdleTime() {    
  6032.         if(this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime==null){
  6033.             try{ 
  6034.                 String name = null;
  6035.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.idleTime");

  6037.                 if(name!=null){
  6038.                     name = name.trim();
  6039.                     this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime = java.lang.Integer.parseInt(name);
  6040.                 }else{
  6041.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  6042.                     this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  6043.                 }
  6044.             }catch(java.lang.Exception e) {
  6045.                 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);
  6046.                 this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  6047.             } 
  6048.             if(this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime!=null && this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime>0) {
  6049.                 // trasformo in millisecondi l'informazione fornita in secondi
  6050.                 this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime = this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime *1000;
  6051.             }
  6052.         }

  6054.         if(this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime!=null) {
  6055.             return this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime.intValue();
  6056.         }
  6057.         return -1;
  6058.     }
  6059.     
  6060.     private Long getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva = null;
  6061.     public long getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva() {   
  6062.         if(this.getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva==null){
  6063.             String pName = "org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.attesaAttiva";
  6064.             try{ 
  6065.                 String name = null;
  6066.                 name = this.reader.getValueConvertEnvProperties(pName);

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

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

  6083.         return this.getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva;
  6084.     }

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

  6094.                 if(name!=null){
  6095.                     name = name.trim();
  6096.                     int time = java.lang.Integer.parseInt(name);
  6097.                     this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval = time;
  6098.                 }else{
  6099.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  6100.                     this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  6101.                 }
  6102.             }catch(java.lang.Exception e) {
  6103.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  6104.                 this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  6105.             }  
  6106.         }

  6108.         return this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval;
  6109.     }
  6110.     
  6111.     
  6112.     
  6113.     // GestoreBuste
  6114.     
  6115.     /**
  6116.      * Restituisce l'indicazione se avviare il timer
  6117.      *
  6118.      * @return Restituisce indicazione se avviare il timer
  6119.      * 
  6120.      */
  6121.     private Boolean isTimerGestoreRepositoryBusteAbilitato = null;
  6122.     public boolean isTimerGestoreRepositoryBusteAbilitato(){
  6123.         if(this.isTimerGestoreRepositoryBusteAbilitato==null){
  6124.             try{  
  6125.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.enable"); 

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

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

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

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

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

  6163.         return this.isTimerGestoreRepositoryBusteAbilitatoInitialState;
  6164.     }

  6166.     /**
  6167.      * Restituisce l'indicazione se usare l'order by nelle queries
  6168.      *
  6169.      * @return Restituisce indicazione se usare l'order by nelle queries
  6170.      * 
  6171.      */
  6172.     private Boolean isTimerGestoreRepositoryBusteAbilitatoOrderBy = null;
  6173.     public boolean isTimerGestoreRepositoryBusteAbilitatoOrderBy(){
  6174.         if(this.isTimerGestoreRepositoryBusteAbilitatoOrderBy==null){
  6175.             try{  
  6176.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.orderBy"); 

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

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

  6192.         return this.isTimerGestoreRepositoryBusteAbilitatoOrderBy;
  6193.     }
  6194.     
  6195.     /**
  6196.      * Restituisce l'indicazione se registrare su log le queries
  6197.      *
  6198.      * @return Restituisce indicazione se registrare su log le queries
  6199.      * 
  6200.      */
  6201.     private Boolean isTimerGestoreRepositoryBusteAbilitatoLog = null;
  6202.     public boolean isTimerGestoreRepositoryBusteAbilitatoLog(){
  6203.         if(this.isTimerGestoreRepositoryBusteAbilitatoLog==null){
  6204.             try{  
  6205.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.logQuery"); 

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

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

  6221.         return this.isTimerGestoreRepositoryBusteAbilitatoLog;
  6222.     }
  6223.     
  6224.     /**
  6225.      * Restituisce l'indicazione sul numero di messaggi alla volta processati
  6226.      *
  6227.      * @return Restituisce indicazione sul numero di messaggi alla volta processati
  6228.      * 
  6229.      */
  6230.     private Integer getTimerGestoreRepositoryBusteLimit = null;
  6231.     public int getTimerGestoreRepositoryBusteLimit(){
  6232.         if(this.getTimerGestoreRepositoryBusteLimit==null){
  6233.             try{  
  6234.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.query.limit"); 

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

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

  6250.         return this.getTimerGestoreRepositoryBusteLimit;
  6251.     }
  6252.     
  6253.     private Integer getTimerGestoreRepositoryBusteLockMaxLife = null;
  6254.     public int getTimerGestoreRepositoryBusteLockMaxLife() {    
  6255.         if(this.getTimerGestoreRepositoryBusteLockMaxLife==null){
  6256.             try{ 
  6257.                 String name = null;
  6258.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.maxLife");

  6260.                 if(name!=null){
  6261.                     name = name.trim();
  6262.                     this.getTimerGestoreRepositoryBusteLockMaxLife = java.lang.Integer.parseInt(name);
  6263.                 }else{
  6264.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
  6265.                     this.getTimerGestoreRepositoryBusteLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  6266.                 }
  6267.             }catch(java.lang.Exception e) {
  6268.                 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);
  6269.                 this.getTimerGestoreRepositoryBusteLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  6270.             }
  6271.             if(this.getTimerGestoreRepositoryBusteLockMaxLife!=null && this.getTimerGestoreRepositoryBusteLockMaxLife>0) {
  6272.                 // trasformo in millisecondi l'informazione fornita in secondi
  6273.                 this.getTimerGestoreRepositoryBusteLockMaxLife = this.getTimerGestoreRepositoryBusteLockMaxLife *1000;
  6274.             }
  6275.         }

  6277.         if(this.getTimerGestoreRepositoryBusteLockMaxLife!=null) {
  6278.             return this.getTimerGestoreRepositoryBusteLockMaxLife.intValue();
  6279.         }
  6280.         return -1;
  6281.     }
  6282.     
  6283.     private Integer getTimerGestoreRepositoryBusteLockIdleTime = null;
  6284.     public int getTimerGestoreRepositoryBusteLockIdleTime() {   
  6285.         if(this.getTimerGestoreRepositoryBusteLockIdleTime==null){
  6286.             try{ 
  6287.                 String name = null;
  6288.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.idleTime");

  6290.                 if(name!=null){
  6291.                     name = name.trim();
  6292.                     this.getTimerGestoreRepositoryBusteLockIdleTime = java.lang.Integer.parseInt(name);
  6293.                 }else{
  6294.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  6295.                     this.getTimerGestoreRepositoryBusteLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  6296.                 }
  6297.             }catch(java.lang.Exception e) {
  6298.                 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);
  6299.                 this.getTimerGestoreRepositoryBusteLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  6300.             }
  6301.             if(this.getTimerGestoreRepositoryBusteLockIdleTime!=null && this.getTimerGestoreRepositoryBusteLockIdleTime>0) {
  6302.                 // trasformo in millisecondi l'informazione fornita in secondi
  6303.                 this.getTimerGestoreRepositoryBusteLockIdleTime = this.getTimerGestoreRepositoryBusteLockIdleTime *1000;
  6304.             }
  6305.         }

  6307.         if(this.getTimerGestoreRepositoryBusteLockIdleTime!=null) {
  6308.             return this.getTimerGestoreRepositoryBusteLockIdleTime.intValue();
  6309.         }
  6310.         return -1;
  6311.     }

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

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

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

  6336.         return this.getTimerGestoreRepositoryBuste_getLockAttesaAttiva;
  6337.     }

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

  6347.                 if(name!=null){
  6348.                     name = name.trim();
  6349.                     int time = java.lang.Integer.parseInt(name);
  6350.                     this.getTimerGestoreRepositoryBuste_getLockCheckInterval = time;
  6351.                 }else{
  6352.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  6353.                     this.getTimerGestoreRepositoryBuste_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  6354.                 }
  6355.             }catch(java.lang.Exception e) {
  6356.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  6357.                 this.getTimerGestoreRepositoryBuste_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  6358.             }  
  6359.         }

  6361.         return this.getTimerGestoreRepositoryBuste_getLockCheckInterval;
  6362.     }
  6363.     


  6366.     
  6367.     
  6368.     // Gestore ConsegnaContenutiApplicativi
  6369.     
  6370.     /**
  6371.      * Restituisce l'indicazione se avviare il timer
  6372.      *
  6373.      * @return Restituisce indicazione se avviare il timer
  6374.      * 
  6375.      */
  6376.     private Boolean isTimerConsegnaContenutiApplicativiAbilitato = null;
  6377.     public boolean isTimerConsegnaContenutiApplicativiAbilitato(){
  6378.         
  6379.         if(this.isTimerConsegnaContenutiApplicativiAbilitato==null){
  6380.             if(this.isServerJ2EE()!=null && this.isServerJ2EE().booleanValue()){
  6381.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.enable' disabilitata poiche' il prodotto e' configurato in modalita' server j2ee");
  6382.                 this.isTimerConsegnaContenutiApplicativiAbilitato = false;
  6383.             }
  6384.             else{           
  6385.                 try{  
  6386.                     String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.enable"); 
  6387.                     if(value!=null){
  6388.                         value = value.trim();
  6389.                         this.isTimerConsegnaContenutiApplicativiAbilitato = Boolean.parseBoolean(value);
  6390.                     }else{
  6391.                         this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.enable' non impostata, viene utilizzato il default=true");
  6392.                         this.isTimerConsegnaContenutiApplicativiAbilitato = true;
  6393.                     }
  6394.     
  6395.                 }catch(java.lang.Exception e) {
  6396.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.enable', viene utilizzato il default=true, errore:"+e.getMessage(),e);
  6397.                     this.isTimerConsegnaContenutiApplicativiAbilitato = true;
  6398.                 }
  6399.             }

  6401.         }
  6402.         
  6403.         return this.isTimerConsegnaContenutiApplicativiAbilitato;
  6404.     }
  6405.     
  6406.     private Boolean isTimerConsegnaContenutiApplicativiSchedulingDebug = null;
  6407.     public boolean isTimerConsegnaContenutiApplicativiSchedulingDebug(){
  6408.         
  6409.         String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.scheduling.debug";
  6410.         if(this.isTimerConsegnaContenutiApplicativiSchedulingDebug==null){
  6411.             if(this.isServerJ2EE()!=null && this.isServerJ2EE().booleanValue()){
  6412.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' disabilitata poiche' il prodotto e' configurato in modalita' server j2ee");
  6413.                 this.isTimerConsegnaContenutiApplicativiSchedulingDebug = false;
  6414.             }
  6415.             else{           
  6416.                 try{  
  6417.                     String value = this.reader.getValueConvertEnvProperties(pName); 
  6418.                     if(value!=null){
  6419.                         value = value.trim();
  6420.                         this.isTimerConsegnaContenutiApplicativiSchedulingDebug = Boolean.parseBoolean(value);
  6421.                     }else{
  6422.                         this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6423.                         this.isTimerConsegnaContenutiApplicativiSchedulingDebug = true;
  6424.                     }
  6425.     
  6426.                 }catch(java.lang.Exception e) {
  6427.                     this.logWarn("Proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true, errore:"+e.getMessage(),e);
  6428.                     this.isTimerConsegnaContenutiApplicativiSchedulingDebug = true;
  6429.                 }
  6430.             }

  6432.         }
  6433.         
  6434.         return this.isTimerConsegnaContenutiApplicativiSchedulingDebug;
  6435.     }
  6436.     
  6437.     private Boolean isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = null;
  6438.     public boolean isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica(){
  6439.         
  6440.         String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.scheduling.checkEliminazioneLogica";
  6441.         if(this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica==null){
  6442.             if(this.isServerJ2EE()!=null && this.isServerJ2EE().booleanValue()){
  6443.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' disabilitata poiche' il prodotto e' configurato in modalita' server j2ee");
  6444.                 this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = false;
  6445.             }
  6446.             else{           
  6447.                 try{  
  6448.                     String value = this.reader.getValueConvertEnvProperties(pName); 
  6449.                     if(value!=null){
  6450.                         value = value.trim();
  6451.                         this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = Boolean.parseBoolean(value);
  6452.                     }else{
  6453.                         this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6454.                         this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = true;
  6455.                     }
  6456.     
  6457.                 }catch(java.lang.Exception e) {
  6458.                     this.logWarn("Proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true, errore:"+e.getMessage(),e);
  6459.                     this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = true;
  6460.                 }
  6461.             }

  6463.         }
  6464.         
  6465.         return this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica;
  6466.     }
  6467.     
  6468.     private Boolean isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare = null;
  6469.     public boolean isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare(){
  6470.         
  6471.         String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.scheduling.checkPassaggioOraLegaleVersoOraSolare";
  6472.         if(this.isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare==null){      
  6473.             try{  
  6474.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  6475.                 if(value!=null){
  6476.                     value = value.trim();
  6477.                     this.isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare = Boolean.parseBoolean(value);
  6478.                 }else{
  6479.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6480.                     this.isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare = true;
  6481.                 }

  6483.             }catch(java.lang.Exception e) {
  6484.                 this.logWarn("Proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true, errore:"+e.getMessage(),e);
  6485.                 this.isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare = true;
  6486.             }
  6487.         }
  6488.         
  6489.         return this.isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare;
  6490.     }
  6491.     
  6492.     private List<String> getTimerConsegnaContenutiApplicativiCode = null;
  6493.     private boolean getTimerConsegnaContenutiApplicativiCodeRead = false;
  6494.     public List<String> getTimerConsegnaContenutiApplicativiCode() {    
  6495.         if(!this.getTimerConsegnaContenutiApplicativiCodeRead){
  6496.             try{ 

  6498.                 String name = null;
  6499.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.code");
  6500.                 if(name==null){
  6501.                     this.getTimerConsegnaContenutiApplicativiCode = null;
  6502.                 }else{
  6503.                     String [] r = name.trim().split(",");
  6504.                     List<String> l = new ArrayList<>();
  6505.                     for(int i=0; i<r.length; i++){
  6506.                         r[i] = r[i].trim();
  6507.                         l.add(r[i]);
  6508.                     }
  6509.                     
  6510.                     if(!l.isEmpty()) {
  6511.                         this.getTimerConsegnaContenutiApplicativiCode = new ArrayList<>();
  6512.                         this.getTimerConsegnaContenutiApplicativiCode.addAll(l);
  6513.                     }
  6514.                 }
  6515.             }catch(java.lang.Exception e) {
  6516.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.code': "+e.getMessage(),e);
  6517.                 this.getTimerConsegnaContenutiApplicativiCode = null;
  6518.             }  
  6519.             this.getTimerConsegnaContenutiApplicativiCodeRead = true;
  6520.         }

  6522.         return this.getTimerConsegnaContenutiApplicativiCode;
  6523.     }
  6524.     
  6525.     private HashMap<String, ConfigurazioneCoda> getTimerConsegnaContenutiApplicativiConfigurazioneCoda = new HashMap<String, ConfigurazioneCoda>();
  6526.     public ConfigurazioneCoda getTimerConsegnaContenutiApplicativiConfigurazioneCoda(String nome) {
  6527.         
  6528.         ConfigurazioneCoda conf = this.getTimerConsegnaContenutiApplicativiConfigurazioneCoda.get(nome);
  6529.         if(conf!=null) {
  6530.             return conf;
  6531.         }
  6532.         
  6533.         String prefix = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.coda."+nome+".";
  6534.         try{ 
  6535.             Properties p = this.reader.readPropertiesConvertEnvProperties(prefix);
  6536.             if(p==null || p.isEmpty()) {
  6537.                 throw new CoreException("Configurazione non presente");
  6538.             }
  6539.             
  6540.             ConfigurazioneCoda confCoda = new ConfigurazioneCoda(nome, p);
  6541.             this.getTimerConsegnaContenutiApplicativiConfigurazioneCoda.put(nome, confCoda);
  6542.             return confCoda;
  6543.             
  6544.         }catch(java.lang.Exception e) {
  6545.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+prefix+"*': "+e.getMessage(),e);
  6546.             return null;
  6547.         }  

  6549.     }
  6550.     
  6551.     private List<String> getTimerConsegnaContenutiApplicativiPriorita = null;
  6552.     private boolean getTimerConsegnaContenutiApplicativiPrioritaRead = false;
  6553.     public List<String> getTimerConsegnaContenutiApplicativiPriorita() {    
  6554.         if(!this.getTimerConsegnaContenutiApplicativiPrioritaRead){
  6555.             try{ 

  6557.                 String name = null;
  6558.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.priorita");
  6559.                 if(name==null){
  6560.                     this.getTimerConsegnaContenutiApplicativiPriorita = null;
  6561.                 }else{
  6562.                     String [] r = name.trim().split(",");
  6563.                     List<String> l = new ArrayList<>();
  6564.                     for(int i=0; i<r.length; i++){
  6565.                         r[i] = r[i].trim();
  6566.                         l.add(r[i]);
  6567.                     }
  6568.                     
  6569.                     if(!l.isEmpty()) {
  6570.                         this.getTimerConsegnaContenutiApplicativiPriorita = new ArrayList<>();
  6571.                         this.getTimerConsegnaContenutiApplicativiPriorita.addAll(l);
  6572.                     }
  6573.                 }
  6574.             }catch(java.lang.Exception e) {
  6575.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.priorita': "+e.getMessage(),e);
  6576.                 this.getTimerConsegnaContenutiApplicativiPriorita = null;
  6577.             }  
  6578.             this.getTimerConsegnaContenutiApplicativiPrioritaRead = true;
  6579.         }

  6581.         return this.getTimerConsegnaContenutiApplicativiPriorita;
  6582.     }
  6583.     
  6584.     private HashMap<String, ConfigurazionePriorita> getTimerConsegnaContenutiApplicativiConfigurazionePriorita = new HashMap<>();
  6585.     public ConfigurazionePriorita getTimerConsegnaContenutiApplicativiConfigurazionePriorita(String nome) {
  6586.         
  6587.         ConfigurazionePriorita conf = this.getTimerConsegnaContenutiApplicativiConfigurazionePriorita.get(nome);
  6588.         if(conf!=null) {
  6589.             return conf;
  6590.         }
  6591.         
  6592.         String prefix = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.priorita."+nome+".";
  6593.         try{ 
  6594.             Properties p = this.reader.readPropertiesConvertEnvProperties(prefix);
  6595.             if(p==null || p.isEmpty()) {
  6596.                 throw new CoreException("Configurazione non presente");
  6597.             }
  6598.             
  6599.             ConfigurazionePriorita confPriorita = new ConfigurazionePriorita(nome, p);
  6600.             this.getTimerConsegnaContenutiApplicativiConfigurazionePriorita.put(nome, confPriorita);
  6601.             return confPriorita;
  6602.             
  6603.         }catch(java.lang.Exception e) {
  6604.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+prefix+"*': "+e.getMessage(),e);
  6605.             return null;
  6606.         }  

  6608.     }
  6609.     
  6610.     private Boolean isLoadBalancerDebug = null;
  6611.     public boolean isLoadBalancerDebug(){
  6612.         if(this.isLoadBalancerDebug==null){
  6613.             try{  
  6614.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.loadBalancer.debug"); 
  6615.                 if(value!=null){
  6616.                     value = value.trim();
  6617.                     this.isLoadBalancerDebug = Boolean.parseBoolean(value);
  6618.                 }else{
  6619.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.loadBalancer.debug' non impostata, viene utilizzato il default=false");
  6620.                     this.isLoadBalancerDebug = false;
  6621.                 }

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

  6629.         return this.isLoadBalancerDebug;
  6630.     }
  6631.     
  6632.     private Integer getTimerConsegnaContenutiApplicativiLockMaxLife = null;
  6633.     public int getTimerConsegnaContenutiApplicativiLockMaxLife() {  
  6634.         if(this.getTimerConsegnaContenutiApplicativiLockMaxLife==null){
  6635.             try{ 
  6636.                 String name = null;
  6637.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.maxLife");

  6639.                 if(name!=null){
  6640.                     name = name.trim();
  6641.                     this.getTimerConsegnaContenutiApplicativiLockMaxLife = java.lang.Integer.parseInt(name);
  6642.                 }else{
  6643.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
  6644.                     this.getTimerConsegnaContenutiApplicativiLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  6645.                 }
  6646.             }catch(java.lang.Exception e) {
  6647.                 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);
  6648.                 this.getTimerConsegnaContenutiApplicativiLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  6649.             }  
  6650.             if(this.getTimerConsegnaContenutiApplicativiLockMaxLife!=null && this.getTimerConsegnaContenutiApplicativiLockMaxLife>0) {
  6651.                 // trasformo in millisecondi l'informazione fornita in secondi
  6652.                 this.getTimerConsegnaContenutiApplicativiLockMaxLife = this.getTimerConsegnaContenutiApplicativiLockMaxLife *1000;
  6653.             }
  6654.         }

  6656.         if(this.getTimerConsegnaContenutiApplicativiLockMaxLife!=null) {
  6657.             return this.getTimerConsegnaContenutiApplicativiLockMaxLife.intValue();
  6658.         }
  6659.         return -1;
  6660.     }
  6661.     
  6662.     private Integer getTimerConsegnaContenutiApplicativiLockIdleTime = null;
  6663.     public int getTimerConsegnaContenutiApplicativiLockIdleTime() { 
  6664.         if(this.getTimerConsegnaContenutiApplicativiLockIdleTime==null){
  6665.             try{ 
  6666.                 String name = null;
  6667.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.idleTime");

  6669.                 if(name!=null){
  6670.                     name = name.trim();
  6671.                     this.getTimerConsegnaContenutiApplicativiLockIdleTime = java.lang.Integer.parseInt(name);
  6672.                 }else{
  6673.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  6674.                     this.getTimerConsegnaContenutiApplicativiLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  6675.                 }
  6676.             }catch(java.lang.Exception e) {
  6677.                 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);
  6678.                 this.getTimerConsegnaContenutiApplicativiLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  6679.             } 
  6680.             if(this.getTimerConsegnaContenutiApplicativiLockIdleTime!=null && this.getTimerConsegnaContenutiApplicativiLockIdleTime>0) {
  6681.                 // trasformo in millisecondi l'informazione fornita in secondi
  6682.                 this.getTimerConsegnaContenutiApplicativiLockIdleTime = this.getTimerConsegnaContenutiApplicativiLockIdleTime *1000;
  6683.             }
  6684.         }

  6686.         if(this.getTimerConsegnaContenutiApplicativiLockIdleTime!=null) {
  6687.             return this.getTimerConsegnaContenutiApplicativiLockIdleTime.intValue();
  6688.         }
  6689.         return -1;
  6690.     }
  6691.     
  6692.     private Integer getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife = null;
  6693.     public int getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife() {   
  6694.         if(this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife==null){
  6695.             try{ 
  6696.                 String name = null;
  6697.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.presaInConsegna.maxLife");

  6699.                 if(name!=null){
  6700.                     name = name.trim();
  6701.                     this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife = java.lang.Integer.parseInt(name);
  6702.                 }else{
  6703.                     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);
  6704.                     this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife = CostantiPdD.TIMER_RICONSEGNA_CONTENUTI_APPLICATIVI_PRESA_IN_CONSEGNA_MAX_LIFE;
  6705.                 }
  6706.             }catch(java.lang.Exception e) {
  6707.                 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);
  6708.                 this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife = CostantiPdD.TIMER_RICONSEGNA_CONTENUTI_APPLICATIVI_PRESA_IN_CONSEGNA_MAX_LIFE;
  6709.             }  
  6710.             if(this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife!=null && this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife>0) {
  6711.                 // trasformo in millisecondi l'informazione fornita in secondi
  6712.                 this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife = this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife *1000;
  6713.             }
  6714.         }

  6716.         if(this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife!=null) {
  6717.             return this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife.intValue();
  6718.         }
  6719.         return -1;
  6720.     }
  6721.     
  6722.     private Long getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva = null;
  6723.     public long getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva() {    
  6724.         if(this.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva==null){
  6725.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.attesaAttiva";
  6726.             try{ 
  6727.                 String name = null;
  6728.                 name = this.reader.getValueConvertEnvProperties(pName);

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

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

  6745.         return this.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva;
  6746.     }

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

  6756.                 if(name!=null){
  6757.                     name = name.trim();
  6758.                     int time = java.lang.Integer.parseInt(name);
  6759.                     this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval = time;
  6760.                 }else{
  6761.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  6762.                     this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  6763.                 }
  6764.             }catch(java.lang.Exception e) {
  6765.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  6766.                 this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  6767.             }  
  6768.         }

  6770.         return this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval;
  6771.     }

  6773.     
  6774.     // *** Smistatore ***
  6775.     
  6776.     private Boolean isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager = null;
  6777.     public boolean isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager() { 
  6778.         if(this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager==null){
  6779.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.smistatore.runtime.useRuntimeManager";
  6780.             try{ 
  6781.                 String name = null;
  6782.                 name = this.reader.getValueConvertEnvProperties(pName);
  6783.                 if(name==null){
  6784.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6785.                     name="true";
  6786.                 }
  6787.                 name = name.trim();
  6788.                 this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager = Boolean.parseBoolean(name);
  6789.             } catch(java.lang.Exception e) {
  6790.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  6791.                 this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager = true;
  6792.             }    
  6793.         }

  6795.         return this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager;
  6796.     }
  6797.     
  6798.     private String getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource = null;
  6799.     public String getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource() throws CoreException {   
  6800.         if(this.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource==null){
  6801.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.smistatore.runtime.dataSource";
  6802.             try{ 
  6803.                 String name = null;
  6804.                 name = this.reader.getValueConvertEnvProperties(pName);
  6805.                 if(name==null){
  6806.                     throw new CoreException("Proprieta' non impostata");
  6807.                 }
  6808.                 name = name.trim();
  6809.                 this.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource = name;
  6810.             } catch(java.lang.Exception e) {
  6811.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  6812.                 throw new CoreException(e.getMessage(),e);
  6813.             }    
  6814.         }

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

  6831.         return this.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSourceJndiContext;
  6832.     }
  6833.     
  6834.     private Boolean isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils = null;
  6835.     public boolean isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils() { 
  6836.         if(this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils==null){
  6837.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.smistatore.runtime.datasource.useDSUtils";
  6838.             try{ 
  6839.                 String name = null;
  6840.                 name = this.reader.getValueConvertEnvProperties(pName);
  6841.                 if(name==null){
  6842.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6843.                     name="true";
  6844.                 }
  6845.                 name = name.trim();
  6846.                 this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils = Boolean.parseBoolean(name);
  6847.             } catch(java.lang.Exception e) {
  6848.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  6849.                 this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils = true;
  6850.             }    
  6851.         }

  6853.         return this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils;
  6854.     }
  6855.     
  6856.     
  6857.     
  6858.     // *** Consegne, gestione runtime ***
  6859.     
  6860.     private Boolean isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager = null;
  6861.     public boolean isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager() {    
  6862.         if(this.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager==null){
  6863.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.runtime.useRuntimeManager";
  6864.             try{ 
  6865.                 String name = null;
  6866.                 name = this.reader.getValueConvertEnvProperties(pName);
  6867.                 if(name==null){
  6868.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6869.                     name="true";
  6870.                 }
  6871.                 name = name.trim();
  6872.                 this.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager = Boolean.parseBoolean(name);
  6873.             } catch(java.lang.Exception e) {
  6874.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  6875.                 this.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager = true;
  6876.             }    
  6877.         }

  6879.         return this.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager;
  6880.     }
  6881.     
  6882.     private String getTimerConsegnaContenutiApplicativi_runtime_dataSource = null;
  6883.     public String getTimerConsegnaContenutiApplicativi_runtime_dataSource() throws CoreException {  
  6884.         if(this.getTimerConsegnaContenutiApplicativi_runtime_dataSource==null){
  6885.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.runtime.dataSource";
  6886.             try{ 
  6887.                 String name = null;
  6888.                 name = this.reader.getValueConvertEnvProperties(pName);
  6889.                 if(name==null){
  6890.                     throw new CoreException("Proprieta' non impostata");
  6891.                 }
  6892.                 name = name.trim();
  6893.                 this.getTimerConsegnaContenutiApplicativi_runtime_dataSource = name;
  6894.             } catch(java.lang.Exception e) {
  6895.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  6896.                 throw new CoreException(e.getMessage(),e);
  6897.             }    
  6898.         }

  6900.         return this.getTimerConsegnaContenutiApplicativi_runtime_dataSource;
  6901.     }
  6902.     
  6903.     private Properties getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext = null;
  6904.     public Properties getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext() throws CoreException {   
  6905.         if(this.getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext==null){
  6906.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.runtime.dataSource.property.";
  6907.             try{ 
  6908.                 this.getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
  6909.             } catch(java.lang.Exception e) {
  6910.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  6911.                 throw new CoreException(e.getMessage(),e);
  6912.             }    
  6913.         }

  6915.         return this.getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext;
  6916.     }
  6917.     
  6918.     private Boolean isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils = null;
  6919.     public boolean isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils() {    
  6920.         if(this.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils==null){
  6921.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.runtime.datasource.useDSUtils";
  6922.             try{ 
  6923.                 String name = null;
  6924.                 name = this.reader.getValueConvertEnvProperties(pName);
  6925.                 if(name==null){
  6926.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6927.                     name="true";
  6928.                 }
  6929.                 name = name.trim();
  6930.                 this.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils = Boolean.parseBoolean(name);
  6931.             } catch(java.lang.Exception e) {
  6932.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  6933.                 this.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils = true;
  6934.             }    
  6935.         }

  6937.         return this.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils;
  6938.     }
  6939.     
  6940.     
  6941.     // *** Consegne, gestione tracce ***
  6942.     
  6943.     private Boolean isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager = null;
  6944.     public boolean isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager() {    
  6945.         if(this.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager==null){
  6946.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.transazioni.useTransactionManager";
  6947.             try{ 
  6948.                 String name = null;
  6949.                 name = this.reader.getValueConvertEnvProperties(pName);
  6950.                 if(name==null){
  6951.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6952.                     name="true";
  6953.                 }
  6954.                 name = name.trim();
  6955.                 this.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager = Boolean.parseBoolean(name);
  6956.             } catch(java.lang.Exception e) {
  6957.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  6958.                 this.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager = true;
  6959.             }    
  6960.         }

  6962.         return this.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager;
  6963.     }
  6964.     
  6965.     private String getTimerConsegnaContenutiApplicativi_transazioni_dataSource = null;
  6966.     public String getTimerConsegnaContenutiApplicativi_transazioni_dataSource() throws CoreException {  
  6967.         if(this.getTimerConsegnaContenutiApplicativi_transazioni_dataSource==null){
  6968.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.transazioni.dataSource";
  6969.             try{ 
  6970.                 String name = null;
  6971.                 name = this.reader.getValueConvertEnvProperties(pName);
  6972.                 if(name==null){
  6973.                     throw new CoreException("Proprieta' non impostata");
  6974.                 }
  6975.                 name = name.trim();
  6976.                 this.getTimerConsegnaContenutiApplicativi_transazioni_dataSource = name;
  6977.             } catch(java.lang.Exception e) {
  6978.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  6979.                 throw new CoreException(e.getMessage(),e);
  6980.             }    
  6981.         }

  6983.         return this.getTimerConsegnaContenutiApplicativi_transazioni_dataSource;
  6984.     }
  6985.     
  6986.     private Properties getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext = null;
  6987.     public Properties getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext() throws CoreException {   
  6988.         if(this.getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext==null){
  6989.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.transazioni.dataSource.property.";
  6990.             try{ 
  6991.                 this.getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
  6992.             } catch(java.lang.Exception e) {
  6993.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  6994.                 throw new CoreException(e.getMessage(),e);
  6995.             }    
  6996.         }

  6998.         return this.getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext;
  6999.     }
  7000.     
  7001.     private Boolean isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils = null;
  7002.     public boolean isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils() {    
  7003.         if(this.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils==null){
  7004.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.transazioni.datasource.useDSUtils";
  7005.             try{ 
  7006.                 String name = null;
  7007.                 name = this.reader.getValueConvertEnvProperties(pName);
  7008.                 if(name==null){
  7009.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7010.                     name="true";
  7011.                 }
  7012.                 name = name.trim();
  7013.                 this.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils = Boolean.parseBoolean(name);
  7014.             } catch(java.lang.Exception e) {
  7015.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  7016.                 this.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils = true;
  7017.             }    
  7018.         }

  7020.         return this.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils;
  7021.     }
  7022.     

  7024.     /* ********  REPOSITORY DI OPENSPCOOP  ******** */

  7026.     /**
  7027.      * Restituisce il tipo di repository utilizzato da OpenSPCoop 
  7028.      *
  7029.      * @return Restituisce il tipo di repository utilizzato da OpenSPCoop 
  7030.      * 
  7031.      */
  7032.     private String repositoryType = null;
  7033.     public String getRepositoryType() { 
  7034.         if(this.repositoryType==null){
  7035.             try{ 
  7036.                 String name = null;
  7037.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.tipo");
  7038.                 if(name==null)
  7039.                     throw new CoreException(NON_DEFINITA);
  7040.                 name = name.trim();
  7041.                 this.repositoryType = name;
  7042.             }catch(java.lang.Exception e) {
  7043.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.tipo': "+e.getMessage(),e);
  7044.                 this.repositoryType = null;
  7045.             }    
  7046.         }

  7048.         return this.repositoryType;
  7049.     }

  7051.     /**
  7052.      * Restituisce il tipo di database utilizzato da OpenSPCoop 
  7053.      *
  7054.      * @return Restituisce il tipo di database utilizzato da OpenSPCoop 
  7055.      * 
  7056.      */
  7057.     private String databaseType = null;
  7058.     public String getDatabaseType() {   
  7059.         if(this.databaseType==null){
  7060.             try{ 
  7061.                 String name = null;
  7062.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.tipoDatabase");
  7063.                 if(name!=null)
  7064.                     name = name.trim();
  7065.                 this.databaseType = name;
  7066.             }catch(java.lang.Exception e) {
  7067.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.tipoDatabase': "+e.getMessage(),e);
  7068.                 this.databaseType = null;
  7069.             }    
  7070.         }

  7072.         return this.databaseType;
  7073.     }

  7075.     /**
  7076.      * Restituisce true se il tipo di repository utilizzato da OpenSPCoop  e' fs
  7077.      *
  7078.      * @return Restituisce true se il tipo di repository utilizzato da OpenSPCoop  e' su file system
  7079.      * 
  7080.      */
  7081.     private Boolean isRepositoryOnFS_value = null;
  7082.     public boolean isRepositoryOnFS() { 

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

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

  7091.                 if(name!=null){
  7092.                     name = name.trim();
  7093.                     if(CostantiConfigurazione.REPOSITORY_DB.equals(name)){
  7094.                         this.isRepositoryOnFS_value = false;
  7095.                     }else{
  7096.                         this.isRepositoryOnFS_value = true;
  7097.                     }
  7098.                 }else{
  7099.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.tipo' non impostata, viene utilizzato il default=true");
  7100.                     this.isRepositoryOnFS_value = true;
  7101.                 }

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

  7109.         return this.isRepositoryOnFS_value;
  7110.     }

  7112.     /**
  7113.      * Restituisce la working directory utilizzata da OpenSPCoop 
  7114.      *
  7115.      * @return Restituisce la working directory utilizzata da OpenSPCoop.
  7116.      * 
  7117.      */
  7118.     private String repositoryDirectory = null;
  7119.     public String getRepositoryDirectory() {
  7120.         if(this.repositoryDirectory==null){
  7121.             try{ 
  7122.                 String name = null;
  7123.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.directory");
  7124.                 if(name==null)
  7125.                     throw new CoreException(NON_DEFINITA);
  7126.                 name = name.trim();
  7127.                 this.repositoryDirectory = name;
  7128.             }catch(java.lang.Exception e) {
  7129.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.directory': "+e.getMessage(),e);
  7130.                 this.repositoryDirectory = null;
  7131.             }  
  7132.         }

  7134.         return this.repositoryDirectory;
  7135.     }

  7137.     /**
  7138.      * Restituisce il JDBC Adapter utilizzato da OpenSPCoop 
  7139.      *
  7140.      * @return Restituisce il JDBC Adapter utilizzato da OpenSPCoop.
  7141.      * 
  7142.      */
  7143.     private String repositoryJDBCAdapter = null;
  7144.     public String getRepositoryJDBCAdapter() {  
  7145.         if(this.repositoryJDBCAdapter==null){
  7146.             try{ 
  7147.                 String name = null;
  7148.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.jdbcAdapter");
  7149.                 if(name==null)
  7150.                     throw new CoreException(NON_DEFINITA);
  7151.                 name = name.trim();
  7152.                 this.repositoryJDBCAdapter = name;
  7153.             }catch(java.lang.Exception e) {
  7154.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.jdbcAdapter': "+e.getMessage(),e);
  7155.                 this.repositoryJDBCAdapter = null;
  7156.             }    
  7157.         }

  7159.         return this.repositoryJDBCAdapter;
  7160.     }


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

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

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

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

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

  7187.         return this.forceIndex;
  7188.     }
  7189.     
  7190.     

  7192.     private AttachmentsProcessingMode attachmentsProcessingMode = null;
  7193.     public AttachmentsProcessingMode getAttachmentsProcessingMode() {   
  7194.         if(this.attachmentsProcessingMode==null){
  7195.             if(this.isFileCacheEnable()){
  7196.                 try{ 
  7197.                     this.attachmentsProcessingMode=AttachmentsProcessingMode.getFileCacheProcessingMode(getAttachmentRepoDir(), getFileThreshold());
  7198.                 } catch(java.lang.Exception e) {
  7199.                     this.logError("Riscontrato errore durante l'identificazione della modalità di processing degli attachments: "+e.getMessage(),e);
  7200.                     this.attachmentsProcessingMode=AttachmentsProcessingMode.getMemoryCacheProcessingMode();
  7201.                 } 
  7202.             }else{
  7203.                 this.attachmentsProcessingMode=AttachmentsProcessingMode.getMemoryCacheProcessingMode();
  7204.             }
  7205.         }

  7207.         return this.attachmentsProcessingMode;
  7208.     }

  7210.     private Boolean isFileCacheEnable = null;
  7211.     private boolean isFileCacheEnable() {   
  7212.         if(this.isFileCacheEnable==null){
  7213.             try{ 
  7214.                 String name = null;
  7215.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.attachment.fileCacheEnable");
  7216.                 if(name==null){
  7217.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.fileCacheEnable' non impostata, viene utilizzato il default=false");
  7218.                     name="false";
  7219.                 }
  7220.                 name = name.trim();
  7221.                 this.isFileCacheEnable = Boolean.parseBoolean(name);
  7222.             } catch(java.lang.Exception e) {
  7223.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.fileCacheEnable': "+e.getMessage(),e);
  7224.                 this.isFileCacheEnable = false;
  7225.             }    
  7226.         }

  7228.         return this.isFileCacheEnable;
  7229.     }


  7232.     private String attachmentRepoDir = null;
  7233.     private String getAttachmentRepoDir() { 

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

  7240.                 if(name!=null){
  7241.                     name = name.trim();
  7242.                     this.attachmentRepoDir = name;
  7243.                 }else{
  7244.                     // Se fileCacheEnable == false allora puo' essere null; 
  7245.                     if(!isFileCacheEnable())
  7246.                         return null;
  7247.                     throw new CoreException(NON_DEFINITA);
  7248.                 }

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

  7256.         return this.attachmentRepoDir;
  7257.     }
  7258.     
  7259.     private String fileThreshold = null;
  7260.     private String getFileThreshold() { 

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

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

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

  7281.         return this.fileThreshold;
  7282.     }
  7283.     
  7284.     private String filePrefix = null;
  7285.     public String getFilePrefix() { 

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

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

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

  7306.         return this.filePrefix;
  7307.     }
  7308.     
  7309.     private String fileSuffix = null;
  7310.     public String getFileSuffix() { 

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

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

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

  7331.         return this.fileSuffix;
  7332.     }
  7333.     
  7334.     private int deleteInterval = 0;
  7335.     public int getDeleteInterval() {    

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

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

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

  7356.         return this.deleteInterval;
  7357.     }

  7359.     /**
  7360.      * Restituisce l'intervallo di pulizia del repository di OpenSPCoop 
  7361.      *
  7362.      * @return Restituisce l'intervallo di pulizia del repository di OpenSPCoo
  7363.      * 
  7364.      */
  7365.     private Long repositoryIntervalloEliminazioneMessaggi = null;
  7366.     public long getRepositoryIntervalloEliminazioneMessaggi() { 
  7367.         if(this.repositoryIntervalloEliminazioneMessaggi==null){
  7368.             try{ 
  7369.                 String name = null;
  7370.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.timer");
  7371.                 if(name==null)
  7372.                     throw new CoreException(NON_DEFINITA);
  7373.                 name = name.trim();
  7374.                 this.repositoryIntervalloEliminazioneMessaggi = java.lang.Long.parseLong(name);
  7375.             }catch(java.lang.Exception e) {
  7376.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.timer': "+e.getMessage(),e);
  7377.                 this.repositoryIntervalloEliminazioneMessaggi = -1L;
  7378.             }   
  7379.         }

  7381.         return this.repositoryIntervalloEliminazioneMessaggi;
  7382.     }

  7384.     /**
  7385.      * Restituisce l'intervallo di tempo che definisce un msg scaduto nel repository di OpenSPCoop 
  7386.      *
  7387.      * @return Restituisce l'intervallo di tempo che definisce un msg scaduto nel repository di OpenSPCoo
  7388.      * 
  7389.      */
  7390.     private Long repositoryIntervalloScadenzaMessaggi = null;
  7391.     public long getRepositoryIntervalloScadenzaMessaggi() { 
  7392.         if(this.repositoryIntervalloScadenzaMessaggi == null){
  7393.             try{ 
  7394.                 String name = null;
  7395.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaMessaggio");
  7396.                 if(name==null)
  7397.                     throw new CoreException(NON_DEFINITA);
  7398.                 name = name.trim();
  7399.                 this.repositoryIntervalloScadenzaMessaggi = java.lang.Long.parseLong(name);
  7400.             }catch(java.lang.Exception e) {
  7401.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaMessaggio': "+e.getMessage(),e);
  7402.                 this.repositoryIntervalloScadenzaMessaggi = -1L;
  7403.             }    
  7404.         }

  7406.         return this.repositoryIntervalloScadenzaMessaggi;
  7407.     }
  7408.     
  7409.     private Boolean useSoapMessageReader = null;
  7410.     public boolean useSoapMessageReader() { 
  7411.         if(this.useSoapMessageReader==null){
  7412.             String pName = "org.openspcoop2.pdd.soapMessage.reader";
  7413.             try{ 
  7414.                 String name = null;
  7415.                 name = this.reader.getValueConvertEnvProperties(pName);
  7416.                 if(name==null){
  7417.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7418.                     name="true";
  7419.                 }
  7420.                 name = name.trim();
  7421.                 this.useSoapMessageReader = Boolean.parseBoolean(name);
  7422.             } catch(java.lang.Exception e) {
  7423.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  7424.                 this.useSoapMessageReader = true;
  7425.             }    
  7426.         }

  7428.         return this.useSoapMessageReader;
  7429.     }
  7430.     
  7431.     private Integer soapMessageReaderBufferThresholdKb = null;
  7432.     public int getSoapMessageReaderBufferThresholdKb() {    

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

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

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

  7453.         return this.soapMessageReaderBufferThresholdKb;
  7454.     }
  7455.     
  7456.     private Boolean useSoapMessageReaderHeaderOptimization = null;
  7457.     public boolean useSoapMessageReaderHeaderOptimization() {   
  7458.         if(this.useSoapMessageReaderHeaderOptimization==null){
  7459.             String pName = "org.openspcoop2.pdd.soapMessage.reader.headerOptimization";
  7460.             try{ 
  7461.                 String name = null;
  7462.                 name = this.reader.getValueConvertEnvProperties(pName);
  7463.                 if(name==null){
  7464.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7465.                     name="true";
  7466.                 }
  7467.                 name = name.trim();
  7468.                 this.useSoapMessageReaderHeaderOptimization = Boolean.parseBoolean(name);
  7469.             } catch(java.lang.Exception e) {
  7470.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  7471.                 this.useSoapMessageReaderHeaderOptimization = true;
  7472.             }    
  7473.         }

  7475.         return this.useSoapMessageReaderHeaderOptimization;
  7476.     }
  7477.     
  7478.     private Boolean useSoapMessagePassthrough = null;
  7479.     public boolean useSoapMessagePassthrough() {    
  7480.         if(this.useSoapMessagePassthrough==null){
  7481.             String pName = "org.openspcoop2.pdd.soapMessage.passthrough";
  7482.             try{ 
  7483.                 String name = null;
  7484.                 name = this.reader.getValueConvertEnvProperties(pName);
  7485.                 if(name==null){
  7486.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7487.                     name="true";
  7488.                 }
  7489.                 name = name.trim();
  7490.                 this.useSoapMessagePassthrough = Boolean.parseBoolean(name);
  7491.             } catch(java.lang.Exception e) {
  7492.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  7493.                 this.useSoapMessagePassthrough = true;
  7494.             }    
  7495.         }

  7497.         return this.useSoapMessagePassthrough;
  7498.     }
  7499.     
  7500.     private Integer soapMessageSaajSaxParserPoolSize = null;
  7501.     public int getSoapMessageSaajSaxParserPoolSize() {  

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

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

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

  7522.         return this.soapMessageSaajSaxParserPoolSize;
  7523.     }
  7524.     
  7525.     private List<String> alternativeContentTypeSoap12 = null;
  7526.     private boolean alternativeContentTypeSoap12Read = false;
  7527.     public List<String> getAlternativeContentTypeSoap12() { 
  7528.         if(!this.alternativeContentTypeSoap12Read){
  7529.             String pName = "org.openspcoop2.pdd.soapMessage.v12.alternativeContentTypes";
  7530.             try{ 
  7531.                 String name = null;
  7532.                 name = this.reader.getValueConvertEnvProperties(pName);
  7533.                 if(name==null){
  7534.                     this.alternativeContentTypeSoap12 = null;
  7535.                 }else{
  7536.                     String [] r = name.trim().split(",");
  7537.                     List<String> l = new ArrayList<>();
  7538.                     for(int i=0; i<r.length; i++){
  7539.                         r[i] = r[i].trim();
  7540.                         l.add(r[i]);
  7541.                     }
  7542.                     
  7543.                     if(!l.isEmpty()) {
  7544.                         this.alternativeContentTypeSoap12 = new ArrayList<>();
  7545.                         this.alternativeContentTypeSoap12.addAll(l);
  7546.                     }
  7547.                 }
  7548.             }catch(java.lang.Exception e) {
  7549.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+": "+e.getMessage(),e);
  7550.                 this.alternativeContentTypeSoap12 = null;
  7551.             }  
  7552.             this.alternativeContentTypeSoap12Read = true;
  7553.         }

  7555.         return this.alternativeContentTypeSoap12;
  7556.     }
  7557.     
  7558.     
  7559.     private Boolean useRestMultipartLazy = null;
  7560.     public boolean useRestMultipartLazy() { 
  7561.         if(this.useRestMultipartLazy==null){
  7562.             String pName = "org.openspcoop2.pdd.restMessage.multipart.lazy";
  7563.             try{ 
  7564.                 String name = null;
  7565.                 name = this.reader.getValueConvertEnvProperties(pName);
  7566.                 if(name==null){
  7567.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7568.                     name="true";
  7569.                 }
  7570.                 name = name.trim();
  7571.                 this.useRestMultipartLazy = Boolean.parseBoolean(name);
  7572.             } catch(java.lang.Exception e) {
  7573.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  7574.                 this.useRestMultipartLazy = true;
  7575.             }    
  7576.         }

  7578.         return this.useRestMultipartLazy;
  7579.     }
  7580.     
  7581.     
  7582.     
  7583.     /**
  7584.      * Restituisce L'indicazione se filtrare le buste rispetto alla scadenza della busta
  7585.      *
  7586.      * @return indicazione se filtrare le buste rispetto alla scadenza della busta
  7587.      * 
  7588.      */
  7589.     private Boolean repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione = null;
  7590.     public boolean isRepositoryBusteFiltraBusteScaduteRispettoOraRegistrazione() {  
  7591.         if(this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione==null){
  7592.             try{ 
  7593.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaMessaggio.filtraBusteScaduteRispettoOraRegistrazione");
  7594.                 if(value==null){
  7595.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaMessaggio.filtraBusteScaduteRispettoOraRegistrazione' non definita (Viene utilizzato il default:true)");
  7596.                     this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione = true;
  7597.                 }else{
  7598.                     this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione = Boolean.parseBoolean(value);
  7599.                 }
  7600.             }catch(java.lang.Exception e) {
  7601.                 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);
  7602.                 this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione = true;
  7603.             }    
  7604.         }

  7606.         return this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione;
  7607.     }

  7609.     /**
  7610.      * Restituisce l'intervallo di tempo che definisce una correlazione scaduta nel repository di OpenSPCoop 
  7611.      *
  7612.      * @return Restituisce l'intervallo di tempo che definisce una correlazione scaduta nel repository di OpenSPCoo
  7613.      * 
  7614.      */
  7615.     private Long repositoryIntervalloScadenzaCorrelazioneApplicativa = null;
  7616.     public long getRepositoryIntervalloScadenzaCorrelazioneApplicativa() {  
  7617.         if(this.repositoryIntervalloScadenzaCorrelazioneApplicativa == null){
  7618.             try{ 
  7619.                 String name = null;
  7620.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa");
  7621.                 if(name==null){
  7622.                     /** throw new CoreException(NON_DEFINITA); */
  7623.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa' non definita, viene usato il valore impostato nella proprieta 'org.openspcoop2.pdd.repository.scadenzaMessaggio'");
  7624.                     this.repositoryIntervalloScadenzaCorrelazioneApplicativa = getRepositoryIntervalloScadenzaMessaggi();
  7625.                 }
  7626.                 else{
  7627.                     name = name.trim();
  7628.                     this.repositoryIntervalloScadenzaCorrelazioneApplicativa = java.lang.Long.parseLong(name);
  7629.                 }
  7630.             }catch(java.lang.Exception e) {
  7631.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa': "+e.getMessage(),e);
  7632.                 this.repositoryIntervalloScadenzaCorrelazioneApplicativa = -1L;
  7633.             }    
  7634.         }
  7635.         
  7636.         return this.repositoryIntervalloScadenzaCorrelazioneApplicativa;
  7637.     }
  7638.     
  7639.     private Integer maxLengthCorrelazioneApplicativa = null;
  7640.     public int getMaxLengthCorrelazioneApplicativa() {  
  7641.         if(this.maxLengthCorrelazioneApplicativa == null){
  7642.             try{ 
  7643.                 String name = null;
  7644.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLength");
  7645.                 if(name==null){
  7646.                     /** throw new CoreException(NON_DEFINITA); */
  7647.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLength' non definita, viene usato il valore di default: 255");
  7648.                     this.maxLengthCorrelazioneApplicativa = 255;
  7649.                 }
  7650.                 else{
  7651.                     name = name.trim();
  7652.                     this.maxLengthCorrelazioneApplicativa = java.lang.Integer.parseInt(name);
  7653.                 }
  7654.             }catch(java.lang.Exception e) {
  7655.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLength': "+e.getMessage(),e);
  7656.                 this.maxLengthCorrelazioneApplicativa = 255;
  7657.             }    
  7658.         }
  7659.         
  7660.         return this.maxLengthCorrelazioneApplicativa;
  7661.     }
  7662.     
  7663.     private Boolean maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateActive = null;
  7664.     public boolean isMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate() {   
  7665.         if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateActive == null){
  7666.             String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLengthExceeded.identificazioneFallita.blocca.truncate";
  7667.             try{ 
  7668.                 String name = null;
  7669.                 name = this.reader.getValueConvertEnvProperties(pName);
  7670.                 if(name==null){
  7671.                     /** throw new CoreException(NON_DEFINITA); */
  7672.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non definita, viene usato il valore di default: false");
  7673.                     this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateActive = false;
  7674.                 }
  7675.                 else{
  7676.                     name = name.trim();
  7677.                     this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateActive = java.lang.Boolean.parseBoolean(name);
  7678.                 }
  7679.             }catch(java.lang.Exception e) {
  7680.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage()+". Viene usato il valore di default: false",e);
  7681.                 this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateActive = false;
  7682.             }    
  7683.         }
  7684.         
  7685.         return this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateActive;
  7686.     }
  7687.     
  7688.     private Integer maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate = null;
  7689.     private Boolean maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateRead = null;
  7690.     public Integer getMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate() {  
  7691.         if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateRead == null){
  7692.             String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLengthExceeded.identificazioneFallita.blocca.truncate.length";
  7693.             try{ 
  7694.                 String name = this.reader.getValueConvertEnvProperties(pName);
  7695.                 if(name!=null && StringUtils.isNotEmpty(name.trim())){
  7696.                     name = name.trim();
  7697.                     this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate = java.lang.Integer.parseInt(name);
  7698.                     if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate<=0) {
  7699.                         throw new CoreException("Deve essere fornito un valore maggiore di 0");
  7700.                     }
  7701.                     if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate>=getMaxLengthCorrelazioneApplicativa()) {
  7702.                         throw new CoreException("Deve essere fornito un valore minore di "+getMaxLengthCorrelazioneApplicativa());
  7703.                     }
  7704.                 }
  7705.                 else {
  7706.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non definita, viene usato il valore di default: 245");
  7707.                     this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate = 245;
  7708.                 }
  7709.             }catch(java.lang.Exception e) {
  7710.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  7711.                 this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate = null;
  7712.             }  
  7713.             
  7714.             this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncateRead = true;
  7715.         }
  7716.         
  7717.         return this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaBloccaTruncate;
  7718.     }
  7719.     
  7720.     private Boolean maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateActive = null;
  7721.     public boolean isMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate() {  
  7722.         if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateActive == null){
  7723.             String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLengthExceeded.identificazioneFallita.accetta.truncate";
  7724.             try{ 
  7725.                 String name = null;
  7726.                 name = this.reader.getValueConvertEnvProperties(pName);
  7727.                 if(name==null){
  7728.                     /** throw new CoreException(NON_DEFINITA); */
  7729.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non definita, viene usato il valore di default: false");
  7730.                     this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateActive = false;
  7731.                 }
  7732.                 else{
  7733.                     name = name.trim();
  7734.                     this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateActive = java.lang.Boolean.parseBoolean(name);
  7735.                 }
  7736.             }catch(java.lang.Exception e) {
  7737.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage()+". Viene usato il valore di default: false",e);
  7738.                 this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateActive = false;
  7739.             }    
  7740.         }
  7741.         
  7742.         return this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateActive;
  7743.     }
  7744.     
  7745.     private Integer maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate = null;
  7746.     private Boolean maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateRead = null;
  7747.     public Integer getMaxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate() { 
  7748.         if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateRead == null){
  7749.             String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.maxLengthExceeded.identificazioneFallita.accetta.truncate.length";
  7750.             try{ 
  7751.                 String name = this.reader.getValueConvertEnvProperties(pName);
  7752.                 if(name!=null && StringUtils.isNotEmpty(name.trim())){
  7753.                     name = name.trim();
  7754.                     this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate = java.lang.Integer.parseInt(name);
  7755.                     if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate<=0) {
  7756.                         throw new CoreException("Deve essere fornito un valore maggiore di 0");
  7757.                     }
  7758.                     if(this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate>=getMaxLengthCorrelazioneApplicativa()) {
  7759.                         throw new CoreException("Deve essere fornito un valore minore di "+getMaxLengthCorrelazioneApplicativa());
  7760.                     }
  7761.                 }
  7762.                 else {
  7763.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non definita, viene usato il valore di default: 245");
  7764.                     this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate = 245;
  7765.                 }
  7766.             }catch(java.lang.Exception e) {
  7767.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  7768.                 this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate = null;
  7769.             }  
  7770.             
  7771.             this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncateRead = true;
  7772.         }
  7773.         
  7774.         return this.maxLengthExceededCorrelazioneApplicativaIdentificazioneFallitaAccettaTruncate;
  7775.     }

  7777.     
  7778.     private Boolean isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione = null;
  7779.     public boolean isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione() {    
  7780.         
  7781.         if(this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione==null){
  7782.             try{ 
  7783.                 String name = null;
  7784.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione");
  7785.                 
  7786.                 if(name!=null){
  7787.                     name = name.trim();
  7788.                     this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione = Boolean.parseBoolean(name);
  7789.                 }else{
  7790.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione' non impostata, viene utilizzato il default=true");
  7791.                     this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione = true;
  7792.                 }
  7793.     
  7794.             }catch(java.lang.Exception e) {
  7795.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  7796.                 this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione = true;
  7797.             }    
  7798.         }
  7799.         
  7800.         return this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione;
  7801.     }
  7802.     
  7803.     private Boolean isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata = null;
  7804.     public boolean isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata() { 
  7805.         
  7806.         if(this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata==null){
  7807.             try{ 
  7808.                 String name = null;
  7809.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione.soloCorrelazioniSenzaScadenza");
  7810.                 
  7811.                 if(name!=null){
  7812.                     name = name.trim();
  7813.                     this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata = Boolean.parseBoolean(name);
  7814.                 }else{
  7815.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione.soloCorrelazioniSenzaScadenza' non impostata, viene utilizzato il default=false");
  7816.                     this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata = false;
  7817.                 }
  7818.     
  7819.             }catch(java.lang.Exception e) {
  7820.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione.soloCorrelazioniSenzaScadenza' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  7821.                 this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata = false;
  7822.             }    
  7823.         }
  7824.         
  7825.         return this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata;
  7826.     }
  7827.     

  7829.     private Boolean isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore = null;
  7830.     public boolean isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore() {  
  7831.         
  7832.         String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.richiesta.identificativoEstrattoIsNull.consideraErrore";
  7833.         if(this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore==null){
  7834.             try{ 
  7835.                 String name = null;
  7836.                 name = this.reader.getValueConvertEnvProperties(pName);
  7837.                 
  7838.                 if(name!=null){
  7839.                     name = name.trim();
  7840.                     this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore = Boolean.parseBoolean(name);
  7841.                 }else{
  7842.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7843.                     this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore = true;
  7844.                 }
  7845.     
  7846.             }catch(java.lang.Exception e) {
  7847.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true));
  7848.                 this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore = true;
  7849.             }    
  7850.         }
  7851.         
  7852.         return this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore;
  7853.     }
  7854.     
  7855.     private Boolean isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore = null;
  7856.     public boolean isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore() {   
  7857.         
  7858.         String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.risposta.identificativoEstrattoIsNull.consideraErrore";
  7859.         if(this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore==null){
  7860.             try{ 
  7861.                 String name = null;
  7862.                 name = this.reader.getValueConvertEnvProperties(pName);
  7863.                 
  7864.                 if(name!=null){
  7865.                     name = name.trim();
  7866.                     this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore = Boolean.parseBoolean(name);
  7867.                 }else{
  7868.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7869.                     this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore = true;
  7870.                 }
  7871.     
  7872.             }catch(java.lang.Exception e) {
  7873.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true));
  7874.                 this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore = true;
  7875.             }    
  7876.         }
  7877.         
  7878.         return this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore;
  7879.     }
  7880.     
  7881.     private Boolean isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore = null;
  7882.     public boolean isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore() { 
  7883.         
  7884.         String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.richiesta.identificativoEstrattoIsEmpty.consideraErrore";
  7885.         if(this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore==null){
  7886.             try{ 
  7887.                 String name = null;
  7888.                 name = this.reader.getValueConvertEnvProperties(pName);
  7889.                 
  7890.                 if(name!=null){
  7891.                     name = name.trim();
  7892.                     this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore = Boolean.parseBoolean(name);
  7893.                 }else{
  7894.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7895.                     this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore = true;
  7896.                 }
  7897.     
  7898.             }catch(java.lang.Exception e) {
  7899.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true));
  7900.                 this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore = true;
  7901.             }    
  7902.         }
  7903.         
  7904.         return this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore;
  7905.     }
  7906.     
  7907.     private Boolean isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore = null;
  7908.     public boolean isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore() {  
  7909.         
  7910.         String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.risposta.identificativoEstrattoIsEmpty.consideraErrore";
  7911.         if(this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore==null){
  7912.             try{ 
  7913.                 String name = null;
  7914.                 name = this.reader.getValueConvertEnvProperties(pName);
  7915.                 
  7916.                 if(name!=null){
  7917.                     name = name.trim();
  7918.                     this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore = Boolean.parseBoolean(name);
  7919.                 }else{
  7920.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7921.                     this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore = true;
  7922.                 }
  7923.     
  7924.             }catch(java.lang.Exception e) {
  7925.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true));
  7926.                 this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore = true;
  7927.             }    
  7928.         }
  7929.         
  7930.         return this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore;
  7931.     }
  7932.     
  7933.     
  7934.     private Boolean isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca = null;
  7935.     public boolean isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca() {   
  7936.         
  7937.         String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.richiesta.regolaCorrelazioneNonTrovata.blocca";
  7938.         if(this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca==null){
  7939.             try{ 
  7940.                 String name = null;
  7941.                 name = this.reader.getValueConvertEnvProperties(pName);
  7942.                 
  7943.                 if(name!=null){
  7944.                     name = name.trim();
  7945.                     this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca = Boolean.parseBoolean(name);
  7946.                 }else{
  7947.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  7948.                     this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca = false;
  7949.                 }
  7950.     
  7951.             }catch(java.lang.Exception e) {
  7952.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false));
  7953.                 this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca = false;
  7954.             }    
  7955.         }
  7956.         
  7957.         return this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca;
  7958.     }
  7959.     
  7960.     private Boolean isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca = null;
  7961.     public boolean isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca() {    
  7962.         
  7963.         String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.risposta.regolaCorrelazioneNonTrovata.blocca";
  7964.         if(this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca==null){
  7965.             try{ 
  7966.                 String name = null;
  7967.                 name = this.reader.getValueConvertEnvProperties(pName);
  7968.                 
  7969.                 if(name!=null){
  7970.                     name = name.trim();
  7971.                     this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca = Boolean.parseBoolean(name);
  7972.                 }else{
  7973.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  7974.                     this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca = false;
  7975.                 }
  7976.     
  7977.             }catch(java.lang.Exception e) {
  7978.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false));
  7979.                 this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca = false;
  7980.             }    
  7981.         }
  7982.         
  7983.         return this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca;
  7984.     }
  7985.     

  7987.     /**
  7988.      * Restituisce l'intervallo in millisecondi di attesa attiva per messaggi gia in processamento
  7989.      * 
  7990.      * @return Restituisce l'intervallo in millisecondi di attesa attiva per messaggi gia in processamento
  7991.      *  * 
  7992.      */
  7993.     private Long msgGiaInProcessamentoAttesaAttiva = null;
  7994.     public long getMsgGiaInProcessamentoAttesaAttiva() {    
  7995.         if(this.msgGiaInProcessamentoAttesaAttiva==null){
  7996.             try{ 
  7997.                 String name = null;
  7998.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.messaggioInProcessamento.attesaAttiva");

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

  8009.             }catch(java.lang.Exception e) {
  8010.                 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);
  8011.                 this.msgGiaInProcessamentoAttesaAttiva = CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_ATTESA_ATTIVA;
  8012.             }    
  8013.         }

  8015.         return this.msgGiaInProcessamentoAttesaAttiva;
  8016.     }

  8018.     /**
  8019.      * Restituisce l'intervallo maggiore per frequenza di check nell'attesa attiva effettuata dal TransactionManager, in millisecondi
  8020.      * 
  8021.      * @return Restituisce Intervallo maggiore per frequenza di check nell'attesa attiva effettuata dal TransactionManager, in millisecondi
  8022.      * 
  8023.      */
  8024.     private Integer msgGiaInProcessamentoCheckInterval = null;
  8025.     public int getMsgGiaInProcessamentoCheckInterval() {    
  8026.         String pName = "org.openspcoop2.pdd.repository.messaggioInProcessamento.check";
  8027.         if(this.msgGiaInProcessamentoCheckInterval==null){
  8028.             try{ 
  8029.                 String name = null;
  8030.                 name = this.reader.getValueConvertEnvProperties(pName);

  8032.                 if(name!=null){
  8033.                     name = name.trim();
  8034.                     int time = java.lang.Integer.parseInt(name);
  8035.                     this.msgGiaInProcessamentoCheckInterval = time;
  8036.                 }else{
  8037.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_CHECK_INTERVAL);
  8038.                     this.msgGiaInProcessamentoCheckInterval = CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_CHECK_INTERVAL;
  8039.                 }
  8040.             }catch(java.lang.Exception e) {
  8041.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  8042.                 this.msgGiaInProcessamentoCheckInterval = CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_CHECK_INTERVAL;
  8043.             }  
  8044.         }

  8046.         return this.msgGiaInProcessamentoCheckInterval;
  8047.     }
  8048.     
  8049.     private Boolean msgGiaInProcessamentoUseLock = null;
  8050.     public boolean isMsgGiaInProcessamentoUseLock() {   
  8051.         if(this.msgGiaInProcessamentoUseLock==null){
  8052.             String pName = "org.openspcoop2.pdd.repository.messaggioInProcessamento.useLock";
  8053.             try{ 
  8054.                 String name = null;
  8055.                 name = this.reader.getValueConvertEnvProperties(pName);

  8057.                 if(name!=null){
  8058.                     name = name.trim();
  8059.                     this.msgGiaInProcessamentoUseLock = Boolean.valueOf(name);
  8060.                 }else{
  8061.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+false);
  8062.                     this.msgGiaInProcessamentoUseLock = false;
  8063.                 }
  8064.             }catch(java.lang.Exception e) {
  8065.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+false+", errore:"+e.getMessage(),e);
  8066.                 this.msgGiaInProcessamentoUseLock = false;
  8067.             }  
  8068.         }

  8070.         return this.msgGiaInProcessamentoUseLock;
  8071.     }

  8073.     /**
  8074.      * Restituisce l'IThreshold utilizzato da OpenSPCoop 
  8075.      *
  8076.      * @return Restituisce l'IThreshold utilizzato da OpenSPCoop.
  8077.      * 
  8078.      */
  8079.     private List<String> repositoryThresholdTypes = null;
  8080.     private boolean repositoryThresholdTypesRead = false;
  8081.     public List<String> getRepositoryThresholdTypes() { 
  8082.         if(!this.repositoryThresholdTypesRead){
  8083.             try{ 
  8084.                 String name = null;
  8085.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.threshold.tipi");
  8086.                 if(name==null){
  8087.                     this.repositoryThresholdTypes = null;
  8088.                 }else{
  8089.                     String [] r = name.trim().split(",");
  8090.                     List<String> l = new ArrayList<>();
  8091.                     for(int i=0; i<r.length; i++){
  8092.                         r[i] = r[i].trim();
  8093.                         l.add(r[i]);
  8094.                     }
  8095.                     
  8096.                     if(!l.isEmpty()) {
  8097.                         this.repositoryThresholdTypes = new ArrayList<>();
  8098.                         this.repositoryThresholdTypes.addAll(l);
  8099.                     }
  8100.                 }
  8101.             }catch(java.lang.Exception e) {
  8102.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.threshold.tipi': "+e.getMessage(),e);
  8103.                 this.repositoryThresholdTypes = null;
  8104.             }  
  8105.             this.repositoryThresholdTypesRead = true;
  8106.         }

  8108.         return this.repositoryThresholdTypes;
  8109.     }
  8110.     /**
  8111.      * Restituisce la soglia utilizzata dall'IThreshold utilizzato da OpenSPCoop 
  8112.      *
  8113.      * @return Restituisce la soglia utilizzata dall'IThreshold utilizzato da OpenSPCoop.
  8114.      * 
  8115.      */
  8116.     private Properties repositoryThresholdParameters = null;
  8117.     private boolean repositoryThresholdParametersRead = false;
  8118.     public Properties getRepositoryThresholdParameters(String tipoThreshould) { 
  8119.         if(!this.repositoryThresholdParametersRead){
  8120.             try{ 
  8121.                 this.repositoryThresholdParameters = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.repository.threshold."+tipoThreshould+".");
  8122.             }catch(java.lang.Exception e) {
  8123.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.threshold."+tipoThreshould+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  8124.                 this.repositoryThresholdParameters = null;
  8125.             }  
  8126.             this.repositoryThresholdParametersRead = true; 
  8127.         }

  8129.         return this.repositoryThresholdParameters;
  8130.     }

  8132.     /**
  8133.      * Restituisce l'intervallo per il timer di Threshold
  8134.      *
  8135.      * @return Restituisce l'intervallo per il timer di Threshold
  8136.      * 
  8137.      */
  8138.     private Long repositoryThresholdCheckInterval = null;
  8139.     public long getRepositoryThresholdCheckInterval() { 
  8140.         if(this.repositoryThresholdCheckInterval == null){
  8141.             try{ 
  8142.                 String name = null;
  8143.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.threshold.checkInterval");
  8144.                 if(name!=null){
  8145.                     name = name.trim();
  8146.                     this.repositoryThresholdCheckInterval = java.lang.Long.parseLong(name);
  8147.                 }else{
  8148.                     this.repositoryThresholdCheckInterval = 0L;
  8149.                 }
  8150.             }catch(java.lang.Exception e) {
  8151.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.threshold.checkInterval': "+e.getMessage(),e);
  8152.                 this.repositoryThresholdCheckInterval = -1L;
  8153.             }    
  8154.         }

  8156.         return this.repositoryThresholdCheckInterval;
  8157.     }

  8159.     /**
  8160.      * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione xml
  8161.      *   
  8162.      * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione xml
  8163.      * 
  8164.      */
  8165.     private Boolean isValidazioneSemanticaConfigurazioneStartupXML = null;
  8166.     public boolean isValidazioneSemanticaConfigurazioneStartupXML(){

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

  8172.                 if (value != null){
  8173.                     value = value.trim();
  8174.                     if(CostantiConfigurazione.ABILITATO.equals(value)){
  8175.                         this.isValidazioneSemanticaConfigurazioneStartupXML = true;
  8176.                     }else if(CostantiConfigurazione.DISABILITATO.equals(value)){
  8177.                         this.isValidazioneSemanticaConfigurazioneStartupXML = false;
  8178.                     }
  8179.                     else{
  8180.                         throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
  8181.                     }
  8182.                 }else{
  8183.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.config.xml.validazioneSemantica' non impostata, viene utilizzato il default=true");
  8184.                     this.isValidazioneSemanticaConfigurazioneStartupXML = true;
  8185.                 }

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

  8193.         return this.isValidazioneSemanticaConfigurazioneStartupXML;
  8194.     }
  8195.     /**
  8196.      * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione
  8197.      *   
  8198.      * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione
  8199.      * 
  8200.      */
  8201.     private Boolean isValidazioneSemanticaConfigurazioneStartup = null;
  8202.     public boolean isValidazioneSemanticaConfigurazioneStartup(){

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

  8208.                 if (value != null){
  8209.                     value = value.trim();
  8210.                     if(CostantiConfigurazione.ABILITATO.equals(value)){
  8211.                         this.isValidazioneSemanticaConfigurazioneStartup = true;
  8212.                     }else if(CostantiConfigurazione.DISABILITATO.equals(value)){
  8213.                         this.isValidazioneSemanticaConfigurazioneStartup = false;
  8214.                     }
  8215.                     else{
  8216.                         throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
  8217.                     }
  8218.                 }else{
  8219.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.config.validazioneSemantica' non impostata, viene utilizzato il default=false");
  8220.                     this.isValidazioneSemanticaConfigurazioneStartup = false;
  8221.                 }

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

  8229.         return this.isValidazioneSemanticaConfigurazioneStartup;
  8230.     }
  8231.     /**
  8232.      * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della registro servizi xml
  8233.      *   
  8234.      * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della registro servizi xml
  8235.      * 
  8236.      */
  8237.     private Boolean isValidazioneSemanticaRegistroServiziStartupXML = null;
  8238.     public boolean isValidazioneSemanticaRegistroServiziStartupXML(){

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

  8244.                 if (value != null){
  8245.                     value = value.trim();
  8246.                     if(CostantiConfigurazione.ABILITATO.equals(value)){
  8247.                         this.isValidazioneSemanticaRegistroServiziStartupXML = true;
  8248.                     }else if(CostantiConfigurazione.DISABILITATO.equals(value)){
  8249.                         this.isValidazioneSemanticaRegistroServiziStartupXML = false;
  8250.                     }
  8251.                     else{
  8252.                         throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
  8253.                     }
  8254.                 }else{
  8255.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.registri.xml.validazioneSemantica' non impostata, viene utilizzato il default=true");
  8256.                     this.isValidazioneSemanticaRegistroServiziStartupXML = true;
  8257.                 }

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

  8265.         return this.isValidazioneSemanticaRegistroServiziStartupXML;
  8266.     }
  8267.     /**
  8268.      * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della registro servizi
  8269.      *   
  8270.      * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della registro servizi
  8271.      * 
  8272.      */
  8273.     private Boolean isValidazioneSemanticaRegistroServiziStartup = null;
  8274.     public boolean isValidazioneSemanticaRegistroServiziStartup(){

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

  8280.                 if (value != null){
  8281.                     value = value.trim();
  8282.                     if(CostantiConfigurazione.ABILITATO.equals(value)){
  8283.                         this.isValidazioneSemanticaRegistroServiziStartup = true;
  8284.                     }else if(CostantiConfigurazione.DISABILITATO.equals(value)){
  8285.                         this.isValidazioneSemanticaRegistroServiziStartup = false;
  8286.                     }
  8287.                     else{
  8288.                         throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
  8289.                     }
  8290.                 }else{
  8291.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.registri.validazioneSemantica' non impostata, viene utilizzato il default=false");
  8292.                     this.isValidazioneSemanticaRegistroServiziStartup = false;
  8293.                 }

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

  8301.         return this.isValidazioneSemanticaRegistroServiziStartup;
  8302.     }
  8303.     /**
  8304.      * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione
  8305.      *   
  8306.      * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione
  8307.      * 
  8308.      */
  8309.     private Boolean isValidazioneSemanticaRegistroServiziCheckURI = null;
  8310.     public boolean isValidazioneSemanticaRegistroServiziCheckURI(){

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

  8316.                 if (value != null){
  8317.                     value = value.trim();
  8318.                     if(CostantiConfigurazione.ABILITATO.equals(value)){
  8319.                         this.isValidazioneSemanticaRegistroServiziCheckURI = true;
  8320.                     }else if(CostantiConfigurazione.DISABILITATO.equals(value)){
  8321.                         this.isValidazioneSemanticaRegistroServiziCheckURI = false;
  8322.                     }
  8323.                     else{
  8324.                         throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
  8325.                     }
  8326.                 }else{
  8327.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.registri.validazioneSemantica.checkURI' non impostata, viene utilizzato il default=false");
  8328.                     this.isValidazioneSemanticaRegistroServiziCheckURI = false;
  8329.                 }

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

  8337.         return this.isValidazioneSemanticaRegistroServiziCheckURI;
  8338.     }
  8339.     

  8341.     private static final String RISORSE_DB = "db";
  8342.     private static final String RISORSE_JMS = "jms";
  8343.     private static final String RISORSE_TRACCIAMENTO = "tracciamento";
  8344.     private static final String RISORSE_MSGDIAGNOSTICI = "msgdiagnostici";
  8345.     private static final String RISORSE_CONFIGURAZIONE = "configurazione";
  8346.     private static final String RISORSE_CONFIGURAZIONE_VALIDAZIONE_SEMANTICA = "configurazione.validazioneSemantica";
  8347.     private static final String RISORSE_REGISTRI = "registri";
  8348.     private static final String RISORSE_REGISTRI_VALIDAZIONE_SEMANTICA = "registri.validazioneSemantica";
  8349.     
  8350.     private static final String RISORSE_PROPERTY_NAME_CHECK = "org.openspcoop2.pdd.risorse.check.";

  8352.     private Boolean isAbilitatoControlloRisorseDB = null;
  8353.     public boolean isAbilitatoControlloRisorseDB() {    
  8354.         if(this.isAbilitatoControlloRisorseDB==null){
  8355.             this.isAbilitatoControlloRisorseDB = isAbilitatoControlloRisorse(RISORSE_DB);
  8356.         }
  8357.         return this.isAbilitatoControlloRisorseDB;
  8358.     }
  8359.     private Boolean isAbilitatoControlloRisorseJMS = null;
  8360.     public boolean isAbilitatoControlloRisorseJMS() {   
  8361.         if(this.isAbilitatoControlloRisorseJMS==null){
  8362.             this.isAbilitatoControlloRisorseJMS = isAbilitatoControlloRisorse(RISORSE_JMS);
  8363.         }
  8364.         return this.isAbilitatoControlloRisorseJMS;
  8365.     }
  8366.     private Boolean isAbilitatoControlloRisorseTracciamentiPersonalizzati = null;
  8367.     public boolean isAbilitatoControlloRisorseTracciamentiPersonalizzati() {    
  8368.         if(this.isAbilitatoControlloRisorseTracciamentiPersonalizzati==null){
  8369.             this.isAbilitatoControlloRisorseTracciamentiPersonalizzati = isAbilitatoControlloRisorse(RISORSE_TRACCIAMENTO);
  8370.         }
  8371.         return this.isAbilitatoControlloRisorseTracciamentiPersonalizzati;
  8372.     }
  8373.     private Boolean isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati = null;
  8374.     public boolean isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati() {  
  8375.         if(this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati==null){
  8376.             this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati = isAbilitatoControlloRisorse(RISORSE_MSGDIAGNOSTICI);
  8377.         }
  8378.         return this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati;
  8379.     }
  8380.     private Boolean isAbilitatoControlloRisorseConfigurazione = null;
  8381.     public boolean isAbilitatoControlloRisorseConfigurazione() {    
  8382.         if(this.isAbilitatoControlloRisorseConfigurazione==null){
  8383.             this.isAbilitatoControlloRisorseConfigurazione = isAbilitatoControlloRisorse(RISORSE_CONFIGURAZIONE);
  8384.         }
  8385.         return this.isAbilitatoControlloRisorseConfigurazione;
  8386.     }
  8387.     private Boolean isAbilitatoControlloValidazioneSemanticaConfigurazione = null;
  8388.     public boolean isAbilitatoControlloValidazioneSemanticaConfigurazione() {   
  8389.         if(this.isAbilitatoControlloValidazioneSemanticaConfigurazione==null){
  8390.             this.isAbilitatoControlloValidazioneSemanticaConfigurazione = isAbilitatoControlloRisorse(RISORSE_CONFIGURAZIONE_VALIDAZIONE_SEMANTICA);
  8391.         }
  8392.         return this.isAbilitatoControlloValidazioneSemanticaConfigurazione;
  8393.     }
  8394.     private Boolean isAbilitatoControlloRisorseRegistriServizi = null;
  8395.     public boolean isAbilitatoControlloRisorseRegistriServizi() {   
  8396.         if(this.isAbilitatoControlloRisorseRegistriServizi==null){
  8397.             this.isAbilitatoControlloRisorseRegistriServizi = isAbilitatoControlloRisorse(RISORSE_REGISTRI);
  8398.         }
  8399.         return this.isAbilitatoControlloRisorseRegistriServizi;
  8400.     }
  8401.     private Boolean isAbilitatoControlloValidazioneSemanticaRegistriServizi = null;
  8402.     public boolean isAbilitatoControlloValidazioneSemanticaRegistriServizi() {  
  8403.         if(this.isAbilitatoControlloValidazioneSemanticaRegistriServizi==null){
  8404.             this.isAbilitatoControlloValidazioneSemanticaRegistriServizi = isAbilitatoControlloRisorse(RISORSE_REGISTRI_VALIDAZIONE_SEMANTICA);
  8405.         }
  8406.         return this.isAbilitatoControlloValidazioneSemanticaRegistriServizi;
  8407.     }
  8408.     private boolean isAbilitatoControlloRisorse(String tipo) {  
  8409.         try{  
  8410.             String value = this.reader.getValueConvertEnvProperties(RISORSE_PROPERTY_NAME_CHECK+tipo); 
  8411.             if(value==null){
  8412.                 this.logWarn(getMessaggioProprietaNonImpostata(RISORSE_PROPERTY_NAME_CHECK+tipo, false));
  8413.                 return false;
  8414.             }
  8415.             return CostantiConfigurazione.ABILITATO.equals(value);
  8416.         }catch(java.lang.Exception e) {
  8417.             this.logWarn(getMessaggioProprietaNonImpostata(RISORSE_PROPERTY_NAME_CHECK+tipo, e, false));
  8418.             return false;
  8419.         }
  8420.     }
  8421.     private Boolean isControlloRisorseRegistriRaggiungibilitaTotale = null;
  8422.     public boolean isControlloRisorseRegistriRaggiungibilitaTotale() {  
  8423.         if(this.isControlloRisorseRegistriRaggiungibilitaTotale==null){
  8424.             try{  
  8425.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.risorse.check.registri.tipo"); 
  8426.                 if(value==null){
  8427.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.check.registri.tipo' non impostata, viene utilizzato il default=false");
  8428.                     this.isControlloRisorseRegistriRaggiungibilitaTotale = false;
  8429.                 }
  8430.                 else
  8431.                     this.isControlloRisorseRegistriRaggiungibilitaTotale = "singolo".equals(value);
  8432.             }catch(java.lang.Exception e) {
  8433.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.check.registri.tipo' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  8434.                 this.isControlloRisorseRegistriRaggiungibilitaTotale = false;
  8435.             }
  8436.         }

  8438.         return this.isControlloRisorseRegistriRaggiungibilitaTotale;
  8439.     }
  8440.     
  8441.     
  8442.     private Integer getNumeroIterazioniFalliteControlloRisorseDB = null;
  8443.     public int getNumeroIterazioniFalliteControlloRisorseDB() { 
  8444.         if(this.getNumeroIterazioniFalliteControlloRisorseDB==null){
  8445.             this.getNumeroIterazioniFalliteControlloRisorseDB = getNumeroIterazioniFalliteControlloRisorse(RISORSE_DB);
  8446.         }
  8447.         return this.getNumeroIterazioniFalliteControlloRisorseDB;
  8448.     }
  8449.     private Integer getNumeroIterazioniFalliteControlloRisorseJMS = null;
  8450.     public int getNumeroIterazioniFalliteControlloRisorseJMS() {    
  8451.         if(this.getNumeroIterazioniFalliteControlloRisorseJMS==null){
  8452.             this.getNumeroIterazioniFalliteControlloRisorseJMS = getNumeroIterazioniFalliteControlloRisorse(RISORSE_JMS);
  8453.         }
  8454.         return this.getNumeroIterazioniFalliteControlloRisorseJMS;
  8455.     }
  8456.     private Integer getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati = null;
  8457.     public int getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati() { 
  8458.         if(this.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati==null){
  8459.             this.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati = getNumeroIterazioniFalliteControlloRisorse(RISORSE_TRACCIAMENTO);
  8460.         }
  8461.         return this.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati;
  8462.     }
  8463.     private Integer getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati = null;
  8464.     public int getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati() {   
  8465.         if(this.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati==null){
  8466.             this.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati = getNumeroIterazioniFalliteControlloRisorse(RISORSE_MSGDIAGNOSTICI);
  8467.         }
  8468.         return this.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati;
  8469.     }
  8470.     private Integer getNumeroIterazioniFalliteControlloRisorseConfigurazione = null;
  8471.     public int getNumeroIterazioniFalliteControlloRisorseConfigurazione() { 
  8472.         if(this.getNumeroIterazioniFalliteControlloRisorseConfigurazione==null){
  8473.             this.getNumeroIterazioniFalliteControlloRisorseConfigurazione = getNumeroIterazioniFalliteControlloRisorse(RISORSE_CONFIGURAZIONE);
  8474.         }
  8475.         return this.getNumeroIterazioniFalliteControlloRisorseConfigurazione;
  8476.     }
  8477.     private Integer getNumeroIterazioniFalliteControlloRisorseRegistriServizi = null;
  8478.     public int getNumeroIterazioniFalliteControlloRisorseRegistriServizi() {    
  8479.         if(this.getNumeroIterazioniFalliteControlloRisorseRegistriServizi==null){
  8480.             this.getNumeroIterazioniFalliteControlloRisorseRegistriServizi = getNumeroIterazioniFalliteControlloRisorse(RISORSE_REGISTRI);
  8481.         }
  8482.         return this.getNumeroIterazioniFalliteControlloRisorseRegistriServizi;
  8483.     }
  8484.     private int getNumeroIterazioniFalliteControlloRisorse(String tipo) {   
  8485.         try{  
  8486.             String value = this.reader.getValueConvertEnvProperties(RISORSE_PROPERTY_NAME_CHECK+tipo+".iterazioni"); 
  8487.             if(value==null){
  8488.                 this.logWarn("Proprieta' di openspcoop '"+RISORSE_PROPERTY_NAME_CHECK+""+tipo+".iterazioni' non impostata, viene utilizzato il default=1");
  8489.                 return 1;
  8490.             }
  8491.             return Integer.parseInt(value);
  8492.         }catch(java.lang.Exception e) {
  8493.             this.logWarn("Proprieta' di openspcoop '"+RISORSE_PROPERTY_NAME_CHECK+""+tipo+"' non impostata, viene utilizzato il default=1, errore:"+e.getMessage(),e);
  8494.             return 1;
  8495.         }
  8496.     }
  8497.     
  8498.     private Integer getIterazioniFalliteCheckIntervalControlloRisorseDB = null;
  8499.     public int getIterazioniFalliteCheckIntervalControlloRisorseDB() {  
  8500.         if(this.getIterazioniFalliteCheckIntervalControlloRisorseDB==null){
  8501.             this.getIterazioniFalliteCheckIntervalControlloRisorseDB = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_DB);
  8502.         }
  8503.         return this.getIterazioniFalliteCheckIntervalControlloRisorseDB;
  8504.     }
  8505.     private Integer getIterazioniFalliteCheckIntervalControlloRisorseJMS = null;
  8506.     public int getIterazioniFalliteCheckIntervalControlloRisorseJMS() { 
  8507.         if(this.getIterazioniFalliteCheckIntervalControlloRisorseJMS==null){
  8508.             this.getIterazioniFalliteCheckIntervalControlloRisorseJMS = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_JMS);
  8509.         }
  8510.         return this.getIterazioniFalliteCheckIntervalControlloRisorseJMS;
  8511.     }
  8512.     private Integer getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati = null;
  8513.     public int getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati() {  
  8514.         if(this.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati==null){
  8515.             this.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_TRACCIAMENTO);
  8516.         }
  8517.         return this.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati;
  8518.     }
  8519.     private Integer getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati = null;
  8520.     public int getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati() {    
  8521.         if(this.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati==null){
  8522.             this.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_MSGDIAGNOSTICI);
  8523.         }
  8524.         return this.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati;
  8525.     }
  8526.     private Integer getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione = null;
  8527.     public int getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione() {  
  8528.         if(this.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione==null){
  8529.             this.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_CONFIGURAZIONE);
  8530.         }
  8531.         return this.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione;
  8532.     }
  8533.     private Integer getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi = null;
  8534.     public int getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi() { 
  8535.         if(this.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi==null){
  8536.             this.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_REGISTRI);
  8537.         }
  8538.         return this.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi;
  8539.     }
  8540.     private int getIterazioniFalliteCheckIntervalControlloRisorse(String tipo) {    
  8541.         try{  
  8542.             String value = this.reader.getValueConvertEnvProperties(RISORSE_PROPERTY_NAME_CHECK+tipo+".checkInterval"); 
  8543.             if(value==null){
  8544.                 this.logWarn("Proprieta' di openspcoop '"+RISORSE_PROPERTY_NAME_CHECK+""+tipo+".checkInterval' non impostata, viene utilizzato il default=500");
  8545.                 return 500;
  8546.             }
  8547.             return Integer.parseInt(value);
  8548.         }catch(java.lang.Exception e) {
  8549.             this.logWarn("Proprieta' di openspcoop '"+RISORSE_PROPERTY_NAME_CHECK+""+tipo+".checkInterval' non impostata, viene utilizzato il default=500, errore:"+e.getMessage(),e);
  8550.             return 500;
  8551.         }
  8552.     }
  8553.     
  8554.     /**
  8555.      * Restituisce l'intervallo per il timer di Threshold
  8556.      *
  8557.      * @return Restituisce l'intervallo per il timer di Threshold
  8558.      * 
  8559.      */
  8560.     private Long controlloRisorseCheckInterval = null;
  8561.     public long getControlloRisorseCheckInterval() {    
  8562.         if(this.controlloRisorseCheckInterval==null){
  8563.             try{ 
  8564.                 String name = null;
  8565.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.risorse.checkInterval");
  8566.                 if(name!=null){
  8567.                     name = name.trim();
  8568.                     this.controlloRisorseCheckInterval = java.lang.Long.parseLong(name);
  8569.                 }else{
  8570.                     this.controlloRisorseCheckInterval = 0L;
  8571.                 }
  8572.             }catch(java.lang.Exception e) {
  8573.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.checkInterval': "+e.getMessage(),e);
  8574.                 this.controlloRisorseCheckInterval = -1L;
  8575.             }    
  8576.         }

  8578.         return this.controlloRisorseCheckInterval;
  8579.     }

  8581.     private Boolean isControlloRisorseRegistrazioneEvento = null;
  8582.     public boolean isControlloRisorseRegistrazioneEvento() {    
  8583.         if(this.isControlloRisorseRegistrazioneEvento==null){
  8584.             try{ 
  8585.                 String name = null;
  8586.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.risorse.registraEvento");
  8587.                 if(name==null){
  8588.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.registraEvento' non impostata, viene utilizzato il default=true");
  8589.                     name="true";
  8590.                 }
  8591.                 name = name.trim();
  8592.                 this.isControlloRisorseRegistrazioneEvento = Boolean.parseBoolean(name);
  8593.             } catch(java.lang.Exception e) {
  8594.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.registraEvento', viene utilizzato il default=true : "+e.getMessage(),e);
  8595.                 this.isControlloRisorseRegistrazioneEvento = true;
  8596.             }    
  8597.         }

  8599.         return this.isControlloRisorseRegistrazioneEvento;
  8600.     }






  8607.     /* ******** ERRORE APPLICATIVO  ******** */

  8609.     /**
  8610.      * Restituisce le proprieta' di default utilizzate dalla porta di dominio per invocazioni di porte delegate che generano errori
  8611.      *
  8612.      * @return Restituisce le proprieta' di default utilizzate dalla porta di dominio per invocazioni di porte delegate che generano errori
  8613.      * 
  8614.      */
  8615.     private ProprietaErroreApplicativo proprietaGestioneErrorePD = null;
  8616.     public ProprietaErroreApplicativo getProprietaGestioneErrorePD(IProtocolManager protocolManager){
  8617.         return getProprietaGestioneErrorePD_engine(protocolManager,false);
  8618.     }
  8619.     private ProprietaErroreApplicativo getProprietaGestioneErrorePD_engine(IProtocolManager protocolManager,boolean testPerValidazione){
  8620.         if(this.proprietaGestioneErrorePD==null){
  8621.             String fault = null;
  8622.             try{  
  8623.                 fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.fault"); 
  8624.                 if(fault==null)
  8625.                     throw new CoreException(NON_DEFINITA);
  8626.                 fault = fault.trim();       
  8627.             }catch(java.lang.Exception e) {
  8628.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.fault': "+e.getMessage(),e);
  8629.                 return null;
  8630.             }

  8632.             String faultCodeIntegrationNamespace = null;
  8633.             try{  
  8634.                 faultCodeIntegrationNamespace = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultCode.integrationNamespace"); 
  8635.                 if(faultCodeIntegrationNamespace!=null) {
  8636.                     faultCodeIntegrationNamespace = faultCodeIntegrationNamespace.trim();
  8637.                 }
  8638.             }catch(java.lang.Exception e) {
  8639.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultCode.integrationNamespace': "+e.getMessage(),e);
  8640.             }
  8641.             
  8642.             String faultCodeProtocolNamespace = null;
  8643.             try{  
  8644.                 faultCodeProtocolNamespace = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultCode.protocolNamespace"); 
  8645.                 if(faultCodeProtocolNamespace!=null) {
  8646.                     faultCodeProtocolNamespace = faultCodeProtocolNamespace.trim();
  8647.                 }
  8648.             }catch(java.lang.Exception e) {
  8649.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultCode.protocolNamespace': "+e.getMessage(),e);
  8650.             }
  8651.             
  8652.             String faultActor = null;
  8653.             try{  
  8654.                 faultActor = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultActor"); 
  8655.                 if(faultActor==null)
  8656.                     throw new CoreException(NON_DEFINITA);
  8657.                 faultActor = faultActor.trim();     
  8658.             }catch(java.lang.Exception e) {
  8659.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultActor': "+e.getMessage(),e);
  8660.                 return null;
  8661.             }

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

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

  8683.             ProprietaErroreApplicativo gestione = new ProprietaErroreApplicativo();
  8684.             if(CostantiConfigurazione.ERRORE_APPLICATIVO_XML.equals(fault))
  8685.                 gestione.setFaultAsXML(true);
  8686.             else
  8687.                 gestione.setFaultAsXML(false); // default: ERRORE_APPLICATIVO_SOAP
  8688.             gestione.setDefaultFaultCodeIntegrationNamespace(faultCodeIntegrationNamespace);
  8689.             gestione.setDefaultFaultCodeProtocolNamespace(faultCodeProtocolNamespace);
  8690.             gestione.setFaultActor(faultActor);
  8691.             if(CostantiConfigurazione.ABILITATO.equals(faultGeneric))
  8692.                 gestione.setFaultAsGenericCode(true);
  8693.             else
  8694.                 gestione.setFaultAsGenericCode(false); // default: false
  8695.             gestione.setFaultPrefixCode(faultPrefix);

  8697.             gestione.setInsertAsDetails(this.isErroreApplicativoIntoDetails());
  8698.             
  8699.             gestione.setAggiungiDetailErroreApplicativo_SoapFaultApplicativo(this.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo());
  8700.             
  8701.             gestione.setAggiungiDetailErroreApplicativo_SoapFaultPdD(this.isAggiungiDetailErroreApplicativo_SoapFaultPdD());

  8703.             this.proprietaGestioneErrorePD = gestione;
  8704.         }

  8706.         ProprietaErroreApplicativo pNew = new ProprietaErroreApplicativo();
  8707.         pNew.setDominio(this.proprietaGestioneErrorePD.getDominio());
  8708.         pNew.setDefaultFaultCodeIntegrationNamespace(this.proprietaGestioneErrorePD.getDefaultFaultCodeIntegrationNamespace());
  8709.         pNew.setDefaultFaultCodeProtocolNamespace(this.proprietaGestioneErrorePD.getDefaultFaultCodeProtocolNamespace());
  8710.         pNew.setFaultActor(this.proprietaGestioneErrorePD.getFaultActor());
  8711.         pNew.setFaultAsGenericCode(this.proprietaGestioneErrorePD.isFaultAsGenericCode());
  8712.         pNew.setFaultAsXML(this.proprietaGestioneErrorePD.isFaultAsXML());
  8713.         pNew.setFaultPrefixCode(this.proprietaGestioneErrorePD.getFaultPrefixCode());
  8714.         pNew.setIdModulo(this.proprietaGestioneErrorePD.getIdModulo());
  8715.         pNew.setInsertAsDetails(this.proprietaGestioneErrorePD.isInsertAsDetails());
  8716.         pNew.setAggiungiDetailErroreApplicativo_SoapFaultApplicativo(this.proprietaGestioneErrorePD.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo());
  8717.         pNew.setAggiungiDetailErroreApplicativo_SoapFaultPdD(this.proprietaGestioneErrorePD.isAggiungiDetailErroreApplicativo_SoapFaultPdD());
  8718.         if(protocolManager!=null){
  8719.             FaultIntegrationGenericInfoMode sf = protocolManager.getModalitaGenerazioneInformazioniGeneriche_DetailsFaultIntegrazione();
  8720.             if(FaultIntegrationGenericInfoMode.SERVIZIO_APPLICATIVO.equals(sf)){
  8721.                 pNew.setInformazioniGenericheDetailsOpenSPCoop(null);
  8722.             }
  8723.             else if(FaultIntegrationGenericInfoMode.ABILITATO.equals(sf)){
  8724.                 pNew.setInformazioniGenericheDetailsOpenSPCoop(true);
  8725.             } 
  8726.             else if(FaultIntegrationGenericInfoMode.DISABILITATO.equals(sf)){
  8727.                 pNew.setInformazioniGenericheDetailsOpenSPCoop(false);
  8728.             } 
  8729.             
  8730.             BooleanNullable enrichNullable = protocolManager.isAggiungiDetailErroreApplicativo_FaultApplicativo();
  8731.             if(enrichNullable!=null && enrichNullable.getValue()!=null){
  8732.                 pNew.setAggiungiDetailErroreApplicativo_SoapFaultApplicativo(enrichNullable.getValue());
  8733.             }
  8734.             
  8735.             enrichNullable = protocolManager.isAggiungiDetailErroreApplicativo_FaultPdD();
  8736.             if(enrichNullable!=null && enrichNullable.getValue()!=null){
  8737.                 pNew.setAggiungiDetailErroreApplicativo_SoapFaultPdD(enrichNullable.getValue());
  8738.             }
  8739.             
  8740.         }else{
  8741.             pNew.setInformazioniGenericheDetailsOpenSPCoop(null); // default
  8742.         }
  8743.         return pNew;
  8744.     }


  8747.     private Locale localeSOAPFaultString = null;
  8748.     private Boolean localeSOAPFaultStringRead = null;
  8749.     public Locale getLocaleSOAPFaultString(){
  8750.         if(this.localeSOAPFaultStringRead==null){
  8751.             try{  
  8752.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultString.language"); 
  8753.                 if (value != null){
  8754.                     value = value.trim();
  8755.                     
  8756.                     String language = value;
  8757.                     
  8758.                     String country = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultString.country"); 
  8759.                     if(country!=null) {
  8760.                         country = country.trim();
  8761.                     }
  8762.                     
  8763.                     String variant = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultString.variant"); 
  8764.                     if(variant!=null) {
  8765.                         variant = variant.trim();
  8766.                     }
  8767.                     
  8768.                     this.localeSOAPFaultString = new Locale(language, country, variant);
  8769.                 }else{
  8770.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultString.language' non impostata, viene utilizzato il default="+Locale.getDefault());
  8771.                 }
  8772.             }catch(java.lang.Exception e) {
  8773.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultString.language' non impostata, viene utilizzato il default="+Locale.getDefault()+", errore:"+e.getMessage(),e);
  8774.             }
  8775.             this.localeSOAPFaultStringRead = true;
  8776.         }

  8778.         return this.localeSOAPFaultString;
  8779.     }
  8780.     

  8782.     /**
  8783.      * Indicazione se l'errore applicativo deve essere inserito in un details.
  8784.      *   
  8785.      * @return Indicazione se l'errore applicativo deve essere inserito in un details.
  8786.      * 
  8787.      */
  8788.     private Boolean isErroreApplicativoIntoDetails = null;
  8789.     public boolean isErroreApplicativoIntoDetails(){
  8790.         if(this.isErroreApplicativoIntoDetails==null){
  8791.             try{  
  8792.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.fault.details"); 

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

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

  8808.         return this.isErroreApplicativoIntoDetails;
  8809.     }
  8810.     
  8811.     
  8812.     /**
  8813.      * Indicazione se aggiungere un detail contenente descrizione dell'errore nel SoapFaultApplicativo originale
  8814.      * 
  8815.      * @return Indicazione se aggiungere un detail contenente descrizione dell'errore nel SoapFaultApplicativo originale
  8816.      */
  8817.     private Boolean isAggiungiDetailErroreApplicativo_SoapFaultApplicativo = null;
  8818.     public boolean isAggiungiDetailErroreApplicativo_SoapFaultApplicativo(){
  8819.         if(this.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo==null){
  8820.             try{  
  8821.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultApplicativo.enrichDetails"); 

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

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

  8837.         return this.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo;
  8838.     }
  8839.     
  8840.     
  8841.     /**
  8842.      * Indicazione se aggiungere un detail contenente descrizione dell'errore nel SoapFaultPdD originale
  8843.      * 
  8844.      * @return Indicazione se aggiungere un detail contenente descrizione dell'errore nel SoapFaultPdD originale
  8845.      */
  8846.     private Boolean isAggiungiDetailErroreApplicativo_SoapFaultPdD = null;
  8847.     public boolean isAggiungiDetailErroreApplicativo_SoapFaultPdD(){
  8848.         if(this.isAggiungiDetailErroreApplicativo_SoapFaultPdD==null){
  8849.             try{  
  8850.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultPdD.enrichDetails"); 

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

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

  8866.         return this.isAggiungiDetailErroreApplicativo_SoapFaultPdD;
  8867.     }
  8868.     
  8869.     
  8870.     
  8871.     private String getErroriHttpHeaderGovWayStatus = null;
  8872.     public String getErroriHttpHeaderGovWayStatus(){
  8873.         
  8874.         String pName = "org.openspcoop2.pdd.errori.http.govwayStatus";
  8875.         if(this.getErroriHttpHeaderGovWayStatus==null){
  8876.             try{  
  8877.                 String name = this.reader.getValueConvertEnvProperties(pName); 
  8878.                 if(name==null)
  8879.                     throw new CoreException(NON_DEFINITA);
  8880.                 name = name.trim();
  8881.                 this.getErroriHttpHeaderGovWayStatus = name;

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

  8889.         return this.getErroriHttpHeaderGovWayStatus;
  8890.     }
  8891.     
  8892.     private String getErroriHttpHeaderGovWayType = null;
  8893.     public String getErroriHttpHeaderGovWayType(){
  8894.         
  8895.         String pName = "org.openspcoop2.pdd.errori.http.govwayType";
  8896.         if(this.getErroriHttpHeaderGovWayType==null){
  8897.             try{  
  8898.                 String name = this.reader.getValueConvertEnvProperties(pName); 
  8899.                 if(name==null)
  8900.                     throw new CoreException(NON_DEFINITA);
  8901.                 name = name.trim();
  8902.                 this.getErroriHttpHeaderGovWayType = name;

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

  8910.         return this.getErroriHttpHeaderGovWayType;
  8911.     }
  8912.     
  8913.     private String getErroriHttpHeaderGovWayCode = null;
  8914.     public String getErroriHttpHeaderGovWayCode(){
  8915.         
  8916.         String pName = "org.openspcoop2.pdd.errori.http.govwayCode";
  8917.         if(this.getErroriHttpHeaderGovWayCode==null){
  8918.             try{  
  8919.                 String name = this.reader.getValueConvertEnvProperties(pName); 
  8920.                 if(name==null)
  8921.                     throw new CoreException(NON_DEFINITA);
  8922.                 name = name.trim();
  8923.                 this.getErroriHttpHeaderGovWayCode = name;

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

  8931.         return this.getErroriHttpHeaderGovWayCode;
  8932.     }
  8933.     
  8934.     
  8935.     
  8936.     private Boolean isErroriSoapUseGovWayStatusAsFaultCode = null;
  8937.     public boolean isErroriSoapUseGovWayStatusAsFaultCode(){
  8938.         if(this.isErroriSoapUseGovWayStatusAsFaultCode==null){
  8939.             String pName = "org.openspcoop2.pdd.errori.soap.useGovWayStatusAsFaultCode";
  8940.             try{  
  8941.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  8943.                 if (value != null){
  8944.                     value = value.trim();
  8945.                     this.isErroriSoapUseGovWayStatusAsFaultCode = Boolean.parseBoolean(value);
  8946.                 }else{
  8947.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  8948.                     this.isErroriSoapUseGovWayStatusAsFaultCode = false;
  8949.                 }

  8951.             }catch(java.lang.Exception e) {
  8952.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  8953.                 this.isErroriSoapUseGovWayStatusAsFaultCode = false;
  8954.             }
  8955.         }

  8957.         return this.isErroriSoapUseGovWayStatusAsFaultCode;
  8958.     }
  8959.     
  8960.     private Boolean isErroriSoapHttpHeaderGovWayCodeEnabled = null;
  8961.     public boolean isErroriSoapHttpHeaderGovWayCodeEnabled(){
  8962.         if(this.isErroriSoapHttpHeaderGovWayCodeEnabled==null){
  8963.             String pName = "org.openspcoop2.pdd.errori.soap.HttpHeaderGovWayCode.enabled";
  8964.             try{  
  8965.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  8967.                 if (value != null){
  8968.                     value = value.trim();
  8969.                     this.isErroriSoapHttpHeaderGovWayCodeEnabled = Boolean.parseBoolean(value);
  8970.                 }else{
  8971.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  8972.                     this.isErroriSoapHttpHeaderGovWayCodeEnabled = false;
  8973.                 }

  8975.             }catch(java.lang.Exception e) {
  8976.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  8977.                 this.isErroriSoapHttpHeaderGovWayCodeEnabled = false;
  8978.             }
  8979.         }

  8981.         return this.isErroriSoapHttpHeaderGovWayCodeEnabled;
  8982.     }
  8983.     
  8984.     private Boolean isErroriGovWayStatusEnabled = null;
  8985.     public boolean isErroriGovWayStatusEnabled(){
  8986.         if(this.isErroriGovWayStatusEnabled==null){
  8987.             String pName = "org.openspcoop2.pdd.errori.status";
  8988.             try{  
  8989.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  8991.                 if (value != null){
  8992.                     value = value.trim();
  8993.                     this.isErroriGovWayStatusEnabled = Boolean.parseBoolean(value);
  8994.                 }else{
  8995.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  8996.                     this.isErroriGovWayStatusEnabled = false;
  8997.                 }

  8999.             }catch(java.lang.Exception e) {
  9000.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9001.                 this.isErroriGovWayStatusEnabled = false;
  9002.             }
  9003.         }

  9005.         return this.isErroriGovWayStatusEnabled;
  9006.     }
  9007.     
  9008.     private Boolean isErroriGovWayInstanceEnabled = null;
  9009.     public boolean isErroriGovWayInstanceEnabled(){
  9010.         if(this.isErroriGovWayInstanceEnabled==null){
  9011.             String pName = "org.openspcoop2.pdd.errori.instance";
  9012.             try{  
  9013.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9015.                 if (value != null){
  9016.                     value = value.trim();
  9017.                     this.isErroriGovWayInstanceEnabled = Boolean.parseBoolean(value);
  9018.                 }else{
  9019.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9020.                     this.isErroriGovWayInstanceEnabled = false;
  9021.                 }

  9023.             }catch(java.lang.Exception e) {
  9024.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9025.                 this.isErroriGovWayInstanceEnabled = false;
  9026.             }
  9027.         }

  9029.         return this.isErroriGovWayInstanceEnabled;
  9030.     }
  9031.     
  9032.     private Boolean isErroriGovWayForceSpecificDetails = null;
  9033.     public boolean isErroriGovWayForceSpecificDetails(){
  9034.         if(this.isErroriGovWayForceSpecificDetails==null){
  9035.             String pName = "org.openspcoop2.pdd.errori.forceSpecificDetails";
  9036.             try{  
  9037.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9039.                 if (value != null){
  9040.                     value = value.trim();
  9041.                     this.isErroriGovWayForceSpecificDetails = Boolean.parseBoolean(value);
  9042.                 }else{
  9043.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9044.                     this.isErroriGovWayForceSpecificDetails = false;
  9045.                 }

  9047.             }catch(java.lang.Exception e) {
  9048.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9049.                 this.isErroriGovWayForceSpecificDetails = false;
  9050.             }
  9051.         }

  9053.         return this.isErroriGovWayForceSpecificDetails;
  9054.     }
  9055.     
  9056.     private Boolean isErroriGovWayFaultDetailsWithProblemRFC7807 = null;
  9057.     public boolean isErroriGovWayFaultDetailsWithProblemRFC7807(){
  9058.         if(this.isErroriGovWayFaultDetailsWithProblemRFC7807==null){
  9059.             String pName = "org.openspcoop2.pdd.errori.faultDetailsWithProblemRFC7807";
  9060.             try{  
  9061.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9063.                 if (value != null){
  9064.                     value = value.trim();
  9065.                     this.isErroriGovWayFaultDetailsWithProblemRFC7807 = Boolean.parseBoolean(value);
  9066.                 }else{
  9067.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9068.                     this.isErroriGovWayFaultDetailsWithProblemRFC7807 = false;
  9069.                 }

  9071.             }catch(java.lang.Exception e) {
  9072.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9073.                 this.isErroriGovWayFaultDetailsWithProblemRFC7807 = false;
  9074.             }
  9075.         }

  9077.         return this.isErroriGovWayFaultDetailsWithProblemRFC7807;
  9078.     }
  9079.     
  9080.     
  9081.     
  9082.     
  9083.     private Boolean isProblemRFC7807_enrichTitleAsGovWayType = null;
  9084.     public boolean isProblemRFC7807_enrichTitleAsGovWayType(){
  9085.         if(this.isProblemRFC7807_enrichTitleAsGovWayType==null){
  9086.             String pName = "org.openspcoop2.pdd.problemRFC7807.enrichTitleAsGovWayType";
  9087.             try{  
  9088.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9090.                 if (value != null){
  9091.                     value = value.trim();
  9092.                     this.isProblemRFC7807_enrichTitleAsGovWayType = Boolean.parseBoolean(value);
  9093.                 }else{
  9094.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  9095.                     this.isProblemRFC7807_enrichTitleAsGovWayType = true;
  9096.                 }

  9098.             }catch(java.lang.Exception e) {
  9099.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  9100.                 this.isProblemRFC7807_enrichTitleAsGovWayType = true;
  9101.             }
  9102.         }

  9104.         return this.isProblemRFC7807_enrichTitleAsGovWayType;
  9105.     }
  9106.     
  9107.     
  9108.     private Boolean isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode = null;
  9109.     public boolean isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode(){
  9110.         if(this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode==null){
  9111.             String pName = "org.openspcoop2.pdd.problemRFC7807.enrichTitleAsGovWayType.camelCaseDecode";
  9112.             try{  
  9113.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9115.                 if (value != null){
  9116.                     value = value.trim();
  9117.                     this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode = Boolean.parseBoolean(value);
  9118.                 }else{
  9119.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9120.                     this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode = false;
  9121.                 }

  9123.             }catch(java.lang.Exception e) {
  9124.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9125.                 this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode = false;
  9126.             }
  9127.         }

  9129.         return this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode;
  9130.     }
  9131.     
  9132.     
  9133.     private Boolean isProblemRFC7807_enrichTitleAsGovWayType_customClaim = null;
  9134.     public boolean isProblemRFC7807_enrichTitleAsGovWayType_customClaim(){
  9135.         if(this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim==null){
  9136.             String pName = "org.openspcoop2.pdd.problemRFC7807.enrichTitleAsGovWayType.customClaim";
  9137.             try{  
  9138.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9140.                 if (value != null){
  9141.                     value = value.trim();
  9142.                     this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim = Boolean.parseBoolean(value);
  9143.                 }else{
  9144.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9145.                     this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim = false;
  9146.                 }

  9148.             }catch(java.lang.Exception e) {
  9149.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9150.                 this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim = false;
  9151.             }
  9152.         }

  9154.         return this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim;
  9155.     }
  9156.     

  9158.     private String getProblemRFC7807_transactionId_claim = null;
  9159.     public String getProblemRFC7807_transactionId_claim(){
  9160.         
  9161.         String pName = "org.openspcoop2.pdd.problemRFC7807.transactionId.claim";
  9162.         if(this.getProblemRFC7807_transactionId_claim==null){
  9163.             try{  
  9164.                 String fault = this.reader.getValueConvertEnvProperties(pName); 
  9165.                 if(fault==null)
  9166.                     throw new CoreException(NON_DEFINITA);
  9167.                 fault = fault.trim();
  9168.                 this.getProblemRFC7807_transactionId_claim = fault;

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

  9176.         return this.getProblemRFC7807_transactionId_claim;
  9177.     }
  9178.     
  9179.     private String getProblemRFC7807_code_claim = null;
  9180.     public String getProblemRFC7807_code_claim(){
  9181.         
  9182.         String pName = "org.openspcoop2.pdd.problemRFC7807.code.claim";
  9183.         if(this.getProblemRFC7807_code_claim==null){
  9184.             try{  
  9185.                 String fault = this.reader.getValueConvertEnvProperties(pName); 
  9186.                 if(fault==null)
  9187.                     throw new CoreException(NON_DEFINITA);
  9188.                 fault = fault.trim();
  9189.                 this.getProblemRFC7807_code_claim = fault;

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

  9197.         return this.getProblemRFC7807_code_claim;
  9198.     }
  9199.     
  9200.     private String getProblemRFC7807_type_claim = null;
  9201.     public String getProblemRFC7807_type_claim(){
  9202.         
  9203.         String pName = "org.openspcoop2.pdd.problemRFC7807.type.claim";
  9204.         if(this.getProblemRFC7807_type_claim==null){
  9205.             try{  
  9206.                 String fault = this.reader.getValueConvertEnvProperties(pName); 
  9207.                 if(fault==null)
  9208.                     throw new CoreException(NON_DEFINITA);
  9209.                 fault = fault.trim();
  9210.                 this.getProblemRFC7807_type_claim = fault;

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

  9218.         return this.getProblemRFC7807_type_claim;
  9219.     }


  9222.     private Boolean isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta = null;
  9223.     public boolean isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta(){
  9224.         if(this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta==null){
  9225.             String pName = "org.openspcoop2.pdd.erroreApplicativo.inoltraClientBustaRispostaErroreRicevuta";
  9226.             try{  
  9227.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9229.                 if (value != null){
  9230.                     value = value.trim();
  9231.                     this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta = Boolean.parseBoolean(value);
  9232.                 }else{
  9233.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9234.                     this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta = false;
  9235.                 }

  9237.             }catch(java.lang.Exception e) {
  9238.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9239.                 this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta = false;
  9240.             }
  9241.         }

  9243.         return this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta;
  9244.     }
  9245.     
  9246.     private Map<String,Boolean> isErroreApplicativoInoltraClientBustaRispostaErroreRicevutaMap = new HashMap<>();
  9247.     public boolean isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta(String protocollo){
  9248.         Boolean v = this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevutaMap.get(protocollo);
  9249.         if(v==null){
  9250.             String pName = "org.openspcoop2.pdd.erroreApplicativo.inoltraClientBustaRispostaErroreRicevuta."+protocollo;
  9251.             try{  
  9252.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9254.                 if (value != null){
  9255.                     value = value.trim();
  9256.                     v = Boolean.parseBoolean(value);
  9257.                 }else{
  9258.                     v = isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta(); // default per qualsiasi protocollo
  9259.                 }

  9261.             }catch(java.lang.Exception e) {
  9262.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta()),e);
  9263.                 v = isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta();
  9264.             }
  9265.             this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevutaMap.put(protocollo, v);
  9266.         }

  9268.         return v;
  9269.     }
  9270.     



  9274.     /* ******** PORTA DI DOMINIO  ******** */

  9276.     /**
  9277.      * Restituisce il nome di default dell'identificativo porta utilizzato dalla porta di dominio
  9278.      *
  9279.      * @return Restituisce il nome di default dell'identificativo porta utilizzato dalla porta di dominio
  9280.      * 
  9281.      */
  9282.     private String identificativoPortaDefault = null;
  9283.     private String getIdentificativoPortaDefault(){
  9284.         if(this.identificativoPortaDefault==null){
  9285.             try{  
  9286.                 String fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.identificativoPorta.dominio"); 
  9287.                 if(fault==null)
  9288.                     throw new CoreException(NON_DEFINITA);
  9289.                 fault = fault.trim();
  9290.                 this.identificativoPortaDefault = fault;

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

  9298.         return this.identificativoPortaDefault;
  9299.     }
  9300.     /**
  9301.      * Restituisce il nome di default della porta utilizzato dalla porta di dominio
  9302.      *
  9303.      * @return Restituisce il nome di default della porta utilizzato dalla porta di dominio
  9304.      * 
  9305.      */
  9306.     private String nomePortaDefault = null;
  9307.     private String getNomePortaDefault(){
  9308.         if(this.nomePortaDefault==null){
  9309.             try{  
  9310.                 String fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.identificativoPorta.nome"); 
  9311.                 if(fault==null)
  9312.                     throw new CoreException(NON_DEFINITA);
  9313.                 fault = fault.trim();
  9314.                 this.nomePortaDefault = fault;

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

  9322.         return this.nomePortaDefault;
  9323.     }


  9326.     /**
  9327.      * Restituisce il nome di default della porta utilizzato dalla porta di dominio
  9328.      *
  9329.      * @return Restituisce il nome di default della porta utilizzato dalla porta di dominio
  9330.      * 
  9331.      */
  9332.     private String tipoPortaDefault = null;
  9333.     private String getTipoPortaDefault(){
  9334.         if(this.tipoPortaDefault==null){
  9335.             try{  
  9336.                 String fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.identificativoPorta.tipo"); 
  9337.                 if(fault==null)
  9338.                     throw new CoreException(NON_DEFINITA);
  9339.                 fault = fault.trim();
  9340.                 this.tipoPortaDefault = fault;

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

  9350.     /**
  9351.      * Restituisce l'identita di default della porta utilizzato dalla porta di dominio
  9352.      *
  9353.      * @return Restituisce l'identita di default della porta utilizzato dalla porta di dominio
  9354.      * 
  9355.      */
  9356.     private IDSoggetto identitaPortaDefault = null;
  9357.     private IDSoggetto getIdentitaPortaDefault(){
  9358.         if(this.identitaPortaDefault==null){
  9359.             String pdd = getIdentificativoPortaDefault();
  9360.             String nome = getNomePortaDefault();
  9361.             String tipo = getTipoPortaDefault();
  9362.             if(tipo==null || nome==null || pdd==null)
  9363.                 this.identitaPortaDefault = null;
  9364.             else    
  9365.                 this.identitaPortaDefault = new IDSoggetto(tipo,nome,pdd);
  9366.         }

  9368.         if(this.identitaPortaDefault!=null){
  9369.             IDSoggetto idNew = new IDSoggetto();
  9370.             idNew.setCodicePorta(this.identitaPortaDefault.getCodicePorta());
  9371.             idNew.setNome(this.identitaPortaDefault.getNome());
  9372.             idNew.setTipo(this.identitaPortaDefault.getTipo());
  9373.             return idNew;
  9374.         }
  9375.         else{
  9376.             return null;
  9377.         }
  9378.     }


  9381.     // protocol mapping
  9382.     
  9383.     private Map<String,String> identificativoPortaDefault_mappingProtocol = new HashMap<>();
  9384.     private String _getIdentificativoPortaDefault(String protocol){
  9385.         
  9386.         if(protocol==null){
  9387.             return getIdentificativoPortaDefault();
  9388.         }
  9389.         
  9390.         if(this.identificativoPortaDefault_mappingProtocol.containsKey(protocol)==false){
  9391.             
  9392.             try{  
  9393.                 
  9394.                 String fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd."+protocol+".identificativoPorta.dominio"); 
  9395.                 if(fault==null){
  9396.                     fault = this.getIdentificativoPortaDefault();
  9397.                 }else{
  9398.                     fault = fault.trim();
  9399.                 }
  9400.                 this.identificativoPortaDefault_mappingProtocol.put(protocol, fault);

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

  9408.         return this.identificativoPortaDefault_mappingProtocol.get(protocol);
  9409.     }

  9411.     private Map<String,String> nomePortaDefault_mappingProtocol = new HashMap<>();
  9412.     private String _getNomePortaDefault(String protocol){
  9413.         
  9414.         if(protocol==null){
  9415.             return getNomePortaDefault();
  9416.         }
  9417.         
  9418.         if(this.nomePortaDefault_mappingProtocol.containsKey(protocol)==false){
  9419.             
  9420.             try{  
  9421.                 
  9422.                 String nome = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd."+protocol+".identificativoPorta.nome"); 
  9423.                 if(nome==null){
  9424.                     nome = this.getNomePortaDefault();
  9425.                 }else{
  9426.                     nome = nome.trim();
  9427.                 }
  9428.                 this.nomePortaDefault_mappingProtocol.put(protocol, nome);

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

  9436.         return this.nomePortaDefault_mappingProtocol.get(protocol);
  9437.     }
  9438.     
  9439.     private Map<String,String> tipoPortaDefault_mappingProtocol = new HashMap<>();
  9440.     private String _getTipoPortaDefault(String protocol){
  9441.         
  9442.         if(protocol==null){
  9443.             return getTipoPortaDefault();
  9444.         }
  9445.         
  9446.         if(this.tipoPortaDefault_mappingProtocol.containsKey(protocol)==false){
  9447.             
  9448.             try{  
  9449.                 
  9450.                 String tipo = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd."+protocol+".identificativoPorta.tipo"); 
  9451.                 if(tipo==null){
  9452.                     tipo = this.getTipoPortaDefault();
  9453.                 }else{
  9454.                     tipo = tipo.trim();
  9455.                 }
  9456.                 this.tipoPortaDefault_mappingProtocol.put(protocol, tipo);

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

  9464.         return this.tipoPortaDefault_mappingProtocol.get(protocol);
  9465.     }

  9467.     public IDSoggetto getIdentitaPortaDefaultWithoutProtocol(){
  9468.         return getIdentitaPortaDefault();
  9469.     }
  9470.     
  9471.     private Map<String,IDSoggetto> identitaPortaDefault_mappingProtocol = new HashMap<String, IDSoggetto>();
  9472.     public IDSoggetto getIdentitaPortaDefault(String protocol, RequestInfo requestInfo){
  9473.         
  9474.         if(requestInfo!=null && requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getDominioDefault()!=null) {
  9475.             IDSoggetto identitaPortaDefault = requestInfo.getRequestConfig().getDominioDefault();
  9476.             
  9477.             IDSoggetto idNew = new IDSoggetto();
  9478.             idNew.setCodicePorta(identitaPortaDefault.getCodicePorta());
  9479.             idNew.setNome(identitaPortaDefault.getNome());
  9480.             idNew.setTipo(identitaPortaDefault.getTipo());
  9481.             return idNew;
  9482.         }
  9483.         
  9484.         if(protocol==null){
  9485.             return getIdentitaPortaDefault();
  9486.         }
  9487.         
  9488.         if(this.identitaPortaDefault_mappingProtocol.containsKey(protocol)==false){
  9489.             String pdd = _getIdentificativoPortaDefault(protocol);
  9490.             String nome = _getNomePortaDefault(protocol);
  9491.             String tipo = _getTipoPortaDefault(protocol);
  9492.             if(tipo!=null && nome!=null && pdd!=null){
  9493.                 IDSoggetto identitaPortaDefault = new IDSoggetto(tipo,nome,pdd);
  9494.                 this.identitaPortaDefault_mappingProtocol.put(protocol, identitaPortaDefault);
  9495.             }
  9496.         }
  9497.         
  9498.         IDSoggetto identitaPortaDefault = this.identitaPortaDefault_mappingProtocol.get(protocol);
  9499.         
  9500.         if(identitaPortaDefault!=null){
  9501.             
  9502.             if(requestInfo!=null && requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getDominioDefault()==null) {
  9503.                 requestInfo.getRequestConfig().setDominioDefault(identitaPortaDefault);
  9504.             }
  9505.             
  9506.             IDSoggetto idNew = new IDSoggetto();
  9507.             idNew.setCodicePorta(identitaPortaDefault.getCodicePorta());
  9508.             idNew.setNome(identitaPortaDefault.getNome());
  9509.             idNew.setTipo(identitaPortaDefault.getTipo());
  9510.             return idNew;
  9511.         }
  9512.         else{
  9513.             return null;
  9514.         }
  9515.     }
  9516.     public String getIdentificativoPortaDefault(String protocol, RequestInfo requestInfo){
  9517.         IDSoggetto identitaPortaDefault = getIdentitaPortaDefault(protocol, requestInfo);
  9518.         if(identitaPortaDefault!=null) {
  9519.             return identitaPortaDefault.getCodicePorta();
  9520.         }
  9521.         return null;
  9522.     }






  9529.     /************ AUTORIZZAZIONE *******************/

  9531.     private Boolean getAutorizzazioneLockPermitsRead = null;
  9532.     private Integer getAutorizzazioneLockPermits = null;
  9533.     public Integer getAutorizzazioneLockPermits() {

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

  9540.                 if (value != null){
  9541.                     value = value.trim();
  9542.                     int permits = Integer.parseInt(value); 
  9543.                     if(permits>1) {
  9544.                         // altrimenti è un normale semaphore binario
  9545.                         this.getAutorizzazioneLockPermits = permits;
  9546.                     }
  9547.                 }
  9548.                 
  9549.                 
  9550.             }catch(java.lang.Exception e) {
  9551.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  9552.             }
  9553.             
  9554.             this.getAutorizzazioneLockPermitsRead = true;
  9555.         }

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

  9563.         String pName = "org.openspcoop2.pdd.core.autorizzazione.lock.permits.";
  9564.         if(this.getTipoAutorizzazioneLockPermits==null){
  9565.             
  9566.             this.getTipoAutorizzazioneLockPermits = new HashMap<>();
  9567.             
  9568.             try{  
  9569.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  9570.                 if(p!=null && !p.isEmpty()) {
  9571.                     for (Object oKey : p.keySet()) {
  9572.                         if(oKey!=null) {
  9573.                             String key = (String) oKey;
  9574.                             String value = p.getProperty(key);
  9575.                             if(value!=null) {
  9576.                                 int permits = Integer.parseInt(value);
  9577.                                 if(permits>1) {
  9578.                                     // altrimenti è un normale semaphore binario
  9579.                                     this.getTipoAutorizzazioneLockPermits.put(key, permits);
  9580.                                 }
  9581.                             }
  9582.                         }
  9583.                     }
  9584.                 }
  9585.                 
  9586.             }catch(java.lang.Exception e) {
  9587.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  9588.             }
  9589.             
  9590.         }

  9592.         return this.getTipoAutorizzazioneLockPermits.get(tipoAutorizzazione);
  9593.     }
  9594.     
  9595.     /**
  9596.      * Restituisce il tipo di autorizzazione delle buste effettuato dalla porta di dominio
  9597.      *
  9598.      * @return Restituisce il tipo di autorizzazione delle buste effettuato dalla porta di dominio
  9599.      * 
  9600.      */
  9601.     private String tipoAutorizzazioneBuste = null;
  9602.     public String getTipoAutorizzazioneBuste(){
  9603.         if(this.tipoAutorizzazioneBuste==null){
  9604.             try{  
  9605.                 String autorizzazione = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.autorizzazioneBuste.tipo");
  9606.                 if(autorizzazione==null)
  9607.                     throw new CoreException(NON_DEFINITA);
  9608.                 autorizzazione = autorizzazione.trim();
  9609.                 this.tipoAutorizzazioneBuste = autorizzazione;

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

  9617.         return this.tipoAutorizzazioneBuste;
  9618.     }
  9619.     
  9620.     
  9621.     private Boolean isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta = null;
  9622.     public boolean isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta() { 
  9623.         if(this.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta==null){
  9624.             String pName = "org.openspcoop2.pdd.autorizzazioneBusta.autenticazioneOpzionale.soggettoFruitoreProfiloInteroperabilitaDifferenteServizio.bloccaRichiesta";
  9625.             try{ 
  9626.                 String name = null;
  9627.                 name = this.reader.getValueConvertEnvProperties(pName);
  9628.                 if(name==null){
  9629.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  9630.                     name="true";
  9631.                 }
  9632.                 name = name.trim();
  9633.                 this.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta = Boolean.parseBoolean(name);
  9634.             } catch(java.lang.Exception e) {
  9635.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  9636.                 this.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta = true;
  9637.             }    
  9638.         }

  9640.         return this.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta;
  9641.     }

  9643.     



  9647.     
  9648.     /************ AUTORIZZAZIONE CONTENUTI *******************/

  9650.     private Boolean getAutorizzazioneContenutiLockPermitsRead = null;
  9651.     private Integer getAutorizzazioneContenutiLockPermits = null;
  9652.     public Integer getAutorizzazioneContenutiLockPermits() {

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

  9659.                 if (value != null){
  9660.                     value = value.trim();
  9661.                     int permits = Integer.parseInt(value); 
  9662.                     if(permits>1) {
  9663.                         // altrimenti è un normale semaphore binario
  9664.                         this.getAutorizzazioneContenutiLockPermits = permits;
  9665.                     }
  9666.                 }
  9667.                 
  9668.                 
  9669.             }catch(java.lang.Exception e) {
  9670.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  9671.             }
  9672.             
  9673.             this.getAutorizzazioneContenutiLockPermitsRead = true;
  9674.         }

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

  9682.         String pName = "org.openspcoop2.pdd.core.autorizzazioneContenuti.lock.permits.";
  9683.         if(this.getTipoAutorizzazioneContenutiLockPermits==null){
  9684.             
  9685.             this.getTipoAutorizzazioneContenutiLockPermits = new HashMap<>();
  9686.             
  9687.             try{  
  9688.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  9689.                 if(p!=null && !p.isEmpty()) {
  9690.                     for (Object oKey : p.keySet()) {
  9691.                         if(oKey!=null) {
  9692.                             String key = (String) oKey;
  9693.                             String value = p.getProperty(key);
  9694.                             if(value!=null) {
  9695.                                 int permits = Integer.parseInt(value);
  9696.                                 if(permits>1) {
  9697.                                     // altrimenti è un normale semaphore binario
  9698.                                     this.getTipoAutorizzazioneContenutiLockPermits.put(key, permits);
  9699.                                 }
  9700.                             }
  9701.                         }
  9702.                     }
  9703.                 }
  9704.                 
  9705.             }catch(java.lang.Exception e) {
  9706.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  9707.             }
  9708.             
  9709.         }

  9711.         return this.getTipoAutorizzazioneContenutiLockPermits.get(tipoAutorizzazioneContenuti);
  9712.     }
  9713.     
  9714.     
  9715.     
  9716.     



  9720.     /* ********  Bypass Filtri  ******** */

  9722.     /**
  9723.      * Restituisce le proprieta' che localizzano gli header element su cui deve essere applicato il filtro bypass.
  9724.      *
  9725.      * @return proprieta' che localizzano gli header element su cui deve essere applicato il filtro bypass.
  9726.      * 
  9727.      */
  9728.     private Map<String,List<NameValue>> mapGetBypassFilterMustUnderstandProperties = null;
  9729.     public List<NameValue> getBypassFilterMustUnderstandProperties(String protocol) {
  9730.         if(this.mapGetBypassFilterMustUnderstandProperties==null){
  9731.             initBypassFilterMustUnderstandProperties();
  9732.         }
  9733.         return this.mapGetBypassFilterMustUnderstandProperties.get(protocol);
  9734.     }
  9735.     private void initBypassFilterMustUnderstandProperties(){
  9736.         if(this.mapGetBypassFilterMustUnderstandProperties==null){
  9737.             
  9738.             this.mapGetBypassFilterMustUnderstandProperties = new HashMap<>();
  9739.             
  9740.             List<NameValue> resultList = new ArrayList<>();
  9741.             try{ 
  9742.                 java.util.Properties tmpP = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.");
  9743.                 if(tmpP!=null && tmpP.size()>0){
  9744.                     Enumeration<Object> keys = tmpP.keys();
  9745.                     while (keys.hasMoreElements()) {
  9746.                         Object object = keys.nextElement();
  9747.                         if(object instanceof String){
  9748.                             String key = (String) object;
  9749.                             String localName = key;
  9750.                             String namespace = tmpP.getProperty(key);
  9751.                             if(key.contains("!")){
  9752.                                 // serve a fornire più proprietà con stesso localName e namespace differente
  9753.                                 // tramite la formula 
  9754.                                 // org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.nomeHeader=http://prova
  9755.                                 // org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.nomeHeader!1=http://prova2
  9756.                                 // org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.nomeHeader!2=http://prova3
  9757.                                 localName = key.split("!")[0];
  9758.                             }
  9759.                             NameValue nameValue = new NameValue();
  9760.                             nameValue.setName(localName);
  9761.                             nameValue.setValue(namespace);
  9762.                             resultList.add(nameValue);
  9763.                         }
  9764.                     }
  9765.                 }
  9766.                 
  9767.                 
  9768.                 // aggiungo i bypass specifici dei protocolli
  9769.                 Enumeration<String> protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
  9770.                 while (protocolli.hasMoreElements()) {
  9771.                     String protocollo = protocolli.nextElement();
  9772.                     IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactories().get(protocollo);
  9773.                     IProtocolConfiguration pc = pf.createProtocolConfiguration();
  9774.                     List<BypassMustUnderstandCheck> list = pc.getBypassMustUnderstandCheck();
  9775.                     
  9776.                     List<NameValue> resultListForProtocol = new ArrayList<>();
  9777.                     if(resultList!=null && !resultList.isEmpty()){
  9778.                         resultListForProtocol.addAll(resultList);
  9779.                     }
  9780.                     
  9781.                     if(list!=null && !list.isEmpty()){
  9782.                         for (Iterator<?> iterator = list.iterator(); iterator.hasNext();) {
  9783.                             BypassMustUnderstandCheck bypassMustUnderstandCheck = (BypassMustUnderstandCheck) iterator.next();
  9784.                             
  9785.                             NameValue nameValue = new NameValue();
  9786.                             nameValue.setName(bypassMustUnderstandCheck.getElementName());
  9787.                             nameValue.setValue(bypassMustUnderstandCheck.getNamespace());
  9788.                             resultListForProtocol.add(nameValue);
  9789.                             
  9790.                         }
  9791.                     }
  9792.                     
  9793.                     for (NameValue nameValue : resultListForProtocol) {
  9794.                         this.logDebug("["+protocollo+"] ["+nameValue.getName()+"]=["+nameValue.getValue()+"]");
  9795.                     }
  9796.                     
  9797.                     this.mapGetBypassFilterMustUnderstandProperties.put(protocollo, resultListForProtocol);
  9798.                 }
  9799.                 
  9800.             }catch(java.lang.Exception e) {
  9801.                 this.logError("Riscontrato errore durante la lettura delle propriete' 'org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.*': "+e.getMessage(),e);
  9802.                 this.mapGetBypassFilterMustUnderstandProperties = null;
  9803.             }    
  9804.             
  9805.         }

  9807.     }

  9809.     /**
  9810.      * Restituisce l'indicazione se il BypassFilterMustUnderstand e' abilitato per tutti gli header
  9811.      *
  9812.      * @return Restituisce l'indicazione se il BypassFilterMustUnderstand e' abilitato per tutti gli header
  9813.      * 
  9814.      */
  9815.     private Boolean isBypassFilterMustUnderstandEnabledForAllHeaders = null;
  9816.     public boolean isBypassFilterMustUnderstandEnabledForAllHeaders(){
  9817.         if(this.isBypassFilterMustUnderstandEnabledForAllHeaders==null){
  9818.             try{  
  9819.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.BypassMustUnderstandHandler.allHeaders"); 

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

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

  9835.         return this.isBypassFilterMustUnderstandEnabledForAllHeaders;
  9836.     }





  9842.     
  9843.     
  9844.     /* ------------- ContentType ---------------------*/
  9845.     
  9846.     private Boolean isControlloContentTypeAbilitatoRicezioneContenutiApplicativi= null;
  9847.     public boolean isControlloContentTypeAbilitatoRicezioneContenutiApplicativi(){
  9848.         if(this.isControlloContentTypeAbilitatoRicezioneContenutiApplicativi==null){
  9849.             try{  
  9850.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.contentType.checkEnabled"); 

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

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

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

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

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

  9898.                 if(value!=null){
  9899.                     value = value.trim();
  9900.                     if("*".equals(value)) {
  9901.                         this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = false;
  9902.                     }
  9903.                     else {
  9904.                         List<String> l = new ArrayList<>();
  9905.                         initSplitValues(l, value, false);
  9906.                         if(!l.isEmpty()) {
  9907.                             this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = true;
  9908.                             this.listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = l;
  9909.                         }
  9910.                         else {
  9911.                             this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = false;
  9912.                         }
  9913.                     }
  9914.                 }else{
  9915.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9916.                     this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = false;
  9917.                 }

  9919.             }catch(java.lang.Exception e) {
  9920.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9921.                 this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = false;
  9922.             }
  9923.         }
  9924.         return this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap;
  9925.     }
  9926.     public List<String> getControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap(){
  9927.         List<String> lNull = null;
  9928.         if(isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap()) {
  9929.             return this.listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap;
  9930.         }
  9931.         return lNull;
  9932.     }
  9933.     
  9934.     private Boolean isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest= null;
  9935.     private List<String> listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = null;
  9936.     public boolean isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest(){
  9937.         if(this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest==null){
  9938.             String pName = "org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.rest.charsetExpected";
  9939.             try{  
  9940.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9942.                 if(value!=null){
  9943.                     value = value.trim();
  9944.                     if("*".equals(value)) {
  9945.                         this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = false;
  9946.                     }
  9947.                     else {
  9948.                         List<String> l = new ArrayList<>();
  9949.                         initSplitValues(l, value, false);
  9950.                         if(!l.isEmpty()) {
  9951.                             this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = true;
  9952.                             this.listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = l;
  9953.                         }
  9954.                         else {
  9955.                             this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = false;
  9956.                         }
  9957.                     }
  9958.                 }else{
  9959.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9960.                     this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = false;
  9961.                 }

  9963.             }catch(java.lang.Exception e) {
  9964.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9965.                 this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = false;
  9966.             }
  9967.         }
  9968.         return this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest;
  9969.     }
  9970.     public List<String> getControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest(){
  9971.         List<String> lNull = null;
  9972.         if(isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest()) {
  9973.             return this.listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest;
  9974.         }
  9975.         return lNull;
  9976.     }
  9977.     
  9978.     private Boolean isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap= null;
  9979.     private List<String> listControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = null;
  9980.     public boolean isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap(){
  9981.         if(this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap==null){
  9982.             String pName = "org.openspcoop2.pdd.services.ricezioneBuste.soap.charsetExpected";
  9983.             try{  
  9984.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9986.                 if(value!=null){
  9987.                     value = value.trim();
  9988.                     if("*".equals(value)) {
  9989.                         this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = false;
  9990.                     }
  9991.                     else {
  9992.                         List<String> l = new ArrayList<>();
  9993.                         initSplitValues(l, value, false);
  9994.                         if(!l.isEmpty()) {
  9995.                             this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = true;
  9996.                             this.listControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = l;
  9997.                         }
  9998.                         else {
  9999.                             this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = false;
  10000.                         }
  10001.                     }
  10002.                 }else{
  10003.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10004.                     this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = false;
  10005.                 }

  10007.             }catch(java.lang.Exception e) {
  10008.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10009.                 this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = false;
  10010.             }
  10011.         }
  10012.         return this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap;
  10013.     }
  10014.     public List<String> getControlloCharsetContentTypeAbilitatoRicezioneBusteSoap(){
  10015.         List<String> lNull = null;
  10016.         if(isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap()) {
  10017.             return this.listControlloCharsetContentTypeAbilitatoRicezioneBusteSoap;
  10018.         }
  10019.         return lNull;
  10020.     }
  10021.     
  10022.     private Boolean isControlloCharsetContentTypeAbilitatoRicezioneBusteRest= null;
  10023.     private List<String> listControlloCharsetContentTypeAbilitatoRicezioneBusteRest = null;
  10024.     public boolean isControlloCharsetContentTypeAbilitatoRicezioneBusteRest(){
  10025.         if(this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest==null){
  10026.             String pName = "org.openspcoop2.pdd.services.ricezioneBuste.rest.charsetExpected";
  10027.             try{  
  10028.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10030.                 if(value!=null){
  10031.                     value = value.trim();
  10032.                     if("*".equals(value)) {
  10033.                         this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = false;
  10034.                     }
  10035.                     else {
  10036.                         List<String> l = new ArrayList<>();
  10037.                         initSplitValues(l, value, false);
  10038.                         if(!l.isEmpty()) {
  10039.                             this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = true;
  10040.                             this.listControlloCharsetContentTypeAbilitatoRicezioneBusteRest = l;
  10041.                         }
  10042.                         else {
  10043.                             this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = false;
  10044.                         }
  10045.                     }
  10046.                 }else{
  10047.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10048.                     this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = false;
  10049.                 }

  10051.             }catch(java.lang.Exception e) {
  10052.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10053.                 this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = false;
  10054.             }
  10055.         }
  10056.         return this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest;
  10057.     }
  10058.     public List<String> getControlloCharsetContentTypeAbilitatoRicezioneBusteRest(){
  10059.         List<String> lNull = null;
  10060.         if(isControlloCharsetContentTypeAbilitatoRicezioneBusteRest()) {
  10061.             return this.listControlloCharsetContentTypeAbilitatoRicezioneBusteRest;
  10062.         }
  10063.         return lNull;
  10064.     }
  10065.     
  10066.     private Boolean isPrintInfoCertificate= null;
  10067.     public boolean isPrintInfoCertificate(){
  10068.         if(this.isPrintInfoCertificate==null){
  10069.             try{  
  10070.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.certificate.printInfo"); 

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

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

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

  10100.                         if(value!=null){
  10101.                                 value = value.trim();
  10102.                                 this.isGestoreCredenzialiPortaDelegataEnabled = Boolean.parseBoolean(value);
  10103.                         }else{
  10104.                                 this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10105.                                 this.isGestoreCredenzialiPortaDelegataEnabled = false;
  10106.                         }

  10108.                 }catch(java.lang.Exception e) {
  10109.                         this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10110.                         this.isGestoreCredenzialiPortaDelegataEnabled = false;
  10111.                 }
  10112.         }
  10113.         return this.isGestoreCredenzialiPortaDelegataEnabled;
  10114.     }

  10116.     
  10117.     private Properties getGestoreCredenzialiPortaDelegataProperties = null;
  10118.     public Properties getGestoreCredenzialiPortaDelegataProperties() {
  10119.         if(this.getGestoreCredenzialiPortaDelegataProperties==null){
  10120.             try{  
  10121.                 this.getGestoreCredenzialiPortaDelegataProperties=this.reader.readProperties(prefixGestoreCredenzialiPortaDelegataProperties);
  10122.                 if(this.getGestoreCredenzialiPortaDelegataProperties==null) {
  10123.                     this.getGestoreCredenzialiPortaDelegataProperties=new Properties();
  10124.                 }
  10125.             }catch(java.lang.Exception e) {
  10126.                 this.logError("Proprieta' di openspcoop '"+prefixGestoreCredenzialiPortaDelegataProperties+"*' non impostate correttamente, errore:"+e.getMessage(),e);
  10127.                 this.getGestoreCredenzialiPortaDelegataProperties = null;
  10128.             }
  10129.         }
  10130.         return this.getGestoreCredenzialiPortaDelegataProperties;
  10131.     }

  10133.     
  10134.     
  10135.     /* ------------- Gestore Credenziali (Porta Applicativa) ---------------------*/

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

  10146.                         if(value!=null){
  10147.                                 value = value.trim();
  10148.                                 this.isGestoreCredenzialiPortaApplicativaEnabled = Boolean.parseBoolean(value);
  10149.                         }else{
  10150.                                 this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10151.                                 this.isGestoreCredenzialiPortaApplicativaEnabled = false;
  10152.                         }

  10154.                 }catch(java.lang.Exception e) {
  10155.                         this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10156.                         this.isGestoreCredenzialiPortaApplicativaEnabled = false;
  10157.                 }
  10158.         }
  10159.         return this.isGestoreCredenzialiPortaApplicativaEnabled;
  10160.     }

  10162.     
  10163.     private Properties getGestoreCredenzialiPortaApplicativaProperties = null;
  10164.     public Properties getGestoreCredenzialiPortaApplicativaProperties() {
  10165.         if(this.getGestoreCredenzialiPortaApplicativaProperties==null){
  10166.             try{  
  10167.                 this.getGestoreCredenzialiPortaApplicativaProperties=this.reader.readProperties(prefixGestoreCredenzialiPortaApplicativaProperties);
  10168.                 if(this.getGestoreCredenzialiPortaApplicativaProperties==null) {
  10169.                     this.getGestoreCredenzialiPortaApplicativaProperties=new Properties();
  10170.                 }
  10171.             }catch(java.lang.Exception e) {
  10172.                 this.logError("Proprieta' di openspcoop '"+prefixGestoreCredenzialiPortaApplicativaProperties+"*' non impostate correttamente, errore:"+e.getMessage(),e);
  10173.                 this.getGestoreCredenzialiPortaApplicativaProperties = null;
  10174.             }
  10175.         }
  10176.         return this.getGestoreCredenzialiPortaApplicativaProperties;
  10177.     }
  10178.     

  10180.     
  10181.     
  10182.     
  10183.     /* ********  MAP  ******** */
  10184.     
  10185.     private String getEnvMapConfig = null;
  10186.     public String getEnvMapConfig(){
  10187.         if(this.getEnvMapConfig==null){
  10188.             String pName = "org.openspcoop2.pdd.env.map.config";
  10189.             try{  
  10190.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  10191.                 if(value!=null){
  10192.                     value = value.trim();
  10193.                     if(!"".equals(value)) {
  10194.                         this.getEnvMapConfig = value;
  10195.                     }
  10196.                 }

  10198.             }catch(java.lang.Exception e) {
  10199.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verranno caricate variabili errore:"+e.getMessage(),e);
  10200.                 this.getEnvMapConfig = null;
  10201.             }
  10202.         }
  10203.         return this.getEnvMapConfig;
  10204.     }
  10205.     
  10206.     private Boolean isEnvMapConfigRequired= null;
  10207.     public boolean isEnvMapConfigRequired(){
  10208.         if(this.isEnvMapConfigRequired==null){
  10209.             String pName = "org.openspcoop2.pdd.env.map.required";
  10210.             try{  
  10211.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10213.                 if(value!=null){
  10214.                     value = value.trim();
  10215.                     this.isEnvMapConfigRequired = Boolean.parseBoolean(value);
  10216.                 }else{
  10217.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10218.                     this.isEnvMapConfigRequired = false;
  10219.                 }

  10221.             }catch(java.lang.Exception e) {
  10222.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10223.                 this.isEnvMapConfigRequired = false;
  10224.             }
  10225.         }
  10226.         return this.isEnvMapConfigRequired;
  10227.     }
  10228.     
  10229.     
  10230.     
  10231.     
  10232.     /* ********  HSM  ******** */
  10233.     
  10234.     private String getHSMConfig = null;
  10235.     public String getHSMConfig(){
  10236.         if(this.getHSMConfig==null){
  10237.             String pName = "org.openspcoop2.pdd.hsm.config";
  10238.             try{  
  10239.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  10240.                 if(value!=null){
  10241.                     value = value.trim();
  10242.                     if(!"".equals(value)) {
  10243.                         this.getHSMConfig = value;
  10244.                     }
  10245.                 }

  10247.             }catch(java.lang.Exception e) {
  10248.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verrà abilitato l'engine HSM errore:"+e.getMessage(),e);
  10249.                 this.getHSMConfig = null;
  10250.             }
  10251.         }
  10252.         return this.getHSMConfig;
  10253.     }
  10254.     
  10255.     private Boolean isHSMConfigRequired= null;
  10256.     public boolean isHSMConfigRequired(){
  10257.         if(this.isHSMConfigRequired==null){
  10258.             String pName = "org.openspcoop2.pdd.hsm.required";
  10259.             try{  
  10260.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10262.                 if(value!=null){
  10263.                     value = value.trim();
  10264.                     this.isHSMConfigRequired = Boolean.parseBoolean(value);
  10265.                 }else{
  10266.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10267.                     this.isHSMConfigRequired = false;
  10268.                 }

  10270.             }catch(java.lang.Exception e) {
  10271.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10272.                 this.isHSMConfigRequired = false;
  10273.             }
  10274.         }
  10275.         return this.isHSMConfigRequired;
  10276.     }
  10277.     
  10278.     private Boolean isHSMConfigUniqueProviderInstance= null;
  10279.     public boolean isHSMConfigUniqueProviderInstance(){
  10280.         if(this.isHSMConfigUniqueProviderInstance==null){
  10281.             String pName = "org.openspcoop2.pdd.hsm.uniqueProviderInstance";
  10282.             try{  
  10283.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10285.                 if(value!=null){
  10286.                     value = value.trim();
  10287.                     this.isHSMConfigUniqueProviderInstance = Boolean.parseBoolean(value);
  10288.                 }else{
  10289.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  10290.                     this.isHSMConfigUniqueProviderInstance = true;
  10291.                 }

  10293.             }catch(java.lang.Exception e) {
  10294.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, true),e);
  10295.                 this.isHSMConfigUniqueProviderInstance = true;
  10296.             }
  10297.         }
  10298.         return this.isHSMConfigUniqueProviderInstance;
  10299.     }
  10300.     

  10302.     
  10303.     
  10304.     /* ********  OCSP  ******** */
  10305.     
  10306.     private String getOCSPConfig = null;
  10307.     public String getOCSPConfig(){
  10308.         if(this.getOCSPConfig==null){
  10309.             String pName = "org.openspcoop2.pdd.ocsp.config";
  10310.             try{  
  10311.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  10312.                 if(value!=null){
  10313.                     value = value.trim();
  10314.                     if(!"".equals(value)) {
  10315.                         this.getOCSPConfig = value;
  10316.                     }
  10317.                 }

  10319.             }catch(java.lang.Exception e) {
  10320.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verrà abilitato l'engine OCSP errore:"+e.getMessage(),e);
  10321.                 this.getOCSPConfig = null;
  10322.             }
  10323.         }
  10324.         return this.getOCSPConfig;
  10325.     }
  10326.     
  10327.     private Boolean isOCSPConfigRequired= null;
  10328.     public boolean isOCSPConfigRequired(){
  10329.         if(this.isOCSPConfigRequired==null){
  10330.             String pName = "org.openspcoop2.pdd.ocsp.required";
  10331.             try{  
  10332.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10334.                 if(value!=null){
  10335.                     value = value.trim();
  10336.                     this.isOCSPConfigRequired = Boolean.parseBoolean(value);
  10337.                 }else{
  10338.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10339.                     this.isOCSPConfigRequired = false;
  10340.                 }

  10342.             }catch(java.lang.Exception e) {
  10343.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10344.                 this.isOCSPConfigRequired = false;
  10345.             }
  10346.         }
  10347.         return this.isOCSPConfigRequired;
  10348.     }
  10349.     
  10350.     private Boolean isOCSPConfigLoadDefault= null;
  10351.     public boolean isOCSPConfigLoadDefault(){
  10352.         if(this.isOCSPConfigLoadDefault==null){
  10353.             String pName = "org.openspcoop2.pdd.ocsp.loadDefault";
  10354.             try{  
  10355.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10357.                 if(value!=null){
  10358.                     value = value.trim();
  10359.                     this.isOCSPConfigLoadDefault = Boolean.parseBoolean(value);
  10360.                 }else{
  10361.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  10362.                     this.isOCSPConfigLoadDefault = true;
  10363.                 }

  10365.             }catch(java.lang.Exception e) {
  10366.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, true),e);
  10367.                 this.isOCSPConfigLoadDefault = true;
  10368.             }
  10369.         }
  10370.         return this.isOCSPConfigLoadDefault;
  10371.     }
  10372.     
  10373.     
  10374.     
  10375.     
  10376.     
  10377.     /* ********  BYOK  ******** */
  10378.     
  10379.     private String getBYOKConfig = null;
  10380.     public String getBYOKConfig(){
  10381.         if(this.getBYOKConfig==null){
  10382.             String pName = "org.openspcoop2.pdd.byok.config";
  10383.             try{  
  10384.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  10385.                 if(value!=null){
  10386.                     value = value.trim();
  10387.                     if(!"".equals(value)) {
  10388.                         this.getBYOKConfig = value;
  10389.                     }
  10390.                 }

  10392.             }catch(java.lang.Exception e) {
  10393.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verrà abilitato l'engine BYOK errore:"+e.getMessage(),e);
  10394.                 this.getBYOKConfig = null;
  10395.             }
  10396.         }
  10397.         return this.getBYOKConfig;
  10398.     }
  10399.     
  10400.     private Boolean isBYOKConfigRequired= null;
  10401.     public boolean isBYOKConfigRequired(){
  10402.         if(this.isBYOKConfigRequired==null){
  10403.             String pName = "org.openspcoop2.pdd.byok.required";
  10404.             try{  
  10405.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10407.                 if(value!=null){
  10408.                     value = value.trim();
  10409.                     this.isBYOKConfigRequired = Boolean.parseBoolean(value);
  10410.                 }else{
  10411.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10412.                     this.isBYOKConfigRequired = false;
  10413.                 }

  10415.             }catch(java.lang.Exception e) {
  10416.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10417.                 this.isBYOKConfigRequired = false;
  10418.             }
  10419.         }
  10420.         return this.isBYOKConfigRequired;
  10421.     }
  10422.     
  10423.     private Boolean isBYOKJmxWrapEnbled= null;
  10424.     public boolean isBYOKJmxWrapEnbled(){
  10425.         if(this.isBYOKJmxWrapEnbled==null){
  10426.             String pName = "org.openspcoop2.pdd.byok.jmx.wrap.enabled";
  10427.             try{  
  10428.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10430.                 if(value!=null){
  10431.                     value = value.trim();
  10432.                     this.isBYOKJmxWrapEnbled = Boolean.parseBoolean(value);
  10433.                 }else{
  10434.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10435.                     this.isBYOKJmxWrapEnbled = false;
  10436.                 }

  10438.             }catch(java.lang.Exception e) {
  10439.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10440.                 this.isBYOKJmxWrapEnbled = false;
  10441.             }
  10442.         }
  10443.         return this.isBYOKJmxWrapEnbled;
  10444.     }
  10445.     
  10446.     private Boolean isBYOKJmxUnwrapEnbled= null;
  10447.     public boolean isBYOKJmxUnwrapEnbled(){
  10448.         if(this.isBYOKJmxUnwrapEnbled==null){
  10449.             String pName = "org.openspcoop2.pdd.byok.jmx.unwrap.enabled";
  10450.             try{  
  10451.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10453.                 if(value!=null){
  10454.                     value = value.trim();
  10455.                     this.isBYOKJmxUnwrapEnbled = Boolean.parseBoolean(value);
  10456.                 }else{
  10457.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10458.                     this.isBYOKJmxUnwrapEnbled = false;
  10459.                 }

  10461.             }catch(java.lang.Exception e) {
  10462.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10463.                 this.isBYOKJmxUnwrapEnbled = false;
  10464.             }
  10465.         }
  10466.         return this.isBYOKJmxUnwrapEnbled;
  10467.     }
  10468.         
  10469.     private String getBYOKEnvSecretsConfig = null;
  10470.     public String getBYOKEnvSecretsConfig(){
  10471.         if(this.getBYOKEnvSecretsConfig==null){
  10472.             String pName = "org.openspcoop2.pdd.byok.env.secrets.config";
  10473.             try{  
  10474.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  10475.                 if(value!=null){
  10476.                     value = value.trim();
  10477.                     if(!"".equals(value)) {
  10478.                         this.getBYOKEnvSecretsConfig = value;
  10479.                     }
  10480.                 }

  10482.             }catch(java.lang.Exception e) {
  10483.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verranno caricati secrets errore:"+e.getMessage(),e);
  10484.                 this.getBYOKEnvSecretsConfig = null;
  10485.             }
  10486.         }
  10487.         return this.getBYOKEnvSecretsConfig;
  10488.     }
  10489.     
  10490.     private Boolean isBYOKEnvSecretsConfigRequired= null;
  10491.     public boolean isBYOKEnvSecretsConfigRequired(){
  10492.         if(this.isBYOKEnvSecretsConfigRequired==null){
  10493.             String pName = "org.openspcoop2.pdd.byok.env.secrets.required";
  10494.             try{  
  10495.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10497.                 if(value!=null){
  10498.                     value = value.trim();
  10499.                     this.isBYOKEnvSecretsConfigRequired = Boolean.parseBoolean(value);
  10500.                 }else{
  10501.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10502.                     this.isBYOKEnvSecretsConfigRequired = false;
  10503.                 }

  10505.             }catch(java.lang.Exception e) {
  10506.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10507.                 this.isBYOKEnvSecretsConfigRequired = false;
  10508.             }
  10509.         }
  10510.         return this.isBYOKEnvSecretsConfigRequired;
  10511.     }
  10512.     
  10513.     
  10514.     
  10515.     

  10517.     /* ********  NODE RECEIVER  ******** */


  10520.     /**
  10521.      * Restituisce il Timeout di attesa di una risposta applicativa
  10522.      *
  10523.      * @return Restituisce il Timeout di attesa di una risposta applicativa
  10524.      * 
  10525.      */
  10526.     private Long nodeReceiverTimeout = null;
  10527.     public long getNodeReceiverTimeout() {  
  10528.         if(this.nodeReceiverTimeout == null){
  10529.             try{ 
  10530.                 String name = null;
  10531.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.timeout");
  10532.                 if(name!=null){
  10533.                     name = name.trim();
  10534.                     this.nodeReceiverTimeout = java.lang.Long.parseLong(name);
  10535.                 }else{
  10536.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.timeout' non impostata, viene utilizzato il default="+CostantiPdD.NODE_RECEIVER_ATTESA_ATTIVA);
  10537.                     this.nodeReceiverTimeout = CostantiPdD.NODE_RECEIVER_ATTESA_ATTIVA;
  10538.                 }
  10539.             }catch(java.lang.Exception e) {
  10540.                 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);
  10541.                 this.nodeReceiverTimeout = CostantiPdD.NODE_RECEIVER_ATTESA_ATTIVA;
  10542.             }    
  10543.         }

  10545.         return this.nodeReceiverTimeout;
  10546.     } 
  10547.     /**
  10548.      * Restituisce il Timeout di attesa di una risposta applicativa
  10549.      *
  10550.      * @return Restituisce il Timeout di attesa di una risposta applicativa
  10551.      * 
  10552.      */
  10553.     private Long nodeReceiverTimeoutRicezioneContenutiApplicativi = null;
  10554.     public long getNodeReceiverTimeoutRicezioneContenutiApplicativi() { 
  10555.         if(this.nodeReceiverTimeoutRicezioneContenutiApplicativi == null){
  10556.             try{ 
  10557.                 String name = null;
  10558.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.ricezioneContenutiApplicativi.timeout");
  10559.                 if(name!=null){
  10560.                     name = name.trim();
  10561.                     this.nodeReceiverTimeoutRicezioneContenutiApplicativi = java.lang.Long.parseLong(name);
  10562.                 }else{
  10563.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.ricezioneContenutiApplicativi.timeout' non impostata, viene utilizzato il default="+this.getNodeReceiverTimeout());
  10564.                     this.nodeReceiverTimeoutRicezioneContenutiApplicativi = this.getNodeReceiverTimeout();
  10565.                 }
  10566.             }catch(java.lang.Exception e) {
  10567.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.ricezioneContenutiApplicativi.timeout' non impostata, viene utilizzato il default="+this.getNodeReceiverTimeout()+", errore:"+e.getMessage(),e);
  10568.                 this.nodeReceiverTimeoutRicezioneContenutiApplicativi = this.getNodeReceiverTimeout();
  10569.             }    
  10570.         }

  10572.         return this.nodeReceiverTimeoutRicezioneContenutiApplicativi;
  10573.     } 
  10574.     /**
  10575.      * Restituisce il Timeout di attesa di una busta
  10576.      *
  10577.      * @return Restituisce il Timeout di attesa di una busta
  10578.      * 
  10579.      */
  10580.     private Long nodeReceiverTimeoutRicezioneBuste = null;
  10581.     public long getNodeReceiverTimeoutRicezioneBuste() {    
  10582.         if(this.nodeReceiverTimeoutRicezioneBuste == null){
  10583.             try{ 
  10584.                 String name = null;
  10585.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.ricezioneBuste.timeout");

  10587.                 if(name!=null){
  10588.                     name = name.trim();
  10589.                     this.nodeReceiverTimeoutRicezioneBuste = java.lang.Long.parseLong(name);
  10590.                 }else{
  10591.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.ricezioneBuste.timeout' non impostata, viene utilizzato il default="+this.getNodeReceiverTimeout());
  10592.                     this.nodeReceiverTimeoutRicezioneBuste = this.getNodeReceiverTimeout();
  10593.                 }
  10594.             }catch(java.lang.Exception e) {
  10595.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.ricezioneBuste.timeout' non impostata, viene utilizzato il default="+this.getNodeReceiverTimeout()+", errore:"+e.getMessage(),e);
  10596.                 this.nodeReceiverTimeoutRicezioneBuste = this.getNodeReceiverTimeout();
  10597.             }    
  10598.         }

  10600.         return this.nodeReceiverTimeoutRicezioneBuste;
  10601.     } 
  10602.     /**
  10603.      * Restituisce la Frequenza di check sulla coda RicezioneBuste/RicezioneContenutiApplicativi
  10604.      *
  10605.      * @return Restituisce la Frequenza di check sulla coda RicezioneBuste/RicezioneContenutiApplicativi
  10606.      * 
  10607.      */
  10608.     private Integer nodeReceiverCheckInterval = null;
  10609.     public int getNodeReceiverCheckInterval() { 
  10610.         if(this.nodeReceiverCheckInterval==null){
  10611.             try{ 
  10612.                 String name = null;
  10613.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.check");
  10614.                 if(name!=null){
  10615.                     name = name.trim();
  10616.                     this.nodeReceiverCheckInterval = java.lang.Integer.parseInt(name);
  10617.                 }else{
  10618.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.check' non impostata, viene utilizzato il default="+CostantiPdD.NODE_RECEIVER_CHECK_INTERVAL);
  10619.                     this.nodeReceiverCheckInterval = CostantiPdD.NODE_RECEIVER_CHECK_INTERVAL;
  10620.                 }
  10621.             }catch(java.lang.Exception e) {
  10622.                 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);
  10623.                 this.nodeReceiverCheckInterval = CostantiPdD.NODE_RECEIVER_CHECK_INTERVAL;
  10624.             }    
  10625.         }

  10627.         return this.nodeReceiverCheckInterval;
  10628.     }

  10630.     /**
  10631.      * Restituisce l'intervallo di check su DB effettuata dal TransactionManager, in caso di cache attiva
  10632.      * 
  10633.      * @return Restituisce intervallo di check su DB effettuata dal TransactionManager, in caso di cache attiva
  10634.      * 
  10635.      */
  10636.     private Integer nodeReceiverCheckDBInterval = null;
  10637.     public int getNodeReceiverCheckDBInterval() {   
  10638.         if(this.nodeReceiverCheckDBInterval==null){
  10639.             try{ 
  10640.                 String name = null;
  10641.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.checkDB");

  10643.                 if(name!=null){
  10644.                     name = name.trim();
  10645.                     int time = java.lang.Integer.parseInt(name);
  10646.                     this.nodeReceiverCheckDBInterval = time;
  10647.                 }else{
  10648.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.checkDB' non impostata, viene utilizzato il default="+CostantiPdD.NODE_RECEIVER_CHECK_DB_INTERVAL);
  10649.                     this.nodeReceiverCheckDBInterval = CostantiPdD.NODE_RECEIVER_CHECK_DB_INTERVAL;
  10650.                 }
  10651.             }catch(java.lang.Exception e) {
  10652.                 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);
  10653.                 this.nodeReceiverCheckDBInterval = CostantiPdD.NODE_RECEIVER_CHECK_DB_INTERVAL;
  10654.             }  
  10655.         }

  10657.         return this.nodeReceiverCheckDBInterval;
  10658.     }

  10660.     /**
  10661.      * Restituisce il nodeReceiver da utilizzare per le comunicazioni infrastrutturali 
  10662.      * 
  10663.      * @return  il nodeReceiver da utilizzare per le comunicazioni infrastrutturali 
  10664.      */
  10665.     private String nodeReceiver = null;
  10666.     public String getNodeReceiver() {
  10667.         if(this.nodeReceiver==null){
  10668.             try{ 
  10669.                 this.nodeReceiver = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver");
  10670.                 if(this.nodeReceiver==null)
  10671.                     throw new CoreException(NON_DEFINITA);
  10672.                 this.nodeReceiver = this.nodeReceiver.trim();

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

  10680.         return this.nodeReceiver;
  10681.     }

  10683.     /**
  10684.      * Restituisce l'indicazione se il NodeReceiver deve essere utilizzato in single connection
  10685.      *
  10686.      * @return Restituisce l'indicazione se il NodeReceiver deve essere utilizzato in single connection
  10687.      * 
  10688.      */
  10689.     private Boolean singleConnectionNodeReceiverValue = null;
  10690.     public boolean singleConnectionNodeReceiver(){

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

  10696.                 if(value!=null){
  10697.                     value = value.trim();
  10698.                     this.singleConnectionNodeReceiverValue = Boolean.parseBoolean(value);
  10699.                 }else{
  10700.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.singleConnection' non impostata, viene utilizzato il default=false");
  10701.                     this.singleConnectionNodeReceiverValue = false;
  10702.                 }

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

  10710.         return this.singleConnectionNodeReceiverValue;

  10712.     }




  10717.     /* ********  NODE SENDER  ******** */

  10719.     /**
  10720.      * Restituisce il nodeSender da utilizzare per le comunicazioni infrastrutturali 
  10721.      * 
  10722.      * @return  il nodeSender da utilizzare per le comunicazioni infrastrutturali 
  10723.      */
  10724.     private String nodeSender = null;
  10725.     public String getNodeSender() {
  10726.         if(this.nodeSender==null){
  10727.             try{ 
  10728.                 this.nodeSender = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeSender");
  10729.                 if(this.nodeSender==null)
  10730.                     throw new CoreException(NON_DEFINITA);
  10731.                 this.nodeSender = this.nodeSender.trim();

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

  10739.         return this.nodeSender;
  10740.     }








  10749.     /* ********  EJB  ******** */

  10751.     /**
  10752.      * Restituisce il Timeout di attesa per i deploy dei timer
  10753.      *
  10754.      * @return Restituisce il Timeout di attesa per i deploy dei timer
  10755.      * 
  10756.      */
  10757.     private Long timerEJBDeployTimeout = null;
  10758.     public long getTimerEJBDeployTimeout() {    
  10759.         if(this.timerEJBDeployTimeout==null){
  10760.             try{ 
  10761.                 String name = null;
  10762.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.timeout");

  10764.                 if(name!=null){
  10765.                     name = name.trim();
  10766.                     this.timerEJBDeployTimeout = java.lang.Long.parseLong(name);
  10767.                 }else{
  10768.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.timeout' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_EJB_ATTESA_ATTIVA);
  10769.                     this.timerEJBDeployTimeout = CostantiPdD.TIMER_EJB_ATTESA_ATTIVA;
  10770.                 }
  10771.             }catch(java.lang.Exception e) {
  10772.                 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);
  10773.                 this.timerEJBDeployTimeout = CostantiPdD.TIMER_EJB_ATTESA_ATTIVA;
  10774.             }    
  10775.         }

  10777.         return this.timerEJBDeployTimeout;
  10778.     } 
  10779.     /**
  10780.      * Restituisce la Frequenza di check per il deploy dei timer
  10781.      *
  10782.      * @return Restituisce la Frequenza di check per il deploy dei timer
  10783.      * 
  10784.      */
  10785.     private Integer timerEJBDeployCheckInterval = null;
  10786.     public int getTimerEJBDeployCheckInterval() {   
  10787.         if(this.timerEJBDeployCheckInterval==null){
  10788.             try{ 
  10789.                 String name = null;
  10790.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.check");

  10792.                 if(name!=null){
  10793.                     name = name.trim();
  10794.                     this.timerEJBDeployCheckInterval = java.lang.Integer.parseInt(name);
  10795.                 }else{
  10796.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.check' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_EJB_CHECK_INTERVAL);
  10797.                     this.timerEJBDeployCheckInterval = CostantiPdD.TIMER_EJB_CHECK_INTERVAL;
  10798.                 }
  10799.             }catch(java.lang.Exception e) {
  10800.                 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);
  10801.                 this.timerEJBDeployCheckInterval = CostantiPdD.TIMER_EJB_CHECK_INTERVAL;
  10802.             }  
  10803.         }

  10805.         return this.timerEJBDeployCheckInterval;
  10806.     }








  10815.     /* ********  TRANSACTION MANAGER  ******** */

  10817.     /**
  10818.      * Restituisce l'intervallo in millisecondi di attesa attiva effettuato dal Transaction Manager (Default 2 minuti)
  10819.      * 
  10820.      * @return Restituisce l'intervallo in millisecondi di attesa attiva effettuato dal Transaction Manager (Default 2 minuti)
  10821.      *  * 
  10822.      */
  10823.     private Long transactionManagerAttesaAttiva = null;
  10824.     public long getTransactionManagerAttesaAttiva() {   
  10825.         if(this.transactionManagerAttesaAttiva==null){
  10826.             try{ 
  10827.                 String name = null;
  10828.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.TransactionManager.attesaAttiva");

  10830.                 if(name!=null){
  10831.                     name = name.trim();
  10832.                     long time = java.lang.Long.parseLong(name);
  10833.                     this.transactionManagerAttesaAttiva = time*1000;
  10834.                 }else{
  10835.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.attesaAttiva' non impostata, viene utilizzato il default="+CostantiPdD.TRANSACTION_MANAGER_ATTESA_ATTIVA);
  10836.                     this.transactionManagerAttesaAttiva = CostantiPdD.TRANSACTION_MANAGER_ATTESA_ATTIVA;
  10837.                 }
  10838.             }catch(java.lang.Exception e) {
  10839.                 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);
  10840.                 this.transactionManagerAttesaAttiva = CostantiPdD.TRANSACTION_MANAGER_ATTESA_ATTIVA;
  10841.             }    
  10842.         }

  10844.         return this.transactionManagerAttesaAttiva;
  10845.     }

  10847.     /**
  10848.      * Restituisce l'intervallo maggiore per frequenza di check nell'attesa attiva effettuata dal TransactionManager, in millisecondi
  10849.      * 
  10850.      * @return Restituisce Intervallo maggiore per frequenza di check nell'attesa attiva effettuata dal TransactionManager, in millisecondi
  10851.      * 
  10852.      */
  10853.     private Integer transactionManagerCheckInterval = null;
  10854.     public int getTransactionManagerCheckInterval() {   
  10855.         if(this.transactionManagerCheckInterval==null){
  10856.             try{ 
  10857.                 String name = null;
  10858.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.TransactionManager.check");

  10860.                 if(name!=null){
  10861.                     name = name.trim();
  10862.                     int time = java.lang.Integer.parseInt(name);
  10863.                     this.transactionManagerCheckInterval = time;
  10864.                 }else{
  10865.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.check' non impostata, viene utilizzato il default="+CostantiPdD.TRANSACTION_MANAGER_CHECK_INTERVAL);
  10866.                     this.transactionManagerCheckInterval = CostantiPdD.TRANSACTION_MANAGER_CHECK_INTERVAL;
  10867.                 }
  10868.             }catch(java.lang.Exception e) {
  10869.                 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);
  10870.                 this.transactionManagerCheckInterval = CostantiPdD.TRANSACTION_MANAGER_CHECK_INTERVAL;
  10871.             }  
  10872.         }

  10874.         return this.transactionManagerCheckInterval;
  10875.     }

  10877.     /**
  10878.      * Restituisce l'intervallo di check su DB effettuata dal TransactionManager, in caso di cache attiva
  10879.      * 
  10880.      * @return Restituisce intervallo di check su DB effettuata dal TransactionManager, in caso di cache attiva
  10881.      * 
  10882.      */
  10883.     private Integer transactionManagerCheckDBInterval = null;
  10884.     public int getTransactionManagerCheckDBInterval() { 
  10885.         if(this.transactionManagerCheckDBInterval==null){
  10886.             try{ 
  10887.                 String name = null;
  10888.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.TransactionManager.checkDB");

  10890.                 if(name!=null){
  10891.                     name = name.trim();
  10892.                     int time = java.lang.Integer.parseInt(name);
  10893.                     this.transactionManagerCheckDBInterval = time;
  10894.                 }else{
  10895.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.checkDB' non impostata, viene utilizzato il default="+CostantiPdD.TRANSACTION_MANAGER_CHECK_DB_INTERVAL);
  10896.                     this.transactionManagerCheckDBInterval = CostantiPdD.TRANSACTION_MANAGER_CHECK_DB_INTERVAL;
  10897.                 }
  10898.             }catch(java.lang.Exception e) {
  10899.                 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);
  10900.                 this.transactionManagerCheckDBInterval = CostantiPdD.TRANSACTION_MANAGER_CHECK_DB_INTERVAL;
  10901.             }  
  10902.         }

  10904.         return this.transactionManagerCheckDBInterval;
  10905.     }


  10908.     /**
  10909.      * Restituisce l'indicazione se il TransactionManager deve essere utilizzato in single connection
  10910.      *
  10911.      * @return Restituisce l'indicazione se il TransactionManager deve essere utilizzato in single connection
  10912.      * 
  10913.      */
  10914.     private Boolean singleConnectionTransactionManagerValue = null;
  10915.     public boolean singleConnectionTransactionManager(){

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

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

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

  10935.         return this.singleConnectionTransactionManagerValue;

  10937.     }






  10944.     /* ********  SERIALIZABLE  ******** */

  10946.     /**
  10947.      * Restituisce l'intervallo di Attesa attiva di default effettuata per la gestione del livello serializable nel DB, in millisecondi 
  10948.      * 
  10949.      * @return Restituisce l'intervallo di Attesa attiva di default effettuata per la gestione del livello serializable nel DB, in millisecondi 
  10950.      * 
  10951.      */
  10952.     private Long gestioneSerializableDBAttesaAttiva = null;
  10953.     public long getGestioneSerializableDBAttesaAttiva() {   
  10954.         if(this.gestioneSerializableDBAttesaAttiva==null){
  10955.             try{ 
  10956.                 String name = null;
  10957.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.jdbc.serializable.attesaAttiva");
  10958.                 if (name != null) {
  10959.                     name = name.trim();
  10960.                     long time = java.lang.Long.parseLong(name);
  10961.                     this.gestioneSerializableDBAttesaAttiva = time*1000;
  10962.                 } else {
  10963.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jdbc.serializable.attesaAttiva' non impostata, viene utilizzato il default="+Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA);
  10964.                     this.gestioneSerializableDBAttesaAttiva =  Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA;
  10965.                 }
  10966.             }catch(java.lang.Exception e) {
  10967.                 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);
  10968.                 this.gestioneSerializableDBAttesaAttiva = Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA;
  10969.             }   
  10970.         }

  10972.         return this.gestioneSerializableDBAttesaAttiva;
  10973.     }

  10975.     /**
  10976.      * Restituisce l'intervallo maggiore per frequenza di check nell'attesa attiva effettuata per la gestione del livello serializable nel DB, in millisecondi
  10977.      * 
  10978.      * @return Restituisce Intervallo maggiore per frequenza di check nell'attesa attiva effettuata per la gestione del livello serializable nel DB, in millisecondi
  10979.      */
  10980.     private Integer gestioneSerializableDBCheckInterval = null;
  10981.     public int getGestioneSerializableDBCheckInterval() {   
  10982.         if(this.gestioneSerializableDBCheckInterval==null){
  10983.             try{ 
  10984.                 String name = null;
  10985.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.jdbc.serializable.check");
  10986.                 if (name != null){
  10987.                     name = name.trim();
  10988.                     int time = java.lang.Integer.parseInt(name);
  10989.                     this.gestioneSerializableDBCheckInterval = time;
  10990.                 } else{
  10991.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jdbc.serializable.check' non impostata, viene utilizzato il default="+Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL);
  10992.                     this.gestioneSerializableDBCheckInterval = Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL;
  10993.                 }
  10994.             }catch(java.lang.Exception e) {
  10995.                 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);
  10996.                 this.gestioneSerializableDBCheckInterval = Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL;
  10997.             }    
  10998.         }

  11000.         return this.gestioneSerializableDBCheckInterval;
  11001.     }

  11003.     private Boolean isJdbcCloseConnectionCheckIsClosed = null;
  11004.     public boolean isJdbcCloseConnectionCheckIsClosed(){

  11006.         if(this.isJdbcCloseConnectionCheckIsClosed==null){
  11007.             String pName = "org.openspcoop2.pdd.jdbc.closeConnection.checkIsClosed";
  11008.             try{  
  11009.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  11011.                 if(value!=null){
  11012.                     value = value.trim();
  11013.                     this.isJdbcCloseConnectionCheckIsClosed = Boolean.parseBoolean(value);
  11014.                 }else{
  11015.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  11016.                     this.isJdbcCloseConnectionCheckIsClosed = true;
  11017.                 }

  11019.             }catch(java.lang.Exception e) {
  11020.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  11021.                 this.isJdbcCloseConnectionCheckIsClosed = true;
  11022.             }
  11023.         }

  11025.         return this.isJdbcCloseConnectionCheckIsClosed;

  11027.     }
  11028.     
  11029.     private Boolean isJdbcCloseConnectionCheckAutocommit = null;
  11030.     public boolean isJdbcCloseConnectionCheckAutocommit(){

  11032.         if(this.isJdbcCloseConnectionCheckAutocommit==null){
  11033.             String pName = "org.openspcoop2.pdd.jdbc.closeConnection.checkAutocommit";
  11034.             try{  
  11035.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  11037.                 if(value!=null){
  11038.                     value = value.trim();
  11039.                     this.isJdbcCloseConnectionCheckAutocommit = Boolean.parseBoolean(value);
  11040.                 }else{
  11041.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  11042.                     this.isJdbcCloseConnectionCheckAutocommit = true;
  11043.                 }

  11045.             }catch(java.lang.Exception e) {
  11046.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  11047.                 this.isJdbcCloseConnectionCheckAutocommit = true;
  11048.             }
  11049.         }

  11051.         return this.isJdbcCloseConnectionCheckAutocommit;

  11053.     }






  11060.     /* ********  LIBRERIA PROTOCOL  ******** */

  11062.     /**
  11063.      * Restituisce il tipo di gestione del RepositoryBuste
  11064.      * 
  11065.      * @return Restituisce il tipo di gestione  del RepositoryBuste
  11066.      */
  11067.     private String gestoreRepositoryBuste = null;
  11068.     public String getGestoreRepositoryBuste() {
  11069.         if(this.gestoreRepositoryBuste==null){
  11070.             try{ 
  11071.                 String name = null;
  11072.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.repository.gestore");
  11073.                 if(name==null)
  11074.                     throw new CoreException(NON_DEFINITA);
  11075.                 name = name.trim();
  11076.                 
  11077.                 if(CostantiConfigurazione.REPOSITORY_BUSTE_AUTO_BYTEWISE.equals(name)){
  11078.                     if(this.getDatabaseType()!=null){
  11079.                         name = GestoreRepositoryFactory.getTipoRepositoryBuste(this.getDatabaseType());
  11080.                     }
  11081.                     else{
  11082.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.protocol.repository.gestore': il valore '"+
  11083.                                 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: "+
  11084.                                 CostantiConfigurazione.REPOSITORY_BUSTE_DEFAULT);
  11085.                         name = CostantiConfigurazione.REPOSITORY_BUSTE_DEFAULT;
  11086.                     }
  11087.                 }
  11088.                 
  11089.                 this.gestoreRepositoryBuste = name;
  11090.             
  11091.             }catch(java.lang.Exception e) {
  11092.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.protocol.repository.gestore': "+e.getMessage(),e);
  11093.                 this.gestoreRepositoryBuste = null;
  11094.             }    
  11095.         }

  11097.         return this.gestoreRepositoryBuste;
  11098.     }

  11100.     /**
  11101.      * Restituisce il tipo di filtro duplicati utilizzato dal RepositoryBuste
  11102.      * 
  11103.      * @return Restituisce il tipo di filtro duplicati utilizzato dal RepositoryBuste
  11104.      */
  11105.     private String gestoreFiltroDuplicatiRepositoryBuste = null;
  11106.     public String getGestoreFiltroDuplicatiRepositoryBuste() {
  11107.         if(this.gestoreFiltroDuplicatiRepositoryBuste==null){
  11108.             try{ 
  11109.                 String name = null;
  11110.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.filtroDuplicati");
  11111.                 if(name==null){
  11112.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.filtroDuplicati' non impostata, viene utilizzato il default="+CostantiConfigurazione.FILTRO_DUPLICATI_OPENSPCOOP);
  11113.                     this.gestoreFiltroDuplicatiRepositoryBuste = CostantiConfigurazione.FILTRO_DUPLICATI_OPENSPCOOP;
  11114.                 }else{
  11115.                     name = name.trim();
  11116.                     this.gestoreFiltroDuplicatiRepositoryBuste = name;
  11117.                 }
  11118.             
  11119.             }catch(java.lang.Exception e) {
  11120.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.filtroDuplicati' non impostata, viene utilizzato il default="+CostantiConfigurazione.FILTRO_DUPLICATI_OPENSPCOOP+", errore:"+e.getMessage(),e);
  11121.                 this.gestoreFiltroDuplicatiRepositoryBuste = CostantiConfigurazione.FILTRO_DUPLICATI_OPENSPCOOP;
  11122.             }    
  11123.         }

  11125.         return this.gestoreFiltroDuplicatiRepositoryBuste;
  11126.     }

  11128.     /**
  11129.      * Restituisce la Generazione attributi 'tipo' e 'servizioCorrelato' nell'elemento 'ProfiloCollaborazione' della richiesta asincrona simmetrica 
  11130.      * e della ricevuta alla richiesta asincrona asimmetrica
  11131.      *   
  11132.      * @return Restituisce la Generazione attributi 'tipo' e 'servizioCorrelato' nell'elemento 'ProfiloCollaborazione' della richiesta asincrona simmetrica 
  11133.      *         e della ricevuta alla richiesta asincrona asimmetrica
  11134.      * 
  11135.      */
  11136.     private Boolean isGenerazioneAttributiAsincroni = null;
  11137.     public boolean isGenerazioneAttributiAsincroni(String implementazionePdDSoggetto){

  11139.         // ovverriding per implementazione porta di dominio
  11140.         if(this.pddReader!=null){
  11141.             String tipo = this.pddReader.getBusta_AsincroniAttributiCorrelatiEnable(implementazionePdDSoggetto);
  11142.             if(tipo!=null && ( 
  11143.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11144.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11145.             ){
  11146.                 return CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo);
  11147.             }
  11148.         }

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

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

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

  11168.         return this.isGenerazioneAttributiAsincroni;
  11169.     }

  11171.     

  11173.     /**
  11174.      * Indicazione se ritenere una busta malformata se la validazione ha rilevato eccezioni di livello non gravi
  11175.      *   
  11176.      * @return Indicazione se ritenere una busta malformata se la validazione ha rilevato eccezioni di livello non gravi
  11177.      * 
  11178.      */
  11179.     private Boolean ignoraEccezioniNonGraviValidazione = null;
  11180.     public boolean ignoraEccezioniNonGraviValidazione(){
  11181.         if(this.ignoraEccezioniNonGraviValidazione==null){
  11182.             try{  
  11183.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.validazione.ignoraEccezioniNonGravi"); 

  11185.                 if (value != null){
  11186.                     value = value.trim();
  11187.                     this.ignoraEccezioniNonGraviValidazione = Boolean.parseBoolean(value);
  11188.                 }else{
  11189.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.validazione.ignoraEccezioniNonGravi' non impostata, viene utilizzato il default=false");
  11190.                     this.ignoraEccezioniNonGraviValidazione = false;
  11191.                 }

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

  11199.         return this.ignoraEccezioniNonGraviValidazione;
  11200.     }
  11201.     
  11202.     /**
  11203.      * Indicazione se forzare la generazione del prefix 'soap' per i fault spcoop (compatibilita' con OpenSPCoop v1).
  11204.      *   
  11205.      * @return Indicazione se forzare la generazione del prefix 'soap' per i fault spcoop (compatibilita' con OpenSPCoop v1).
  11206.      * 
  11207.      */
  11208.     private Boolean forceSoapPrefixCompatibilitaOpenSPCoopV1 = null;
  11209.     public boolean isForceSoapPrefixCompatibilitaOpenSPCoopV1(){
  11210.         if(this.forceSoapPrefixCompatibilitaOpenSPCoopV1==null){
  11211.             try{  
  11212.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.spcoop.backwardCompatibility.forceSoapPrefix"); 

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

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

  11228.         return this.forceSoapPrefixCompatibilitaOpenSPCoopV1;
  11229.     }
  11230.     

  11232.     /**
  11233.      * Indicazione se generare la lista Trasmissione
  11234.      *   
  11235.      * @return Indicazione se generare la lista Trasmissione
  11236.      * 
  11237.      */
  11238.     private Boolean isGenerazioneListaTrasmissioni = null;
  11239.     public boolean isGenerazioneListaTrasmissioni(String implementazionePdDSoggetto){

  11241.         // ovverriding per implementazione porta di dominio
  11242.         if(this.pddReader!=null){           
  11243.             String tipo = this.pddReader.getBusta_TrasmissioneEnable(implementazionePdDSoggetto);
  11244.             if(tipo!=null && ( 
  11245.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11246.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11247.             ){
  11248.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11249.                     return true;
  11250.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11251.                     return false;
  11252.             }
  11253.         }

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

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

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

  11273.         return this.isGenerazioneListaTrasmissioni;
  11274.     }

  11276.     /**
  11277.      * Indicazione se generare un msg di Protocollo errore in caso di filtro duplicati anche per il profilo oneway
  11278.      *   
  11279.      * @return Indicazione se generare un msg di Protocollo errore in caso di filtro duplicati  anche per il profilo oneway
  11280.      * 
  11281.      */
  11282.     private Boolean isGenerazioneErroreFiltroDuplicati = null;
  11283.     public boolean isGenerazioneErroreProtocolloFiltroDuplicati(String implementazionePdDSoggetto){

  11285.         // ovverriding per implementazione porta di dominio
  11286.         if(this.pddReader!=null){
  11287.             String tipo = this.pddReader.getBusta_FiltroduplicatiGenerazioneBustaErrore(implementazionePdDSoggetto);
  11288.             if(tipo!=null && ( 
  11289.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11290.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11291.             ){
  11292.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11293.                     return true;
  11294.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11295.                     return false;
  11296.             }
  11297.         }

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

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

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

  11317.         return this.isGenerazioneErroreFiltroDuplicati;
  11318.     }

  11320.     /**
  11321.      * Indicazione se leggere dal registro se abilitato il filtro duplicati
  11322.      *   
  11323.      * @return Indicazione se leggere dal registro se abilitato il filtro duplicati
  11324.      * 
  11325.      */
  11326.     private Boolean isCheckFromRegistroFiltroDuplicatiAbilitato = null;
  11327.     public boolean isCheckFromRegistroFiltroDuplicatiAbilitato(String implementazionePdDSoggetto){

  11329.         // ovverriding per implementazione porta di dominio
  11330.         if(this.pddReader!=null){
  11331.             String tipo = this.pddReader.getValidazione_FiltroDuplicatiLetturaRegistro(implementazionePdDSoggetto);
  11332.             if(tipo!=null && ( 
  11333.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11334.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11335.             ){
  11336.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11337.                     return true;
  11338.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11339.                     return false;
  11340.             }
  11341.         }

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

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

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

  11361.         return this.isCheckFromRegistroFiltroDuplicatiAbilitato;
  11362.     }

  11364.     /**
  11365.      * Indicazione se leggere dal registro se abilitato la gestione dei riscontri
  11366.      *   
  11367.      * @return Indicazione se leggere dal registro se abilitato la gestione dei riscontri
  11368.      * 
  11369.      */
  11370.     private Boolean isCheckFromRegistroConfermaRicezioneAbilitato = null;
  11371.     public boolean isCheckFromRegistroConfermaRicezioneAbilitato(String implementazionePdDSoggetto){

  11373.         // ovverriding per implementazione porta di dominio
  11374.         if(this.pddReader!=null){
  11375.             String tipo = this.pddReader.getValidazione_ConfermaRicezioneLetturaRegistro(implementazionePdDSoggetto);
  11376.             if(tipo!=null && ( 
  11377.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11378.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11379.             ){
  11380.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11381.                     return true;
  11382.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11383.                     return false;
  11384.             }
  11385.         }

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

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

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

  11405.         return this.isCheckFromRegistroConfermaRicezioneAbilitato;
  11406.     }

  11408.     /**
  11409.      * Indicazione se leggere dal registro se abilitato la consegna in ordine
  11410.      *   
  11411.      * @return Indicazione se leggere dal registro se abilitato la gestione dei riscontri
  11412.      * 
  11413.      */
  11414.     private Boolean isCheckFromRegistroConsegnaInOrdineAbilitato = null;
  11415.     public boolean isCheckFromRegistroConsegnaInOrdineAbilitato(String implementazionePdDSoggetto){

  11417.         // ovverriding per implementazione porta di dominio
  11418.         if(this.pddReader!=null){
  11419.             String tipo = this.pddReader.getValidazione_ConsegnaInOrdineLetturaRegistro(implementazionePdDSoggetto);
  11420.             if(tipo!=null && ( 
  11421.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11422.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11423.             ){
  11424.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11425.                     return true;
  11426.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11427.                     return false;
  11428.             }
  11429.         }

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

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

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

  11449.         return this.isCheckFromRegistroConsegnaInOrdineAbilitato;
  11450.     }

  11452.     /**
  11453.      * Indicazione se l'elemento collaborazione deve essere gestito
  11454.      *   
  11455.      * @return Indicazione se l'elemento collaborazione deve essere gestito
  11456.      * 
  11457.      */
  11458.     private Boolean isGestioneElementoCollaborazione = null;
  11459.     public boolean isGestioneElementoCollaborazione(String implementazionePdDSoggetto){

  11461.         // ovverriding per implementazione porta di dominio
  11462.         if(this.pddReader!=null){
  11463.             String tipo = this.pddReader.getBusta_CollaborazioneEnable(implementazionePdDSoggetto);
  11464.             if(tipo!=null && ( 
  11465.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11466.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11467.             ){
  11468.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11469.                     return true;
  11470.                 else 
  11471.                     return false;
  11472.             }
  11473.         }

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

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

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

  11493.         return this.isGestioneElementoCollaborazione;
  11494.     }
  11495.     
  11496.     private Boolean isGestioneElementoIdRiferimentoRichiesta = null;
  11497.     public boolean isGestioneElementoIdRiferimentoRichiesta(String implementazionePdDSoggetto){

  11499.         // ovverriding per implementazione porta di dominio
  11500.         if(this.pddReader!=null){
  11501.             String tipo = this.pddReader.getBusta_IdRiferimentoRichiestaEnable(implementazionePdDSoggetto);
  11502.             if(tipo!=null && ( 
  11503.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11504.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11505.             ){
  11506.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11507.                     return true;
  11508.                 else 
  11509.                     return false;
  11510.             }
  11511.         }

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

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

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

  11531.         return this.isGestioneElementoIdRiferimentoRichiesta;
  11532.     }

  11534.     /**
  11535.      * Indicazione se la funzionalita' di consegna in ordine deve essere gestita
  11536.      *   
  11537.      * @return Indicazione se la funzionalita' di consegna in ordine deve essere gestita
  11538.      * 
  11539.      */
  11540.     private Boolean isGestioneConsegnaInOrdine = null;
  11541.     public boolean isGestioneConsegnaInOrdine(String implementazionePdDSoggetto){

  11543.         // ovverriding per implementazione porta di dominio
  11544.         if(this.pddReader!=null){
  11545.             String tipo = this.pddReader.getBusta_ConsegnaInOrdineEnable(implementazionePdDSoggetto);
  11546.             if(tipo!=null && ( 
  11547.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11548.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11549.             ){
  11550.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11551.                     return true;
  11552.                 else 
  11553.                     return false;
  11554.             }
  11555.         }

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

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

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

  11575.         return this.isGestioneConsegnaInOrdine;
  11576.     }

  11578.     /**
  11579.      * Indicazione se la funzionalita' dei riscontri deve essere gestita
  11580.      *   
  11581.      * @return Indicazione se la funzionalita' dei riscontri deve essere gestita
  11582.      * 
  11583.      */
  11584.     private Boolean isGestioneRiscontri = null;
  11585.     public boolean isGestioneRiscontri(String implementazionePdDSoggetto){

  11587.         // ovverriding per implementazione porta di dominio
  11588.         if(this.pddReader!=null){
  11589.             String tipo = this.pddReader.getBusta_RiscontriEnable(implementazionePdDSoggetto);
  11590.             if(tipo!=null && ( 
  11591.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11592.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11593.             ){
  11594.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11595.                     return true;
  11596.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11597.                     return false;
  11598.             }
  11599.         }

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

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

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

  11619.         return this.isGestioneRiscontri;
  11620.     }
  11621.     
  11622.    

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

  11637.         // ovverriding per implementazione porta di dominio
  11638.         if(this.pddReader!=null){
  11639.             String tipo = this.pddReader.getValidazione_readQualifiedAttribute(implementazionePdDSoggetto);
  11640.             if(tipo!=null && ( 
  11641.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11642.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11643.             ){
  11644.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11645.                     return true;
  11646.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11647.                     return false;
  11648.             }
  11649.         }

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

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

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

  11669.         return this.isReadQualifiedAttribute;
  11670.     }

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

  11685.         // ovverriding per implementazione porta di dominio
  11686.         if(this.pddReader!=null){
  11687.             String tipo = this.pddReader.getValidazione_ValidazioneIDBustaCompleta(implementazionePdDSoggetto);
  11688.             if(tipo!=null && ( 
  11689.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11690.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11691.             ){
  11692.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11693.                     return true;
  11694.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11695.                     return false;
  11696.             }
  11697.         }

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

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

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

  11717.         return this.isValidazioneIDBustaCompleta;
  11718.     }
  11719.     
  11720.     public ProprietaManifestAttachments getProprietaManifestAttachments(String implementazionePdDSoggetto){
  11721.         ProprietaManifestAttachments properties = new ProprietaManifestAttachments();
  11722.         properties.setReadQualifiedAttribute(this.isReadQualifiedAttribute(implementazionePdDSoggetto));
  11723.         return properties;
  11724.     }


  11727.     /**
  11728.      * Restituisce l'eventuale location del file govway.pdd.properties
  11729.      * 
  11730.      * @return Restituisce la location del file govway.pdd.properties
  11731.      */
  11732.     private String filePddProperties = null;
  11733.     private boolean filePddPropertiesLetto = false;
  11734.     public String getLocationPddProperties() {
  11735.         if(this.filePddPropertiesLetto==false){
  11736.             try{ 
  11737.                 String name = null;
  11738.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.pddProperties");
  11739.                 if(name!=null){
  11740.                     name = name.trim();
  11741.                     this.filePddProperties = name;
  11742.                 }
  11743.                 this.filePddPropertiesLetto= true;
  11744.             }catch(java.lang.Exception e) {
  11745.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.protocol.pddProperties': "+e.getMessage(),e);
  11746.                 this.filePddProperties = null;
  11747.             }               
  11748.         }

  11750.         return this.filePddProperties;
  11751.     }






  11758.     /* ********  INTEGRAZIONE  ******** */

  11760.     /**
  11761.      * Restituisce l'elenco dei tipi di integrazione da gestire lato PortaDelegata
  11762.      * 
  11763.      * @return  Restituisce l'elenco dei tipi di integrazione da gestire lato PortaDelegata
  11764.      */
  11765.     private String[] tipoIntegrazionePD = null;
  11766.     private boolean tipoIntegrazionePDRead = false;
  11767.     public String[] getTipoIntegrazionePD() {
  11768.         if(!this.tipoIntegrazionePDRead){
  11769.             try{  
  11770.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pd"); 
  11771.                 if(value==null)
  11772.                     throw new CoreException(NON_DEFINITA);
  11773.                 value = value.trim();
  11774.                 String [] r = value.split(",");
  11775.                 this.tipoIntegrazionePD = r;

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

  11784.         return this.tipoIntegrazionePD;
  11785.     }
  11786.     /**
  11787.      * Restituisce l'elenco dei tipi di integrazione da gestire lato PortaApplicativa
  11788.      * 
  11789.      * @return  Restituisce l'elenco dei tipi di integrazione da gestire lato PortaApplicativa
  11790.      */
  11791.     private String[] tipoIntegrazionePA = null;
  11792.     private boolean tipoIntegrazionePARead = false;
  11793.     public String[] getTipoIntegrazionePA() {
  11794.         if(!this.tipoIntegrazionePARead){
  11795.             try{ 
  11796.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pa");
  11797.                 if(value==null)
  11798.                     throw new CoreException(NON_DEFINITA);
  11799.                 value = value.trim();
  11800.                 String [] r = value.split(",");
  11801.                 this.tipoIntegrazionePA = r;
  11802.             }catch(java.lang.Exception e) {
  11803.                 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);
  11804.                 this.tipoIntegrazionePA = null;
  11805.             }   
  11806.             this.tipoIntegrazionePARead = true;
  11807.         }

  11809.         return this.tipoIntegrazionePA;
  11810.     }
  11811.     
  11812.     /**
  11813.      * Restituisce l'elenco dei tipi di integrazione da gestire lato PortaDelegata specifici per protocollo
  11814.      * 
  11815.      * @return  Restituisce l'elenco dei tipi di integrazione da gestire lato PortaDelegata specifici per protocollo
  11816.      */
  11817.     private Map<String, String[]> tipoIntegrazionePD_perProtocollo = new HashMap<>();
  11818.     private Map<String, Boolean> tipoIntegrazionePD_perProtocollo_notExists = new HashMap<>();
  11819.     public String[] getTipoIntegrazionePD(String protocollo) {
  11820.         
  11821.         if( 
  11822.             (!this.tipoIntegrazionePD_perProtocollo.containsKey(protocollo)) 
  11823.             &&
  11824.             (!this.tipoIntegrazionePD_perProtocollo_notExists.containsKey(protocollo)) 
  11825.         ){
  11826.             try{  
  11827.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pd."+protocollo); 
  11828.                 if(value==null){
  11829.                     this.tipoIntegrazionePD_perProtocollo_notExists.put(protocollo, false);
  11830.                 }
  11831.                 else{
  11832.                     value = value.trim();
  11833.                     String [] r = value.split(",");
  11834.                     this.tipoIntegrazionePD_perProtocollo.put(protocollo, r);
  11835.                 }

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

  11842.         if(this.tipoIntegrazionePD_perProtocollo.containsKey(protocollo)){
  11843.             return this.tipoIntegrazionePD_perProtocollo.get(protocollo);
  11844.         }else{
  11845.             return null;
  11846.         }
  11847.     }
  11848.     
  11849.     /**
  11850.      * Restituisce l'elenco dei tipi di integrazione da gestire lato PortaApplicativa specifici per protocollo
  11851.      * 
  11852.      * @return  Restituisce l'elenco dei tipi di integrazione da gestire lato PortaApplicativa specifici per protocollo
  11853.      */
  11854.     private Map<String, String[]> tipoIntegrazionePA_perProtocollo = new HashMap<>();
  11855.     private Map<String, Boolean> tipoIntegrazionePA_perProtocollo_notExists = new HashMap<>();
  11856.     public String[] getTipoIntegrazionePA(String protocollo) {
  11857.         
  11858.         if( 
  11859.             (!this.tipoIntegrazionePA_perProtocollo.containsKey(protocollo)) 
  11860.             &&
  11861.             (!this.tipoIntegrazionePA_perProtocollo_notExists.containsKey(protocollo)) 
  11862.         ){
  11863.             try{  
  11864.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pa."+protocollo); 
  11865.                 if(value==null){
  11866.                     this.tipoIntegrazionePA_perProtocollo_notExists.put(protocollo, false);
  11867.                 }
  11868.                 else{
  11869.                     value = value.trim();
  11870.                     String [] r = value.split(",");
  11871.                     this.tipoIntegrazionePA_perProtocollo.put(protocollo, r);
  11872.                 }

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

  11879.         if(this.tipoIntegrazionePA_perProtocollo.containsKey(protocollo)){
  11880.             return this.tipoIntegrazionePA_perProtocollo.get(protocollo);
  11881.         }else{
  11882.             return null;
  11883.         }
  11884.     }
  11885.     

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

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

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

  11918.         return this.isIntegrazioneAsincroniConIdCollaborazioneEnabled;
  11919.     }
  11920.     
  11921.     private Map<String, String> newOldMapping_backward_compatibility_trasparente_soggetto = null;
  11922.     public Map<String, String> getNewOldMapping_backward_compatibility_trasparente_soggetto() { 
  11923.         if(this.newOldMapping_backward_compatibility_trasparente_soggetto==null){
  11924.             String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.trasparente.soggetto.tipo.";
  11925.             try{ 
  11926.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  11927.                 this.newOldMapping_backward_compatibility_trasparente_soggetto=new HashMap<>();
  11928.                 if(p!=null && !p.isEmpty()) {
  11929.                     for (Object oKey : p.keySet()) {
  11930.                         if(oKey!=null && oKey instanceof String) {
  11931.                             String key = (String) oKey;
  11932.                             String old = p.getProperty(key);
  11933.                             this.newOldMapping_backward_compatibility_trasparente_soggetto.put(key, old);
  11934.                         }
  11935.                     }
  11936.                 }
  11937.             }catch(java.lang.Exception e) {
  11938.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
  11939.                 this.newOldMapping_backward_compatibility_trasparente_soggetto = null;
  11940.             }    
  11941.         }

  11943.         return this.newOldMapping_backward_compatibility_trasparente_soggetto;
  11944.     }
  11945.     private Map<String, String> newOldMapping_backward_compatibility_trasparente_servizio = null;
  11946.     public Map<String, String> getNewOldMapping_backward_compatibility_trasparente_servizio() { 
  11947.         if(this.newOldMapping_backward_compatibility_trasparente_servizio==null){
  11948.             String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.trasparente.servizio.tipo.";
  11949.             try{ 
  11950.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  11951.                 this.newOldMapping_backward_compatibility_trasparente_servizio=new HashMap<>();
  11952.                 if(p!=null && !p.isEmpty()) {
  11953.                     for (Object oKey : p.keySet()) {
  11954.                         if(oKey!=null && oKey instanceof String) {
  11955.                             String key = (String) oKey;
  11956.                             String old = p.getProperty(key);
  11957.                             this.newOldMapping_backward_compatibility_trasparente_servizio.put(key, old);
  11958.                         }
  11959.                     }
  11960.                 }
  11961.             }catch(java.lang.Exception e) {
  11962.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
  11963.                 this.newOldMapping_backward_compatibility_trasparente_servizio = null;
  11964.             }    
  11965.         }

  11967.         return this.newOldMapping_backward_compatibility_trasparente_servizio;
  11968.     }

  11970.     private Map<String, String> newOldMapping_backward_compatibility_spcoop_soggetto = null;
  11971.     public Map<String, String> getNewOldMapping_backward_compatibility_spcoop_soggetto() {  
  11972.         if(this.newOldMapping_backward_compatibility_spcoop_soggetto==null){
  11973.             String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.spcoop.soggetto.tipo.";
  11974.             try{ 
  11975.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  11976.                 this.newOldMapping_backward_compatibility_spcoop_soggetto=new HashMap<>();
  11977.                 if(p!=null && !p.isEmpty()) {
  11978.                     for (Object oKey : p.keySet()) {
  11979.                         if(oKey!=null && oKey instanceof String) {
  11980.                             String key = (String) oKey;
  11981.                             String old = p.getProperty(key);
  11982.                             this.newOldMapping_backward_compatibility_spcoop_soggetto.put(key, old);
  11983.                         }
  11984.                     }
  11985.                 }
  11986.             }catch(java.lang.Exception e) {
  11987.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
  11988.                 this.newOldMapping_backward_compatibility_spcoop_soggetto = null;
  11989.             }    
  11990.         }

  11992.         return this.newOldMapping_backward_compatibility_spcoop_soggetto;
  11993.     }
  11994.     private Map<String, String> newOldMapping_backward_compatibility_spcoop_servizio = null;
  11995.     public Map<String, String> getNewOldMapping_backward_compatibility_spcoop_servizio() {  
  11996.         if(this.newOldMapping_backward_compatibility_spcoop_servizio==null){
  11997.             String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.spcoop.servizio.tipo.";
  11998.             try{ 
  11999.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  12000.                 this.newOldMapping_backward_compatibility_spcoop_servizio=new HashMap<>();
  12001.                 if(p!=null && !p.isEmpty()) {
  12002.                     for (Object oKey : p.keySet()) {
  12003.                         if(oKey!=null && oKey instanceof String) {
  12004.                             String key = (String) oKey;
  12005.                             String old = p.getProperty(key);
  12006.                             this.newOldMapping_backward_compatibility_spcoop_servizio.put(key, old);
  12007.                         }
  12008.                     }
  12009.                 }
  12010.             }catch(java.lang.Exception e) {
  12011.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
  12012.                 this.newOldMapping_backward_compatibility_spcoop_servizio = null;
  12013.             }    
  12014.         }

  12016.         return this.newOldMapping_backward_compatibility_spcoop_servizio;
  12017.     }
  12018.     
  12019.     private Map<String, String> newOldMapping_backward_compatibility_sdi_soggetto = null;
  12020.     public Map<String, String> getNewOldMapping_backward_compatibility_sdi_soggetto() { 
  12021.         if(this.newOldMapping_backward_compatibility_sdi_soggetto==null){
  12022.             String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.sdi.soggetto.tipo.";
  12023.             try{ 
  12024.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  12025.                 this.newOldMapping_backward_compatibility_sdi_soggetto=new HashMap<>();
  12026.                 if(p!=null && !p.isEmpty()) {
  12027.                     for (Object oKey : p.keySet()) {
  12028.                         if(oKey!=null && oKey instanceof String) {
  12029.                             String key = (String) oKey;
  12030.                             String old = p.getProperty(key);
  12031.                             this.newOldMapping_backward_compatibility_sdi_soggetto.put(key, old);
  12032.                         }
  12033.                     }
  12034.                 }
  12035.             }catch(java.lang.Exception e) {
  12036.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
  12037.                 this.newOldMapping_backward_compatibility_sdi_soggetto = null;
  12038.             }    
  12039.         }

  12041.         return this.newOldMapping_backward_compatibility_sdi_soggetto;
  12042.     }
  12043.     private Map<String, String> newOldMapping_backward_compatibility_sdi_servizio = null;
  12044.     public Map<String, String> getNewOldMapping_backward_compatibility_sdi_servizio() { 
  12045.         if(this.newOldMapping_backward_compatibility_sdi_servizio==null){
  12046.             String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.sdi.servizio.tipo.";
  12047.             try{ 
  12048.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  12049.                 this.newOldMapping_backward_compatibility_sdi_servizio=new HashMap<>();
  12050.                 if(p!=null && !p.isEmpty()) {
  12051.                     for (Object oKey : p.keySet()) {
  12052.                         if(oKey!=null && oKey instanceof String) {
  12053.                             String key = (String) oKey;
  12054.                             String old = p.getProperty(key);
  12055.                             this.newOldMapping_backward_compatibility_sdi_servizio.put(key, old);
  12056.                         }
  12057.                     }
  12058.                 }
  12059.             }catch(java.lang.Exception e) {
  12060.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
  12061.                 this.newOldMapping_backward_compatibility_sdi_servizio = null;
  12062.             }    
  12063.         }

  12065.         return this.newOldMapping_backward_compatibility_sdi_servizio;
  12066.     }
  12067.     
  12068.     


  12071.     private <T> Map<MapKey<String>, T> _convertMapToCostantiIntegrazione(Map<String, T> map) throws CoreException{
  12072.         List<MapKey<String>> keywordsIntegrazione = getKeywordsIntegrazioneEngine(true);
  12073.         Map<MapKey<String>, T> newMap = new HashMap<MapKey<String>, T>();
  12074.         for (String key : map.keySet()) {
  12075.             boolean find = false;
  12076.             for (MapKey<String> mapKey : keywordsIntegrazione) {
  12077.                 if(key.equals(mapKey.getValue())){
  12078.                     newMap.put(mapKey, map.get(key));
  12079.                     find = true;
  12080.                 }
  12081.             }
  12082.             if(!find) {
  12083.                 throw new CoreException("Chiave '"+key+"' sconosciuta, non risulta essere una keyword di integrazione");
  12084.             }
  12085.         }
  12086.         return newMap;
  12087.     }
  12088.     
  12089.     /**
  12090.      * Restituisce le proprieta' che identificano gli header di integrazione in caso di 'trasporto' 
  12091.      *
  12092.      * @return Restituisce le proprieta' che identificano gli header di integrazione in caso di 'trasporto'
  12093.      *  
  12094.      */
  12095.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneTrasporto = null;
  12096.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneTrasporto() {  
  12097.         if(this.keyValue_HeaderIntegrazioneTrasporto==null){

  12099.             try{ 

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

  12109.         return this.keyValue_HeaderIntegrazioneTrasporto;
  12110.     }
  12111.     
  12112.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2 = null;
  12113.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2() {    
  12114.         if(this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2==null){

  12116.             try{ 

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

  12128.         return this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2;
  12129.     }
  12130.     
  12131.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1 = null;
  12132.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1() {    
  12133.         if(this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1==null){

  12135.             try{ 

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

  12147.         return this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1;
  12148.     }
  12149.     
  12150.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_setPD_request = null;
  12151.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_setPD_response = null;
  12152.     public Map<MapKey<String>, Boolean> getKeyPDSetEnabled_HeaderIntegrazioneTrasporto(boolean request) throws CoreException {  
  12153.                 
  12154.         if( (request && this.keyValue_HeaderIntegrazioneTrasporto_setPD_request==null)
  12155.             ||
  12156.             (!request && this.keyValue_HeaderIntegrazioneTrasporto_setPD_response==null)
  12157.             ){

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

  12167.                 prop = this.reader.readPropertiesConvertEnvProperties(pName);
  12168.                 Map<String, Boolean> _tmp = new HashMap<>();
  12169.                 Iterator<?> it = prop.keySet().iterator();
  12170.                 while (it.hasNext()) {
  12171.                     Object object = (Object) it.next();
  12172.                     if(object instanceof String) {
  12173.                         String key = (String) object;
  12174.                         String value = prop.getProperty(key);
  12175.                         try {
  12176.                             boolean b = Boolean.parseBoolean(value);
  12177.                             _tmp.put(key, b);
  12178.                         }catch(Exception e) {
  12179.                             throw new CoreException("Rilevato errore durante il parsing della property '"+pName+"."+key+"' (atteso: true/false): "+e.getMessage(),e);
  12180.                         }
  12181.                     }
  12182.                 }
  12183.                 if(request) {
  12184.                     this.keyValue_HeaderIntegrazioneTrasporto_setPD_request = _convertMapToCostantiIntegrazione(_tmp);
  12185.                 }
  12186.                 else {
  12187.                     this.keyValue_HeaderIntegrazioneTrasporto_setPD_response = _convertMapToCostantiIntegrazione(_tmp);
  12188.                 }
  12189.                 
  12190.             }catch(java.lang.Exception e) {
  12191.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  12192.                 throw new CoreException(e.getMessage(),e);
  12193.             }    
  12194.         }

  12196.         if(request) {
  12197.             return this.keyValue_HeaderIntegrazioneTrasporto_setPD_request;
  12198.         }
  12199.         else {
  12200.             return this.keyValue_HeaderIntegrazioneTrasporto_setPD_response;
  12201.         }
  12202.     }
  12203.     
  12204.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_readPD = null;
  12205.     public Map<MapKey<String>, Boolean> getKeyPDReadEnabled_HeaderIntegrazioneTrasporto() throws CoreException {    
  12206.         if(this.keyValue_HeaderIntegrazioneTrasporto_readPD==null){

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

  12211.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.trasporto.pd.read.enabled.");
  12212.                 Map<String, Boolean> _tmp = new HashMap<>();
  12213.                 Iterator<?> it = prop.keySet().iterator();
  12214.                 while (it.hasNext()) {
  12215.                     Object object = (Object) it.next();
  12216.                     if(object instanceof String) {
  12217.                         String key = (String) object;
  12218.                         String value = prop.getProperty(key);
  12219.                         try {
  12220.                             boolean b = Boolean.parseBoolean(value);
  12221.                             _tmp.put(key, b);
  12222.                         }catch(Exception e) {
  12223.                             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);
  12224.                         }
  12225.                     }
  12226.                 }
  12227.                 this.keyValue_HeaderIntegrazioneTrasporto_readPD = _convertMapToCostantiIntegrazione(_tmp);
  12228.                 
  12229.             }catch(java.lang.Exception e) {
  12230.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.trasporto.pd.read.enabled.*': "+e.getMessage(),e);
  12231.                 throw new CoreException(e.getMessage(),e);
  12232.             }    
  12233.         }

  12235.         return this.keyValue_HeaderIntegrazioneTrasporto_readPD;
  12236.     }
  12237.     
  12238.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_setPA_request = null;
  12239.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_setPA_response = null;
  12240.     public Map<MapKey<String>, Boolean> getKeyPASetEnabled_HeaderIntegrazioneTrasporto(boolean request) throws CoreException {
  12241.                 
  12242.         if( (request && this.keyValue_HeaderIntegrazioneTrasporto_setPA_request==null)
  12243.                 ||
  12244.                 (!request && this.keyValue_HeaderIntegrazioneTrasporto_setPA_response==null)
  12245.                 ){

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

  12255.                 prop = this.reader.readPropertiesConvertEnvProperties(pName);
  12256.                 Map<String, Boolean> _tmp = new HashMap<>();
  12257.                 Iterator<?> it = prop.keySet().iterator();
  12258.                 while (it.hasNext()) {
  12259.                     Object object = (Object) it.next();
  12260.                     if(object instanceof String) {
  12261.                         String key = (String) object;
  12262.                         String value = prop.getProperty(key);
  12263.                         try {
  12264.                             boolean b = Boolean.parseBoolean(value);
  12265.                             //if(request) {
  12266.                             //  _tmp.put(key, b);
  12267.                             //}
  12268.                             //else {
  12269.                             _tmp.put(key, b);
  12270.                             //}
  12271.                         }catch(Exception e) {
  12272.                             throw new CoreException("Rilevato errore durante il parsing della property '"+pName+"."+key+"' (atteso: true/false): "+e.getMessage(),e);
  12273.                         }
  12274.                     }
  12275.                 }
  12276.                 if(request) {
  12277.                     this.keyValue_HeaderIntegrazioneTrasporto_setPA_request = _convertMapToCostantiIntegrazione(_tmp);
  12278.                 }
  12279.                 else {
  12280.                     this.keyValue_HeaderIntegrazioneTrasporto_setPA_response = _convertMapToCostantiIntegrazione(_tmp);
  12281.                 }
  12282.                 
  12283.             }catch(java.lang.Exception e) {
  12284.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  12285.                 throw new CoreException(e.getMessage(),e);
  12286.             }    
  12287.         }

  12289.         if(request) {
  12290.             return this.keyValue_HeaderIntegrazioneTrasporto_setPA_request;
  12291.         }
  12292.         else {
  12293.             return this.keyValue_HeaderIntegrazioneTrasporto_setPA_response;
  12294.         }
  12295.     }
  12296.     
  12297.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_readPA = null;
  12298.     public Map<MapKey<String>, Boolean> getKeyPAReadEnabled_HeaderIntegrazioneTrasporto() throws CoreException {    
  12299.         if(this.keyValue_HeaderIntegrazioneTrasporto_readPA==null){

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

  12304.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.trasporto.pa.read.enabled.");
  12305.                 Map<String, Boolean> _tmp = new HashMap<>();
  12306.                 Iterator<?> it = prop.keySet().iterator();
  12307.                 while (it.hasNext()) {
  12308.                     Object object = (Object) it.next();
  12309.                     if(object instanceof String) {
  12310.                         String key = (String) object;
  12311.                         String value = prop.getProperty(key);
  12312.                         try {
  12313.                             boolean b = Boolean.parseBoolean(value);
  12314.                             _tmp.put(key, b);
  12315.                         }catch(Exception e) {
  12316.                             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);
  12317.                         }
  12318.                     }
  12319.                 }
  12320.                 this.keyValue_HeaderIntegrazioneTrasporto_readPA = _convertMapToCostantiIntegrazione(_tmp);
  12321.                                 
  12322.             }catch(java.lang.Exception e) {
  12323.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.trasporto.pa.read.enabled.*': "+e.getMessage(),e);
  12324.                 throw new CoreException(e.getMessage(),e);
  12325.             }    
  12326.         }

  12328.         return this.keyValue_HeaderIntegrazioneTrasporto_readPA;
  12329.     }
  12330.     
  12331.     /**
  12332.      * Restituisce le proprieta' che identificano gli header di integrazione in caso di 'urlBased'.
  12333.      *
  12334.      * @return Restituisce le proprieta' che identificano gli header di integrazione in caso di 'urlBased'.
  12335.      *  
  12336.      */
  12337.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneUrlBased = null;
  12338.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneUrlBased() {   
  12339.         if(this.keyValue_HeaderIntegrazioneUrlBased==null){

  12341.             try{ 

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

  12353.         return this.keyValue_HeaderIntegrazioneUrlBased;
  12354.     }
  12355.     
  12356.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2 = null;
  12357.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2() { 
  12358.         if(this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2==null){

  12360.             try{ 

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

  12372.         return this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2;
  12373.     }
  12374.     
  12375.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1 = null;
  12376.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1() { 
  12377.         if(this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1==null){

  12379.             try{ 

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

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

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

  12401.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.urlBased.pd.set.request.enabled.");
  12402.                 Map<String, Boolean> _tmp = new HashMap<>();
  12403.                 Iterator<?> it = prop.keySet().iterator();
  12404.                 while (it.hasNext()) {
  12405.                     Object object = (Object) it.next();
  12406.                     if(object instanceof String) {
  12407.                         String key = (String) object;
  12408.                         String value = prop.getProperty(key);
  12409.                         try {
  12410.                             boolean b = Boolean.parseBoolean(value);
  12411.                             _tmp.put(key, b);
  12412.                         }catch(Exception e) {
  12413.                             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);
  12414.                         }
  12415.                     }
  12416.                 }
  12417.                 this.keyValue_HeaderIntegrazioneUrlBased_setPD = _convertMapToCostantiIntegrazione(_tmp);
  12418.                 
  12419.             }catch(java.lang.Exception e) {
  12420.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.urlBased.pd.set.request.enabled*': "+e.getMessage(),e);
  12421.                 throw new CoreException(e.getMessage(),e);
  12422.             }    
  12423.         }

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

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

  12435.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.urlBased.pd.read.enabled.");
  12436.                 Map<String, Boolean> _tmp = new HashMap<>();
  12437.                 Iterator<?> it = prop.keySet().iterator();
  12438.                 while (it.hasNext()) {
  12439.                     Object object = (Object) it.next();
  12440.                     if(object instanceof String) {
  12441.                         String key = (String) object;
  12442.                         String value = prop.getProperty(key);
  12443.                         try {
  12444.                             boolean b = Boolean.parseBoolean(value);
  12445.                             _tmp.put(key, b);
  12446.                         }catch(Exception e) {
  12447.                             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);
  12448.                         }
  12449.                     }
  12450.                 }
  12451.                 this.keyValue_HeaderIntegrazioneUrlBased_readPD = _convertMapToCostantiIntegrazione(_tmp);
  12452.                                 
  12453.             }catch(java.lang.Exception e) {
  12454.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.urlBased.pd.read.enabled.*': "+e.getMessage(),e);
  12455.                 throw new CoreException(e.getMessage(),e);
  12456.             }    
  12457.         }

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

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

  12469.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.urlBased.pa.set.request.enabled.");
  12470.                 Map<String, Boolean> _tmp = new HashMap<>();
  12471.                 Iterator<?> it = prop.keySet().iterator();
  12472.                 while (it.hasNext()) {
  12473.                     Object object = (Object) it.next();
  12474.                     if(object instanceof String) {
  12475.                         String key = (String) object;
  12476.                         String value = prop.getProperty(key);
  12477.                         try {
  12478.                             boolean b = Boolean.parseBoolean(value);
  12479.                             _tmp.put(key, b);
  12480.                         }catch(Exception e) {
  12481.                             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);
  12482.                         }
  12483.                     }
  12484.                 }
  12485.                 this.keyValue_HeaderIntegrazioneUrlBased_setPA = _convertMapToCostantiIntegrazione(_tmp);
  12486.                 
  12487.             }catch(java.lang.Exception e) {
  12488.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.urlBased.pa.set.request.enabled*': "+e.getMessage(),e);
  12489.                 throw new CoreException(e.getMessage(),e);
  12490.             }    
  12491.         }

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

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

  12503.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.urlBased.pa.read.enabled.");
  12504.                 Map<String, Boolean> _tmp = new HashMap<>();
  12505.                 Iterator<?> it = prop.keySet().iterator();
  12506.                 while (it.hasNext()) {
  12507.                     Object object = (Object) it.next();
  12508.                     if(object instanceof String) {
  12509.                         String key = (String) object;
  12510.                         String value = prop.getProperty(key);
  12511.                         try {
  12512.                             boolean b = Boolean.parseBoolean(value);
  12513.                             _tmp.put(key, b);
  12514.                         }catch(Exception e) {
  12515.                             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);
  12516.                         }
  12517.                     }
  12518.                 }
  12519.                 this.keyValue_HeaderIntegrazioneUrlBased_readPA = _convertMapToCostantiIntegrazione(_tmp);
  12520.                 
  12521.             }catch(java.lang.Exception e) {
  12522.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.urlBased.pa.read.enabled.*': "+e.getMessage(),e);
  12523.                 throw new CoreException(e.getMessage(),e);
  12524.             }    
  12525.         }

  12527.         return this.keyValue_HeaderIntegrazioneUrlBased_readPA;
  12528.     }
  12529.     
  12530.     /**
  12531.      * Restituisce le proprieta' che identificano gli header di integrazione in caso di 'soap'.
  12532.      *
  12533.      * @return Restituisce le proprieta' che identificano gli header di integrazione in caso di 'soap'.
  12534.      *  
  12535.      */
  12536.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneSoap = null;
  12537.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneSoap() {   
  12538.         if(this.keyValue_HeaderIntegrazioneSoap==null){

  12540.             try{ 

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

  12552.         return this.keyValue_HeaderIntegrazioneSoap;
  12553.     }
  12554.     
  12555.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2 = null;
  12556.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2() { 
  12557.         if(this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2==null){

  12559.             try{ 

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

  12571.         return this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2;
  12572.     }
  12573.     
  12574.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1 = null;
  12575.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1() { 
  12576.         if(this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1==null){

  12578.             try{ 

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

  12590.         return this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1;
  12591.     }
  12592.     
  12593.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_setPD_request = null;
  12594.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_setPD_response = null;
  12595.     public Map<MapKey<String>, Boolean> getKeyPDSetEnabled_HeaderIntegrazioneSoap(boolean request) throws CoreException {
  12596.         
  12597.         if( (request && this.keyValue_HeaderIntegrazioneSoap_setPD_request==null)
  12598.                 ||
  12599.                 (!request && this.keyValue_HeaderIntegrazioneSoap_setPD_response==null)
  12600.                 ){

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

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

  12610.                 prop = this.reader.readPropertiesConvertEnvProperties(pName);
  12611.                 Map<String, Boolean> _tmp = new HashMap<>();
  12612.                 Iterator<?> it = prop.keySet().iterator();
  12613.                 while (it.hasNext()) {
  12614.                     Object object = (Object) it.next();
  12615.                     if(object instanceof String) {
  12616.                         String key = (String) object;
  12617.                         String value = prop.getProperty(key);
  12618.                         try {
  12619.                             boolean b = Boolean.parseBoolean(value);
  12620.                             _tmp.put(key, b);
  12621.                         }catch(Exception e) {
  12622.                             throw new CoreException("Rilevato errore durante il parsing della property '"+pName+"."+key+"' (atteso: true/false): "+e.getMessage(),e);
  12623.                         }
  12624.                     }
  12625.                 }
  12626.                 if(request) {
  12627.                     this.keyValue_HeaderIntegrazioneSoap_setPD_request = _convertMapToCostantiIntegrazione(_tmp);
  12628.                 }
  12629.                 else {
  12630.                     this.keyValue_HeaderIntegrazioneSoap_setPD_response = _convertMapToCostantiIntegrazione(_tmp);
  12631.                 }
  12632.                 
  12633.             }catch(java.lang.Exception e) {
  12634.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  12635.                 throw new CoreException(e.getMessage(),e);
  12636.             }    
  12637.         }

  12639.         if(request) {
  12640.             return this.keyValue_HeaderIntegrazioneSoap_setPD_request;
  12641.         }
  12642.         else {
  12643.             return this.keyValue_HeaderIntegrazioneSoap_setPD_response;
  12644.         }
  12645.     }
  12646.     
  12647.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_readPD = null;
  12648.     public Map<MapKey<String>, Boolean> getKeyPDReadEnabled_HeaderIntegrazioneSoap() throws CoreException { 
  12649.         if(this.keyValue_HeaderIntegrazioneSoap_readPD==null){

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

  12654.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.pd.read.enabled.");
  12655.                 Map<String, Boolean> _tmp = new HashMap<>();
  12656.                 Iterator<?> it = prop.keySet().iterator();
  12657.                 while (it.hasNext()) {
  12658.                     Object object = (Object) it.next();
  12659.                     if(object instanceof String) {
  12660.                         String key = (String) object;
  12661.                         String value = prop.getProperty(key);
  12662.                         try {
  12663.                             boolean b = Boolean.parseBoolean(value);
  12664.                             _tmp.put(key, b);
  12665.                         }catch(Exception e) {
  12666.                             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);
  12667.                         }
  12668.                     }
  12669.                 }
  12670.                 this.keyValue_HeaderIntegrazioneSoap_readPD = _convertMapToCostantiIntegrazione(_tmp);
  12671.                 
  12672.             }catch(java.lang.Exception e) {
  12673.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.soap.pd.read.enabled.*': "+e.getMessage(),e);
  12674.                 throw new CoreException(e.getMessage(),e);
  12675.             }    
  12676.         }

  12678.         return this.keyValue_HeaderIntegrazioneSoap_readPD;
  12679.     }
  12680.     
  12681.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_setPA_request = null;
  12682.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_setPA_response = null;
  12683.     public Map<MapKey<String>, Boolean> getKeyPASetEnabled_HeaderIntegrazioneSoap(boolean request) throws CoreException {   
  12684.         if( (request && this.keyValue_HeaderIntegrazioneSoap_setPA_request==null)
  12685.                 ||
  12686.                 (!request && this.keyValue_HeaderIntegrazioneSoap_setPA_response==null)
  12687.                 ){

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

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

  12697.                 prop = this.reader.readPropertiesConvertEnvProperties(pName);
  12698.                 Map<String, Boolean> _tmp = new HashMap<>();
  12699.                 Iterator<?> it = prop.keySet().iterator();
  12700.                 while (it.hasNext()) {
  12701.                     Object object = (Object) it.next();
  12702.                     if(object instanceof String) {
  12703.                         String key = (String) object;
  12704.                         String value = prop.getProperty(key);
  12705.                         try {
  12706.                             boolean b = Boolean.parseBoolean(value);
  12707.                             //if(request) {
  12708.                             //  _tmp.put(key, b);
  12709.                             //}
  12710.                             //else {
  12711.                             _tmp.put(key, b);
  12712.                             //}
  12713.                         }catch(Exception e) {
  12714.                             throw new CoreException("Rilevato errore durante il parsing della property '"+pName+"."+key+"' (atteso: true/false): "+e.getMessage(),e);
  12715.                         }
  12716.                     }
  12717.                 }
  12718.                 if(request) {
  12719.                     this.keyValue_HeaderIntegrazioneSoap_setPA_request = _convertMapToCostantiIntegrazione(_tmp);
  12720.                 }
  12721.                 else {
  12722.                     this.keyValue_HeaderIntegrazioneSoap_setPA_response = _convertMapToCostantiIntegrazione(_tmp);
  12723.                 }
  12724.                 
  12725.             }catch(java.lang.Exception e) {
  12726.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  12727.                 throw new CoreException(e.getMessage(),e);
  12728.             }    
  12729.         }

  12731.         if(request) {
  12732.             return this.keyValue_HeaderIntegrazioneSoap_setPA_request;
  12733.         }
  12734.         else {
  12735.             return this.keyValue_HeaderIntegrazioneSoap_setPA_response;
  12736.         }
  12737.     }
  12738.     
  12739.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_readPA = null;
  12740.     public Map<MapKey<String>, Boolean> getKeyPAReadEnabled_HeaderIntegrazioneSoap() throws CoreException { 
  12741.         if(this.keyValue_HeaderIntegrazioneSoap_readPA==null){

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

  12746.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.pa.read.enabled.");
  12747.                 Map<String, Boolean> _tmp = new HashMap<>();
  12748.                 Iterator<?> it = prop.keySet().iterator();
  12749.                 while (it.hasNext()) {
  12750.                     Object object = (Object) it.next();
  12751.                     if(object instanceof String) {
  12752.                         String key = (String) object;
  12753.                         String value = prop.getProperty(key);
  12754.                         try {
  12755.                             boolean b = Boolean.parseBoolean(value);
  12756.                             _tmp.put(key, b);
  12757.                         }catch(Exception e) {
  12758.                             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);
  12759.                         }
  12760.                     }
  12761.                 }
  12762.                 this.keyValue_HeaderIntegrazioneSoap_readPA = _convertMapToCostantiIntegrazione(_tmp);
  12763.                                 
  12764.             }catch(java.lang.Exception e) {
  12765.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.soap.pa.read.enabled.*': "+e.getMessage(),e);
  12766.                 throw new CoreException(e.getMessage(),e);
  12767.             }    
  12768.         }

  12770.         return this.keyValue_HeaderIntegrazioneSoap_readPA;
  12771.     }
  12772.     
  12773.     private String headerIntegrazioneSOAPPdDVersione = null;
  12774.     public String getHeaderIntegrazioneSOAPPdDVersione(){
  12775.         if(this.headerIntegrazioneSOAPPdDVersione==null){
  12776.             try{  
  12777.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.pddVersion"); 

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

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

  12793.         return this.headerIntegrazioneSOAPPdDVersione;
  12794.     }
  12795.     
  12796.     private Boolean readHeaderIntegrazioneSOAPPdDDetails = null;
  12797.     private String headerIntegrazioneSOAPPdDDetails = null;
  12798.     public String getHeaderIntegrazioneSOAPPdDDetails(){
  12799.         if(this.readHeaderIntegrazioneSOAPPdDDetails==null){
  12800.             try{  
  12801.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.pddDetails"); 

  12803.                 if (value != null){
  12804.                     value = value.trim();
  12805.                     this.headerIntegrazioneSOAPPdDDetails = value;
  12806.                 }else{
  12807.                     this.headerIntegrazioneSOAPPdDDetails = this.getDetails();
  12808.                 }

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

  12816.         this.readHeaderIntegrazioneSOAPPdDDetails = true;
  12817.         return this.headerIntegrazioneSOAPPdDDetails;
  12818.     }
  12819.     
  12820.     /**
  12821.      * Restituisce l'indicazione l'header di integrazione letto
  12822.      * durante l'integrazione tra servizio applicativo e PdD
  12823.      * deve essere eliminato o meno
  12824.      *  
  12825.      * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
  12826.      * 
  12827.      */
  12828.     private Boolean deleteHeaderIntegrazioneRequestPD = null;
  12829.     public boolean deleteHeaderIntegrazioneRequestPD(){
  12830.         if(this.deleteHeaderIntegrazioneRequestPD==null){
  12831.             try{  
  12832.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pd.request.readAndDelete"); 

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

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

  12848.         return this.deleteHeaderIntegrazioneRequestPD;
  12849.     }
  12850.     
  12851.     /**
  12852.      * Restituisce l'indicazione l'header di integrazione letto
  12853.      * durante l'integrazione tra servizio applicativo e PdD
  12854.      * deve essere eliminato o meno
  12855.      *  
  12856.      * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
  12857.      * 
  12858.      */
  12859.     private Boolean deleteHeaderIntegrazioneResponsePD = null;
  12860.     public boolean deleteHeaderIntegrazioneResponsePD(){
  12861.         if(this.deleteHeaderIntegrazioneResponsePD==null){
  12862.             try{  
  12863.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pd.response.readAndDelete"); 

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

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

  12879.         return this.deleteHeaderIntegrazioneResponsePD;
  12880.     }

  12882.     /**
  12883.      * Restituisce l'indicazione l'header di integrazione letto
  12884.      * durante l'integrazione tra servizio applicativo e PdD
  12885.      * deve essere eliminato o meno
  12886.      *  
  12887.      * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
  12888.      * 
  12889.      */
  12890.     private Boolean processHeaderIntegrazionePDResponse = null;
  12891.     public boolean processHeaderIntegrazionePDResponse(boolean functionAsRouter){
  12892.         if(functionAsRouter){
  12893.             return false;
  12894.         }
  12895.         if(this.processHeaderIntegrazionePDResponse==null){
  12896.             try{  
  12897.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pd.response.process"); 

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

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

  12913.         return this.processHeaderIntegrazionePDResponse;
  12914.     }
  12915.     
  12916.     
  12917.     
  12918.     /**
  12919.      * Restituisce l'indicazione l'header di integrazione letto
  12920.      * durante l'integrazione tra servizio applicativo e PdD
  12921.      * deve essere eliminato o meno
  12922.      *  
  12923.      * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
  12924.      * 
  12925.      */
  12926.     private Boolean deleteHeaderIntegrazioneRequestPA = null;
  12927.     public boolean deleteHeaderIntegrazioneRequestPA(){
  12928.         if(this.deleteHeaderIntegrazioneRequestPA==null){
  12929.             try{  
  12930.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pa.request.readAndDelete"); 

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

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

  12946.         return this.deleteHeaderIntegrazioneRequestPA;
  12947.     }
  12948.     
  12949.     /**
  12950.      * Restituisce l'indicazione l'header di integrazione letto
  12951.      * durante l'integrazione tra servizio applicativo e PdD
  12952.      * deve essere eliminato o meno
  12953.      *  
  12954.      * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
  12955.      * 
  12956.      */
  12957.     private Boolean deleteHeaderIntegrazioneResponsePA = null;
  12958.     public boolean deleteHeaderIntegrazioneResponsePA(){
  12959.         if(this.deleteHeaderIntegrazioneResponsePA==null){
  12960.             try{  
  12961.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pa.response.readAndDelete"); 

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

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

  12977.         return this.deleteHeaderIntegrazioneResponsePA;
  12978.     }

  12980.     /**
  12981.      * Restituisce l'indicazione l'header di integrazione letto
  12982.      * durante l'integrazione tra servizio applicativo e PdD
  12983.      * deve essere eliminato o meno
  12984.      *  
  12985.      * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
  12986.      * 
  12987.      */
  12988.     private Boolean processHeaderIntegrazionePARequest = null;
  12989.     public boolean processHeaderIntegrazionePARequest(boolean functionAsRouter){
  12990.         if(functionAsRouter){
  12991.             return false;
  12992.         }
  12993.         if(this.processHeaderIntegrazionePARequest==null){
  12994.             try{  
  12995.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pa.request.process"); 

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

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

  13011.         return this.processHeaderIntegrazionePARequest;
  13012.     }
  13013.     

  13015.     /**
  13016.      * Restituisce il nome dell'header Soap di integrazione di default
  13017.      * 
  13018.      * @return Restituisce il nome dell'header Soap di integrazione di default
  13019.      */
  13020.     private String headerSoapNameIntegrazione = null;
  13021.     public String getHeaderSoapNameIntegrazione() {
  13022.         if(this.headerSoapNameIntegrazione==null){
  13023.             try{ 
  13024.                 String name = null;
  13025.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.headerName");
  13026.                 if(name==null)
  13027.                     throw new CoreException(NON_DEFINITA);
  13028.                 name = name.trim();
  13029.                 this.headerSoapNameIntegrazione = name;
  13030.             }catch(java.lang.Exception e) {
  13031.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.headerName': "+e.getMessage(),e);
  13032.                 this.headerSoapNameIntegrazione = null;
  13033.             }    
  13034.         }

  13036.         return this.headerSoapNameIntegrazione;
  13037.     }
  13038.     
  13039.     private String headerSoapNameIntegrazione_backwardCompatibility_openspcoop2 = null;
  13040.     public String getHeaderSoapNameIntegrazione_backwardCompatibility_openspcoop2() {
  13041.         if(this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop2==null){
  13042.             try{ 
  13043.                 String name = null;
  13044.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerName");
  13045.                 if(name==null)
  13046.                     throw new CoreException(NON_DEFINITA);
  13047.                 name = name.trim();
  13048.                 this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop2 = name;
  13049.             }catch(java.lang.Exception e) {
  13050.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerName': "+e.getMessage(),e);
  13051.                 this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop2 = null;
  13052.             }    
  13053.         }

  13055.         return this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop2;
  13056.     }
  13057.     
  13058.     private String headerSoapNameIntegrazione_backwardCompatibility_openspcoop1 = null;
  13059.     public String getHeaderSoapNameIntegrazione_backwardCompatibility_openspcoop1() {
  13060.         if(this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop1==null){
  13061.             try{ 
  13062.                 String name = null;
  13063.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerName");
  13064.                 if(name==null)
  13065.                     throw new CoreException(NON_DEFINITA);
  13066.                 name = name.trim();
  13067.                 this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop1 = name;
  13068.             }catch(java.lang.Exception e) {
  13069.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerName': "+e.getMessage(),e);
  13070.                 this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop1 = null;
  13071.             }    
  13072.         }

  13074.         return this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop1;
  13075.     }

  13077.     /**
  13078.      * Restituisce l'actord dell'header Soap di integrazione di default
  13079.      * 
  13080.      * @return Restituisce l'actor dell'header Soap di integrazione di default
  13081.      */
  13082.     private String headerSoapActorIntegrazione = null;
  13083.     public String getHeaderSoapActorIntegrazione() {
  13084.         if(this.headerSoapActorIntegrazione==null){
  13085.             try{ 
  13086.                 String name = null;
  13087.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.headerActor");
  13088.                 if(name==null)
  13089.                     throw new CoreException(NON_DEFINITA);
  13090.                 name = name.trim();
  13091.                 this.headerSoapActorIntegrazione = name;
  13092.             }catch(java.lang.Exception e) {
  13093.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.headerActor': "+e.getMessage(),e);
  13094.                 this.headerSoapActorIntegrazione = null;
  13095.             }    
  13096.         }

  13098.         return this.headerSoapActorIntegrazione;
  13099.     }
  13100.     
  13101.     private String headerSoapActorIntegrazione_backwardCompatibility_openspcoop2 = null;
  13102.     public String getHeaderSoapActorIntegrazione_backwardCompatibility_openspcoop2() {
  13103.         if(this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop2==null){
  13104.             try{ 
  13105.                 String name = null;
  13106.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerActor");
  13107.                 if(name==null)
  13108.                     throw new CoreException(NON_DEFINITA);
  13109.                 name = name.trim();
  13110.                 this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop2 = name;
  13111.             }catch(java.lang.Exception e) {
  13112.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerActor': "+e.getMessage(),e);
  13113.                 this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop2 = null;
  13114.             }    
  13115.         }

  13117.         return this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop2;
  13118.     }
  13119.     
  13120.     private String headerSoapActorIntegrazione_backwardCompatibility_openspcoop1 = null;
  13121.     public String getHeaderSoapActorIntegrazione_backwardCompatibility_openspcoop1() {
  13122.         if(this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop1==null){
  13123.             try{ 
  13124.                 String name = null;
  13125.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerActor");
  13126.                 if(name==null)
  13127.                     throw new CoreException(NON_DEFINITA);
  13128.                 name = name.trim();
  13129.                 this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop1 = name;
  13130.             }catch(java.lang.Exception e) {
  13131.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerActor': "+e.getMessage(),e);
  13132.                 this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop1 = null;
  13133.             }    
  13134.         }

  13136.         return this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop1;
  13137.     }

  13139.     /**
  13140.      * Restituisce il prefix dell'header Soap di integrazione di default
  13141.      * 
  13142.      * @return Restituisce il prefix dell'header Soap di integrazione di default
  13143.      */
  13144.     private String headerSoapPrefixIntegrazione = null;
  13145.     public String getHeaderSoapPrefixIntegrazione() {
  13146.         if(this.headerSoapPrefixIntegrazione==null){
  13147.             try{ 
  13148.                 String name = null;
  13149.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.headerPrefix");
  13150.                 if(name==null)
  13151.                     throw new CoreException(NON_DEFINITA);
  13152.                 name = name.trim();
  13153.                 this.headerSoapPrefixIntegrazione = name;
  13154.             }catch(java.lang.Exception e) {
  13155.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.headerPrefix': "+e.getMessage(),e);
  13156.                 this.headerSoapPrefixIntegrazione = null;
  13157.             }    
  13158.         }

  13160.         return this.headerSoapPrefixIntegrazione;
  13161.     }
  13162.     
  13163.     private String headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2 = null;
  13164.     public String getHeaderSoapPrefixIntegrazione_backwardCompatibility_openspcoop2() {
  13165.         if(this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2==null){
  13166.             try{ 
  13167.                 String name = null;
  13168.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerPrefix");
  13169.                 if(name==null)
  13170.                     throw new CoreException(NON_DEFINITA);
  13171.                 name = name.trim();
  13172.                 this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2 = name;
  13173.             }catch(java.lang.Exception e) {
  13174.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerPrefix': "+e.getMessage(),e);
  13175.                 this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2 = null;
  13176.             }    
  13177.         }

  13179.         return this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2;
  13180.     }
  13181.     
  13182.     private String headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1 = null;
  13183.     public String getHeaderSoapPrefixIntegrazione_backwardCompatibility_openspcoop1() {
  13184.         if(this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1==null){
  13185.             try{ 
  13186.                 String name = null;
  13187.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerPrefix");
  13188.                 if(name==null)
  13189.                     throw new CoreException(NON_DEFINITA);
  13190.                 name = name.trim();
  13191.                 this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1 = name;
  13192.             }catch(java.lang.Exception e) {
  13193.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerPrefix': "+e.getMessage(),e);
  13194.                 this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1 = null;
  13195.             }    
  13196.         }

  13198.         return this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1;
  13199.     }
  13200.     
  13201.     /**
  13202.      * Restituisce il nome dell'elemento che contiene le informazioni di protocollo
  13203.      * 
  13204.      * @return Restituisce il nome dell'elemento che contiene le informazioni di protocollo
  13205.      */
  13206.     private String headerSoapExtProtocolInfoNomeElementoIntegrazione = null;
  13207.     public String getHeaderSoapExtProtocolInfoNomeElementoIntegrazione() {
  13208.         if(this.headerSoapExtProtocolInfoNomeElementoIntegrazione==null){
  13209.             try{ 
  13210.                 String name = null;
  13211.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.extProtocolInfo.elemento.nome");
  13212.                 if(name==null)
  13213.                     throw new CoreException(NON_DEFINITA);
  13214.                 name = name.trim();
  13215.                 this.headerSoapExtProtocolInfoNomeElementoIntegrazione = name;
  13216.             }catch(java.lang.Exception e) {
  13217.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.extProtocolInfo.elemento.nome': "+e.getMessage(),e);
  13218.                 this.headerSoapExtProtocolInfoNomeElementoIntegrazione = null;
  13219.             }    
  13220.         }

  13222.         return this.headerSoapExtProtocolInfoNomeElementoIntegrazione;
  13223.     }
  13224.     private String headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2 = null;
  13225.     public String getHeaderSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2() {
  13226.         if(this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2==null){
  13227.             try{ 
  13228.                 String name = null;
  13229.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.extProtocolInfo.elemento.nome");
  13230.                 if(name==null)
  13231.                     throw new CoreException(NON_DEFINITA);
  13232.                 name = name.trim();
  13233.                 this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2 = name;
  13234.             }catch(java.lang.Exception e) {
  13235.                 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);
  13236.                 this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2 = null;
  13237.             }    
  13238.         }

  13240.         return this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2;
  13241.     }
  13242.     private String headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1 = null;
  13243.     public String getHeaderSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1() {
  13244.         if(this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1==null){
  13245.             try{ 
  13246.                 String name = null;
  13247.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.extProtocolInfo.elemento.nome");
  13248.                 if(name==null)
  13249.                     throw new CoreException(NON_DEFINITA);
  13250.                 name = name.trim();
  13251.                 this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1 = name;
  13252.             }catch(java.lang.Exception e) {
  13253.                 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);
  13254.                 this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1 = null;
  13255.             }    
  13256.         }

  13258.         return this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1;
  13259.     }
  13260.     /**
  13261.      * Restituisce il nome del tipo dell'elemento che contiene le informazioni di protocollo
  13262.      * 
  13263.      * @return Restituisce il nome del tipo dell'elemento che contiene le informazioni di protocollo
  13264.      */
  13265.     private String headerSoapExtProtocolInfoNomeAttributoIntegrazione = null;
  13266.     public String getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione() {
  13267.         if(this.headerSoapExtProtocolInfoNomeAttributoIntegrazione==null){
  13268.             try{ 
  13269.                 String name = null;
  13270.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.extProtocolInfo.attributo.nome");
  13271.                 if(name==null)
  13272.                     throw new CoreException(NON_DEFINITA);
  13273.                 name = name.trim();
  13274.                 this.headerSoapExtProtocolInfoNomeAttributoIntegrazione = name;
  13275.             }catch(java.lang.Exception e) {
  13276.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.extProtocolInfo.attributo.nome': "+e.getMessage(),e);
  13277.                 this.headerSoapExtProtocolInfoNomeAttributoIntegrazione = null;
  13278.             }    
  13279.         }

  13281.         return this.headerSoapExtProtocolInfoNomeAttributoIntegrazione;
  13282.     }
  13283.     
  13284.     private String headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2 = null;
  13285.     public String getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2() {
  13286.         if(this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2==null){
  13287.             try{ 
  13288.                 String name = null;
  13289.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.extProtocolInfo.attributo.nome");
  13290.                 if(name==null)
  13291.                     throw new CoreException(NON_DEFINITA);
  13292.                 name = name.trim();
  13293.                 this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2 = name;
  13294.             }catch(java.lang.Exception e) {
  13295.                 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);
  13296.                 this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2 = null;
  13297.             }    
  13298.         }

  13300.         return this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2;
  13301.     }
  13302.     
  13303.     private String headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1 = null;
  13304.     public String getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1() {
  13305.         if(this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1==null){
  13306.             try{ 
  13307.                 String name = null;
  13308.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.extProtocolInfo.attributo.nome");
  13309.                 if(name==null)
  13310.                     throw new CoreException(NON_DEFINITA);
  13311.                 name = name.trim();
  13312.                 this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1 = name;
  13313.             }catch(java.lang.Exception e) {
  13314.                 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);
  13315.                 this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1 = null;
  13316.             }    
  13317.         }

  13319.         return this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1;
  13320.     }

  13322.     
  13323.     
  13324.     /* ********  INTEGRAZIONE INFORMAZIONI DINAMICHE  ******** */
  13325.     
  13326.     private Boolean isIntegrazioneDynamicInfoEnabled = null;
  13327.     public boolean isIntegrazioneDynamicInfoEnabled() {
  13328.         String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.enabled";
  13329.         if(this.isIntegrazioneDynamicInfoEnabled==null){
  13330.             try{ 
  13331.                 String name = null;
  13332.                 name = this.reader.getValueConvertEnvProperties(pName);
  13333.                 if(name==null)
  13334.                     throw new CoreException(NON_DEFINITA);
  13335.                 name = name.trim();
  13336.                 this.isIntegrazioneDynamicInfoEnabled = Boolean.parseBoolean(name);
  13337.             }catch(java.lang.Exception e) {
  13338.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13339.                 this.isIntegrazioneDynamicInfoEnabled = false;
  13340.             }    
  13341.         }

  13343.         if(this.isIntegrazioneDynamicInfoEnabled==null){
  13344.             return false;
  13345.         }
  13346.         return this.isIntegrazioneDynamicInfoEnabled;
  13347.     }
  13348.     
  13349.     private InformazioniIntegrazioneSorgente getIntegrazioneDynamicInfoType = null;
  13350.     public InformazioniIntegrazioneSorgente getIntegrazioneDynamicInfoType() {
  13351.         String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.type";
  13352.         if(this.getIntegrazioneDynamicInfoType==null){
  13353.             try{ 
  13354.                 String name = null;
  13355.                 name = this.reader.getValueConvertEnvProperties(pName);
  13356.                 if(name==null)
  13357.                     throw new CoreException(NON_DEFINITA);
  13358.                 name = name.trim();
  13359.                 this.getIntegrazioneDynamicInfoType = InformazioniIntegrazioneSorgente.valueOf(name);
  13360.             }catch(java.lang.Exception e) {
  13361.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13362.             }    
  13363.         }

  13365.         return this.getIntegrazioneDynamicInfoType;
  13366.     }
  13367.     
  13368.     private String getIntegrazioneDynamicInfoName = null;
  13369.     public String getIntegrazioneDynamicInfoName() {
  13370.         String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.name";
  13371.         if(this.getIntegrazioneDynamicInfoName==null){
  13372.             try{ 
  13373.                 String name = null;
  13374.                 name = this.reader.getValueConvertEnvProperties(pName);
  13375.                 if(name==null)
  13376.                     throw new CoreException(NON_DEFINITA);
  13377.                 name = name.trim();
  13378.                 this.getIntegrazioneDynamicInfoName = name;
  13379.             }catch(java.lang.Exception e) {
  13380.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13381.             }    
  13382.         }

  13384.         return this.getIntegrazioneDynamicInfoName;
  13385.     }
  13386.     
  13387.     private InformazioniIntegrazioneCodifica getIntegrazioneDynamicInfoEncodeType = null;
  13388.     public InformazioniIntegrazioneCodifica getIntegrazioneDynamicInfoEncodeType() {
  13389.         String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.encode";
  13390.         if(this.getIntegrazioneDynamicInfoEncodeType==null){
  13391.             try{ 
  13392.                 String name = null;
  13393.                 name = this.reader.getValueConvertEnvProperties(pName);
  13394.                 if(name==null)
  13395.                     throw new CoreException(NON_DEFINITA);
  13396.                 name = name.trim();
  13397.                 this.getIntegrazioneDynamicInfoEncodeType = InformazioniIntegrazioneCodifica.valueOf(name);
  13398.             }catch(java.lang.Exception e) {
  13399.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13400.             }    
  13401.         }

  13403.         return this.getIntegrazioneDynamicInfoEncodeType;
  13404.     }
  13405.     
  13406.     private Boolean isIntegrazioneDynamicInfoRequired = null;
  13407.     public boolean isIntegrazioneDynamicInfoRequired() {
  13408.         String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.required";
  13409.         if(this.isIntegrazioneDynamicInfoRequired==null){
  13410.             try{ 
  13411.                 String name = null;
  13412.                 name = this.reader.getValueConvertEnvProperties(pName);
  13413.                 if(name==null)
  13414.                     throw new CoreException(NON_DEFINITA);
  13415.                 name = name.trim();
  13416.                 this.isIntegrazioneDynamicInfoRequired = Boolean.parseBoolean(name);
  13417.             }catch(java.lang.Exception e) {
  13418.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13419.                 this.isIntegrazioneDynamicInfoRequired = false;
  13420.             }    
  13421.         }

  13423.         if(this.isIntegrazioneDynamicInfoRequired==null){
  13424.             return false;
  13425.         }
  13426.         return this.isIntegrazioneDynamicInfoRequired;
  13427.     }
  13428.     
  13429.     // risposta
  13430.     
  13431.     private Boolean isIntegrazioneResponseDynamicInfoEnabled = null;
  13432.     public boolean isIntegrazioneResponseDynamicInfoEnabled() {
  13433.         String pName = "org.openspcoop2.pdd.integrazione.responseDynamicInfo.enabled";
  13434.         if(this.isIntegrazioneResponseDynamicInfoEnabled==null){
  13435.             try{ 
  13436.                 String name = null;
  13437.                 name = this.reader.getValueConvertEnvProperties(pName);
  13438.                 if(name==null)
  13439.                     throw new CoreException(NON_DEFINITA);
  13440.                 name = name.trim();
  13441.                 this.isIntegrazioneResponseDynamicInfoEnabled = Boolean.parseBoolean(name);
  13442.             }catch(java.lang.Exception e) {
  13443.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13444.                 this.isIntegrazioneResponseDynamicInfoEnabled = false;
  13445.             }    
  13446.         }

  13448.         if(this.isIntegrazioneResponseDynamicInfoEnabled==null){
  13449.             return false;
  13450.         }
  13451.         return this.isIntegrazioneResponseDynamicInfoEnabled;
  13452.     }
  13453.     
  13454.     private String getIntegrazioneResponseDynamicInfoName = null;
  13455.     public String getIntegrazioneResponseDynamicInfoName() {
  13456.         String pName = "org.openspcoop2.pdd.integrazione.responseDynamicInfo.name";
  13457.         if(this.getIntegrazioneResponseDynamicInfoName==null){
  13458.             try{ 
  13459.                 String name = null;
  13460.                 name = this.reader.getValueConvertEnvProperties(pName);
  13461.                 if(name==null)
  13462.                     throw new CoreException(NON_DEFINITA);
  13463.                 name = name.trim();
  13464.                 this.getIntegrazioneResponseDynamicInfoName = name;
  13465.             }catch(java.lang.Exception e) {
  13466.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13467.             }    
  13468.         }

  13470.         return this.getIntegrazioneResponseDynamicInfoName;
  13471.     }
  13472.     
  13473.     private InformazioniIntegrazioneCodifica getIntegrazioneResponseDynamicInfoEncodeType = null;
  13474.     public InformazioniIntegrazioneCodifica getIntegrazioneResponseDynamicInfoEncodeType() {
  13475.         String pName = "org.openspcoop2.pdd.integrazione.responseDynamicInfo.encode";
  13476.         if(this.getIntegrazioneResponseDynamicInfoEncodeType==null){
  13477.             try{ 
  13478.                 String name = null;
  13479.                 name = this.reader.getValueConvertEnvProperties(pName);
  13480.                 if(name==null)
  13481.                     throw new CoreException(NON_DEFINITA);
  13482.                 name = name.trim();
  13483.                 this.getIntegrazioneResponseDynamicInfoEncodeType = InformazioniIntegrazioneCodifica.valueOf(name);
  13484.             }catch(java.lang.Exception e) {
  13485.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13486.             }    
  13487.         }

  13489.         return this.getIntegrazioneResponseDynamicInfoEncodeType;
  13490.     }
  13491.     
  13492.     private Boolean isIntegrazioneResponseDynamicInfoRequired = null;
  13493.     public boolean isIntegrazioneResponseDynamicInfoRequired() {
  13494.         String pName = "org.openspcoop2.pdd.integrazione.responseDynamicInfo.required";
  13495.         if(this.isIntegrazioneResponseDynamicInfoRequired==null){
  13496.             try{ 
  13497.                 String name = null;
  13498.                 name = this.reader.getValueConvertEnvProperties(pName);
  13499.                 if(name==null)
  13500.                     throw new CoreException(NON_DEFINITA);
  13501.                 name = name.trim();
  13502.                 this.isIntegrazioneResponseDynamicInfoRequired = Boolean.parseBoolean(name);
  13503.             }catch(java.lang.Exception e) {
  13504.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13505.                 this.isIntegrazioneResponseDynamicInfoRequired = false;
  13506.             }    
  13507.         }

  13509.         if(this.isIntegrazioneResponseDynamicInfoRequired==null){
  13510.             return false;
  13511.         }
  13512.         return this.isIntegrazioneResponseDynamicInfoRequired;
  13513.     }
  13514.     
  13515.     
  13516.     
  13517.     /* ********  INTEGRAZIONE TEMPLATE  ******** */
  13518.     
  13519.     private String getIntegrazioneTemplateRequestPropertyTipo = null;
  13520.     public String getIntegrazioneTemplateRequestPropertyTipo() {
  13521.         String pName = "org.openspcoop2.pdd.integrazione.template.request.property.tipo";
  13522.         if(this.getIntegrazioneTemplateRequestPropertyTipo==null){
  13523.             try{ 
  13524.                 String name = null;
  13525.                 name = this.reader.getValueConvertEnvProperties(pName);
  13526.                 if(name==null)
  13527.                     throw new CoreException(NON_DEFINITA);
  13528.                 name = name.trim();
  13529.                 this.getIntegrazioneTemplateRequestPropertyTipo = name;
  13530.             }catch(java.lang.Exception e) {
  13531.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13532.                 this.getIntegrazioneTemplateRequestPropertyTipo = null;
  13533.             }    
  13534.         }

  13536.         return this.getIntegrazioneTemplateRequestPropertyTipo;
  13537.     }
  13538.     
  13539.     private String getIntegrazioneTemplateRequestPropertyFile = null;
  13540.     public String getIntegrazioneTemplateRequestPropertyFile() {
  13541.         String pName = "org.openspcoop2.pdd.integrazione.template.request.property.file";
  13542.         if(this.getIntegrazioneTemplateRequestPropertyFile==null){
  13543.             try{ 
  13544.                 String name = null;
  13545.                 name = this.reader.getValueConvertEnvProperties(pName);
  13546.                 if(name==null)
  13547.                     throw new CoreException(NON_DEFINITA);
  13548.                 name = name.trim();
  13549.                 this.getIntegrazioneTemplateRequestPropertyFile = name;
  13550.             }catch(java.lang.Exception e) {
  13551.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13552.                 this.getIntegrazioneTemplateRequestPropertyFile = null;
  13553.             }    
  13554.         }

  13556.         return this.getIntegrazioneTemplateRequestPropertyFile;
  13557.     }
  13558.     
  13559.     private String getIntegrazioneTemplateResponsePropertyTipo = null;
  13560.     public String getIntegrazioneTemplateResponsePropertyTipo() {
  13561.         String pName = "org.openspcoop2.pdd.integrazione.template.response.property.tipo";
  13562.         if(this.getIntegrazioneTemplateResponsePropertyTipo==null){
  13563.             try{ 
  13564.                 String name = null;
  13565.                 name = this.reader.getValueConvertEnvProperties(pName);
  13566.                 if(name==null)
  13567.                     throw new CoreException(NON_DEFINITA);
  13568.                 name = name.trim();
  13569.                 this.getIntegrazioneTemplateResponsePropertyTipo = name;
  13570.             }catch(java.lang.Exception e) {
  13571.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13572.                 this.getIntegrazioneTemplateResponsePropertyTipo = null;
  13573.             }    
  13574.         }

  13576.         return this.getIntegrazioneTemplateResponsePropertyTipo;
  13577.     }
  13578.     
  13579.     private String getIntegrazioneTemplateResponsePropertyFile = null;
  13580.     public String getIntegrazioneTemplateResponsePropertyFile() {
  13581.         String pName = "org.openspcoop2.pdd.integrazione.template.response.property.file";
  13582.         if(this.getIntegrazioneTemplateResponsePropertyFile==null){
  13583.             try{ 
  13584.                 String name = null;
  13585.                 name = this.reader.getValueConvertEnvProperties(pName);
  13586.                 if(name==null)
  13587.                     throw new CoreException(NON_DEFINITA);
  13588.                 name = name.trim();
  13589.                 this.getIntegrazioneTemplateResponsePropertyFile = name;
  13590.             }catch(java.lang.Exception e) {
  13591.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13592.                 this.getIntegrazioneTemplateResponsePropertyFile = null;
  13593.             }    
  13594.         }

  13596.         return this.getIntegrazioneTemplateResponsePropertyFile;
  13597.     }
  13598.     
  13599.     
  13600.     
  13601.     private Boolean getIntegrazioneTemplatePortaDelegataRequestTipo_read = null;
  13602.     private TipoTrasformazione getIntegrazioneTemplatePortaDelegataRequestTipo = null;
  13603.     public TipoTrasformazione getIntegrazioneTemplatePortaDelegataRequestTipo() throws CoreException{
  13604.         String pName = "org.openspcoop2.pdd.integrazione.template.pd.request.tipo";
  13605.         if(this.getIntegrazioneTemplatePortaDelegataRequestTipo_read==null){
  13606.             try{ 
  13607.                 String name = null;
  13608.                 name = this.reader.getValueConvertEnvProperties(pName);
  13609.                 if(name!=null) {
  13610.                     name = name.trim();
  13611.                     this.getIntegrazioneTemplatePortaDelegataRequestTipo = UtilitiesTemplate.convert(name);
  13612.                     
  13613.                     this.getIntegrazioneTemplatePortaDelegataRequestTipo_read = true;
  13614.                 }
  13615.             }catch(java.lang.Exception e) {
  13616.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13617.                 throw new CoreException (e);
  13618.             }    
  13619.         }

  13621.         return this.getIntegrazioneTemplatePortaDelegataRequestTipo;
  13622.     }
  13623.     
  13624.     private Boolean getIntegrazioneTemplatePortaDelegataRequestFile_read = null;
  13625.     private String getIntegrazioneTemplatePortaDelegataRequestFile = null;
  13626.     public String getIntegrazioneTemplatePortaDelegataRequestFile() throws CoreException{
  13627.         String pName = "org.openspcoop2.pdd.integrazione.template.pd.request.file";
  13628.         if(this.getIntegrazioneTemplatePortaDelegataRequestFile_read==null){
  13629.             try{ 
  13630.                 String name = null;
  13631.                 name = this.reader.getValueConvertEnvProperties(pName);
  13632.                 if(name!=null) {
  13633.                     name = name.trim();
  13634.                     this.getIntegrazioneTemplatePortaDelegataRequestFile = name;
  13635.                     
  13636.                     this.getIntegrazioneTemplatePortaDelegataRequestFile_read = true;
  13637.                 }
  13638.             }catch(java.lang.Exception e) {
  13639.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13640.                 throw new CoreException (e);
  13641.             }    
  13642.         }

  13644.         return this.getIntegrazioneTemplatePortaDelegataRequestFile;
  13645.     }
  13646.     
  13647.     private Boolean getIntegrazioneTemplatePortaDelegataResponseTipo_read = null;
  13648.     private TipoTrasformazione getIntegrazioneTemplatePortaDelegataResponseTipo = null;
  13649.     public TipoTrasformazione getIntegrazioneTemplatePortaDelegataResponseTipo() throws CoreException{
  13650.         String pName = "org.openspcoop2.pdd.integrazione.template.pd.response.tipo";
  13651.         if(this.getIntegrazioneTemplatePortaDelegataResponseTipo_read==null){
  13652.             try{ 
  13653.                 String name = null;
  13654.                 name = this.reader.getValueConvertEnvProperties(pName);
  13655.                 if(name!=null) {
  13656.                     name = name.trim();
  13657.                     this.getIntegrazioneTemplatePortaDelegataResponseTipo = UtilitiesTemplate.convert(name);

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

  13667.         return this.getIntegrazioneTemplatePortaDelegataResponseTipo;
  13668.     }
  13669.     
  13670.     private Boolean getIntegrazioneTemplatePortaDelegataResponseFile_read = null;
  13671.     private String getIntegrazioneTemplatePortaDelegataResponseFile = null;
  13672.     public String getIntegrazioneTemplatePortaDelegataResponseFile() throws CoreException{
  13673.         String pName = "org.openspcoop2.pdd.integrazione.template.pd.response.file";
  13674.         if(this.getIntegrazioneTemplatePortaDelegataResponseFile_read==null){
  13675.             try{ 
  13676.                 String name = null;
  13677.                 name = this.reader.getValueConvertEnvProperties(pName);
  13678.                 if(name!=null) {
  13679.                     name = name.trim();
  13680.                     this.getIntegrazioneTemplatePortaDelegataResponseFile = name;
  13681.                     
  13682.                     this.getIntegrazioneTemplatePortaDelegataResponseFile_read = true;
  13683.                 }
  13684.             }catch(java.lang.Exception e) {
  13685.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13686.                 throw new CoreException (e);
  13687.             }    
  13688.         }

  13690.         return this.getIntegrazioneTemplatePortaDelegataResponseFile;
  13691.     }
  13692.     
  13693.     
  13694.     private Boolean getIntegrazioneTemplatePortaApplicativaRequestTipo_read = null;
  13695.     private TipoTrasformazione getIntegrazioneTemplatePortaApplicativaRequestTipo = null;
  13696.     public TipoTrasformazione getIntegrazioneTemplatePortaApplicativaRequestTipo() throws CoreException{
  13697.         String pName = "org.openspcoop2.pdd.integrazione.template.pa.request.tipo";
  13698.         if(this.getIntegrazioneTemplatePortaApplicativaRequestTipo_read==null){
  13699.             try{ 
  13700.                 String name = null;
  13701.                 name = this.reader.getValueConvertEnvProperties(pName);
  13702.                 if(name!=null) {
  13703.                     name = name.trim();
  13704.                     this.getIntegrazioneTemplatePortaApplicativaRequestTipo = UtilitiesTemplate.convert(name);
  13705.                     
  13706.                     this.getIntegrazioneTemplatePortaApplicativaRequestTipo_read = true;
  13707.                 }
  13708.             }catch(java.lang.Exception e) {
  13709.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13710.                 throw new CoreException (e);
  13711.             }    
  13712.         }

  13714.         return this.getIntegrazioneTemplatePortaApplicativaRequestTipo;
  13715.     }
  13716.     
  13717.     private Boolean getIntegrazioneTemplatePortaApplicativaRequestFile_read = null;
  13718.     private String getIntegrazioneTemplatePortaApplicativaRequestFile = null;
  13719.     public String getIntegrazioneTemplatePortaApplicativaRequestFile() throws CoreException{
  13720.         String pName = "org.openspcoop2.pdd.integrazione.template.pa.request.file";
  13721.         if(this.getIntegrazioneTemplatePortaApplicativaRequestFile_read==null){
  13722.             try{ 
  13723.                 String name = null;
  13724.                 name = this.reader.getValueConvertEnvProperties(pName);
  13725.                 if(name!=null) {
  13726.                     name = name.trim();
  13727.                     this.getIntegrazioneTemplatePortaApplicativaRequestFile = name;
  13728.                     
  13729.                     this.getIntegrazioneTemplatePortaApplicativaRequestFile_read = true;
  13730.                 }
  13731.             }catch(java.lang.Exception e) {
  13732.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13733.                 throw new CoreException (e);
  13734.             }    
  13735.         }

  13737.         return this.getIntegrazioneTemplatePortaApplicativaRequestFile;
  13738.     }
  13739.     
  13740.     private Boolean getIntegrazioneTemplatePortaApplicativaResponseTipo_read = null;
  13741.     private TipoTrasformazione getIntegrazioneTemplatePortaApplicativaResponseTipo = null;
  13742.     public TipoTrasformazione getIntegrazioneTemplatePortaApplicativaResponseTipo() throws CoreException{
  13743.         String pName = "org.openspcoop2.pdd.integrazione.template.pa.response.tipo";
  13744.         if(this.getIntegrazioneTemplatePortaApplicativaResponseTipo_read==null){
  13745.             try{ 
  13746.                 String name = null;
  13747.                 name = this.reader.getValueConvertEnvProperties(pName);
  13748.                 if(name!=null) {
  13749.                     name = name.trim();
  13750.                     this.getIntegrazioneTemplatePortaApplicativaResponseTipo = UtilitiesTemplate.convert(name);
  13751.                     
  13752.                     this.getIntegrazioneTemplatePortaApplicativaResponseTipo_read = true;
  13753.                 }
  13754.             }catch(java.lang.Exception e) {
  13755.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13756.                 throw new CoreException (e);
  13757.             }    
  13758.         }

  13760.         return this.getIntegrazioneTemplatePortaApplicativaResponseTipo;
  13761.     }
  13762.     
  13763.     private Boolean getIntegrazioneTemplatePortaApplicativaResponseFile_read = null;
  13764.     private String getIntegrazioneTemplatePortaApplicativaResponseFile = null;
  13765.     public String getIntegrazioneTemplatePortaApplicativaResponseFile() throws CoreException{
  13766.         String pName = "org.openspcoop2.pdd.integrazione.template.pa.response.file";
  13767.         if(this.getIntegrazioneTemplatePortaApplicativaResponseFile_read==null){
  13768.             try{ 
  13769.                 String name = null;
  13770.                 name = this.reader.getValueConvertEnvProperties(pName);
  13771.                 if(name!=null) {
  13772.                     name = name.trim();
  13773.                     this.getIntegrazioneTemplatePortaApplicativaResponseFile = name;
  13774.                     
  13775.                     this.getIntegrazioneTemplatePortaApplicativaResponseFile_read = true;
  13776.                 }
  13777.             }catch(java.lang.Exception e) {
  13778.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13779.                 throw new CoreException (e);
  13780.             }    
  13781.         }

  13783.         return this.getIntegrazioneTemplatePortaApplicativaResponseFile;
  13784.     }
  13785.     
  13786.     
  13787.     /* ********  INTEGRAZIONE AUTENTICAZIONE  ******** */
  13788.     
  13789.     private List<String> getIntegrazioneAutenticazionePortaDelegataRequestHeaders = null;
  13790.     public List<String> getIntegrazioneAutenticazionePortaDelegataRequestHeaders() throws CoreException{
  13791.         String pName = "org.openspcoop2.pdd.integrazione.autenticazione.pd.request.headers";
  13792.         if(this.getIntegrazioneAutenticazionePortaDelegataRequestHeaders==null){
  13793.             try{
  13794.                 
  13795.                 this.getIntegrazioneAutenticazionePortaDelegataRequestHeaders = new ArrayList<>();
  13796.                 
  13797.                 String name = null;
  13798.                 name = this.reader.getValueConvertEnvProperties(pName);
  13799.                 if(name!=null) {
  13800.                     name = name.trim();
  13801.                     String [] split = name.split(",");
  13802.                     if(split!=null){
  13803.                         for (int i = 0; i < split.length; i++) {
  13804.                             String v = split[i];
  13805.                             if(v!=null) {
  13806.                                 v = v.trim();
  13807.                             }
  13808.                             if(!"".equals(v)) {
  13809.                                 this.getIntegrazioneAutenticazionePortaDelegataRequestHeaders.add(v);
  13810.                             }
  13811.                         }
  13812.                     }
  13813.                 }
  13814.             }catch(java.lang.Exception e) {
  13815.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13816.                 throw new CoreException (e);
  13817.             }    
  13818.         }

  13820.         return this.getIntegrazioneAutenticazionePortaDelegataRequestHeaders;
  13821.     }
  13822.    
  13823.     private Map<String, String> getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap = null;
  13824.     public Map<String, String> getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap() throws CoreException{
  13825.         String pNamePrefix = "org.openspcoop2.pdd.integrazione.autenticazione.pd.request.header.";
  13826.         if(this.getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap==null){
  13827.             try{
  13828.                 
  13829.                 this.getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap = new HashMap<>();
  13830.                 List<String> getIntegrazioneAutenticazionePortaDelegataRequestHeaders = getIntegrazioneAutenticazionePortaDelegataRequestHeaders();
  13831.                 if(getIntegrazioneAutenticazionePortaDelegataRequestHeaders!=null && !getIntegrazioneAutenticazionePortaDelegataRequestHeaders.isEmpty()) {
  13832.                     for (String hdrName : getIntegrazioneAutenticazionePortaDelegataRequestHeaders) {
  13833.                         String pName = pNamePrefix+hdrName;
  13834.                         try {
  13835.                             String hdrValue = this.reader.getValueConvertEnvProperties(pName);
  13836.                             if(hdrValue==null) {
  13837.                                 throw new CoreException(NON_DEFINITA);
  13838.                             }
  13839.                             hdrValue = hdrValue.trim();
  13840.                             this.getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap.put(hdrName, hdrValue);
  13841.                         }catch(java.lang.Exception e) {
  13842.                             throw new CoreException ("Proprietà '"+pName+"' "+e.getMessage(),e);
  13843.                         }   
  13844.                     }
  13845.                 }
  13846.             }catch(java.lang.Exception e) {
  13847.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNamePrefix+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  13848.                 throw new CoreException (e);
  13849.             }    
  13850.         }

  13852.         return this.getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap;
  13853.     }
  13854.     
  13855.     private List<String> getIntegrazioneAutenticazionePortaApplicativaRequestHeaders = null;
  13856.     public List<String> getIntegrazioneAutenticazionePortaApplicativaRequestHeaders() throws CoreException{
  13857.         String pName = "org.openspcoop2.pdd.integrazione.autenticazione.pa.request.headers";
  13858.         if(this.getIntegrazioneAutenticazionePortaApplicativaRequestHeaders==null){
  13859.             try{
  13860.                 
  13861.                 this.getIntegrazioneAutenticazionePortaApplicativaRequestHeaders = new ArrayList<>();
  13862.                 
  13863.                 String name = null;
  13864.                 name = this.reader.getValueConvertEnvProperties(pName);
  13865.                 if(name!=null) {
  13866.                     name = name.trim();
  13867.                     String [] split = name.split(",");
  13868.                     if(split!=null){
  13869.                         for (int i = 0; i < split.length; i++) {
  13870.                             String v = split[i];
  13871.                             if(v!=null) {
  13872.                                 v = v.trim();
  13873.                             }
  13874.                             if(!"".equals(v)) {
  13875.                                 this.getIntegrazioneAutenticazionePortaApplicativaRequestHeaders.add(v);
  13876.                             }
  13877.                         }
  13878.                     }
  13879.                 }
  13880.             }catch(java.lang.Exception e) {
  13881.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13882.                 throw new CoreException (e);
  13883.             }    
  13884.         }

  13886.         return this.getIntegrazioneAutenticazionePortaApplicativaRequestHeaders;
  13887.     }
  13888.    
  13889.     private Map<String, String> getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap = null;
  13890.     public Map<String, String> getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap() throws CoreException{
  13891.         String pNamePrefix = "org.openspcoop2.pdd.integrazione.autenticazione.pa.request.header.";
  13892.         if(this.getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap==null){
  13893.             try{
  13894.                 
  13895.                 this.getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap = new HashMap<>();
  13896.                 List<String> getIntegrazioneAutenticazionePortaApplicativaRequestHeaders = getIntegrazioneAutenticazionePortaApplicativaRequestHeaders();
  13897.                 if(getIntegrazioneAutenticazionePortaApplicativaRequestHeaders!=null && !getIntegrazioneAutenticazionePortaApplicativaRequestHeaders.isEmpty()) {
  13898.                     for (String hdrName : getIntegrazioneAutenticazionePortaApplicativaRequestHeaders) {
  13899.                         String pName = pNamePrefix+hdrName;
  13900.                         try {
  13901.                             String hdrValue = this.reader.getValueConvertEnvProperties(pName);
  13902.                             if(hdrValue==null) {
  13903.                                 throw new CoreException(NON_DEFINITA);
  13904.                             }
  13905.                             hdrValue = hdrValue.trim();
  13906.                             this.getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap.put(hdrName, hdrValue);
  13907.                         }catch(java.lang.Exception e) {
  13908.                             throw new CoreException ("Proprietà '"+pName+"' "+e.getMessage(),e);
  13909.                         }   
  13910.                     }
  13911.                 }
  13912.             }catch(java.lang.Exception e) {
  13913.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNamePrefix+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  13914.                 throw new CoreException (e);
  13915.             }    
  13916.         }

  13918.         return this.getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap;
  13919.     }
  13920.     
  13921.     private String getIntegrazioneAutenticazionePropertyHeaders = null;
  13922.     public String getIntegrazioneAutenticazionePropertyHeaders() {
  13923.         String pName = "org.openspcoop2.pdd.integrazione.autenticazione.request.property.headers";
  13924.         if(this.getIntegrazioneAutenticazionePropertyHeaders==null){
  13925.             try{ 
  13926.                 String name = null;
  13927.                 name = this.reader.getValueConvertEnvProperties(pName);
  13928.                 if(name==null)
  13929.                     throw new CoreException(NON_DEFINITA);
  13930.                 name = name.trim();
  13931.                 this.getIntegrazioneAutenticazionePropertyHeaders = name;
  13932.             }catch(java.lang.Exception e) {
  13933.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13934.                 this.getIntegrazioneAutenticazionePropertyHeaders = null;
  13935.             }    
  13936.         }

  13938.         return this.getIntegrazioneAutenticazionePropertyHeaders;
  13939.     }
  13940.     
  13941.     private String getIntegrazioneAutenticazionePropertyHeaderPrefix = null;
  13942.     public String getIntegrazioneAutenticazionePropertyHeaderPrefix() {
  13943.         String pName = "org.openspcoop2.pdd.integrazione.autenticazione.request.property.header.prefix";
  13944.         if(this.getIntegrazioneAutenticazionePropertyHeaderPrefix==null){
  13945.             try{ 
  13946.                 String name = null;
  13947.                 name = this.reader.getValueConvertEnvProperties(pName);
  13948.                 if(name==null)
  13949.                     throw new CoreException(NON_DEFINITA);
  13950.                 name = name.trim();
  13951.                 this.getIntegrazioneAutenticazionePropertyHeaderPrefix = name;
  13952.             }catch(java.lang.Exception e) {
  13953.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13954.                 this.getIntegrazioneAutenticazionePropertyHeaderPrefix = null;
  13955.             }    
  13956.         }

  13958.         return this.getIntegrazioneAutenticazionePropertyHeaderPrefix;
  13959.     }


  13962.     /* ********  CONNETTORI  ******** */

  13964.     private Boolean isRitardoConsegnaAbilitato = null;
  13965.     public boolean isRitardoConsegnaAbilitato() throws CoreException{
  13966.         if(this.isRitardoConsegnaAbilitato==null){
  13967.             try{ 
  13968.                 String name = null;
  13969.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettore.ritardo.stato");
  13970.                 if(name==null)
  13971.                     throw new CoreException(NON_DEFINITA);
  13972.                 name = name.trim();
  13973.                 this.isRitardoConsegnaAbilitato = CostantiConfigurazione.ABILITATO.equals(name);

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

  13981.         return this.isRitardoConsegnaAbilitato;
  13982.     }

  13984.     private Long ritardoConsegnaEsponenziale = null;
  13985.     public long getRitardoConsegnaEsponenziale() {  
  13986.         if(this.ritardoConsegnaEsponenziale==null){
  13987.             try{ 
  13988.                 long r = -1;
  13989.                 String name = null;
  13990.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettore.ritardo.fattore");
  13991.                 if (name != null) {
  13992.                     name = name.trim();
  13993.                     r = java.lang.Long.parseLong(name);
  13994.                 }
  13995.                 if(r<0)
  13996.                     throw new CoreException("Il ritardo deve essere > 0");
  13997.                 this.ritardoConsegnaEsponenziale = r;
  13998.             }catch(java.lang.Exception e) {
  13999.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettore.ritardo.fattore': "+e.getMessage(),e);
  14000.                 this.ritardoConsegnaEsponenziale = -1L;
  14001.             }    
  14002.         }

  14004.         return this.ritardoConsegnaEsponenziale;
  14005.     }

  14007.     private Boolean isRitardoConsegnaEsponenzialeConMoltiplicazione = null;
  14008.     public boolean isRitardoConsegnaEsponenzialeConMoltiplicazione() throws CoreException{
  14009.         if(this.isRitardoConsegnaEsponenzialeConMoltiplicazione==null){
  14010.             try{ 
  14011.                 String name = null;
  14012.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettore.ritardo.operazione");
  14013.                 if (name != null) {
  14014.                     name = name.trim();
  14015.                     if(name.equals("+")){
  14016.                         this.isRitardoConsegnaEsponenzialeConMoltiplicazione = false;
  14017.                     }else if(name.equals("*")){
  14018.                         this.isRitardoConsegnaEsponenzialeConMoltiplicazione = true;
  14019.                     }else{
  14020.                         throw new CoreException("Tipo di operazione non conosciuta: "+name);
  14021.                     }
  14022.                 }else{
  14023.                     throw new CoreException("Tipo di operazione non definita");
  14024.                 }
  14025.             }catch(java.lang.Exception e) {
  14026.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettore.ritardo.operazione': "+e.getMessage(),e);
  14027.                 throw new CoreException (e);
  14028.             }    
  14029.         }

  14031.         return this.isRitardoConsegnaEsponenzialeConMoltiplicazione;
  14032.     }

  14034.     private Long ritardoConsegnaEsponenzialeLimite = null;
  14035.     public long getRitardoConsegnaEsponenzialeLimite() {    
  14036.         if(this.ritardoConsegnaEsponenzialeLimite==null){
  14037.             try{ 
  14038.                 long r = 0;
  14039.                 String name = null;
  14040.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettore.ritardo.limite");
  14041.                 if (name != null) {
  14042.                     name = name.trim();
  14043.                     r = java.lang.Long.parseLong(name);
  14044.                 }
  14045.                 if(r<=0)
  14046.                     throw new CoreException("Il limite deve essere > 0");
  14047.                 this.ritardoConsegnaEsponenzialeLimite = r;
  14048.             }catch(java.lang.Exception e) {
  14049.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettore.ritardo.limite': "+e.getMessage(),e);
  14050.                 this.ritardoConsegnaEsponenzialeLimite = -1L;
  14051.             }    
  14052.         }

  14054.         return this.ritardoConsegnaEsponenzialeLimite;
  14055.     }














  14070.     /* ************* CACHE GESTORE MESSAGGIO *******************/

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

  14083.                 if (value != null){
  14084.                     value = value.trim();
  14085.                     this.isAbilitataCacheGestoreMessaggi_value = Boolean.parseBoolean(value);
  14086.                 }else{
  14087.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.enable' non impostata, viene utilizzato il default=false");
  14088.                     this.isAbilitataCacheGestoreMessaggi_value = false;
  14089.                 }
  14090.             }catch(java.lang.Exception e) {
  14091.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.enable' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  14092.                 this.isAbilitataCacheGestoreMessaggi_value = false;
  14093.             }
  14094.         }

  14096.         return this.isAbilitataCacheGestoreMessaggi_value;
  14097.     }

  14099.     /**
  14100.      * Restituisce la dimensione della cache
  14101.      *
  14102.      * @return Restituisce la dimensione della cache
  14103.      */
  14104.     private Integer dimensioneCacheGestoreMessaggi_value = null;
  14105.     public int getDimensioneCacheGestoreMessaggi() throws OpenSPCoop2ConfigurationException{    
  14106.         if(this.dimensioneCacheGestoreMessaggi_value==null){
  14107.             try{  
  14108.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.dimensione"); 
  14109.                 if(value!=null){
  14110.                     value = value.trim();
  14111.                     this.dimensioneCacheGestoreMessaggi_value = Integer.parseInt(value);
  14112.                 }else{
  14113.                     this.dimensioneCacheGestoreMessaggi_value = -1;
  14114.                 }
  14115.             }catch(java.lang.Exception e) {
  14116.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.dimensione': "+e.getMessage(),e);
  14117.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.dimensione'",e);
  14118.             }
  14119.         }

  14121.         return this.dimensioneCacheGestoreMessaggi_value;
  14122.     }

  14124.     /**
  14125.      * Restituisce l'algoritmo della cache
  14126.      *
  14127.      * @return Restituisce l'algoritmo della cache
  14128.      */
  14129.     private String algoritmoCacheGestoreMessaggi_value = null;
  14130.     public String getAlgoritmoCacheGestoreMessaggi() throws OpenSPCoop2ConfigurationException{  
  14131.         if(this.algoritmoCacheGestoreMessaggi_value==null){
  14132.             try{  
  14133.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.algoritmo"); 
  14134.                 if(value!=null){
  14135.                     value = value.trim();
  14136.                     this.algoritmoCacheGestoreMessaggi_value = value;
  14137.                 }else{
  14138.                     this.algoritmoCacheGestoreMessaggi_value = null;
  14139.                 }
  14140.             }catch(java.lang.Exception e) {
  14141.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.algoritmo': "+e.getMessage(),e);
  14142.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.algoritmo'",e);
  14143.             }
  14144.         }

  14146.         return this.algoritmoCacheGestoreMessaggi_value;
  14147.     }

  14149.     /**
  14150.      * Restituisce la itemIdleTime della cache
  14151.      *
  14152.      * @return Restituisce la itemIdleTime della cache
  14153.      */
  14154.     private Integer itemIdleTimeCacheGestoreMessaggi_value = null;
  14155.     public int getItemIdleTimeCacheGestoreMessaggi() throws OpenSPCoop2ConfigurationException{  
  14156.         if(this.itemIdleTimeCacheGestoreMessaggi_value==null){
  14157.             try{  
  14158.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemIdleTime"); 
  14159.                 if(value!=null){
  14160.                     value = value.trim();
  14161.                     this.itemIdleTimeCacheGestoreMessaggi_value = Integer.parseInt(value);
  14162.                 }else{
  14163.                     this.itemIdleTimeCacheGestoreMessaggi_value = -1;
  14164.                 }
  14165.             }catch(java.lang.Exception e) {
  14166.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemIdleTime': "+e.getMessage(),e);
  14167.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemIdleTime'",e);
  14168.             }
  14169.         }

  14171.         return this.itemIdleTimeCacheGestoreMessaggi_value;
  14172.     }

  14174.     /**
  14175.      * Restituisce la  itemLifeSecond della cache
  14176.      *
  14177.      * @return Restituisce la itemLifeSecond della cache
  14178.      */
  14179.     private Integer itemLifeSecondCacheGestoreMessaggi_value = null;
  14180.     public int getItemLifeSecondCacheGestoreMessaggi() throws OpenSPCoop2ConfigurationException{
  14181.         if(this.itemLifeSecondCacheGestoreMessaggi_value==null){
  14182.             try{  
  14183.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemLifeSecond"); 
  14184.                 if(value!=null){
  14185.                     value = value.trim();
  14186.                     this.itemLifeSecondCacheGestoreMessaggi_value = Integer.parseInt(value);
  14187.                 }else{
  14188.                     this.itemLifeSecondCacheGestoreMessaggi_value = -1;
  14189.                 }
  14190.             }catch(java.lang.Exception e) {
  14191.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemLifeSecond': "+e.getMessage(),e);
  14192.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemLifeSecond'",e);
  14193.             }
  14194.         }

  14196.         return this.itemLifeSecondCacheGestoreMessaggi_value;
  14197.     }





  14203.     /* ******* GESTORE JMX *********** */
  14204.     /**
  14205.      * Restituisce l'indicazione se istanziare le risorse JMX
  14206.      *
  14207.      * @return Restituisce Restituisce l'indicazione se istanziare le risorse JMX
  14208.      * 
  14209.      */
  14210.     private Boolean isRisorseJMXAbilitate = null;
  14211.     public boolean isRisorseJMXAbilitate(){
  14212.         if(this.isRisorseJMXAbilitate==null){
  14213.             try{  
  14214.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.jmx.enable"); 

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

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

  14230.         return this.isRisorseJMXAbilitate;
  14231.     }

  14233.     /**
  14234.      * Restituisce il Nome JNDI del MBeanServer
  14235.      *
  14236.      * @return il Nome JNDI del MBeanServer
  14237.      * 
  14238.      */
  14239.     private String jndiNameMBeanServer = null;
  14240.     public String getJNDIName_MBeanServer() {   
  14241.         if(this.jndiNameMBeanServer==null){
  14242.             try{ 
  14243.                 String name = null;
  14244.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.jmx.jndi.mbeanServer");
  14245.                 if(name!=null)
  14246.                     name = name.trim();
  14247.                 this.jndiNameMBeanServer = name;
  14248.             }catch(java.lang.Exception e) {
  14249.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.core.jmx.jndi.mbeanServer': "+e.getMessage(),e);
  14250.                 this.jndiNameMBeanServer = null;
  14251.             }    
  14252.         }

  14254.         return this.jndiNameMBeanServer;
  14255.     }

  14257.     /**
  14258.      * Restituisce le proprieta' da utilizzare con il contesto JNDI di lookup, se impostate.
  14259.      *
  14260.      * @return proprieta' da utilizzare con il contesto JNDI di lookup.
  14261.      * 
  14262.      */
  14263.     private java.util.Properties jndiContextMBeanServer = null;
  14264.     public java.util.Properties getJNDIContext_MBeanServer() {
  14265.         if(this.jndiContextMBeanServer==null){
  14266.             java.util.Properties prop = new java.util.Properties();
  14267.             try{ 

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

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

  14278.         return this.jndiContextMBeanServer;
  14279.     }









  14289.     /* ************* CONNETTORI ***************** */
  14290.     
  14291.     private Boolean isConnettoriUseLimitedInputStream = null;
  14292.     public boolean isConnettoriUseLimitedInputStream() {    
  14293.         if(this.isConnettoriUseLimitedInputStream==null){
  14294.             String pName = "org.openspcoop2.pdd.connettori.useLimitedInputStream";
  14295.             try{ 
  14296.                 String name = null;
  14297.                 name = this.reader.getValueConvertEnvProperties(pName);
  14298.                 if(name!=null){
  14299.                     name = name.trim();
  14300.                     this.isConnettoriUseLimitedInputStream = Boolean.parseBoolean(name);
  14301.                 }else{
  14302.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  14303.                     this.isConnettoriUseLimitedInputStream = false;
  14304.                 }
  14305.             }catch(java.lang.Exception e) {
  14306.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  14307.                 this.isConnettoriUseLimitedInputStream = false;
  14308.             }  
  14309.         }

  14311.         return this.isConnettoriUseLimitedInputStream;
  14312.     }
  14313.     
  14314.     private Long getLimitedInputStreamThreshold = null;
  14315.     private boolean limitedInputStreamThresholdDefined = false;
  14316.     public boolean isLimitedInputStreamThresholdDefined() {
  14317.         return this.limitedInputStreamThresholdDefined;
  14318.     }
  14319.     public long getLimitedInputStreamThresholdKb() {    
  14320.         if(this.getLimitedInputStreamThreshold==null){
  14321.             String pName = "org.openspcoop2.pdd.connettori.limitedInputStream.threshold";
  14322.             try{ 
  14323.                 String name = null;
  14324.                 name = this.reader.getValueConvertEnvProperties(pName);
  14325.                 if(name!=null){
  14326.                     name = name.trim();
  14327.                     this.getLimitedInputStreamThreshold = java.lang.Long.valueOf(name);
  14328.                     this.limitedInputStreamThresholdDefined = true;
  14329.                 }else{
  14330.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, Integer.MAX_VALUE));
  14331.                     this.getLimitedInputStreamThreshold = (long)Integer.MAX_VALUE;
  14332.                 }
  14333.             }catch(java.lang.Exception e) {
  14334.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, Integer.MAX_VALUE),e);
  14335.                 this.getLimitedInputStreamThreshold = (long)Integer.MAX_VALUE;
  14336.             }  
  14337.         }

  14339.         return this.getLimitedInputStreamThreshold;
  14340.     }
  14341.     
  14342.     private Boolean isLimitedInputStreamUseContentLength = null;
  14343.     public boolean isLimitedInputStreamUseContentLength() { 
  14344.         if(this.isLimitedInputStreamUseContentLength==null){
  14345.             String pName = "org.openspcoop2.pdd.connettori.limitedInputStream.useContentLength";
  14346.             try{ 
  14347.                 String name = null;
  14348.                 name = this.reader.getValueConvertEnvProperties(pName);
  14349.                 if(name!=null){
  14350.                     name = name.trim();
  14351.                     this.isLimitedInputStreamUseContentLength = Boolean.parseBoolean(name);
  14352.                 }else{
  14353.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  14354.                     this.isLimitedInputStreamUseContentLength = true;
  14355.                 }
  14356.             }catch(java.lang.Exception e) {
  14357.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  14358.                 this.isLimitedInputStreamUseContentLength = true;
  14359.             }  
  14360.         }

  14362.         return this.isLimitedInputStreamUseContentLength;
  14363.     }
  14364.     
  14365.     private Boolean isLimitedInputStreamUseContentLengthAcceptZeroValue = null;
  14366.     public boolean isLimitedInputStreamUseContentLengthAcceptZeroValue() {  
  14367.         if(this.isLimitedInputStreamUseContentLengthAcceptZeroValue==null){
  14368.             String pName = "org.openspcoop2.pdd.connettori.limitedInputStream.useContentLength.acceptZeroValue";
  14369.             try{ 
  14370.                 String name = null;
  14371.                 name = this.reader.getValueConvertEnvProperties(pName);
  14372.                 if(name!=null){
  14373.                     name = name.trim();
  14374.                     this.isLimitedInputStreamUseContentLengthAcceptZeroValue = Boolean.parseBoolean(name);
  14375.                 }else{
  14376.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  14377.                     this.isLimitedInputStreamUseContentLengthAcceptZeroValue = true;
  14378.                 }
  14379.             }catch(java.lang.Exception e) {
  14380.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  14381.                 this.isLimitedInputStreamUseContentLengthAcceptZeroValue = true;
  14382.             }  
  14383.         }

  14385.         return this.isLimitedInputStreamUseContentLengthAcceptZeroValue;
  14386.     }
  14387.     
  14388.     private Boolean isConnettoriUseTimeoutInputStream = null;
  14389.     public boolean isConnettoriUseTimeoutInputStream() {    
  14390.         if(this.isConnettoriUseTimeoutInputStream==null){
  14391.             String pName = "org.openspcoop2.pdd.connettori.useTimeoutInputStream";
  14392.             try{ 
  14393.                 String name = null;
  14394.                 name = this.reader.getValueConvertEnvProperties(pName);
  14395.                 if(name!=null){
  14396.                     name = name.trim();
  14397.                     this.isConnettoriUseTimeoutInputStream = Boolean.parseBoolean(name);
  14398.                 }else{
  14399.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  14400.                     this.isConnettoriUseTimeoutInputStream = false;
  14401.                 }
  14402.             }catch(java.lang.Exception e) {
  14403.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  14404.                 this.isConnettoriUseTimeoutInputStream = false;
  14405.             }  
  14406.         }

  14408.         return this.isConnettoriUseTimeoutInputStream;
  14409.     }
  14410.     
  14411.     /**
  14412.      * Restituisce timeout per la istanziazione della connessione
  14413.      *
  14414.      * @return Restituisce timeout per la istanziazione della connessione
  14415.      * 
  14416.      */
  14417.     private Integer connectionTimeout_inoltroBuste = null;
  14418.     public int getConnectionTimeout_inoltroBuste() {    
  14419.         if(this.connectionTimeout_inoltroBuste==null){
  14420.             try{ 
  14421.                 String name = null;
  14422.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.connection.timeout");
  14423.                 if(name!=null){
  14424.                     name = name.trim();
  14425.                     this.connectionTimeout_inoltroBuste = java.lang.Integer.parseInt(name);
  14426.                 }else{
  14427.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.connection.timeout' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_INOLTRO_BUSTE);
  14428.                     this.connectionTimeout_inoltroBuste = CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14429.                 }
  14430.             }catch(java.lang.Exception e) {
  14431.                 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);
  14432.                 this.connectionTimeout_inoltroBuste = CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14433.             }  
  14434.         }

  14436.         return this.connectionTimeout_inoltroBuste;
  14437.     }


  14440.     /**
  14441.      * Restituisce timeout per la istanziazione della connessione
  14442.      *
  14443.      * @return Restituisce timeout per la istanziazione della connessione
  14444.      * 
  14445.      */
  14446.     private Integer connectionTimeout_consegnaContenutiApplicativi = null;
  14447.     public int getConnectionTimeout_consegnaContenutiApplicativi() {    
  14448.         if(this.connectionTimeout_consegnaContenutiApplicativi==null){
  14449.             try{ 
  14450.                 String name = null;
  14451.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.connection.timeout");
  14452.                 if(name!=null){
  14453.                     name = name.trim();
  14454.                     this.connectionTimeout_consegnaContenutiApplicativi = java.lang.Integer.parseInt(name);
  14455.                 }else{
  14456.                     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);
  14457.                     this.connectionTimeout_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI;
  14458.                 }
  14459.             }catch(java.lang.Exception e) {
  14460.                 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);
  14461.                 this.connectionTimeout_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI;
  14462.             }  
  14463.         }

  14465.         return this.connectionTimeout_consegnaContenutiApplicativi;
  14466.     }


  14469.     /**
  14470.      * Restituisce timeout per la lettura dalla connessione
  14471.      *
  14472.      * @return Restituisce timeout per la lettura dalla connessione
  14473.      * 
  14474.      */
  14475.     private Integer readConnectionTimeout_inoltroBuste = null;
  14476.     public int getReadConnectionTimeout_inoltroBuste() {    
  14477.         if(this.readConnectionTimeout_inoltroBuste==null){
  14478.             try{ 
  14479.                 String name = null;
  14480.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.readConnection.timeout");
  14481.                 if(name!=null){
  14482.                     name = name.trim();
  14483.                     this.readConnectionTimeout_inoltroBuste = java.lang.Integer.parseInt(name);
  14484.                 }else{
  14485.                     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);
  14486.                     this.readConnectionTimeout_inoltroBuste = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14487.                 }
  14488.             }catch(java.lang.Exception e) {
  14489.                 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);
  14490.                 this.readConnectionTimeout_inoltroBuste = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14491.             }  
  14492.         }

  14494.         return this.readConnectionTimeout_inoltroBuste;
  14495.     }


  14498.     /**
  14499.      * Restituisce timeout per la lettura dalla connessione
  14500.      *
  14501.      * @return Restituisce timeout per la lettura dalla connessione
  14502.      * 
  14503.      */
  14504.     private Integer readConnectionTimeout_consegnaContenutiApplicativi = null;
  14505.     public int getReadConnectionTimeout_consegnaContenutiApplicativi() {    
  14506.         if(this.readConnectionTimeout_consegnaContenutiApplicativi==null){
  14507.             try{ 
  14508.                 String name = null;
  14509.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.readConnection.timeout");
  14510.                 if(name!=null){
  14511.                     name = name.trim();
  14512.                     this.readConnectionTimeout_consegnaContenutiApplicativi = java.lang.Integer.parseInt(name);
  14513.                 }else{
  14514.                     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);
  14515.                     this.readConnectionTimeout_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI;
  14516.                 }
  14517.             }catch(java.lang.Exception e) {
  14518.                 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);
  14519.                 this.readConnectionTimeout_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI;
  14520.             }  
  14521.         }

  14523.         return this.readConnectionTimeout_consegnaContenutiApplicativi;
  14524.     }

  14526.     /**
  14527.      * Restituisce timeout in millisecondi massimi durante il quale una connessione viene mantenuta aperta dalla PdD. 
  14528.      *
  14529.      * @return Restituisce timeout in millisecondi massimi durante il quale una connessione viene mantenuta aperta dalla PdD. 
  14530.      * 
  14531.      */
  14532.     private Integer connectionLife_inoltroBuste = null;
  14533.     public int getConnectionLife_inoltroBuste() {   
  14534.         if(this.connectionLife_inoltroBuste==null){
  14535.             try{ 
  14536.                 String name = null;
  14537.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.connection.life");
  14538.                 if(name!=null){
  14539.                     name = name.trim();
  14540.                     this.connectionLife_inoltroBuste = java.lang.Integer.parseInt(name);
  14541.                 }else{
  14542.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.connection.life' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_CONNECTION_LIFE_INOLTRO_BUSTE);
  14543.                     this.connectionLife_inoltroBuste = CostantiPdD.CONNETTORE_CONNECTION_LIFE_INOLTRO_BUSTE;
  14544.                 }
  14545.             }catch(java.lang.Exception e) {
  14546.                 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);
  14547.                 this.connectionLife_inoltroBuste = CostantiPdD.CONNETTORE_CONNECTION_LIFE_INOLTRO_BUSTE;
  14548.             }  
  14549.         }

  14551.         return this.connectionLife_inoltroBuste;
  14552.     }


  14555.     /**
  14556.      * Restituisce timeout in millisecondi massimi durante il quale una connessione viene mantenuta aperta dalla PdD. 
  14557.      *
  14558.      * @return Restituisce timeout in millisecondi massimi durante il quale una connessione viene mantenuta aperta dalla PdD. 
  14559.      * 
  14560.      */
  14561.     private Integer connectionLife_consegnaContenutiApplicativi = null;
  14562.     public int getConnectionLife_consegnaContenutiApplicativi() {   
  14563.         if(this.connectionLife_consegnaContenutiApplicativi==null){
  14564.             try{ 
  14565.                 String name = null;
  14566.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.connection.life");
  14567.                 if(name!=null){
  14568.                     name = name.trim();
  14569.                     this.connectionLife_consegnaContenutiApplicativi = java.lang.Integer.parseInt(name);
  14570.                 }else{
  14571.                     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);
  14572.                     this.connectionLife_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_CONNECTION_LIFE_CONSEGNA_CONTENUTI_APPLICATIVI;
  14573.                 }
  14574.             }catch(java.lang.Exception e) {
  14575.                 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);
  14576.                 this.connectionLife_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_CONNECTION_LIFE_CONSEGNA_CONTENUTI_APPLICATIVI;
  14577.             }  
  14578.         }

  14580.         return this.connectionLife_consegnaContenutiApplicativi;
  14581.     }

  14583.     
  14584.     private Integer readConnectionTimeout_ricezioneContenutiApplicativi = null;
  14585.     public int getReadConnectionTimeout_ricezioneContenutiApplicativi() {   
  14586.         String pName = "org.openspcoop2.pdd.connettori.ricezioneContenutiApplicativi.readConnection.timeout";
  14587.         if(this.readConnectionTimeout_ricezioneContenutiApplicativi==null){
  14588.             try{ 
  14589.                 String name = null;
  14590.                 name = this.reader.getValueConvertEnvProperties(pName);
  14591.                 if(name!=null){
  14592.                     name = name.trim();
  14593.                     this.readConnectionTimeout_ricezioneContenutiApplicativi = java.lang.Integer.parseInt(name);
  14594.                 }else{
  14595.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE));
  14596.                     this.readConnectionTimeout_ricezioneContenutiApplicativi = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14597.                 }
  14598.             }catch(java.lang.Exception e) {
  14599.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE),e);
  14600.                 this.readConnectionTimeout_ricezioneContenutiApplicativi = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14601.             }  
  14602.         }

  14604.         return this.readConnectionTimeout_ricezioneContenutiApplicativi;
  14605.     }
  14606.     
  14607.     private Integer readConnectionTimeout_ricezioneBuste = null;
  14608.     public int getReadConnectionTimeout_ricezioneBuste() {  
  14609.         String pName = "org.openspcoop2.pdd.connettori.ricezioneBuste.readConnection.timeout";
  14610.         if(this.readConnectionTimeout_ricezioneBuste==null){
  14611.             try{ 
  14612.                 String name = null;
  14613.                 name = this.reader.getValueConvertEnvProperties(pName);
  14614.                 if(name!=null){
  14615.                     name = name.trim();
  14616.                     this.readConnectionTimeout_ricezioneBuste = java.lang.Integer.parseInt(name);
  14617.                 }else{
  14618.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE));
  14619.                     this.readConnectionTimeout_ricezioneBuste = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14620.                 }
  14621.             }catch(java.lang.Exception e) {
  14622.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE),e);
  14623.                 this.readConnectionTimeout_ricezioneBuste = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14624.             }  
  14625.         }

  14627.         return this.readConnectionTimeout_ricezioneBuste;
  14628.     }
  14629.     
  14630.     
  14631.     
  14632.     private Boolean isConnettoriUseDiagnosticInputStream_inoltroBuste = null;
  14633.     public boolean isConnettoriUseDiagnosticInputStream_inoltroBuste() {    
  14634.         if(this.isConnettoriUseDiagnosticInputStream_inoltroBuste==null){
  14635.             String pName = "org.openspcoop2.pdd.connettori.inoltroBuste.useDiagnosticInputStream";
  14636.             try{ 
  14637.                 String name = null;
  14638.                 name = this.reader.getValueConvertEnvProperties(pName);
  14639.                 if(name!=null){
  14640.                     name = name.trim();
  14641.                     this.isConnettoriUseDiagnosticInputStream_inoltroBuste = Boolean.parseBoolean(name);
  14642.                 }else{
  14643.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  14644.                     this.isConnettoriUseDiagnosticInputStream_inoltroBuste = true;
  14645.                 }
  14646.             }catch(java.lang.Exception e) {
  14647.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  14648.                 this.isConnettoriUseDiagnosticInputStream_inoltroBuste = true;
  14649.             }  
  14650.         }

  14652.         return this.isConnettoriUseDiagnosticInputStream_inoltroBuste;
  14653.     }
  14654.     
  14655.     private Boolean isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi = null;
  14656.     public boolean isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi() {    
  14657.         if(this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi==null){
  14658.             String pName = "org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.useDiagnosticInputStream";
  14659.             try{ 
  14660.                 String name = null;
  14661.                 name = this.reader.getValueConvertEnvProperties(pName);
  14662.                 if(name!=null){
  14663.                     name = name.trim();
  14664.                     this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
  14665.                 }else{
  14666.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  14667.                     this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi = true;
  14668.                 }
  14669.             }catch(java.lang.Exception e) {
  14670.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  14671.                 this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi = true;
  14672.             }  
  14673.         }

  14675.         return this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi;
  14676.     }
  14677.     
  14678.     private Boolean isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi = null;
  14679.     public boolean isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi() {   
  14680.         if(this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi==null){
  14681.             String pName = "org.openspcoop2.pdd.connettori.ricezioneContenutiApplicativi.useDiagnosticInputStream";
  14682.             try{ 
  14683.                 String name = null;
  14684.                 name = this.reader.getValueConvertEnvProperties(pName);
  14685.                 if(name!=null){
  14686.                     name = name.trim();
  14687.                     this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi = Boolean.parseBoolean(name);
  14688.                 }else{
  14689.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  14690.                     this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi = true;
  14691.                 }
  14692.             }catch(java.lang.Exception e) {
  14693.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  14694.                 this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi = true;
  14695.             }  
  14696.         }

  14698.         return this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi;
  14699.     }
  14700.     
  14701.     private Boolean isConnettoriUseDiagnosticInputStream_ricezioneBuste = null;
  14702.     public boolean isConnettoriUseDiagnosticInputStream_ricezioneBuste() {  
  14703.         if(this.isConnettoriUseDiagnosticInputStream_ricezioneBuste==null){
  14704.             String pName = "org.openspcoop2.pdd.connettori.ricezioneBuste.useDiagnosticInputStream";
  14705.             try{ 
  14706.                 String name = null;
  14707.                 name = this.reader.getValueConvertEnvProperties(pName);
  14708.                 if(name!=null){
  14709.                     name = name.trim();
  14710.                     this.isConnettoriUseDiagnosticInputStream_ricezioneBuste = Boolean.parseBoolean(name);
  14711.                 }else{
  14712.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  14713.                     this.isConnettoriUseDiagnosticInputStream_ricezioneBuste = true;
  14714.                 }
  14715.             }catch(java.lang.Exception e) {
  14716.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  14717.                 this.isConnettoriUseDiagnosticInputStream_ricezioneBuste = true;
  14718.             }  
  14719.         }

  14721.         return this.isConnettoriUseDiagnosticInputStream_ricezioneBuste;
  14722.     }
  14723.     
  14724.     
  14725.     private Boolean isConnettoriUseDiagnosticInputStream_setDateEmptyStream = null;
  14726.     public boolean isConnettoriUseDiagnosticInputStream_setDateEmptyStream() {  
  14727.         if(this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream==null){
  14728.             String pName = "org.openspcoop2.pdd.connettori.useDiagnosticInputStream.setDateEmptyStream";
  14729.             try{ 
  14730.                 String name = null;
  14731.                 name = this.reader.getValueConvertEnvProperties(pName);
  14732.                 if(name!=null){
  14733.                     name = name.trim();
  14734.                     this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream = Boolean.parseBoolean(name);
  14735.                 }else{
  14736.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  14737.                     this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream = false;
  14738.                 }
  14739.             }catch(java.lang.Exception e) {
  14740.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  14741.                 this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream = false;
  14742.             }  
  14743.         }

  14745.         return this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream;
  14746.     }
  14747.     
  14748.     
  14749.     

  14751.     /* ***************** HTTPS  ************* */
  14752.     
  14753.     private Boolean isConnettoreHttps_useSecureRandom = null;
  14754.     public boolean isConnettoreHttps_useSecureRandom() {    
  14755.         if(this.isConnettoreHttps_useSecureRandom==null){
  14756.             String pName = "org.openspcoop2.pdd.connettori.secureRandom";
  14757.             try{ 
  14758.                 String name = null;
  14759.                 name = this.reader.getValueConvertEnvProperties(pName);
  14760.                 if(name!=null){
  14761.                     name = name.trim();
  14762.                     this.isConnettoreHttps_useSecureRandom = Boolean.parseBoolean(name);
  14763.                 }else{
  14764.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  14765.                     this.isConnettoreHttps_useSecureRandom = false;
  14766.                 }
  14767.             }catch(java.lang.Exception e) {
  14768.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  14769.                 this.isConnettoreHttps_useSecureRandom = false;
  14770.             }  
  14771.         }

  14773.         return this.isConnettoreHttps_useSecureRandom;
  14774.     }
  14775.     private String getConnettoreHttps_secureRandomAlgo = null;
  14776.     private Boolean getConnettoreHttps_secureRandomAlgoRead = null;
  14777.     public String getConnettoreHttps_secureRandomAlgo() {   
  14778.         if(this.getConnettoreHttps_secureRandomAlgoRead==null){
  14779.             String pName = "org.openspcoop2.pdd.connettori.secureRandomAlgorithm";
  14780.             try{ 
  14781.                 String name = null;
  14782.                 name = this.reader.getValueConvertEnvProperties(pName);
  14783.                 if(name!=null){
  14784.                     name = name.trim();
  14785.                     this.getConnettoreHttps_secureRandomAlgo = name;
  14786.                 }
  14787.             }catch(java.lang.Exception e) {
  14788.                 this.logWarn("Proprieta' di openspcoop '"+pName+"', errore:"+e.getMessage(),e);
  14789.             }  
  14790.             
  14791.             this.getConnettoreHttps_secureRandomAlgoRead=true;
  14792.         }

  14794.         return this.getConnettoreHttps_secureRandomAlgo;
  14795.     }
  14796.     
  14797.     private Boolean isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste = null;
  14798.     public boolean isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste() {  
  14799.         if(this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste==null){
  14800.             try{ 
  14801.                 String name = null;
  14802.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.overrideDefaultConfiguration");
  14803.                 if(name!=null){
  14804.                     name = name.trim();
  14805.                     this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste = Boolean.parseBoolean(name);
  14806.                 }else{
  14807.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.overrideDefaultConfiguration' non impostata, viene utilizzato il default="+true);
  14808.                     this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste = true;
  14809.                 }
  14810.             }catch(java.lang.Exception e) {
  14811.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.overrideDefaultConfiguration' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
  14812.                 this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste = true;
  14813.             }  
  14814.         }

  14816.         return this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste;
  14817.     }
  14818.     
  14819.     private Boolean isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi = null;
  14820.     public boolean isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi() {  
  14821.         if(this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi==null){
  14822.             try{ 
  14823.                 String name = null;
  14824.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.overrideDefaultConfiguration");
  14825.                 if(name!=null){
  14826.                     name = name.trim();
  14827.                     this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
  14828.                 }else{
  14829.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.overrideDefaultConfiguration' non impostata, viene utilizzato il default="+true);
  14830.                     this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi = true;
  14831.                 }
  14832.             }catch(java.lang.Exception e) {
  14833.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.overrideDefaultConfiguration' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
  14834.                 this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi = true;
  14835.             }  
  14836.         }

  14838.         return this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi;
  14839.     }
  14840.     
  14841.     private File getConnettoreHttp_urlHttps_repository_inoltroBuste = null;
  14842.     public File getConnettoreHttp_urlHttps_repository_inoltroBuste() throws CoreException { 
  14843.         if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste==null){
  14844.             try{ 
  14845.                 String name = null;
  14846.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.repository");
  14847.                 if(name==null){
  14848.                     throw new CoreException("Proprieta' non impostata");
  14849.                 }
  14850.                 name = name.trim();
  14851.                 this.getConnettoreHttp_urlHttps_repository_inoltroBuste = new File(name);
  14852.                 if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste.exists()) {
  14853.                     if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste.isDirectory()==false) {
  14854.                         throw newCoreExceptionNotDir(this.getConnettoreHttp_urlHttps_repository_inoltroBuste,true);
  14855.                     }
  14856.                     if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste.canRead()==false) {
  14857.                         throw newCoreExceptionCannotRead(this.getConnettoreHttp_urlHttps_repository_inoltroBuste,true);
  14858.                     }
  14859.                     if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste.canWrite()==false) {
  14860.                         throw newCoreExceptionCannotWrite(this.getConnettoreHttp_urlHttps_repository_inoltroBuste,true);
  14861.                     }
  14862.                 }
  14863.                 else {
  14864.                     // viene creata automaticamente
  14865.                 }
  14866.             } catch(java.lang.Exception e) {
  14867.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.repository': "+e.getMessage(),e);
  14868.                 throw new CoreException(e.getMessage(),e);
  14869.             }    
  14870.         }

  14872.         return this.getConnettoreHttp_urlHttps_repository_inoltroBuste;
  14873.     }
  14874.     
  14875.     private File getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi = null;
  14876.     public File getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi() throws CoreException { 
  14877.         if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi==null){
  14878.             try{ 
  14879.                 String name = null;
  14880.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.repository");
  14881.                 if(name==null){
  14882.                     throw new CoreException("Proprieta' non impostata");
  14883.                 }
  14884.                 name = name.trim();
  14885.                 this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi = new File(name);
  14886.                 if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi.exists()) {
  14887.                     if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi.isDirectory()==false) {
  14888.                         throw newCoreExceptionNotDir(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi,true);
  14889.                     }
  14890.                     if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi.canRead()==false) {
  14891.                         throw newCoreExceptionCannotRead(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi,true);
  14892.                     }
  14893.                     if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi.canWrite()==false) {
  14894.                         throw newCoreExceptionCannotWrite(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi,true);
  14895.                     }
  14896.                 }
  14897.                 else {
  14898.                     // viene creata automaticamente
  14899.                 }
  14900.             } catch(java.lang.Exception e) {
  14901.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.repository': "+e.getMessage(),e);
  14902.                 throw new CoreException(e.getMessage(),e);
  14903.             }    
  14904.         }

  14906.         return this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi;
  14907.     }
  14908.     
  14909.     private Boolean isConnettoreHttp_urlHttps_cacheEnabled = null;
  14910.     public boolean isConnettoreHttp_urlHttps_cacheEnabled() {   
  14911.         if(this.isConnettoreHttp_urlHttps_cacheEnabled==null){
  14912.             try{ 
  14913.                 String name = null;
  14914.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.http.urlHttps.cache.enabled");
  14915.                 if(name!=null){
  14916.                     name = name.trim();
  14917.                     this.isConnettoreHttp_urlHttps_cacheEnabled = Boolean.parseBoolean(name);
  14918.                 }else{
  14919.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.http.urlHttps.cache.enabled' non impostata, viene utilizzato il default="+true);
  14920.                     this.isConnettoreHttp_urlHttps_cacheEnabled = true;
  14921.                 }
  14922.             }catch(java.lang.Exception e) {
  14923.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.http.urlHttps.cache.enabled' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
  14924.                 this.isConnettoreHttp_urlHttps_cacheEnabled = true;
  14925.             }  
  14926.         }

  14928.         return this.isConnettoreHttp_urlHttps_cacheEnabled;
  14929.     }
  14930.     
  14931.     private Integer getConnettoreHttp_urlHttps_cacheSize = null;
  14932.     public int getConnettoreHttp_urlHttps_cacheSize() { 
  14933.         if(this.getConnettoreHttp_urlHttps_cacheSize==null){
  14934.             try{ 
  14935.                 String name = null;
  14936.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.http.urlHttps.cache.size");
  14937.                 if(name!=null){
  14938.                     name = name.trim();
  14939.                     this.getConnettoreHttp_urlHttps_cacheSize = java.lang.Integer.parseInt(name);
  14940.                 }else{
  14941.                     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);
  14942.                     this.getConnettoreHttp_urlHttps_cacheSize = CostantiPdD.CONNETTORE_HTTP_URL_HTTPS_CACHE_SIZE;
  14943.                 }
  14944.             }catch(java.lang.Exception e) {
  14945.                 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);
  14946.                 this.getConnettoreHttp_urlHttps_cacheSize = CostantiPdD.CONNETTORE_HTTP_URL_HTTPS_CACHE_SIZE;
  14947.             }  
  14948.         }

  14950.         return this.getConnettoreHttp_urlHttps_cacheSize;
  14951.     }
  14952.     
  14953.     
  14954.     
  14955.     
  14956.     /* ***************** Servizi HTTP  ************* */
  14957.     
  14958.     private Boolean isHttpDisableKeepAlive = null;
  14959.     public boolean isHttpDisableKeepAlive() {   
  14960.         String pName = "org.openspcoop2.pdd.services.http.disableKeepAlive";
  14961.         if(this.isHttpDisableKeepAlive==null){
  14962.             try{ 
  14963.                 String name = null;
  14964.                 name = this.reader.getValueConvertEnvProperties(pName);
  14965.                 if(name!=null){
  14966.                     name = name.trim();
  14967.                     this.isHttpDisableKeepAlive = Boolean.parseBoolean(name);
  14968.                 }else{
  14969.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  14970.                     this.isHttpDisableKeepAlive = false;
  14971.                 }
  14972.             }catch(java.lang.Exception e) {
  14973.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  14974.                 this.isHttpDisableKeepAlive = false;
  14975.             }  
  14976.         }

  14978.         return this.isHttpDisableKeepAlive;
  14979.     }
  14980.     
  14981.     private Boolean serviceRequestHttpMethodPatchEnabled = null;
  14982.     public boolean isServiceRequestHttpMethodPatchEnabled() {   
  14983.         if(this.serviceRequestHttpMethodPatchEnabled==null){
  14984.             try{ 
  14985.                 String name = null;
  14986.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.request.method.PATCH");
  14987.                 if(name!=null){
  14988.                     name = name.trim();
  14989.                     this.serviceRequestHttpMethodPatchEnabled = Boolean.parseBoolean(name);
  14990.                 }else{
  14991.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.PATCH' non impostata, viene utilizzato il default="+true);
  14992.                     this.serviceRequestHttpMethodPatchEnabled = true;
  14993.                 }
  14994.             }catch(java.lang.Exception e) {
  14995.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.PATCH' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
  14996.                 this.serviceRequestHttpMethodPatchEnabled = true;
  14997.             }  
  14998.         }

  15000.         return this.serviceRequestHttpMethodPatchEnabled;
  15001.     }
  15002.     
  15003.     private Boolean serviceRequestHttpMethodLinkEnabled = null;
  15004.     public boolean isServiceRequestHttpMethodLinkEnabled() {    
  15005.         if(this.serviceRequestHttpMethodLinkEnabled==null){
  15006.             try{ 
  15007.                 String name = null;
  15008.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.request.method.LINK");
  15009.                 if(name!=null){
  15010.                     name = name.trim();
  15011.                     this.serviceRequestHttpMethodLinkEnabled = Boolean.parseBoolean(name);
  15012.                 }else{
  15013.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.LINK' non impostata, viene utilizzato il default="+true);
  15014.                     this.serviceRequestHttpMethodLinkEnabled = true;
  15015.                 }
  15016.             }catch(java.lang.Exception e) {
  15017.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.LINK' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
  15018.                 this.serviceRequestHttpMethodLinkEnabled = true;
  15019.             }  
  15020.         }

  15022.         return this.serviceRequestHttpMethodLinkEnabled;
  15023.     }
  15024.     
  15025.     private Boolean serviceRequestHttpMethodUnlinkEnabled = null;
  15026.     public boolean isServiceRequestHttpMethodUnlinkEnabled() {  
  15027.         if(this.serviceRequestHttpMethodUnlinkEnabled==null){
  15028.             try{ 
  15029.                 String name = null;
  15030.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.request.method.UNLINK");
  15031.                 if(name!=null){
  15032.                     name = name.trim();
  15033.                     this.serviceRequestHttpMethodUnlinkEnabled = Boolean.parseBoolean(name);
  15034.                 }else{
  15035.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.UNLINK' non impostata, viene utilizzato il default="+true);
  15036.                     this.serviceRequestHttpMethodUnlinkEnabled = true;
  15037.                 }
  15038.             }catch(java.lang.Exception e) {
  15039.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.UNLINK' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
  15040.                 this.serviceRequestHttpMethodUnlinkEnabled = true;
  15041.             }  
  15042.         }

  15044.         return this.serviceRequestHttpMethodUnlinkEnabled;
  15045.     }
  15046.     
  15047.     
  15048.     private TransferLengthModes readTransferLengthModes_ricezioneContenutiApplicativi = null;
  15049.     public TransferLengthModes getTransferLengthModes_ricezioneContenutiApplicativi() { 
  15050.         if(this.readTransferLengthModes_ricezioneContenutiApplicativi==null){
  15051.             try{ 
  15052.                 String name = null;
  15053.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.httpTransferLength");
  15054.                 if(name!=null){
  15055.                     name = name.trim();
  15056.                     this.readTransferLengthModes_ricezioneContenutiApplicativi = TransferLengthModes.getTransferLengthModes(name);
  15057.                 }else{
  15058.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.WEBSERVER_DEFAULT);
  15059.                     this.readTransferLengthModes_ricezioneContenutiApplicativi = TransferLengthModes.WEBSERVER_DEFAULT;
  15060.                 }
  15061.             }catch(java.lang.Exception e) {
  15062.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.WEBSERVER_DEFAULT+", errore:"+e.getMessage(),e);
  15063.                 this.readTransferLengthModes_ricezioneContenutiApplicativi = TransferLengthModes.WEBSERVER_DEFAULT;
  15064.             }  
  15065.         }

  15067.         return this.readTransferLengthModes_ricezioneContenutiApplicativi;
  15068.     }
  15069.     
  15070.     private TransferLengthModes readTransferLengthModes_ricezioneBuste = null;
  15071.     public TransferLengthModes getTransferLengthModes_ricezioneBuste() {    
  15072.         if(this.readTransferLengthModes_ricezioneBuste==null){
  15073.             try{ 
  15074.                 String name = null;
  15075.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.httpTransferLength");
  15076.                 if(name!=null){
  15077.                     name = name.trim();
  15078.                     this.readTransferLengthModes_ricezioneBuste = TransferLengthModes.getTransferLengthModes(name);
  15079.                 }else{
  15080.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.WEBSERVER_DEFAULT);
  15081.                     this.readTransferLengthModes_ricezioneBuste = TransferLengthModes.WEBSERVER_DEFAULT;
  15082.                 }
  15083.             }catch(java.lang.Exception e) {
  15084.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.WEBSERVER_DEFAULT+", errore:"+e.getMessage(),e);
  15085.                 this.readTransferLengthModes_ricezioneBuste = TransferLengthModes.WEBSERVER_DEFAULT;
  15086.             }  
  15087.         }

  15089.         return this.readTransferLengthModes_ricezioneBuste;
  15090.     }
  15091.     
  15092.     private TransferLengthModes readTransferLengthModes_inoltroBuste = null;
  15093.     public TransferLengthModes getTransferLengthModes_inoltroBuste() {  
  15094.         if(this.readTransferLengthModes_inoltroBuste==null){
  15095.             try{ 
  15096.                 String name = null;
  15097.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength");
  15098.                 if(name!=null){
  15099.                     name = name.trim();
  15100.                     this.readTransferLengthModes_inoltroBuste = TransferLengthModes.getTransferLengthModes(name);
  15101.                 }else{
  15102.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.CONTENT_LENGTH);
  15103.                     this.readTransferLengthModes_inoltroBuste = TransferLengthModes.CONTENT_LENGTH;
  15104.                 }
  15105.             }catch(java.lang.Exception e) {
  15106.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.CONTENT_LENGTH+", errore:"+e.getMessage(),e);
  15107.                 this.readTransferLengthModes_inoltroBuste = TransferLengthModes.CONTENT_LENGTH;
  15108.             }  
  15109.         }

  15111.         return this.readTransferLengthModes_inoltroBuste;
  15112.     }
  15113.     
  15114.     private Integer getChunkLength_inoltroBuste = null;
  15115.     public int getChunkLength_inoltroBuste() {  
  15116.         if(this.getChunkLength_inoltroBuste==null){
  15117.             try{ 
  15118.                 String name = null;
  15119.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength.chunkLength");
  15120.                 if(name!=null){
  15121.                     name = name.trim();
  15122.                     this.getChunkLength_inoltroBuste = Integer.parseInt(name);
  15123.                 }else{
  15124.                     int DEFAULT_CHUNKLEN = 0;
  15125.                     this.getChunkLength_inoltroBuste = DEFAULT_CHUNKLEN;
  15126.                 }
  15127.             }catch(java.lang.Exception e) {
  15128.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength.chunkLength' posside un valore non corretto:"+e.getMessage(),e);
  15129.                 this.getChunkLength_inoltroBuste = -1;
  15130.             }  
  15131.         }

  15133.         return this.getChunkLength_inoltroBuste;
  15134.     }
  15135.     
  15136.     private TransferLengthModes readTransferLengthModes_consegnaContenutiApplicativi = null;
  15137.     public TransferLengthModes getTransferLengthModes_consegnaContenutiApplicativi() {  
  15138.         if(this.readTransferLengthModes_consegnaContenutiApplicativi==null){
  15139.             try{ 
  15140.                 String name = null;
  15141.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength");
  15142.                 if(name!=null){
  15143.                     name = name.trim();
  15144.                     this.readTransferLengthModes_consegnaContenutiApplicativi = TransferLengthModes.getTransferLengthModes(name);
  15145.                 }else{
  15146.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.CONTENT_LENGTH);
  15147.                     this.readTransferLengthModes_consegnaContenutiApplicativi = TransferLengthModes.CONTENT_LENGTH;
  15148.                 }
  15149.             }catch(java.lang.Exception e) {
  15150.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.CONTENT_LENGTH+", errore:"+e.getMessage(),e);
  15151.                 this.readTransferLengthModes_consegnaContenutiApplicativi = TransferLengthModes.CONTENT_LENGTH;
  15152.             }  
  15153.         }

  15155.         return this.readTransferLengthModes_consegnaContenutiApplicativi;
  15156.     }
  15157.     
  15158.     private Integer getChunkLength_consegnaContenutiApplicativi = null;
  15159.     public int getChunkLength_consegnaContenutiApplicativi() {  
  15160.         if(this.getChunkLength_consegnaContenutiApplicativi==null){
  15161.             try{ 
  15162.                 String name = null;
  15163.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength.chunkLength");
  15164.                 if(name!=null){
  15165.                     name = name.trim();
  15166.                     this.getChunkLength_consegnaContenutiApplicativi = Integer.parseInt(name);
  15167.                 }else{
  15168.                     int DEFAULT_CHUNKLEN = 0;
  15169.                     this.getChunkLength_consegnaContenutiApplicativi = DEFAULT_CHUNKLEN;
  15170.                 }
  15171.             }catch(java.lang.Exception e) {
  15172.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength.chunkLength' posside un valore non corretto:"+e.getMessage(),e);
  15173.                 this.getChunkLength_consegnaContenutiApplicativi = -1;
  15174.             }  
  15175.         }

  15177.         return this.getChunkLength_consegnaContenutiApplicativi;
  15178.     }
  15179.     
  15180.     private Boolean isAcceptOnlyReturnCode_200_202_inoltroBuste = null;
  15181.     public boolean isAcceptOnlyReturnCode_200_202_inoltroBuste() {  
  15182.         if(this.isAcceptOnlyReturnCode_200_202_inoltroBuste==null){
  15183.             try{ 
  15184.                 String name = null;
  15185.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.2xx.acceptOnly_202_200");
  15186.                 if(name!=null){
  15187.                     name = name.trim();
  15188.                     this.isAcceptOnlyReturnCode_200_202_inoltroBuste = Boolean.parseBoolean(name);
  15189.                 }else{
  15190.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.2xx.acceptOnly_202_200' non impostata, viene utilizzato il default=true");
  15191.                     this.isAcceptOnlyReturnCode_200_202_inoltroBuste = true;
  15192.                 }
  15193.             }catch(java.lang.Exception e) {
  15194.                 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);
  15195.                 this.isAcceptOnlyReturnCode_200_202_inoltroBuste = true;
  15196.             }  
  15197.         }

  15199.         return this.isAcceptOnlyReturnCode_200_202_inoltroBuste;
  15200.     }
  15201.     
  15202.     private Boolean isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi = null;
  15203.     public boolean isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi() {  
  15204.         if(this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi==null){
  15205.             try{ 
  15206.                 String name = null;
  15207.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.2xx.acceptOnly_202_200");
  15208.                 if(name!=null){
  15209.                     name = name.trim();
  15210.                     this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
  15211.                 }else{
  15212.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.2xx.acceptOnly_202_200' non impostata, viene utilizzato il default=true");
  15213.                     this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi = true;
  15214.                 }
  15215.             }catch(java.lang.Exception e) {
  15216.                 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);
  15217.                 this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi = true;
  15218.             }  
  15219.         }

  15221.         return this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi;
  15222.     }
  15223.     
  15224.     private Boolean isAcceptOnlyReturnCode_307_inoltroBuste = null;
  15225.     public boolean isAcceptOnlyReturnCode_307_inoltroBuste() {  
  15226.         if(this.isAcceptOnlyReturnCode_307_inoltroBuste==null){
  15227.             try{ 
  15228.                 String name = null;
  15229.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.3xx.acceptOnly_307");
  15230.                 if(name!=null){
  15231.                     name = name.trim();
  15232.                     this.isAcceptOnlyReturnCode_307_inoltroBuste = Boolean.parseBoolean(name);
  15233.                 }else{
  15234.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.3xx.acceptOnly_307' non impostata, viene utilizzato il default=false");
  15235.                     this.isAcceptOnlyReturnCode_307_inoltroBuste = false;
  15236.                 }
  15237.             }catch(java.lang.Exception e) {
  15238.                 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);
  15239.                 this.isAcceptOnlyReturnCode_307_inoltroBuste = false;
  15240.             }  
  15241.         }

  15243.         return this.isAcceptOnlyReturnCode_307_inoltroBuste;
  15244.     }
  15245.     
  15246.     private Boolean isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi = null;
  15247.     public boolean isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi() {  
  15248.         if(this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi==null){
  15249.             try{ 
  15250.                 String name = null;
  15251.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.3xx.acceptOnly_307");
  15252.                 if(name!=null){
  15253.                     name = name.trim();
  15254.                     this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
  15255.                 }else{
  15256.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.3xx.acceptOnly_307' non impostata, viene utilizzato il default=false");
  15257.                     this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi = false;
  15258.                 }
  15259.             }catch(java.lang.Exception e) {
  15260.                 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);
  15261.                 this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi = false;
  15262.             }  
  15263.         }

  15265.         return this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi;
  15266.     }
  15267.     
  15268.     private Boolean isFollowRedirects_inoltroBuste_soap = null;
  15269.     public boolean isFollowRedirects_inoltroBuste_soap() {  
  15270.         if(this.isFollowRedirects_inoltroBuste_soap==null){
  15271.             try{ 
  15272.                 String name = null;
  15273.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.soap");
  15274.                 if(name!=null){
  15275.                     name = name.trim();
  15276.                     this.isFollowRedirects_inoltroBuste_soap = Boolean.parseBoolean(name);
  15277.                 }else{
  15278.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.soap' non impostata, viene utilizzato il default=false");
  15279.                     this.isFollowRedirects_inoltroBuste_soap = false;
  15280.                 }
  15281.             }catch(java.lang.Exception e) {
  15282.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.soap' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  15283.                 this.isFollowRedirects_inoltroBuste_soap = false;
  15284.             }  
  15285.         }

  15287.         return this.isFollowRedirects_inoltroBuste_soap;
  15288.     }
  15289.     
  15290.     private Boolean isFollowRedirects_inoltroBuste_rest = null;
  15291.     public boolean isFollowRedirects_inoltroBuste_rest() {  
  15292.         if(this.isFollowRedirects_inoltroBuste_rest==null){
  15293.             try{ 
  15294.                 String name = null;
  15295.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.rest");
  15296.                 if(name!=null){
  15297.                     name = name.trim();
  15298.                     this.isFollowRedirects_inoltroBuste_rest = Boolean.parseBoolean(name);
  15299.                 }else{
  15300.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.rest' non impostata, viene utilizzato il default=false");
  15301.                     this.isFollowRedirects_inoltroBuste_rest = false;
  15302.                 }
  15303.             }catch(java.lang.Exception e) {
  15304.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.rest' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  15305.                 this.isFollowRedirects_inoltroBuste_rest = false;
  15306.             }  
  15307.         }

  15309.         return this.isFollowRedirects_inoltroBuste_rest;
  15310.     }
  15311.     

  15313.     
  15314.     private Boolean isFollowRedirects_consegnaContenutiApplicativi_soap = null;
  15315.     public boolean isFollowRedirects_consegnaContenutiApplicativi_soap() {  
  15316.         if(this.isFollowRedirects_consegnaContenutiApplicativi_soap==null){
  15317.             try{ 
  15318.                 String name = null;
  15319.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.soap");
  15320.                 if(name!=null){
  15321.                     name = name.trim();
  15322.                     this.isFollowRedirects_consegnaContenutiApplicativi_soap = Boolean.parseBoolean(name);
  15323.                 }else{
  15324.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.soap' non impostata, viene utilizzato il default=false");
  15325.                     this.isFollowRedirects_consegnaContenutiApplicativi_soap = false;
  15326.                 }
  15327.             }catch(java.lang.Exception e) {
  15328.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.soap' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  15329.                 this.isFollowRedirects_consegnaContenutiApplicativi_soap = false;
  15330.             }  
  15331.         }

  15333.         return this.isFollowRedirects_consegnaContenutiApplicativi_soap;
  15334.     }
  15335.     
  15336.     private Boolean isFollowRedirects_consegnaContenutiApplicativi_rest = null;
  15337.     public boolean isFollowRedirects_consegnaContenutiApplicativi_rest() {  
  15338.         if(this.isFollowRedirects_consegnaContenutiApplicativi_rest==null){
  15339.             try{ 
  15340.                 String name = null;
  15341.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.rest");
  15342.                 if(name!=null){
  15343.                     name = name.trim();
  15344.                     this.isFollowRedirects_consegnaContenutiApplicativi_rest = Boolean.parseBoolean(name);
  15345.                 }else{
  15346.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.rest' non impostata, viene utilizzato il default=false");
  15347.                     this.isFollowRedirects_consegnaContenutiApplicativi_rest = false;
  15348.                 }
  15349.             }catch(java.lang.Exception e) {
  15350.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.rest' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  15351.                 this.isFollowRedirects_consegnaContenutiApplicativi_rest = false;
  15352.             }  
  15353.         }

  15355.         return this.isFollowRedirects_consegnaContenutiApplicativi_rest;
  15356.     }
  15357.         
  15358.     private Integer getFollowRedirectsMaxHop_inoltroBuste = null;
  15359.     public int getFollowRedirectsMaxHop_inoltroBuste() {    
  15360.         if(this.getFollowRedirectsMaxHop_inoltroBuste==null){
  15361.             try{ 
  15362.                 String name = null;
  15363.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.maxHop");
  15364.                 if(name!=null){
  15365.                     name = name.trim();
  15366.                     this.getFollowRedirectsMaxHop_inoltroBuste = Integer.parseInt(name);
  15367.                 }else{
  15368.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.maxHop' non impostata, viene utilizzato il default=5");
  15369.                     this.getFollowRedirectsMaxHop_inoltroBuste = 5;
  15370.                 }
  15371.             }catch(java.lang.Exception e) {
  15372.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.maxHop' non impostata, viene utilizzato il default=5, errore:"+e.getMessage(),e);
  15373.                 this.getFollowRedirectsMaxHop_inoltroBuste = 5;
  15374.             }  
  15375.         }

  15377.         return this.getFollowRedirectsMaxHop_inoltroBuste;
  15378.     }
  15379.     
  15380.     private Integer getFollowRedirectsMaxHop_consegnaContenutiApplicativi = null;
  15381.     public int getFollowRedirectsMaxHop_consegnaContenutiApplicativi() {    
  15382.         if(this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi==null){
  15383.             try{ 
  15384.                 String name = null;
  15385.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.maxHop");
  15386.                 if(name!=null){
  15387.                     name = name.trim();
  15388.                     this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi = Integer.parseInt(name);
  15389.                 }else{
  15390.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.maxHop' non impostata, viene utilizzato il default=5");
  15391.                     this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi = 5;
  15392.                 }
  15393.             }catch(java.lang.Exception e) {
  15394.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.maxHop' non impostata, viene utilizzato il default=5, errore:"+e.getMessage(),e);
  15395.                 this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi = 5;
  15396.             }  
  15397.         }

  15399.         return this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi;
  15400.     }

  15402.     
  15403.     private Boolean checkSoapActionQuotedString_ricezioneContenutiApplicativi = null;
  15404.     public boolean checkSoapActionQuotedString_ricezioneContenutiApplicativi() {    
  15405.         if(this.checkSoapActionQuotedString_ricezioneContenutiApplicativi==null){
  15406.             try{ 
  15407.                 String name = null;
  15408.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.soapAction.checkQuotedString");
  15409.                 if(name!=null){
  15410.                     name = name.trim();
  15411.                     this.checkSoapActionQuotedString_ricezioneContenutiApplicativi = Boolean.parseBoolean(name);
  15412.                 }else{
  15413.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.soapAction.checkQuotedString' non impostata, viene utilizzato il default=false");
  15414.                     this.checkSoapActionQuotedString_ricezioneContenutiApplicativi = false;
  15415.                 }
  15416.             }catch(java.lang.Exception e) {
  15417.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.soapAction.checkQuotedString' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  15418.                 this.checkSoapActionQuotedString_ricezioneContenutiApplicativi = false;
  15419.             }  
  15420.         }

  15422.         return this.checkSoapActionQuotedString_ricezioneContenutiApplicativi;
  15423.     }
  15424.     
  15425.     private Boolean checkSoapActionQuotedString_ricezioneBuste = null;
  15426.     public boolean checkSoapActionQuotedString_ricezioneBuste() {   
  15427.         if(this.checkSoapActionQuotedString_ricezioneBuste==null){
  15428.             try{ 
  15429.                 String name = null;
  15430.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.soapAction.checkQuotedString");
  15431.                 if(name!=null){
  15432.                     name = name.trim();
  15433.                     this.checkSoapActionQuotedString_ricezioneBuste = Boolean.parseBoolean(name);
  15434.                 }else{
  15435.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.soapAction.checkQuotedString' non impostata, viene utilizzato il default=false");
  15436.                     this.checkSoapActionQuotedString_ricezioneBuste = false;
  15437.                 }
  15438.             }catch(java.lang.Exception e) {
  15439.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.soapAction.checkQuotedString' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  15440.                 this.checkSoapActionQuotedString_ricezioneBuste = false;
  15441.             }  
  15442.         }

  15444.         return this.checkSoapActionQuotedString_ricezioneBuste;
  15445.     }
  15446.     
  15447.     private String httpUserAgent = null;
  15448.     public String getHttpUserAgent() {  
  15449.         if(this.httpUserAgent==null){
  15450.             try{ 
  15451.                 String name = null;
  15452.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.http.userAgent");
  15453.                 if(name!=null){
  15454.                     name = name.trim();
  15455.                     this.httpUserAgent = name;
  15456.                 }else{
  15457.                     /**NON EMETTO WARNING: this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.userAgent' non impostata, viene utilizzato il default="+Costanti.OPENSPCOOP_PRODUCT_VERSION);*/
  15458.                     this.httpUserAgent = this.getProductName();
  15459.                 }
  15460.             }catch(java.lang.Exception e) {
  15461.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.userAgent' non impostata, viene utilizzato il default="+this.getProductName()+", errore:"+e.getMessage(),e);
  15462.                 this.httpUserAgent = this.getProductName();
  15463.             }  
  15464.         }

  15466.         return this.httpUserAgent;
  15467.     }
  15468.     
  15469.     private String httpServer = null;
  15470.     public String getHttpServer() { 
  15471.         if(this.httpServer==null){
  15472.             try{ 
  15473.                 String name = null;
  15474.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.http.xPdd");
  15475.                 if(name!=null){
  15476.                     name = name.trim();
  15477.                     this.httpServer = name;
  15478.                 }else{
  15479.                     /**NON EMETTO WARNING: this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.xPdd' non impostata, viene utilizzato il default="+this.getHttpUserAgent());*/
  15480.                     this.httpServer = this.getVersione();
  15481.                 }
  15482.             }catch(java.lang.Exception e) {
  15483.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.xPdd' non impostata, viene utilizzato il default="+this.getVersione()+", errore:"+e.getMessage(),e);
  15484.                 this.httpServer = this.getVersione();
  15485.             }  
  15486.         }

  15488.         return this.httpServer;
  15489.     }
  15490.     
  15491.     private Boolean readHttpXPdDDetails = null;
  15492.     private String httpXPdDDetails = null;
  15493.     public String getHttpXPdDDetails() {    
  15494.         if(this.readHttpXPdDDetails==null){
  15495.             try{ 
  15496.                 String name = null;
  15497.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.http.xDetails");
  15498.                 if(name!=null){
  15499.                     name = name.trim();
  15500.                     this.httpXPdDDetails = name;
  15501.                 }else{
  15502.                     this.httpXPdDDetails = this.getDetails();
  15503.                 }
  15504.             }catch(java.lang.Exception e) {
  15505.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.xDetails' non impostata correttamente:"+e.getMessage(),e);
  15506.                 this.httpXPdDDetails = this.getDetails();
  15507.             }  
  15508.         }
  15509.         this.readHttpXPdDDetails = true;

  15511.         return this.httpXPdDDetails;
  15512.     }
  15513.     
  15514.     
  15515.     private Boolean isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = null;
  15516.     public boolean isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi() { 
  15517.         if(this.isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi==null){
  15518.             try{ 
  15519.                 String name = null;
  15520.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.enabled");
  15521.                 if(name!=null){
  15522.                     name = name.trim();
  15523.                     this.isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = Boolean.parseBoolean(name);
  15524.                 }else{
  15525.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true");
  15526.                     this.isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = true;
  15527.                 }
  15528.             }catch(java.lang.Exception e) {
  15529.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15530.                 this.isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = true;
  15531.             }  
  15532.         }

  15534.         return this.isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi;
  15535.     }
  15536.     
  15537.     private Charset getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = null;
  15538.     public Charset getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi() {    
  15539.         if(this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi==null){
  15540.             try{ 
  15541.                 String name = null;
  15542.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.charset");
  15543.                 if(name!=null){
  15544.                     name = name.trim();
  15545.                     this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = Charset.toEnumConstant(name);
  15546.                     if(this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi==null){
  15547.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15548.                     }
  15549.                 }else{
  15550.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name());
  15551.                     this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = Charset.US_ASCII;
  15552.                 }
  15553.             }catch(java.lang.Exception e) {
  15554.                 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);
  15555.                 this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = Charset.US_ASCII;
  15556.             }  
  15557.         }

  15559.         return this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi;
  15560.     }
  15561.     
  15562.     private RFC2047Encoding getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = null;
  15563.     public RFC2047Encoding getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi() {   
  15564.         if(this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi==null){
  15565.             try{ 
  15566.                 String name = null;
  15567.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.encoding");
  15568.                 if(name!=null){
  15569.                     name = name.trim();
  15570.                     this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = RFC2047Encoding.valueOf(name);
  15571.                     if(this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi==null){
  15572.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15573.                     }
  15574.                 }else{
  15575.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name());
  15576.                     this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = RFC2047Encoding.Q;
  15577.                 }
  15578.             }catch(java.lang.Exception e) {
  15579.                 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);
  15580.                 this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = RFC2047Encoding.Q;
  15581.             }  
  15582.         }

  15584.         return this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi;
  15585.     }
  15586.     
  15587.     private Boolean isEnabledEncodingRFC2047HeaderValueRicezioneBuste = null;
  15588.     public boolean isEnabledEncodingRFC2047HeaderValueRicezioneBuste() {    
  15589.         if(this.isEnabledEncodingRFC2047HeaderValueRicezioneBuste==null){
  15590.             try{ 
  15591.                 String name = null;
  15592.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.enabled");
  15593.                 if(name!=null){
  15594.                     name = name.trim();
  15595.                     this.isEnabledEncodingRFC2047HeaderValueRicezioneBuste = Boolean.parseBoolean(name);
  15596.                 }else{
  15597.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true");
  15598.                     this.isEnabledEncodingRFC2047HeaderValueRicezioneBuste = true;
  15599.                 }
  15600.             }catch(java.lang.Exception e) {
  15601.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15602.                 this.isEnabledEncodingRFC2047HeaderValueRicezioneBuste = true;
  15603.             }  
  15604.         }

  15606.         return this.isEnabledEncodingRFC2047HeaderValueRicezioneBuste;
  15607.     }
  15608.     
  15609.     private Charset getCharsetEncodingRFC2047HeaderValueRicezioneBuste = null;
  15610.     public Charset getCharsetEncodingRFC2047HeaderValueRicezioneBuste() {   
  15611.         if(this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste==null){
  15612.             try{ 
  15613.                 String name = null;
  15614.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.charset");
  15615.                 if(name!=null){
  15616.                     name = name.trim();
  15617.                     this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste = Charset.toEnumConstant(name);
  15618.                     if(this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste==null){
  15619.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15620.                     }
  15621.                 }else{
  15622.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name());
  15623.                     this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste = Charset.US_ASCII;
  15624.                 }
  15625.             }catch(java.lang.Exception e) {
  15626.                 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);
  15627.                 this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste = Charset.US_ASCII;
  15628.             }  
  15629.         }

  15631.         return this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste;
  15632.     }
  15633.     
  15634.     private RFC2047Encoding getEncodingRFC2047HeaderValueRicezioneBuste = null;
  15635.     public RFC2047Encoding getEncodingRFC2047HeaderValueRicezioneBuste() {  
  15636.         if(this.getEncodingRFC2047HeaderValueRicezioneBuste==null){
  15637.             try{ 
  15638.                 String name = null;
  15639.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.encoding");
  15640.                 if(name!=null){
  15641.                     name = name.trim();
  15642.                     this.getEncodingRFC2047HeaderValueRicezioneBuste = RFC2047Encoding.valueOf(name);
  15643.                     if(this.getEncodingRFC2047HeaderValueRicezioneBuste==null){
  15644.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15645.                     }
  15646.                 }else{
  15647.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name());
  15648.                     this.getEncodingRFC2047HeaderValueRicezioneBuste = RFC2047Encoding.Q;
  15649.                 }
  15650.             }catch(java.lang.Exception e) {
  15651.                 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);
  15652.                 this.getEncodingRFC2047HeaderValueRicezioneBuste = RFC2047Encoding.Q;
  15653.             }  
  15654.         }

  15656.         return this.getEncodingRFC2047HeaderValueRicezioneBuste;
  15657.     }
  15658.     
  15659.     private Boolean isEnabledEncodingRFC2047HeaderValueInoltroBuste = null;
  15660.     public boolean isEnabledEncodingRFC2047HeaderValueInoltroBuste() {  
  15661.         if(this.isEnabledEncodingRFC2047HeaderValueInoltroBuste==null){
  15662.             try{ 
  15663.                 String name = null;
  15664.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.enabled");
  15665.                 if(name!=null){
  15666.                     name = name.trim();
  15667.                     this.isEnabledEncodingRFC2047HeaderValueInoltroBuste = Boolean.parseBoolean(name);
  15668.                 }else{
  15669.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true");
  15670.                     this.isEnabledEncodingRFC2047HeaderValueInoltroBuste = true;
  15671.                 }
  15672.             }catch(java.lang.Exception e) {
  15673.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15674.                 this.isEnabledEncodingRFC2047HeaderValueInoltroBuste = true;
  15675.             }  
  15676.         }

  15678.         return this.isEnabledEncodingRFC2047HeaderValueInoltroBuste;
  15679.     }
  15680.     
  15681.     private Charset getCharsetEncodingRFC2047HeaderValueInoltroBuste = null;
  15682.     public Charset getCharsetEncodingRFC2047HeaderValueInoltroBuste() { 
  15683.         if(this.getCharsetEncodingRFC2047HeaderValueInoltroBuste==null){
  15684.             try{ 
  15685.                 String name = null;
  15686.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.charset");
  15687.                 if(name!=null){
  15688.                     name = name.trim();
  15689.                     this.getCharsetEncodingRFC2047HeaderValueInoltroBuste = Charset.toEnumConstant(name);
  15690.                     if(this.getCharsetEncodingRFC2047HeaderValueInoltroBuste==null){
  15691.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15692.                     }
  15693.                 }else{
  15694.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name());
  15695.                     this.getCharsetEncodingRFC2047HeaderValueInoltroBuste = Charset.US_ASCII;
  15696.                 }
  15697.             }catch(java.lang.Exception e) {
  15698.                 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);
  15699.                 this.getCharsetEncodingRFC2047HeaderValueInoltroBuste = Charset.US_ASCII;
  15700.             }  
  15701.         }

  15703.         return this.getCharsetEncodingRFC2047HeaderValueInoltroBuste;
  15704.     }
  15705.     
  15706.     private RFC2047Encoding getEncodingRFC2047HeaderValueInoltroBuste = null;
  15707.     public RFC2047Encoding getEncodingRFC2047HeaderValueInoltroBuste() {    
  15708.         if(this.getEncodingRFC2047HeaderValueInoltroBuste==null){
  15709.             try{ 
  15710.                 String name = null;
  15711.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.encoding");
  15712.                 if(name!=null){
  15713.                     name = name.trim();
  15714.                     this.getEncodingRFC2047HeaderValueInoltroBuste = RFC2047Encoding.valueOf(name);
  15715.                     if(this.getEncodingRFC2047HeaderValueInoltroBuste==null){
  15716.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15717.                     }
  15718.                 }else{
  15719.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name());
  15720.                     this.getEncodingRFC2047HeaderValueInoltroBuste = RFC2047Encoding.Q;
  15721.                 }
  15722.             }catch(java.lang.Exception e) {
  15723.                 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);
  15724.                 this.getEncodingRFC2047HeaderValueInoltroBuste = RFC2047Encoding.Q;
  15725.             }  
  15726.         }

  15728.         return this.getEncodingRFC2047HeaderValueInoltroBuste;
  15729.     }
  15730.     
  15731.     private Boolean isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = null;
  15732.     public boolean isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi() {  
  15733.         if(this.isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi==null){
  15734.             try{ 
  15735.                 String name = null;
  15736.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.enabled");
  15737.                 if(name!=null){
  15738.                     name = name.trim();
  15739.                     this.isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = Boolean.parseBoolean(name);
  15740.                 }else{
  15741.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true");
  15742.                     this.isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = true;
  15743.                 }
  15744.             }catch(java.lang.Exception e) {
  15745.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15746.                 this.isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = true;
  15747.             }  
  15748.         }

  15750.         return this.isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi;
  15751.     }
  15752.     
  15753.     private Charset getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = null;
  15754.     public Charset getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi() { 
  15755.         if(this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi==null){
  15756.             try{ 
  15757.                 String name = null;
  15758.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.charset");
  15759.                 if(name!=null){
  15760.                     name = name.trim();
  15761.                     this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = Charset.toEnumConstant(name);
  15762.                     if(this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi==null){
  15763.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15764.                     }
  15765.                 }else{
  15766.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name());
  15767.                     this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = Charset.US_ASCII;
  15768.                 }
  15769.             }catch(java.lang.Exception e) {
  15770.                 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);
  15771.                 this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = Charset.US_ASCII;
  15772.             }  
  15773.         }

  15775.         return this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi;
  15776.     }
  15777.     
  15778.     private RFC2047Encoding getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = null;
  15779.     public RFC2047Encoding getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi() {    
  15780.         if(this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi==null){
  15781.             try{ 
  15782.                 String name = null;
  15783.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.encoding");
  15784.                 if(name!=null){
  15785.                     name = name.trim();
  15786.                     this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = RFC2047Encoding.valueOf(name);
  15787.                     if(this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi==null){
  15788.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15789.                     }
  15790.                 }else{
  15791.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name());
  15792.                     this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = RFC2047Encoding.Q;
  15793.                 }
  15794.             }catch(java.lang.Exception e) {
  15795.                 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);
  15796.                 this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = RFC2047Encoding.Q;
  15797.             }  
  15798.         }

  15800.         return this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi;
  15801.     }
  15802.     

  15804.     private Boolean isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi = null;
  15805.     public boolean isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi() {  
  15806.         if(this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi==null){
  15807.             try{ 
  15808.                 String name = null;
  15809.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerNameValue.validazione.enabled");
  15810.                 if(name!=null){
  15811.                     name = name.trim();
  15812.                     this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi = Boolean.parseBoolean(name);
  15813.                 }else{
  15814.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true");
  15815.                     this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi = true;
  15816.                 }
  15817.             }catch(java.lang.Exception e) {
  15818.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15819.                 this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi = true;
  15820.             }  
  15821.         }

  15823.         return this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi;
  15824.     }
  15825.     
  15826.     private Boolean isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste = null;
  15827.     public boolean isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste() { 
  15828.         if(this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste==null){
  15829.             try{ 
  15830.                 String name = null;
  15831.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.headerNameValue.validazione.enabled");
  15832.                 if(name!=null){
  15833.                     name = name.trim();
  15834.                     this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste = Boolean.parseBoolean(name);
  15835.                 }else{
  15836.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true");
  15837.                     this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste = true;
  15838.                 }
  15839.             }catch(java.lang.Exception e) {
  15840.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15841.                 this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste = true;
  15842.             }  
  15843.         }

  15845.         return this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste;
  15846.     }
  15847.     
  15848.     private Boolean isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste = null;
  15849.     public boolean isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste() {   
  15850.         if(this.isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste==null){
  15851.             try{ 
  15852.                 String name = null;
  15853.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.headerNameValue.validazione.enabled");
  15854.                 if(name!=null){
  15855.                     name = name.trim();
  15856.                     this.isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste = Boolean.parseBoolean(name);
  15857.                 }else{
  15858.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true");
  15859.                     this.isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste = true;
  15860.                 }
  15861.             }catch(java.lang.Exception e) {
  15862.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15863.                 this.isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste = true;
  15864.             }  
  15865.         }

  15867.         return this.isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste;
  15868.     }
  15869.     
  15870.     private Boolean isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi = null;
  15871.     public boolean isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi() {   
  15872.         if(this.isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi==null){
  15873.             try{ 
  15874.                 String name = null;
  15875.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerNameValue.validazione.enabled");
  15876.                 if(name!=null){
  15877.                     name = name.trim();
  15878.                     this.isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi = Boolean.parseBoolean(name);
  15879.                 }else{
  15880.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true");
  15881.                     this.isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi = true;
  15882.                 }
  15883.             }catch(java.lang.Exception e) {
  15884.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15885.                 this.isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi = true;
  15886.             }  
  15887.         }

  15889.         return this.isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi;
  15890.     }
  15891.     
  15892.     private Integer getGestioneCORS_returnCode_ricezioneContenutiApplicativi = null;
  15893.     public int getGestioneCORS_returnCode_ricezioneContenutiApplicativi() { 
  15894.         if(this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi==null){
  15895.             try{ 
  15896.                 String name = null;
  15897.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.cors.returnCode");
  15898.                 if(name!=null){
  15899.                     name = name.trim();
  15900.                     this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi = java.lang.Integer.parseInt(name);
  15901.                 }else{
  15902.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.cors.returnCode' non impostata, viene utilizzato il default="+CostantiPdD.GESTIONE_CORS_RETURN_CODE);
  15903.                     this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi = CostantiPdD.GESTIONE_CORS_RETURN_CODE;
  15904.                 }
  15905.             }catch(java.lang.Exception e) {
  15906.                 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);
  15907.                 this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi = CostantiPdD.GESTIONE_CORS_RETURN_CODE;
  15908.             }    
  15909.         }

  15911.         return this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi;
  15912.     }
  15913.     
  15914.     private Boolean isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi = null;
  15915.     public boolean isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi() { 
  15916.         if(this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi==null){
  15917.             String pName = "org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.cors.resourceHttpMethodQualsiasi";
  15918.             try{ 
  15919.                 String name = null;
  15920.                 name = this.reader.getValueConvertEnvProperties(pName);
  15921.                 if(name!=null){
  15922.                     name = name.trim();
  15923.                     this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi = java.lang.Boolean.valueOf(name);
  15924.                 }else{
  15925.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  15926.                     this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi = false;
  15927.                 }
  15928.             }catch(java.lang.Exception e) {
  15929.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  15930.                 this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi = false;
  15931.             }    
  15932.         }

  15934.         return this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi;
  15935.     }
  15936.     
  15937.     private Integer getGestioneCORS_returnCode_ricezioneBuste = null;
  15938.     public int getGestioneCORS_returnCode_ricezioneBuste() {    
  15939.         if(this.getGestioneCORS_returnCode_ricezioneBuste==null){
  15940.             try{ 
  15941.                 String name = null;
  15942.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.cors.returnCode");
  15943.                 if(name!=null){
  15944.                     name = name.trim();
  15945.                     this.getGestioneCORS_returnCode_ricezioneBuste = java.lang.Integer.parseInt(name);
  15946.                 }else{
  15947.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.cors.returnCode' non impostata, viene utilizzato il default="+CostantiPdD.GESTIONE_CORS_RETURN_CODE);
  15948.                     this.getGestioneCORS_returnCode_ricezioneBuste = CostantiPdD.GESTIONE_CORS_RETURN_CODE;
  15949.                 }
  15950.             }catch(java.lang.Exception e) {
  15951.                 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);
  15952.                 this.getGestioneCORS_returnCode_ricezioneBuste = CostantiPdD.GESTIONE_CORS_RETURN_CODE;
  15953.             }    
  15954.         }

  15956.         return this.getGestioneCORS_returnCode_ricezioneBuste;
  15957.     }
  15958.     
  15959.     private Boolean isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste = null;
  15960.     public boolean isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste() {    
  15961.         if(this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste==null){
  15962.             String pName = "org.openspcoop2.pdd.services.ricezioneBuste.cors.resourceHttpMethodQualsiasi";
  15963.             try{ 
  15964.                 String name = null;
  15965.                 name = this.reader.getValueConvertEnvProperties(pName);
  15966.                 if(name!=null){
  15967.                     name = name.trim();
  15968.                     this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste = java.lang.Boolean.valueOf(name);
  15969.                 }else{
  15970.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  15971.                     this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste = false;
  15972.                 }
  15973.             }catch(java.lang.Exception e) {
  15974.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  15975.                 this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste = false;
  15976.             }    
  15977.         }

  15979.         return this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste;
  15980.     }
  15981.     
  15982.     
  15983.     private ArchiveType getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType = null;
  15984.     public ArchiveType getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType() {    
  15985.         if(this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType==null){
  15986.             String pName = "org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.notificaRichiestaRisposta.archiveType";
  15987.             try{ 
  15988.                 String name = null;
  15989.                 name = this.reader.getValueConvertEnvProperties(pName);
  15990.                 if(name!=null){
  15991.                     name = name.trim();
  15992.                     this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType = ArchiveType.valueOf(name.toUpperCase());
  15993.                 }else{
  15994.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ArchiveType.ZIP.toString()));
  15995.                     this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType = ArchiveType.ZIP;
  15996.                 }
  15997.             }catch(java.lang.Exception e) {
  15998.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ArchiveType.ZIP.toString()),e);
  15999.                 this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType = ArchiveType.ZIP;
  16000.             }    
  16001.         }

  16003.         return this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType;
  16004.     }
  16005.     


  16008.     /* ***************** DATE ************* */
  16009.     /**
  16010.      * Restituisce il tipo di tempo da utilizzare
  16011.      *
  16012.      * @return il tipo di tempo da utilizzare
  16013.      * 
  16014.      */
  16015.     private TipoOraRegistrazione tipoTempo = null;
  16016.     public TipoOraRegistrazione getTipoTempoBusta(String implementazionePdDSoggetto) {
  16017.         
  16018.         // ovverriding per implementazione porta di dominio
  16019.         if(this.pddReader!=null){
  16020.             String tipo = this.pddReader.getBusta_TempoTipo(implementazionePdDSoggetto);
  16021.             if(tipo!=null && ( 
  16022.                     CostantiConfigurazione.TEMPO_TIPO_LOCALE.equalsIgnoreCase(tipo) || 
  16023.                     CostantiConfigurazione.TEMPO_TIPO_SINCRONIZZATO.equalsIgnoreCase(tipo)  ) 
  16024.             ){
  16025.                 if(CostantiConfigurazione.TEMPO_TIPO_LOCALE.equalsIgnoreCase(tipo))
  16026.                     return TipoOraRegistrazione.LOCALE;
  16027.                 else 
  16028.                     return TipoOraRegistrazione.SINCRONIZZATO;
  16029.             }
  16030.         }

  16032.         if(this.tipoTempo==null){
  16033.             try{ 
  16034.                 String name = null;
  16035.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.tempo.tipo");
  16036.                 if(name!=null){
  16037.                     name = name.trim();
  16038.                     if(CostantiConfigurazione.TEMPO_TIPO_LOCALE.equals(name))
  16039.                         this.tipoTempo = TipoOraRegistrazione.LOCALE;
  16040.                     else if(CostantiConfigurazione.TEMPO_TIPO_SINCRONIZZATO.equals(name))
  16041.                         this.tipoTempo = TipoOraRegistrazione.SINCRONIZZATO;
  16042.                     else
  16043.                         throw new CoreException("Tipo "+name+" non conosciuto");
  16044.                 }
  16045.                 else{
  16046.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.tempo.tipo' non impostata, viene utilizzato il default="+CostantiConfigurazione.TEMPO_TIPO_LOCALE);
  16047.                     this.tipoTempo = TipoOraRegistrazione.LOCALE;
  16048.                 }

  16050.             }catch(java.lang.Exception e) {
  16051.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.tempo.tipo' non impostata, viene utilizzato il default="+CostantiConfigurazione.TEMPO_TIPO_LOCALE+", errore:"+e.getMessage(),e);
  16052.                 this.tipoTempo = TipoOraRegistrazione.LOCALE;
  16053.             }    
  16054.         }

  16056.         return this.tipoTempo;
  16057.     }

  16059.     /**
  16060.      * Restituisce il tipo di Date da utilizzare
  16061.      *
  16062.      * @return il tipo di Date da utilizzare
  16063.      * 
  16064.      */
  16065.     private String tipoDateManager = null;
  16066.     public String getTipoDateManager() {    
  16067.         if(this.tipoDateManager==null){
  16068.             try{ 
  16069.                 String name = null;
  16070.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.date.tipo");
  16071.                 if(name!=null)
  16072.                     name = name.trim();
  16073.                 else
  16074.                     throw new CoreException(NON_DEFINITA);
  16075.                 this.tipoDateManager = name;
  16076.             }catch(java.lang.Exception e) {
  16077.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.date.tipo': "+e.getMessage(),e);
  16078.                 this.tipoDateManager = null;
  16079.             }    
  16080.         }

  16082.         return this.tipoDateManager;
  16083.     }
  16084.     
  16085.     private DateEngineType tipoDateTimeFormat = null;
  16086.     public DateEngineType getTipoDateTimeFormat() { 
  16087.         if(this.tipoDateTimeFormat==null){
  16088.             try{ 
  16089.                 String name = null;
  16090.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dateTimeFormat");
  16091.                 if(name!=null)
  16092.                     name = name.trim();
  16093.                 else
  16094.                     throw new CoreException(NON_DEFINITA);
  16095.                 this.tipoDateTimeFormat = DateEngineType.valueOf(name);
  16096.             }catch(java.lang.Exception e) {
  16097.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.dateTimeFormat': "+e.getMessage(),e);
  16098.                 this.tipoDateTimeFormat = null;
  16099.             }    
  16100.         }

  16102.         return this.tipoDateTimeFormat;
  16103.     }

  16105.     /**
  16106.      * Restituisce le proprieta' da utilizzare sul tipo di Date da utilizzare
  16107.      *
  16108.      * @return proprieta' da utilizzare sul tipo di Date da utilizzare
  16109.      * 
  16110.      */
  16111.     private java.util.Properties dateManagerProperties = null;
  16112.     public java.util.Properties getDateManagerProperties() {
  16113.         if(this.dateManagerProperties==null){
  16114.             java.util.Properties prop = new java.util.Properties();
  16115.             try{ 

  16117.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.date.property.");
  16118.                 this.dateManagerProperties = prop;

  16120.             }catch(java.lang.Exception e) {
  16121.                 this.logError("Riscontrato errore durante la lettura delle propriete' 'org.openspcoop2.pdd.date.property.*': "+e.getMessage(),e);
  16122.                 this.dateManagerProperties = null;
  16123.             }    
  16124.         }

  16126.         return this.dateManagerProperties;
  16127.     }








  16136.     /* ************** INTEGRATION MANAGER ****************** */

  16138.     private Boolean isIntegrationManagerEnabled = null;
  16139.     public boolean isIntegrationManagerEnabled() {  
  16140.         if(this.isIntegrationManagerEnabled==null){
  16141.             try{ 
  16142.                 String name = null;
  16143.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.enabled");
  16144.                 if(name==null){
  16145.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrationManager.enabled' non impostata, viene utilizzato il default=false");
  16146.                     name="false";
  16147.                 }
  16148.                 name = name.trim();
  16149.                 this.isIntegrationManagerEnabled = Boolean.parseBoolean(name);
  16150.             } catch(java.lang.Exception e) {
  16151.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrationManager.enabled': "+e.getMessage(),e);
  16152.                 this.isIntegrationManagerEnabled = false;
  16153.             }    
  16154.         }

  16156.         return this.isIntegrationManagerEnabled;
  16157.     }
  16158.     
  16159.     private Boolean isIntegrationManagerIdWithDate = null;
  16160.     public boolean isIntegrationManagerIdWithDate() {   
  16161.         if(this.isIntegrationManagerIdWithDate==null){
  16162.             try{ 
  16163.                 String name = null;
  16164.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.idWithDate");
  16165.                 if(name==null){
  16166.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrationManager.idWithDate' non impostata, viene utilizzato il default=false");
  16167.                     name="false";
  16168.                 }
  16169.                 name = name.trim();
  16170.                 this.isIntegrationManagerIdWithDate = Boolean.parseBoolean(name);
  16171.             } catch(java.lang.Exception e) {
  16172.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrationManager.idWithDate': "+e.getMessage(),e);
  16173.                 this.isIntegrationManagerIdWithDate = false;
  16174.             }    
  16175.         }

  16177.         return this.isIntegrationManagerIdWithDate;
  16178.     }
  16179.     
  16180.     private Integer getIntegrationManagerIdsLimit = null;
  16181.     private Boolean getIntegrationManagerIdsLimit_read = null;
  16182.     public Integer getIntegrationManagerIdsLimit() {    
  16183.         String pName = "org.openspcoop2.pdd.integrationManager.ids.limit";
  16184.         if(this.getIntegrationManagerIdsLimit_read==null){
  16185.             try{ 
  16186.                 String name = null;
  16187.                 name = this.reader.getValueConvertEnvProperties(pName);
  16188.                 if(name==null){
  16189.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  16190.                     name="false";
  16191.                 }
  16192.                 name = name.trim();
  16193.                 this.getIntegrationManagerIdsLimit = Integer.valueOf(name);
  16194.             } catch(java.lang.Exception e) {
  16195.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  16196.                 this.getIntegrationManagerIdsLimit = null;
  16197.             }   
  16198.             this.getIntegrationManagerIdsLimit_read = true;
  16199.         }

  16201.         return this.getIntegrationManagerIdsLimit;
  16202.     }
  16203.     
  16204.     private Boolean integrationManager_isNomePortaDelegataUrlBasedValue = null;
  16205.     public boolean integrationManager_isNomePortaDelegataUrlBased() {
  16206.         if(this.integrationManager_isNomePortaDelegataUrlBasedValue==null){
  16207.             try{  
  16208.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.service.IntegrationManager.nomePortaDelegataUrlBased"); 

  16210.                 if(value!=null){
  16211.                     value = value.trim();
  16212.                     this.integrationManager_isNomePortaDelegataUrlBasedValue = Boolean.parseBoolean(value);
  16213.                 }else{
  16214.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.service.IntegrationManager.nomePortaDelegataUrlBased' non impostata, viene utilizzato il default=false");
  16215.                     this.integrationManager_isNomePortaDelegataUrlBasedValue = false;
  16216.                 }
  16217.             }catch(java.lang.Exception e) {
  16218.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.service.IntegrationManager.nomePortaDelegataUrlBased' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  16219.                 this.integrationManager_isNomePortaDelegataUrlBasedValue = false;
  16220.             }
  16221.         }

  16223.         return this.integrationManager_isNomePortaDelegataUrlBasedValue;
  16224.     }

  16226.     private Boolean integrationManager_readInformazioniTrasportoValue = null;
  16227.     public boolean integrationManager_readInformazioniTrasporto() {
  16228.         if(this.integrationManager_readInformazioniTrasportoValue==null){
  16229.             try{  
  16230.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.service.IntegrationManager.infoTrasporto"); 

  16232.                 if(value!=null){
  16233.                     value = value.trim();
  16234.                     this.integrationManager_readInformazioniTrasportoValue = Boolean.parseBoolean(value);
  16235.                 }else{
  16236.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.service.IntegrationManager.infoTrasporto' non impostata, viene utilizzato il default=false");
  16237.                     this.integrationManager_readInformazioniTrasportoValue = false;
  16238.                 }
  16239.             }catch(java.lang.Exception e) {
  16240.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.service.IntegrationManager.infoTrasporto' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  16241.                 this.integrationManager_readInformazioniTrasportoValue = false;
  16242.             }
  16243.         }

  16245.         return this.integrationManager_readInformazioniTrasportoValue;
  16246.     }



  16250.     // *** Consegne, gestione runtime ***
  16251.     
  16252.     private Boolean isIntegrationManager_runtime_useRuntimeManager = null;
  16253.     public boolean isIntegrationManager_runtime_useRuntimeManager() {   
  16254.         if(this.isIntegrationManager_runtime_useRuntimeManager==null){
  16255.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.useRuntimeManager";
  16256.             try{ 
  16257.                 String name = null;
  16258.                 name = this.reader.getValueConvertEnvProperties(pName);
  16259.                 if(name==null){
  16260.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  16261.                     name="true";
  16262.                 }
  16263.                 name = name.trim();
  16264.                 this.isIntegrationManager_runtime_useRuntimeManager = Boolean.parseBoolean(name);
  16265.             } catch(java.lang.Exception e) {
  16266.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  16267.                 this.isIntegrationManager_runtime_useRuntimeManager = true;
  16268.             }    
  16269.         }

  16271.         return this.isIntegrationManager_runtime_useRuntimeManager;
  16272.     }
  16273.     
  16274.     private Boolean isIntegrationManager_runtime_useConsegnePreseInCaricoManager = null;
  16275.     public boolean isIntegrationManager_runtime_useConsegnePreseInCaricoManager() { 
  16276.         if(this.isIntegrationManager_runtime_useConsegnePreseInCaricoManager==null){
  16277.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.useConsegnePreseInCaricoManager";
  16278.             try{ 
  16279.                 String name = null;
  16280.                 name = this.reader.getValueConvertEnvProperties(pName);
  16281.                 if(name==null){
  16282.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  16283.                     name="true";
  16284.                 }
  16285.                 name = name.trim();
  16286.                 this.isIntegrationManager_runtime_useConsegnePreseInCaricoManager = Boolean.parseBoolean(name);
  16287.             } catch(java.lang.Exception e) {
  16288.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  16289.                 this.isIntegrationManager_runtime_useConsegnePreseInCaricoManager = true;
  16290.             }    
  16291.         }

  16293.         return this.isIntegrationManager_runtime_useConsegnePreseInCaricoManager;
  16294.     }
  16295.     
  16296.     private String getIntegrationManager_runtime_dataSource = null;
  16297.     public String getIntegrationManager_runtime_dataSource() throws CoreException { 
  16298.         if(this.getIntegrationManager_runtime_dataSource==null){
  16299.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.dataSource";
  16300.             try{ 
  16301.                 String name = null;
  16302.                 name = this.reader.getValueConvertEnvProperties(pName);
  16303.                 if(name==null){
  16304.                     throw new CoreException("Proprieta' non impostata");
  16305.                 }
  16306.                 name = name.trim();
  16307.                 this.getIntegrationManager_runtime_dataSource = name;
  16308.             } catch(java.lang.Exception e) {
  16309.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  16310.                 throw new CoreException(e.getMessage(),e);
  16311.             }    
  16312.         }

  16314.         return this.getIntegrationManager_runtime_dataSource;
  16315.     }
  16316.     
  16317.     private Properties getIntegrationManager_runtime_dataSourceJndiContext = null;
  16318.     public Properties getIntegrationManager_runtime_dataSourceJndiContext() throws CoreException {  
  16319.         if(this.getIntegrationManager_runtime_dataSourceJndiContext==null){
  16320.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.dataSource.property.";
  16321.             try{ 
  16322.                 this.getIntegrationManager_runtime_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
  16323.             } catch(java.lang.Exception e) {
  16324.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  16325.                 throw new CoreException(e.getMessage(),e);
  16326.             }    
  16327.         }

  16329.         return this.getIntegrationManager_runtime_dataSourceJndiContext;
  16330.     }
  16331.     
  16332.     private Boolean isIntegrationManager_runtime_dataSource_useDBUtils = null;
  16333.     public boolean isIntegrationManager_runtime_dataSource_useDBUtils() {   
  16334.         if(this.isIntegrationManager_runtime_dataSource_useDBUtils==null){
  16335.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.datasource.useDSUtils";
  16336.             try{ 
  16337.                 String name = null;
  16338.                 name = this.reader.getValueConvertEnvProperties(pName);
  16339.                 if(name==null){
  16340.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  16341.                     name="true";
  16342.                 }
  16343.                 name = name.trim();
  16344.                 this.isIntegrationManager_runtime_dataSource_useDBUtils = Boolean.parseBoolean(name);
  16345.             } catch(java.lang.Exception e) {
  16346.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  16347.                 this.isIntegrationManager_runtime_dataSource_useDBUtils = true;
  16348.             }    
  16349.         }

  16351.         return this.isIntegrationManager_runtime_dataSource_useDBUtils;
  16352.     }
  16353.     
  16354.     
  16355.     // *** Consegne, gestione tracce ***
  16356.     
  16357.     private Boolean isIntegrationManager_transazioni_useTransactionManager = null;
  16358.     public boolean isIntegrationManager_transazioni_useTransactionManager() {   
  16359.         if(this.isIntegrationManager_transazioni_useTransactionManager==null){
  16360.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.useTransactionManager";
  16361.             try{ 
  16362.                 String name = null;
  16363.                 name = this.reader.getValueConvertEnvProperties(pName);
  16364.                 if(name==null){
  16365.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  16366.                     name="true";
  16367.                 }
  16368.                 name = name.trim();
  16369.                 this.isIntegrationManager_transazioni_useTransactionManager = Boolean.parseBoolean(name);
  16370.             } catch(java.lang.Exception e) {
  16371.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  16372.                 this.isIntegrationManager_transazioni_useTransactionManager = true;
  16373.             }    
  16374.         }

  16376.         return this.isIntegrationManager_transazioni_useTransactionManager;
  16377.     }
  16378.     
  16379.     private Boolean isIntegrationManager_transazioni_useConsegnePreseInCaricoManager = null;
  16380.     public boolean isIntegrationManager_transazioni_useConsegnePreseInCaricoManager() { 
  16381.         if(this.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager==null){
  16382.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.useConsegnePreseInCaricoManager";
  16383.             try{ 
  16384.                 String name = null;
  16385.                 name = this.reader.getValueConvertEnvProperties(pName);
  16386.                 if(name==null){
  16387.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  16388.                     name="true";
  16389.                 }
  16390.                 name = name.trim();
  16391.                 this.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager = Boolean.parseBoolean(name);
  16392.             } catch(java.lang.Exception e) {
  16393.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  16394.                 this.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager = true;
  16395.             }    
  16396.         }

  16398.         return this.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager;
  16399.     }
  16400.     
  16401.     private String getIntegrationManager_transazioni_dataSource = null;
  16402.     public String getIntegrationManager_transazioni_dataSource() throws CoreException { 
  16403.         if(this.getIntegrationManager_transazioni_dataSource==null){
  16404.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.dataSource";
  16405.             try{ 
  16406.                 String name = null;
  16407.                 name = this.reader.getValueConvertEnvProperties(pName);
  16408.                 if(name==null){
  16409.                     throw new CoreException("Proprieta' non impostata");
  16410.                 }
  16411.                 name = name.trim();
  16412.                 this.getIntegrationManager_transazioni_dataSource = name;
  16413.             } catch(java.lang.Exception e) {
  16414.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  16415.                 throw new CoreException(e.getMessage(),e);
  16416.             }    
  16417.         }

  16419.         return this.getIntegrationManager_transazioni_dataSource;
  16420.     }
  16421.     
  16422.     private Properties getIntegrationManager_transazioni_dataSourceJndiContext = null;
  16423.     public Properties getIntegrationManager_transazioni_dataSourceJndiContext() throws CoreException {  
  16424.         if(this.getIntegrationManager_transazioni_dataSourceJndiContext==null){
  16425.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.dataSource.property.";
  16426.             try{ 
  16427.                 this.getIntegrationManager_transazioni_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
  16428.             } catch(java.lang.Exception e) {
  16429.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  16430.                 throw new CoreException(e.getMessage(),e);
  16431.             }    
  16432.         }

  16434.         return this.getIntegrationManager_transazioni_dataSourceJndiContext;
  16435.     }
  16436.     
  16437.     private Boolean isIntegrationManager_transazioni_dataSource_useDBUtils = null;
  16438.     public boolean isIntegrationManager_transazioni_dataSource_useDBUtils() {   
  16439.         if(this.isIntegrationManager_transazioni_dataSource_useDBUtils==null){
  16440.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.datasource.useDSUtils";
  16441.             try{ 
  16442.                 String name = null;
  16443.                 name = this.reader.getValueConvertEnvProperties(pName);
  16444.                 if(name==null){
  16445.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  16446.                     name="true";
  16447.                 }
  16448.                 name = name.trim();
  16449.                 this.isIntegrationManager_transazioni_dataSource_useDBUtils = Boolean.parseBoolean(name);
  16450.             } catch(java.lang.Exception e) {
  16451.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  16452.                 this.isIntegrationManager_transazioni_dataSource_useDBUtils = true;
  16453.             }    
  16454.         }

  16456.         return this.isIntegrationManager_transazioni_dataSource_useDBUtils;
  16457.     }
  16458.     







  16466.     /* ************** GESTIONE ATTACHMENTS *************** */
  16467.     /**
  16468.      * Restituisce l'indicazione se cancellare l'istruzione <?xml
  16469.      *
  16470.      * @return Restituisce Restituisce l'indicazione se cancellare l'istruzione <?xml
  16471.      * 
  16472.      */
  16473.     private Boolean isDeleteInstructionTargetMachineXml= null;
  16474.     public boolean isDeleteInstructionTargetMachineXml(){
  16475.         if(this.isDeleteInstructionTargetMachineXml==null){
  16476.             try{  
  16477.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.deleteInstructionTargetMachineXml"); 

  16479.                 if(value!=null){
  16480.                     value = value.trim();
  16481.                     this.isDeleteInstructionTargetMachineXml = Boolean.parseBoolean(value);
  16482.                 }else{
  16483.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.deleteInstructionTargetMachineXml' non impostata, viene utilizzato il default=false");
  16484.                     this.isDeleteInstructionTargetMachineXml = false;
  16485.                 }

  16487.             }catch(java.lang.Exception e) {
  16488.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.deleteInstructionTargetMachineXml' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  16489.                 this.isDeleteInstructionTargetMachineXml = false;
  16490.             }
  16491.         }

  16493.         return this.isDeleteInstructionTargetMachineXml;
  16494.     }

  16496.     private Boolean tunnelSOAP_loadMailcap = null;
  16497.     public boolean isTunnelSOAP_loadMailcap() { 
  16498.         if(this.tunnelSOAP_loadMailcap==null){
  16499.             try{ 
  16500.                 String name = null;
  16501.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.mailcap.load");
  16502.                 if(name!=null){
  16503.                     name = name.trim();
  16504.                     this.tunnelSOAP_loadMailcap = Boolean.parseBoolean(name);
  16505.                 }else{
  16506.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mailcap.load' non impostata, viene utilizzato il default="+false);
  16507.                     this.tunnelSOAP_loadMailcap = false;
  16508.                 }
  16509.             }catch(java.lang.Exception e) {
  16510.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mailcap.load' non impostata, viene utilizzato il default="+false+", errore:"+e.getMessage(),e);
  16511.                 this.tunnelSOAP_loadMailcap = false;
  16512.             }    
  16513.         }

  16515.         return this.tunnelSOAP_loadMailcap;
  16516.     }
  16517.     
  16518.     /**
  16519.      * Restituisce il tipo di Date da utilizzare
  16520.      *
  16521.      * @return il tipo di Date da utilizzare
  16522.      * 
  16523.      */
  16524.     private String tunnelSOAPKeyWord_headerTrasporto = null;
  16525.     public String getTunnelSOAPKeyWord_headerTrasporto() {  
  16526.         if(this.tunnelSOAPKeyWord_headerTrasporto==null){
  16527.             try{ 
  16528.                 String name = null;
  16529.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.trasporto");
  16530.                 if(name!=null){
  16531.                     name = name.trim();
  16532.                     this.tunnelSOAPKeyWord_headerTrasporto = name;
  16533.                 }else{
  16534.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.trasporto' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_ATTACHMENT);
  16535.                     this.tunnelSOAPKeyWord_headerTrasporto = CostantiPdD.IMBUSTAMENTO_ATTACHMENT;
  16536.                 }
  16537.             }catch(java.lang.Exception e) {
  16538.                 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);
  16539.                 this.tunnelSOAPKeyWord_headerTrasporto = CostantiPdD.IMBUSTAMENTO_ATTACHMENT;
  16540.             }    
  16541.         }

  16543.         return this.tunnelSOAPKeyWord_headerTrasporto;
  16544.     }

  16546.     /**
  16547.      * Restituisce il tipo di Date da utilizzare
  16548.      *
  16549.      * @return il tipo di Date da utilizzare
  16550.      * 
  16551.      */
  16552.     private String tunnelSOAPKeyWordMimeType_headerTrasporto = null;
  16553.     public String getTunnelSOAPKeyWordMimeType_headerTrasporto() {  
  16554.         if(this.tunnelSOAPKeyWordMimeType_headerTrasporto==null){
  16555.             try{ 
  16556.                 String name = null;
  16557.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.trasporto");
  16558.                 if(name!=null){
  16559.                     name = name.trim();
  16560.                     this.tunnelSOAPKeyWordMimeType_headerTrasporto = name;
  16561.                 }else{
  16562.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.trasporto' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_MIME_TYPE);
  16563.                     this.tunnelSOAPKeyWordMimeType_headerTrasporto = CostantiPdD.IMBUSTAMENTO_MIME_TYPE;
  16564.                 }
  16565.             }catch(java.lang.Exception e) {
  16566.                 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);
  16567.                 this.tunnelSOAPKeyWordMimeType_headerTrasporto = CostantiPdD.IMBUSTAMENTO_MIME_TYPE;
  16568.             }    
  16569.         }

  16571.         return this.tunnelSOAPKeyWordMimeType_headerTrasporto;
  16572.     }

  16574.     /**
  16575.      * Restituisce il tipo di Date da utilizzare
  16576.      *
  16577.      * @return il tipo di Date da utilizzare
  16578.      * 
  16579.      */
  16580.     private String tunnelSOAPKeyWord_urlBased = null;
  16581.     public String getTunnelSOAPKeyWord_urlBased() { 
  16582.         if(this.tunnelSOAPKeyWord_urlBased==null){
  16583.             try{ 
  16584.                 String name = null;
  16585.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.urlBased");
  16586.                 if(name!=null){
  16587.                     name = name.trim();
  16588.                     this.tunnelSOAPKeyWord_urlBased = name;
  16589.                 }else{
  16590.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.urlBased' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_ATTACHMENT);
  16591.                     this.tunnelSOAPKeyWord_urlBased = CostantiPdD.IMBUSTAMENTO_ATTACHMENT;
  16592.                 }
  16593.             }catch(java.lang.Exception e) {
  16594.                 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);
  16595.                 this.tunnelSOAPKeyWord_urlBased = CostantiPdD.IMBUSTAMENTO_ATTACHMENT;
  16596.             }    
  16597.         }

  16599.         return this.tunnelSOAPKeyWord_urlBased;
  16600.     }

  16602.     /**
  16603.      * Restituisce il tipo di Date da utilizzare
  16604.      *
  16605.      * @return il tipo di Date da utilizzare
  16606.      * 
  16607.      */
  16608.     private String tunnelSOAPKeyWordMimeType_urlBased = null;
  16609.     public String getTunnelSOAPKeyWordMimeType_urlBased() { 
  16610.         if(this.tunnelSOAPKeyWordMimeType_urlBased==null){
  16611.             try{ 
  16612.                 String name = null;
  16613.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.urlBased");
  16614.                 if(name!=null){
  16615.                     name = name.trim();
  16616.                     this.tunnelSOAPKeyWordMimeType_urlBased = name;
  16617.                 }else{
  16618.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.urlBased' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_MIME_TYPE);
  16619.                     this.tunnelSOAPKeyWordMimeType_urlBased = CostantiPdD.IMBUSTAMENTO_MIME_TYPE;
  16620.                 }
  16621.             }catch(java.lang.Exception e) {
  16622.                 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);
  16623.                 this.tunnelSOAPKeyWordMimeType_urlBased = CostantiPdD.IMBUSTAMENTO_MIME_TYPE;
  16624.             }    
  16625.         }

  16627.         return this.tunnelSOAPKeyWordMimeType_urlBased;
  16628.     }
  16629.     



  16633.     /* ***************** ASINCRONI ************/
  16634.     /**
  16635.      * Restituisce il Timeout di attesa di una busta di richiesta/ricevutaRichiesta asincrona non completamente processata 
  16636.      *
  16637.      * @return Restituisce il Timeout di attesa di una busta
  16638.      * 
  16639.      */
  16640.     private Long timeoutBustaRispostaAsincrona = null;
  16641.     public long getTimeoutBustaRispostaAsincrona() {    
  16642.         if(this.timeoutBustaRispostaAsincrona == null){
  16643.             try{ 
  16644.                 String name = null;
  16645.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.attesaAttiva");
  16646.                 if(name!=null){
  16647.                     name = name.trim();
  16648.                     this.timeoutBustaRispostaAsincrona = java.lang.Long.parseLong(name) * 1000;
  16649.                 }else{
  16650.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.attesaAttiva' non impostata, viene utilizzato il default="+(CostantiPdD.RISPOSTA_ASINCRONA_ATTESA_ATTIVA/1000));
  16651.                     this.timeoutBustaRispostaAsincrona = CostantiPdD.RISPOSTA_ASINCRONA_ATTESA_ATTIVA;
  16652.                 }
  16653.             }catch(java.lang.Exception e) {
  16654.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.attesaAttiva' non impostata" +
  16655.                         ", viene utilizzato il default="+(CostantiPdD.RISPOSTA_ASINCRONA_ATTESA_ATTIVA/1000)+", errore:"+e.getMessage(),e);
  16656.                 this.timeoutBustaRispostaAsincrona = CostantiPdD.RISPOSTA_ASINCRONA_ATTESA_ATTIVA;
  16657.             }    
  16658.         }

  16660.         return this.timeoutBustaRispostaAsincrona;
  16661.     } 
  16662.     /**
  16663.      * Restituisce la Frequenza di check di attesa di una busta di richiesta/ricevutaRichiesta asincrona non completamente processata 
  16664.      *
  16665.      * @return Restituisce la Frequenza di check di attesa di una busta di richiesta/ricevutaRichiesta asincrona non completamente processata 
  16666.      * 
  16667.      */
  16668.     private Integer checkIntervalBustaRispostaAsincrona = null;
  16669.     public int getCheckIntervalBustaRispostaAsincrona() {   
  16670.         if(this.checkIntervalBustaRispostaAsincrona==null){
  16671.             try{ 
  16672.                 String name = null;
  16673.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.check");
  16674.                 if(name!=null){
  16675.                     name = name.trim();
  16676.                     this.checkIntervalBustaRispostaAsincrona = java.lang.Integer.parseInt(name);
  16677.                 }else{
  16678.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.check' non impostata, viene utilizzato il default="+CostantiPdD.RISPOSTA_ASINCRONA_CHECK_INTERVAL);
  16679.                     this.checkIntervalBustaRispostaAsincrona = CostantiPdD.RISPOSTA_ASINCRONA_CHECK_INTERVAL;
  16680.                 }
  16681.             }catch(java.lang.Exception e) {
  16682.                 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);
  16683.                 this.checkIntervalBustaRispostaAsincrona = CostantiPdD.RISPOSTA_ASINCRONA_CHECK_INTERVAL;
  16684.             }    
  16685.         }

  16687.         return this.checkIntervalBustaRispostaAsincrona;
  16688.     }




  16693.     /*---------- Cluster ID -------------*/

  16695.     private Boolean isClusterDinamico = null;
  16696.     public boolean isClusterDinamico(){
  16697.         String pName = "org.openspcoop2.pdd.cluster_dinamico.enabled";
  16698.         if(this.isClusterDinamico==null){
  16699.             try{  
  16700.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  16702.                 if(value!=null){
  16703.                     value = value.trim();
  16704.                     this.isClusterDinamico = Boolean.parseBoolean(value);
  16705.                 }else{
  16706.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  16707.                     this.isClusterDinamico = false;
  16708.                 }

  16710.             }catch(java.lang.Exception e) {
  16711.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  16712.                 this.isClusterDinamico = false;
  16713.             }
  16714.         }
  16715.         return this.isClusterDinamico;
  16716.     }
  16717.     
  16718.     private Integer getClusterDinamicoRefreshSecondsInterval = null;
  16719.     public int getClusterDinamicoRefreshSecondsInterval() { 
  16720.         String pName = "org.openspcoop2.pdd.cluster_dinamico.refresh";
  16721.         if(this.getClusterDinamicoRefreshSecondsInterval==null){
  16722.             try{ 
  16723.                 String name = null;
  16724.                 name = this.reader.getValueConvertEnvProperties(pName);
  16725.                 if(name!=null){
  16726.                     name = name.trim();
  16727.                     this.getClusterDinamicoRefreshSecondsInterval = java.lang.Integer.parseInt(name);
  16728.                 }else{
  16729.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.CLUSTER_DINAMICO_REFRESH_SECONDS));
  16730.                     this.getClusterDinamicoRefreshSecondsInterval = CostantiPdD.CLUSTER_DINAMICO_REFRESH_SECONDS;
  16731.                 }
  16732.             }catch(java.lang.Exception e) {
  16733.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.CLUSTER_DINAMICO_REFRESH_SECONDS),e);
  16734.                 this.getClusterDinamicoRefreshSecondsInterval = CostantiPdD.CLUSTER_DINAMICO_REFRESH_SECONDS;
  16735.             }  
  16736.         }

  16738.         return this.getClusterDinamicoRefreshSecondsInterval;
  16739.     }
  16740.     
  16741.     private String cluster_hostname = null;
  16742.     public String getClusterHostname() {
  16743.         if(this.cluster_hostname==null){
  16744.             try{ 
  16745.                 String name = null;
  16746.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cluster_id.hostname");
  16747.                 if(name==null) {
  16748.                     this.cluster_hostname = getClusterId(true);
  16749.                 }
  16750.                 else{
  16751.                     name = name.trim();
  16752.                     this.cluster_hostname = name;
  16753.                 }
  16754.             }catch(java.lang.Exception e) {
  16755.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.cluster_id.hostname': "+e.getMessage(),e);
  16756.                 this.cluster_hostname = null;
  16757.             }  
  16758.         }

  16760.         return this.cluster_hostname;
  16761.     }
  16762.         
  16763.     private String group_id = null;
  16764.     public String getGroupId(boolean rateLimitingGestioneCluster) {
  16765.         String pName = "org.openspcoop2.pdd.group_id";
  16766.         if(this.group_id==null){
  16767.             try{ 
  16768.                 String name = null;
  16769.                 name = this.reader.getValueConvertEnvProperties(pName);
  16770.                 if(name==null) {
  16771.                     // Gestione RateLimiting senza una effettiva attivazione di un cluster dinamico
  16772.                     if(!isClusterDinamico()) {
  16773.                         if(rateLimitingGestioneCluster) {
  16774.                             this.group_id = org.openspcoop2.utils.Costanti.OPENSPCOOP2;
  16775.                         }
  16776.                         else {
  16777.                             throw new CoreException(NON_DEFINITA);
  16778.                         }
  16779.                     }
  16780.                     else {
  16781.                         throw new CoreException(NON_DEFINITA);
  16782.                     }
  16783.                 }
  16784.                 else if(name!=null){
  16785.                     name = name.trim();
  16786.                     this.group_id = name;
  16787.                 }
  16788.             }catch(java.lang.Exception e) {
  16789.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  16790.                 this.group_id = null;
  16791.             }  
  16792.         }

  16794.         return this.group_id;
  16795.     }
  16796.     
  16797.     /**
  16798.      * Restituisce il cluster id del nodo del cluster su cui gira la pdd 
  16799.      *
  16800.      * @return Il cluster id di questo nodo
  16801.      * @added Fabio Tronci (tronci@link.it) 06/06/08 
  16802.      */
  16803.     private String cluster_id = null;
  16804.     public String getClusterId(boolean required) {
  16805.         if(this.cluster_id==null){
  16806.             try{ 
  16807.                 String name = null;
  16808.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cluster_id");
  16809.                 if(name==null && required)
  16810.                     throw new CoreException(NON_DEFINITA);
  16811.                 if(name!=null){
  16812.                     name = name.trim();
  16813.                     this.cluster_id = name;
  16814.                 }
  16815.             }catch(java.lang.Exception e) {
  16816.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.cluster_id': "+e.getMessage(),e);
  16817.                 this.cluster_id = null;
  16818.             }  
  16819.         }

  16821.         return this.cluster_id;
  16822.     }
  16823.     
  16824.     private Boolean isUseHashClusterId = null;
  16825.     public boolean isUseHashClusterId(){
  16826.         String pName = "org.openspcoop2.pdd.cluster_id.hash.enabled";
  16827.         if(this.isUseHashClusterId==null){
  16828.             try{  
  16829.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  16831.                 if(value!=null){
  16832.                     value = value.trim();
  16833.                     this.isUseHashClusterId = Boolean.parseBoolean(value);
  16834.                 }else{
  16835.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  16836.                     this.isUseHashClusterId = false;
  16837.                 }

  16839.             }catch(java.lang.Exception e) {
  16840.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  16841.                 this.isUseHashClusterId = false;
  16842.             }
  16843.         }
  16844.         return this.isUseHashClusterId;
  16845.     }
  16846.     
  16847.     private String cluster_id_preCodificaHash = null;
  16848.     public String getCluster_id_preCodificaHash() {
  16849.         return this.cluster_id_preCodificaHash;
  16850.     }
  16851.     public void updateClusterId() {
  16852.         this.cluster_id_preCodificaHash = this.cluster_id;
  16853.         // calcolo il cluster fornito come hash value
  16854.         this.cluster_id = DynamicClusterManager.hashClusterId(this.cluster_id);
  16855.     }
  16856.     
  16857.     private String cluster_id_numerico =null;
  16858.     private Boolean cluster_id_numerico_read =null;
  16859.     public String getClusterIdNumerico() throws ProtocolException {
  16860.         if(this.cluster_id_numerico_read==null){
  16861.             try{ 
  16862.                 String name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cluster_id.numeric");
  16863.                 if(name!=null){
  16864.                     int numero = Integer.parseInt(name.trim());
  16865.                     if(numero<0 || numero>99){
  16866.                         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";
  16867.                         this.logError(msg);
  16868.                         throw new ProtocolException(msg);
  16869.                     }
  16870.                     this.cluster_id_numerico = name.trim();
  16871.                 }
  16872.                 
  16873.                 this.cluster_id_numerico_read = true;
  16874.                 
  16875.             }catch(java.lang.Exception e) {
  16876.                 String msg = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.cluster_id.numeric': "+e.getMessage();
  16877.                 this.logError(msg,e);
  16878.                 throw new ProtocolException(msg,e);
  16879.             }   
  16880.         }
  16881.         return this.cluster_id_numerico;
  16882.     }
  16883.     
  16884.     private Integer getClusterDinamicoIdNumericoCifre = null;
  16885.     public int getClusterDinamicoIdNumericoCifre(boolean rateLimitingGestioneCluster) { 
  16886.         String pName = "org.openspcoop2.pdd.cluster_id.numeric.dinamico.cifre";
  16887.         if(this.getClusterDinamicoIdNumericoCifre==null){
  16888.             try{ 
  16889.                 String name = null;
  16890.                 name = this.reader.getValueConvertEnvProperties(pName);
  16891.                 if(name!=null){
  16892.                     name = name.trim();
  16893.                     this.getClusterDinamicoIdNumericoCifre = java.lang.Integer.parseInt(name);
  16894.                     if(this.getClusterDinamicoIdNumericoCifre<=0) {
  16895.                         throw new CoreException("Il valore indicato deve essere maggiore di 0");
  16896.                     }
  16897.                 }
  16898.                 else{
  16899.                     // Gestione RateLimiting senza una effettiva attivazione di un cluster dinamico
  16900.                     if(!isClusterDinamico()) {
  16901.                         if(rateLimitingGestioneCluster) {
  16902.                             this.getClusterDinamicoIdNumericoCifre = 2; // per default si registra staticamente fino a 99 nodi
  16903.                         }
  16904.                         else {
  16905.                             throw new CoreException("Non Impostato");
  16906.                         }
  16907.                     }
  16908.                     else {
  16909.                         throw new CoreException("Non Impostato");
  16910.                     }
  16911.                 }
  16912.             }catch(java.lang.Exception e) {
  16913.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  16914.                 this.getClusterDinamicoIdNumericoCifre = -1;
  16915.             }  
  16916.         }

  16918.         return this.getClusterDinamicoIdNumericoCifre;
  16919.     }
  16920.     public boolean isClusterIdNumericoDinamico(boolean rateLimitingGestioneCluster) {
  16921.         return getClusterDinamicoIdNumericoCifre(rateLimitingGestioneCluster)>0;
  16922.     }

  16924.     private Boolean isTimerLockByDatabase = null;
  16925.     public boolean isTimerLockByDatabase(){
  16926.         if(this.isTimerLockByDatabase==null){
  16927.             try{  
  16928.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.lockDatabase"); 

  16930.                 if(value!=null){
  16931.                     value = value.trim();
  16932.                     this.isTimerLockByDatabase = Boolean.parseBoolean(value);
  16933.                 }else{
  16934.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.lockDatabase' non impostata, viene utilizzato il default=true");
  16935.                     this.isTimerLockByDatabase = true;
  16936.                 }

  16938.             }catch(java.lang.Exception e) {
  16939.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.lockDatabase' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  16940.                 this.isTimerLockByDatabase = true;
  16941.             }
  16942.             
  16943.             if(this.isTimerLockByDatabase) {
  16944.                 // Richiede la definizione di un clusterId e di un tipo di database
  16945.                 if(this.getClusterId(false)==null) {
  16946.                     this.isTimerLockByDatabase = false;
  16947.                 }
  16948.                 else if(this.getDatabaseType()==null) {
  16949.                     this.isTimerLockByDatabase = false;
  16950.                 }
  16951.             }
  16952.         }
  16953.         return this.isTimerLockByDatabase;
  16954.     }
  16955.     
  16956.     private Boolean isTimerLockByDatabaseNotifyLogEnabled = null;
  16957.     public boolean isTimerLockByDatabaseNotifyLogEnabled(){
  16958.         if(this.isTimerLockByDatabaseNotifyLogEnabled==null){
  16959.             try{  
  16960.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.lockDatabase.notify.log"); 

  16962.                 if(value!=null){
  16963.                     value = value.trim();
  16964.                     this.isTimerLockByDatabaseNotifyLogEnabled = Boolean.parseBoolean(value);
  16965.                 }else{
  16966.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.lockDatabase.notify.log' non impostata, viene utilizzato il default=true");
  16967.                     this.isTimerLockByDatabaseNotifyLogEnabled = true;
  16968.                 }

  16970.             }catch(java.lang.Exception e) {
  16971.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.lockDatabase.notify.log' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  16972.                 this.isTimerLockByDatabaseNotifyLogEnabled = true;
  16973.             }
  16974.         }
  16975.         return this.isTimerLockByDatabaseNotifyLogEnabled;
  16976.     }
  16977.     
  16978.     private String pddContextSerializer = null;
  16979.     public String getPddContextSerializer() {
  16980.         if(this.pddContextSerializer==null){
  16981.             try{ 
  16982.                 String name = null;
  16983.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.contextSerializer");
  16984.                 if(name!=null){
  16985.                     name = name.trim();
  16986.                     this.pddContextSerializer = name;
  16987.                 }else{
  16988.                     this.pddContextSerializer = CostantiConfigurazione.NONE;
  16989.                 }
  16990.             }catch(java.lang.Exception e) {
  16991.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.contextSerializer': "+e.getMessage(),e);
  16992.                 this.pddContextSerializer = CostantiConfigurazione.NONE;
  16993.             }  
  16994.         }

  16996.         return this.pddContextSerializer;
  16997.     }




  17002.     /*---------- Stateless -------------*/

  17004.     /**
  17005.      * Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo oneway
  17006.      *
  17007.      * @return il Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo oneway
  17008.      * 
  17009.      */
  17010.     private String statelessOneWay = null;
  17011.     public String getStatelessOneWay() {    
  17012.         if(this.statelessOneWay==null){
  17013.             try{ 
  17014.                 String name = null;
  17015.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.default.oneway");
  17016.                 if(name!=null){
  17017.                     name = name.trim();
  17018.                     if( (CostantiConfigurazione.ABILITATO.equals(name)==false) && (CostantiConfigurazione.DISABILITATO.equals(name)==false) ){
  17019.                         throw new CoreException("Valori ammessi sono abilitato/disabilito");
  17020.                     }
  17021.                 }
  17022.                 else{
  17023.                     throw new CoreException(NON_DEFINITA);
  17024.                 }
  17025.                 this.statelessOneWay = name;
  17026.             }catch(java.lang.Exception e) {
  17027.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.default.oneway': "+e.getMessage(),e);
  17028.                 this.statelessOneWay = null;
  17029.             }    
  17030.         }

  17032.         return this.statelessOneWay;
  17033.     }

  17035.     /**
  17036.      * Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo sincrono
  17037.      *
  17038.      * @return il Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo sincrono
  17039.      * 
  17040.      */
  17041.     private String statelessSincrono = null;
  17042.     public String getStatelessSincrono() {
  17043.         if(this.statelessSincrono==null){
  17044.             try{ 
  17045.                 String name = null;
  17046.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.default.sincrono");
  17047.                 if(name!=null){
  17048.                     name = name.trim();
  17049.                     if( (CostantiConfigurazione.ABILITATO.equals(name)==false) && (CostantiConfigurazione.DISABILITATO.equals(name)==false) ){
  17050.                         throw new CoreException("Valori ammessi sono abilitato/disabilito");
  17051.                     }
  17052.                 }
  17053.                 else{
  17054.                     throw new CoreException(NON_DEFINITA);
  17055.                 }
  17056.                 this.statelessSincrono = name;
  17057.             }catch(java.lang.Exception e) {
  17058.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.default.sincrono': "+e.getMessage(),e);
  17059.                 this.statelessSincrono = null;
  17060.             }    
  17061.         }
  17062.         //System.out.println("MODALITA default per sincrono: "+OpenSPCoopProperties.statelessSincrono);
  17063.         return this.statelessSincrono;
  17064.     }

  17066.     /**
  17067.      * Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo asincrono simmetrico e asimmetrico
  17068.      *
  17069.      * @return il Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo asincrono simmetrico e asimmetrico
  17070.      * 
  17071.      */
  17072.     private String statelessAsincrono = null;
  17073.     public String getStatelessAsincroni() { 
  17074.         if(this.statelessAsincrono==null){
  17075.             try{ 
  17076.                 String name = null;
  17077.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.default.asincroni");
  17078.                 if(name!=null){
  17079.                     name = name.trim();
  17080.                     if( (CostantiConfigurazione.ABILITATO.equals(name)==false) && (CostantiConfigurazione.DISABILITATO.equals(name)==false) ){
  17081.                         throw new CoreException("Valori ammessi sono abilitato/disabilito");
  17082.                     }
  17083.                 }
  17084.                 else{
  17085.                     throw new CoreException(NON_DEFINITA);
  17086.                 }
  17087.                 this.statelessAsincrono = name;
  17088.             }catch(java.lang.Exception e) {
  17089.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.default.asincroni': "+e.getMessage(),e);
  17090.                 this.statelessAsincrono = null;
  17091.             }    
  17092.         }
  17093.         //System.out.println("MODALITA default per asincroni: "+OpenSPCoopProperties.statelessAsincrono);
  17094.         return this.statelessAsincrono;
  17095.     }

  17097.     /**
  17098.      * Restituisce l'indicazione se gestire il oneway non stateless nella nuova modalita della versione 1.4 o come la vecchia 1.0
  17099.      *
  17100.      * @return Restituisce l'indicazione se gestire il oneway non stateless nella nuova modalita della versione 1.4 o come la vecchia 1.0
  17101.      * 
  17102.      */
  17103.     private Boolean isGestioneOnewayStateful_1_1= null;
  17104.     public boolean isGestioneOnewayStateful_1_1(){
  17105.         if(this.isGestioneOnewayStateful_1_1==null){
  17106.             try{  
  17107.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateful.oneway"); 

  17109.                 if(value!=null){
  17110.                     value = value.trim();
  17111.                     if( (CostantiConfigurazione.ONEWAY_STATEFUL_1_0.equals(value)==false) && (CostantiConfigurazione.ONEWAY_STATEFUL_1_1.equals(value)==false) ){
  17112.                         throw new CoreException("Valori ammessi sono 1.0/1.1");
  17113.                     }
  17114.                     this.isGestioneOnewayStateful_1_1 = CostantiConfigurazione.ONEWAY_STATEFUL_1_1.equals(value);
  17115.                 }else{
  17116.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.stateful.oneway' non impostata, viene utilizzato il default=true");
  17117.                     this.isGestioneOnewayStateful_1_1 = true;
  17118.                 }

  17120.             }catch(java.lang.Exception e) {
  17121.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.stateful.oneway' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  17122.                 this.isGestioneOnewayStateful_1_1 = true;
  17123.             }
  17124.         }
  17125.         //System.out.println("MODALITA 11 per gestione Oneway; "+OpenSPCoopProperties.isGestioneOnewayStateful_1_1);
  17126.         return this.isGestioneOnewayStateful_1_1;
  17127.     }

  17129.     /**
  17130.      * Restituisce il comportamento per il routing
  17131.      *
  17132.      * @return il Restituisce il comportamento per il routing
  17133.      * 
  17134.      */
  17135.     private String statelessRouting = null;
  17136.     public String getStatelessRouting() {   
  17137.         if(this.statelessRouting==null){
  17138.             try{ 
  17139.                 String name = null;
  17140.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.router");
  17141.                 if(name!=null){
  17142.                     name = name.trim();
  17143.                     if( (CostantiConfigurazione.ABILITATO.equals(name)==false) && (CostantiConfigurazione.DISABILITATO.equals(name)==false) ){
  17144.                         throw new CoreException("Valori ammessi sono abilitato/disabilito");
  17145.                     }
  17146.                 }
  17147.                 else{
  17148.                     throw new CoreException(NON_DEFINITA);
  17149.                 }
  17150.                 this.statelessRouting = name;
  17151.             }catch(java.lang.Exception e) {
  17152.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.router': "+e.getMessage(),e);
  17153.                 this.statelessRouting = null;
  17154.             }    
  17155.         }
  17156.         //System.out.println("MODALITA per routing: "+OpenSPCoopProperties.statelessRouting);
  17157.         return this.statelessRouting;
  17158.     }


  17161.     /**
  17162.      * Restituisce l'indicazione se una gestione stateless deve rinegoziare la connessione
  17163.      *
  17164.      * @return Restituisce l'indicazione se una gestione stateless deve rinegoziare la connessione
  17165.      * 
  17166.      */
  17167.     private Boolean isGestioneStateful_RinegoziamentoConnessione= null;
  17168.     private boolean isRinegoziamentoConnessione(){
  17169.         if(this.isGestioneStateful_RinegoziamentoConnessione==null){
  17170.             try{  
  17171.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.dataSource.rinegoziamentoConnessione"); 

  17173.                 if(value!=null){
  17174.                     value = value.trim();
  17175.                     if( (CostantiConfigurazione.ABILITATO.equals(value)==false) && (CostantiConfigurazione.DISABILITATO.equals(value)==false) ){
  17176.                         throw new CoreException("Valori ammessi sono abilitato/disabilitato");
  17177.                     }
  17178.                     if( CostantiConfigurazione.DISABILITATO.equals(value) ){
  17179.                         this.isGestioneStateful_RinegoziamentoConnessione = false;
  17180.                     }else{
  17181.                         this.isGestioneStateful_RinegoziamentoConnessione = true;
  17182.                     }
  17183.                 }else{
  17184.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.dataSource.rinegoziamentoConnessione' non impostata, viene utilizzato il default=true");
  17185.                     this.isGestioneStateful_RinegoziamentoConnessione = true;
  17186.                 }

  17188.             }catch(java.lang.Exception e) {
  17189.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.dataSource.rinegoziamentoConnessione' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  17190.                 this.isGestioneStateful_RinegoziamentoConnessione = true;
  17191.             }
  17192.         }
  17193.         return this.isGestioneStateful_RinegoziamentoConnessione;
  17194.     }
  17195.     
  17196.     public boolean isRinegoziamentoConnessione(ProfiloDiCollaborazione profilo){
  17197.         if(ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(profilo) || ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(profilo))
  17198.             return true;
  17199.         else
  17200.             return this.isRinegoziamentoConnessione();
  17201.     }




  17206.     private Boolean mergeHandlerBuiltInAndHandlerUser = null;
  17207.     public boolean isMergeHandlerBuiltInAndHandlerUser() {  
  17208.         if(this.mergeHandlerBuiltInAndHandlerUser==null){
  17209.             try{ 
  17210.                 String v = null;
  17211.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.merge");
  17212.                 if(v!=null){
  17213.                     v = v.trim();
  17214.                     this.mergeHandlerBuiltInAndHandlerUser = Boolean.parseBoolean(v);
  17215.                 } 
  17216.                 else{
  17217.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.merge' non impostata, viene utilizzato il default="+false);
  17218.                     this.mergeHandlerBuiltInAndHandlerUser = false;
  17219.                 }
  17220.             }catch(java.lang.Exception e) {
  17221.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.merge' non impostata correttamente,  errore:"+e.getMessage(),e);
  17222.             } 
  17223.         }
  17224.         return this.mergeHandlerBuiltInAndHandlerUser;
  17225.     }
  17226.     
  17227.     /*---------- Gestori handler built-in -------------*/
  17228.     
  17229.     private Boolean printInfoHandlerBuiltIn = null;
  17230.     public boolean isPrintInfoHandlerBuiltIn() {    
  17231.         if(this.printInfoHandlerBuiltIn==null){
  17232.             try{ 
  17233.                 String v = null;
  17234.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.printInfo");
  17235.                 if(v!=null){
  17236.                     v = v.trim();
  17237.                     this.printInfoHandlerBuiltIn = Boolean.parseBoolean(v);
  17238.                 } 
  17239.                 else{
  17240.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.built-in.printInfo' non impostata, viene utilizzato il default="+true);
  17241.                     this.printInfoHandlerBuiltIn = true;
  17242.                 }
  17243.             }catch(java.lang.Exception e) {
  17244.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.built-in.printInfo' non impostata correttamente,  errore:"+e.getMessage(),e);
  17245.             } 
  17246.         }
  17247.         return this.printInfoHandlerBuiltIn;
  17248.     }
  17249.     
  17250.     
  17251.     /**
  17252.      * Restituisce l'elenco degli handlers di tipo InitHandlerBuiltIn
  17253.      * 
  17254.      * @return  Restituisce l'elenco degli handlers di tipo InitHandlerBuiltIn
  17255.      */
  17256.     private String[] tipiInitHandlerBuiltIn = null;
  17257.     private boolean tipiInitHandlerBuiltInRead = false;
  17258.     public String[] getInitHandlerBuiltIn() {
  17259.         if(this.tipiInitHandlerBuiltInRead == false){
  17260.             try{ 
  17261.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.init");
  17262.                 if(value!=null){
  17263.                     value = value.trim();
  17264.                     String [] r = value.split(",");
  17265.                     this.tipiInitHandlerBuiltIn = r;
  17266.                 }else{
  17267.                     this.tipiInitHandlerBuiltIn = null;
  17268.                 }
  17269.             }catch(java.lang.Exception e) {
  17270.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.init': "+e.getMessage(),e);
  17271.                 this.tipiInitHandlerBuiltIn = null;
  17272.             }   
  17273.             this.tipiInitHandlerBuiltInRead = true;
  17274.         }

  17276.         return this.tipiInitHandlerBuiltIn;
  17277.     }
  17278.     
  17279.     /**
  17280.      * Restituisce l'elenco degli handlers di tipo ExitHandlerBuiltIn
  17281.      * 
  17282.      * @return  Restituisce l'elenco degli handlers di tipo ExitHandlerBuiltIn
  17283.      */
  17284.     private String[] tipiExitHandlerBuiltIn = null;
  17285.     private boolean tipiExitHandlerBuiltInRead = false;
  17286.     public String[] getExitHandlerBuiltIn() {
  17287.         if(this.tipiExitHandlerBuiltInRead == false){
  17288.             try{ 
  17289.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.exit");
  17290.                 if(value!=null){
  17291.                     value = value.trim();
  17292.                     String [] r = value.split(",");
  17293.                     this.tipiExitHandlerBuiltIn = r;
  17294.                 }else{
  17295.                     this.tipiExitHandlerBuiltIn = null;
  17296.                 }
  17297.             }catch(java.lang.Exception e) {
  17298.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.exit': "+e.getMessage(),e);
  17299.                 this.tipiExitHandlerBuiltIn = null;
  17300.             }   
  17301.             this.tipiExitHandlerBuiltInRead = true;
  17302.         }

  17304.         return this.tipiExitHandlerBuiltIn;
  17305.     }
  17306.     
  17307.     /**
  17308.      * Restituisce l'elenco degli handlers di tipo PreInRequestHandlerBuiltIn
  17309.      * 
  17310.      * @return  Restituisce l'elenco degli handlers di tipo PreInRequestHandlerBuiltIn
  17311.      */
  17312.     private String[] tipiPreInRequestHandlerBuiltIn = null;
  17313.     private boolean tipiPreInRequestHandlerBuiltInRead = false;
  17314.     public String[] getPreInRequestHandlerBuiltIn() {
  17315.         if(this.tipiPreInRequestHandlerBuiltInRead == false){
  17316.             try{ 
  17317.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.pre-in-request");
  17318.                 if(value!=null){
  17319.                     value = value.trim();
  17320.                     String [] r = value.split(",");
  17321.                     this.tipiPreInRequestHandlerBuiltIn = r;
  17322.                 }else{
  17323.                     this.tipiPreInRequestHandlerBuiltIn = null;
  17324.                 }
  17325.             }catch(java.lang.Exception e) {
  17326.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.pre-in-request': "+e.getMessage(),e);
  17327.                 this.tipiPreInRequestHandlerBuiltIn = null;
  17328.             }   
  17329.             this.tipiPreInRequestHandlerBuiltInRead = true;
  17330.         }

  17332.         return this.tipiPreInRequestHandlerBuiltIn;
  17333.     }

  17335.     
  17336.     /**
  17337.      * Restituisce l'elenco degli handlers di tipo InRequestHandlerBuiltIn
  17338.      * 
  17339.      * @return  Restituisce l'elenco degli handlers di tipo InRequestHandlerBuiltIn
  17340.      */
  17341.     private String[] tipiInRequestHandlerBuiltIn = null;
  17342.     private boolean tipiInRequestHandlerBuiltInRead = false;
  17343.     public String[] getInRequestHandlerBuiltIn() {
  17344.         if(this.tipiInRequestHandlerBuiltInRead == false){
  17345.             try{ 
  17346.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.in-request");
  17347.                 if(value!=null){
  17348.                     value = value.trim();
  17349.                     String [] r = value.split(",");
  17350.                     this.tipiInRequestHandlerBuiltIn = r;
  17351.                 }else{
  17352.                     this.tipiInRequestHandlerBuiltIn = null;
  17353.                 }
  17354.             }catch(java.lang.Exception e) {
  17355.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.in-request': "+e.getMessage(),e);
  17356.                 this.tipiInRequestHandlerBuiltIn = null;
  17357.             }   
  17358.             this.tipiInRequestHandlerBuiltInRead = true;
  17359.         }

  17361.         return this.tipiInRequestHandlerBuiltIn;
  17362.     }
  17363.     
  17364.     /**
  17365.      * Restituisce l'elenco degli handlers di tipo InRequestProtocolHandlerBuiltIn
  17366.      * 
  17367.      * @return  Restituisce l'elenco degli handlers di tipo InRequestProtocolHandlerBuiltIn
  17368.      */
  17369.     private String[] tipiInRequestProtocolHandlerBuiltIn = null;
  17370.     private boolean tipiInRequestProtocolHandlerBuiltInRead = false;
  17371.     public String[] getInRequestProtocolHandlerBuiltIn() {
  17372.         if(this.tipiInRequestProtocolHandlerBuiltInRead == false){
  17373.             try{ 
  17374.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.in-protocol-request");
  17375.                 if(value!=null){
  17376.                     value = value.trim();
  17377.                     String [] r = value.split(",");
  17378.                     this.tipiInRequestProtocolHandlerBuiltIn = r;
  17379.                 }else{
  17380.                     this.tipiInRequestProtocolHandlerBuiltIn = null;
  17381.                 }
  17382.             }catch(java.lang.Exception e) {
  17383.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.in-protocol-request': "+e.getMessage(),e);
  17384.                 this.tipiInRequestProtocolHandlerBuiltIn = null;
  17385.             }   
  17386.             this.tipiInRequestProtocolHandlerBuiltInRead = true;
  17387.         }

  17389.         return this.tipiInRequestProtocolHandlerBuiltIn;
  17390.     }
  17391.     
  17392.     /**
  17393.      * Restituisce l'elenco degli handlers di tipo OutRequestHandlerBuiltIn
  17394.      * 
  17395.      * @return  Restituisce l'elenco degli handlers di tipo OutRequestHandlerBuiltIn
  17396.      */
  17397.     private String[] tipiOutRequestHandlerBuiltIn = null;
  17398.     private boolean tipiOutRequestHandlerBuiltInRead = false;
  17399.     public String[] getOutRequestHandlerBuiltIn() {
  17400.         if(this.tipiOutRequestHandlerBuiltInRead == false){
  17401.             try{ 
  17402.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.out-request");
  17403.                 if(value!=null){
  17404.                     value = value.trim();
  17405.                     String [] r = value.split(",");
  17406.                     this.tipiOutRequestHandlerBuiltIn = r;
  17407.                 }else{
  17408.                     this.tipiOutRequestHandlerBuiltIn = null;
  17409.                 }
  17410.             }catch(java.lang.Exception e) {
  17411.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.out-request': "+e.getMessage(),e);
  17412.                 this.tipiOutRequestHandlerBuiltIn = null;
  17413.             }   
  17414.             this.tipiOutRequestHandlerBuiltInRead = true;
  17415.         }

  17417.         return this.tipiOutRequestHandlerBuiltIn;
  17418.     }
  17419.     
  17420.     /**
  17421.      * Restituisce l'elenco degli handlers di tipo PostOutRequestHandlerBuiltIn
  17422.      * 
  17423.      * @return  Restituisce l'elenco degli handlers di tipo PostOutRequestHandlerBuiltIn
  17424.      */
  17425.     private String[] tipiPostOutRequestHandlerBuiltIn = null;
  17426.     private boolean tipiPostOutRequestHandlerBuiltInRead = false;
  17427.     public String[] getPostOutRequestHandlerBuiltIn() {
  17428.         if(this.tipiPostOutRequestHandlerBuiltInRead == false){
  17429.             try{ 
  17430.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.post-out-request");
  17431.                 if(value!=null){
  17432.                     value = value.trim();
  17433.                     String [] r = value.split(",");
  17434.                     this.tipiPostOutRequestHandlerBuiltIn = r;
  17435.                 }else{
  17436.                     this.tipiPostOutRequestHandlerBuiltIn = null;
  17437.                 }
  17438.             }catch(java.lang.Exception e) {
  17439.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.post-out-request': "+e.getMessage(),e);
  17440.                 this.tipiPostOutRequestHandlerBuiltIn = null;
  17441.             }   
  17442.             this.tipiPostOutRequestHandlerBuiltInRead = true;
  17443.         }

  17445.         return this.tipiPostOutRequestHandlerBuiltIn;
  17446.     }
  17447.     
  17448.     /**
  17449.      * Restituisce l'elenco degli handlers di tipo PreInResponseHandlerBuiltIn
  17450.      * 
  17451.      * @return  Restituisce l'elenco degli handlers di tipo PreInResponseHandlerBuiltIn
  17452.      */
  17453.     private String[] tipiPreInResponseHandlerBuiltIn = null;
  17454.     private boolean tipiPreInResponseHandlerBuiltInRead = false;
  17455.     public String[] getPreInResponseHandlerBuiltIn() {
  17456.         if(this.tipiPreInResponseHandlerBuiltInRead == false){
  17457.             try{ 
  17458.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.pre-in-response");
  17459.                 if(value!=null){
  17460.                     value = value.trim();
  17461.                     String [] r = value.split(",");
  17462.                     this.tipiPreInResponseHandlerBuiltIn = r;
  17463.                 }else{
  17464.                     this.tipiPreInResponseHandlerBuiltIn = null;
  17465.                 }
  17466.             }catch(java.lang.Exception e) {
  17467.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.pre-in-response': "+e.getMessage(),e);
  17468.                 this.tipiPreInResponseHandlerBuiltIn = null;
  17469.             }   
  17470.             this.tipiPreInResponseHandlerBuiltInRead = true;
  17471.         }

  17473.         return this.tipiPreInResponseHandlerBuiltIn;
  17474.     }
  17475.     
  17476.     /**
  17477.      * Restituisce l'elenco degli handlers di tipo InResponseHandlerBuiltIn
  17478.      * 
  17479.      * @return  Restituisce l'elenco degli handlers di tipo InResponseHandlerBuiltIn
  17480.      */
  17481.     private String[] tipiInResponseHandlerBuiltIn = null;
  17482.     private boolean tipiInResponseHandlerBuiltInRead = false;
  17483.     public String[] getInResponseHandlerBuiltIn() {
  17484.         if(this.tipiInResponseHandlerBuiltInRead == false){
  17485.             try{ 
  17486.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.in-response");
  17487.                 if(value!=null){
  17488.                     value = value.trim();
  17489.                     String [] r = value.split(",");
  17490.                     this.tipiInResponseHandlerBuiltIn = r;
  17491.                 }else{
  17492.                     this.tipiInResponseHandlerBuiltIn = null;
  17493.                 }
  17494.             }catch(java.lang.Exception e) {
  17495.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.in-response': "+e.getMessage(),e);
  17496.                 this.tipiInResponseHandlerBuiltIn = null;
  17497.             }   
  17498.             this.tipiInResponseHandlerBuiltInRead = true;
  17499.         }

  17501.         return this.tipiInResponseHandlerBuiltIn;
  17502.     }
  17503.     
  17504.     /**
  17505.      * Restituisce l'elenco degli handlers di tipo OutResponseHandlerBuiltIn
  17506.      * 
  17507.      * @return  Restituisce l'elenco degli handlers di tipo OutResponseHandlerBuiltIn
  17508.      */
  17509.     private String[] tipiOutResponseHandlerBuiltIn = null;
  17510.     private boolean tipiOutResponseHandlerBuiltInRead = false;
  17511.     public String[] getOutResponseHandlerBuiltIn() {
  17512.         if(this.tipiOutResponseHandlerBuiltInRead == false){
  17513.             try{ 
  17514.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.out-response");
  17515.                 if(value!=null){
  17516.                     value = value.trim();
  17517.                     String [] r = value.split(",");
  17518.                     this.tipiOutResponseHandlerBuiltIn = r;
  17519.                 }else{
  17520.                     this.tipiOutResponseHandlerBuiltIn = null;
  17521.                 }
  17522.             }catch(java.lang.Exception e) {
  17523.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.out-response': "+e.getMessage(),e);
  17524.                 this.tipiOutResponseHandlerBuiltIn = null;
  17525.             }   
  17526.             this.tipiOutResponseHandlerBuiltInRead = true;
  17527.         }

  17529.         return this.tipiOutResponseHandlerBuiltIn;
  17530.     }
  17531.     
  17532.     /**
  17533.      * Restituisce l'elenco degli handlers di tipo PostOutResponseHandlerBuiltIn
  17534.      * 
  17535.      * @return  Restituisce l'elenco degli handlers di tipo PostOutResponseHandlerBuiltIn
  17536.      */
  17537.     private String[] tipiPostOutResponseHandlerBuiltIn = null;
  17538.     private boolean tipiPostOutResponseHandlerBuiltInRead = false;
  17539.     public String[] getPostOutResponseHandlerBuiltIn() {
  17540.         if(this.tipiPostOutResponseHandlerBuiltInRead == false){
  17541.             try{ 
  17542.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.post-out-response");
  17543.                 if(value!=null){
  17544.                     value = value.trim();
  17545.                     String [] r = value.split(",");
  17546.                     this.tipiPostOutResponseHandlerBuiltIn = r;
  17547.                 }else{
  17548.                     this.tipiPostOutResponseHandlerBuiltIn = null;
  17549.                 }
  17550.             }catch(java.lang.Exception e) {
  17551.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.post-out-response': "+e.getMessage(),e);
  17552.                 this.tipiPostOutResponseHandlerBuiltIn = null;
  17553.             }   
  17554.             this.tipiPostOutResponseHandlerBuiltInRead = true;
  17555.         }

  17557.         return this.tipiPostOutResponseHandlerBuiltIn;
  17558.     }

  17560.     /**
  17561.      * Restituisce l'elenco degli handlers di tipo IntegrationManagerRequestHandlerBuiltIn
  17562.      * 
  17563.      * @return  Restituisce l'elenco degli handlers di tipo IntegrationManagerRequestHandlerBuiltIn
  17564.      */
  17565.     private String[] tipiIntegrationManagerRequestHandlerBuiltIn = null;
  17566.     private boolean tipiIntegrationManagerRequestHandlerBuiltInRead = false;
  17567.     public String[] getIntegrationManagerRequestHandlerBuiltIn() {
  17568.         if(this.tipiIntegrationManagerRequestHandlerBuiltInRead == false){
  17569.             try{ 
  17570.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.handler.built-in.request");
  17571.                 if(value!=null){
  17572.                     value = value.trim();
  17573.                     String [] r = value.split(",");
  17574.                     this.tipiIntegrationManagerRequestHandlerBuiltIn = r;
  17575.                 }else{
  17576.                     this.tipiIntegrationManagerRequestHandlerBuiltIn = null;
  17577.                 }
  17578.             }catch(java.lang.Exception e) {
  17579.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.integrationManager.handler.built-in.request': "+e.getMessage(),e);
  17580.                 this.tipiIntegrationManagerRequestHandlerBuiltIn = null;
  17581.             }   
  17582.             this.tipiIntegrationManagerRequestHandlerBuiltInRead = true;
  17583.         }

  17585.         return this.tipiIntegrationManagerRequestHandlerBuiltIn;
  17586.     }
  17587.     
  17588.     /**
  17589.      * Restituisce l'elenco degli handlers di tipo IntegrationManagerResponseHandlerBuiltIn
  17590.      * 
  17591.      * @return  Restituisce l'elenco degli handlers di tipo IntegrationManagerResponseHandlerBuiltIn
  17592.      */
  17593.     private String[] tipiIntegrationManagerResponseHandlerBuiltIn = null;
  17594.     private boolean tipiIntegrationManagerResponseHandlerBuiltInRead = false;
  17595.     public String[] getIntegrationManagerResponseHandlerBuiltIn() {
  17596.         if(this.tipiIntegrationManagerResponseHandlerBuiltInRead == false){
  17597.             try{ 
  17598.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.handler.built-in.response");
  17599.                 if(value!=null){
  17600.                     value = value.trim();
  17601.                     String [] r = value.split(",");
  17602.                     this.tipiIntegrationManagerResponseHandlerBuiltIn = r;
  17603.                 }else{
  17604.                     this.tipiIntegrationManagerResponseHandlerBuiltIn = null;
  17605.                 }
  17606.             }catch(java.lang.Exception e) {
  17607.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.integrationManager.handler.built-in.response': "+e.getMessage(),e);
  17608.                 this.tipiIntegrationManagerResponseHandlerBuiltIn = null;
  17609.             }   
  17610.             this.tipiIntegrationManagerResponseHandlerBuiltInRead = true;
  17611.         }

  17613.         return this.tipiIntegrationManagerResponseHandlerBuiltIn;
  17614.     }
  17615.     
  17616.     
  17617.     
  17618.     
  17619.     

  17621.     /*---------- Gestori handler -------------*/
  17622.     
  17623.     private Boolean printInfoHandler = null;
  17624.     public boolean isPrintInfoHandler() {   
  17625.         if(this.printInfoHandler==null){
  17626.             try{ 
  17627.                 String v = null;
  17628.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.printInfo");
  17629.                 if(v!=null){
  17630.                     v = v.trim();
  17631.                     this.printInfoHandler = Boolean.parseBoolean(v);
  17632.                 } 
  17633.                 else{
  17634.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.printInfo' non impostata, viene utilizzato il default="+true);
  17635.                     this.printInfoHandler = true;
  17636.                 }
  17637.             }catch(java.lang.Exception e) {
  17638.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.printInfo' non impostata correttamente,  errore:"+e.getMessage(),e);
  17639.             } 
  17640.         }
  17641.         return this.printInfoHandler;
  17642.     }
  17643.     
  17644.     /**
  17645.      * Restituisce l'elenco degli handlers di tipo InitHandler
  17646.      * 
  17647.      * @return  Restituisce l'elenco degli handlers di tipo InitHandler
  17648.      */
  17649.     private String[] tipiInitHandler = null;
  17650.     private boolean tipiInitHandlerRead = false;
  17651.     public String[] getInitHandler() {
  17652.         if(this.tipiInitHandlerRead == false){
  17653.             try{ 
  17654.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.init");
  17655.                 if(value!=null){
  17656.                     value = value.trim();
  17657.                     String [] r = value.split(",");
  17658.                     this.tipiInitHandler = r;
  17659.                 }else{
  17660.                     this.tipiInitHandler = null;
  17661.                 }
  17662.             }catch(java.lang.Exception e) {
  17663.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.init': "+e.getMessage(),e);
  17664.                 this.tipiInitHandler = null;
  17665.             }   
  17666.             this.tipiInitHandlerRead = true;
  17667.         }

  17669.         return this.tipiInitHandler;
  17670.     }
  17671.     
  17672.     /**
  17673.      * Restituisce l'elenco degli handlers di tipo ExitHandler
  17674.      * 
  17675.      * @return  Restituisce l'elenco degli handlers di tipo ExitHandler
  17676.      */
  17677.     private String[] tipiExitHandler = null;
  17678.     private boolean tipiExitHandlerRead = false;
  17679.     public String[] getExitHandler() {
  17680.         if(this.tipiExitHandlerRead == false){
  17681.             try{ 
  17682.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.exit");
  17683.                 if(value!=null){
  17684.                     value = value.trim();
  17685.                     String [] r = value.split(",");
  17686.                     this.tipiExitHandler = r;
  17687.                 }else{
  17688.                     this.tipiExitHandler = null;
  17689.                 }
  17690.             }catch(java.lang.Exception e) {
  17691.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.exit': "+e.getMessage(),e);
  17692.                 this.tipiExitHandler = null;
  17693.             }   
  17694.             this.tipiExitHandlerRead = true;
  17695.         }

  17697.         return this.tipiExitHandler;
  17698.     }
  17699.     
  17700.     /**
  17701.      * Restituisce l'elenco degli handlers di tipo PreInRequestHandler
  17702.      * 
  17703.      * @return  Restituisce l'elenco degli handlers di tipo PreInRequestHandler
  17704.      */
  17705.     private String[] tipiPreInRequestHandler = null;
  17706.     private boolean tipiPreInRequestHandlerRead = false;
  17707.     public String[] getPreInRequestHandler() {
  17708.         if(this.tipiPreInRequestHandlerRead == false){
  17709.             try{ 
  17710.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.pre-in-request");
  17711.                 if(value!=null){
  17712.                     value = value.trim();
  17713.                     String [] r = value.split(",");
  17714.                     this.tipiPreInRequestHandler = r;
  17715.                 }else{
  17716.                     this.tipiPreInRequestHandler = null;
  17717.                 }
  17718.             }catch(java.lang.Exception e) {
  17719.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.pre-in-request': "+e.getMessage(),e);
  17720.                 this.tipiPreInRequestHandler = null;
  17721.             }   
  17722.             this.tipiPreInRequestHandlerRead = true;
  17723.         }

  17725.         return this.tipiPreInRequestHandler;
  17726.     }

  17728.     
  17729.     /**
  17730.      * Restituisce l'elenco degli handlers di tipo InRequestHandler
  17731.      * 
  17732.      * @return  Restituisce l'elenco degli handlers di tipo InRequestHandler
  17733.      */
  17734.     private String[] tipiInRequestHandler = null;
  17735.     private boolean tipiInRequestHandlerRead = false;
  17736.     public String[] getInRequestHandler() {
  17737.         if(this.tipiInRequestHandlerRead == false){
  17738.             try{ 
  17739.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.in-request");
  17740.                 if(value!=null){
  17741.                     value = value.trim();
  17742.                     String [] r = value.split(",");
  17743.                     this.tipiInRequestHandler = r;
  17744.                 }else{
  17745.                     this.tipiInRequestHandler = null;
  17746.                 }
  17747.             }catch(java.lang.Exception e) {
  17748.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.in-request': "+e.getMessage(),e);
  17749.                 this.tipiInRequestHandler = null;
  17750.             }   
  17751.             this.tipiInRequestHandlerRead = true;
  17752.         }

  17754.         return this.tipiInRequestHandler;
  17755.     }
  17756.     
  17757.     /**
  17758.      * Restituisce l'elenco degli handlers di tipo InRequestProtocolHandler
  17759.      * 
  17760.      * @return  Restituisce l'elenco degli handlers di tipo InRequestProtocolHandler
  17761.      */
  17762.     private String[] tipiInRequestProtocolHandler = null;
  17763.     private boolean tipiInRequestProtocolHandlerRead = false;
  17764.     public String[] getInRequestProtocolHandler() {
  17765.         if(this.tipiInRequestProtocolHandlerRead == false){
  17766.             try{ 
  17767.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.in-protocol-request");
  17768.                 if(value!=null){
  17769.                     value = value.trim();
  17770.                     String [] r = value.split(",");
  17771.                     this.tipiInRequestProtocolHandler = r;
  17772.                 }else{
  17773.                     this.tipiInRequestProtocolHandler = null;
  17774.                 }
  17775.             }catch(java.lang.Exception e) {
  17776.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.in-protocol-request': "+e.getMessage(),e);
  17777.                 this.tipiInRequestProtocolHandler = null;
  17778.             }   
  17779.             this.tipiInRequestProtocolHandlerRead = true;
  17780.         }

  17782.         return this.tipiInRequestProtocolHandler;
  17783.     }
  17784.     
  17785.     /**
  17786.      * Restituisce l'elenco degli handlers di tipo OutRequestHandler
  17787.      * 
  17788.      * @return  Restituisce l'elenco degli handlers di tipo OutRequestHandler
  17789.      */
  17790.     private String[] tipiOutRequestHandler = null;
  17791.     private boolean tipiOutRequestHandlerRead = false;
  17792.     public String[] getOutRequestHandler() {
  17793.         if(this.tipiOutRequestHandlerRead == false){
  17794.             try{ 
  17795.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.out-request");
  17796.                 if(value!=null){
  17797.                     value = value.trim();
  17798.                     String [] r = value.split(",");
  17799.                     this.tipiOutRequestHandler = r;
  17800.                 }else{
  17801.                     this.tipiOutRequestHandler = null;
  17802.                 }
  17803.             }catch(java.lang.Exception e) {
  17804.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.out-request': "+e.getMessage(),e);
  17805.                 this.tipiOutRequestHandler = null;
  17806.             }   
  17807.             this.tipiOutRequestHandlerRead = true;
  17808.         }

  17810.         return this.tipiOutRequestHandler;
  17811.     }
  17812.     
  17813.     /**
  17814.      * Restituisce l'elenco degli handlers di tipo PostOutRequestHandler
  17815.      * 
  17816.      * @return  Restituisce l'elenco degli handlers di tipo PostOutRequestHandler
  17817.      */
  17818.     private String[] tipiPostOutRequestHandler = null;
  17819.     private boolean tipiPostOutRequestHandlerRead = false;
  17820.     public String[] getPostOutRequestHandler() {
  17821.         if(this.tipiPostOutRequestHandlerRead == false){
  17822.             try{ 
  17823.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.post-out-request");
  17824.                 if(value!=null){
  17825.                     value = value.trim();
  17826.                     String [] r = value.split(",");
  17827.                     this.tipiPostOutRequestHandler = r;
  17828.                 }else{
  17829.                     this.tipiPostOutRequestHandler = null;
  17830.                 }
  17831.             }catch(java.lang.Exception e) {
  17832.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.post-out-request': "+e.getMessage(),e);
  17833.                 this.tipiPostOutRequestHandler = null;
  17834.             }   
  17835.             this.tipiPostOutRequestHandlerRead = true;
  17836.         }

  17838.         return this.tipiPostOutRequestHandler;
  17839.     }
  17840.     
  17841.     /**
  17842.      * Restituisce l'elenco degli handlers di tipo PreInResponseHandler
  17843.      * 
  17844.      * @return  Restituisce l'elenco degli handlers di tipo PreInResponseHandler
  17845.      */
  17846.     private String[] tipiPreInResponseHandler = null;
  17847.     private boolean tipiPreInResponseHandlerRead = false;
  17848.     public String[] getPreInResponseHandler() {
  17849.         if(this.tipiPreInResponseHandlerRead == false){
  17850.             try{ 
  17851.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.pre-in-response");
  17852.                 if(value!=null){
  17853.                     value = value.trim();
  17854.                     String [] r = value.split(",");
  17855.                     this.tipiPreInResponseHandler = r;
  17856.                 }else{
  17857.                     this.tipiPreInResponseHandler = null;
  17858.                 }
  17859.             }catch(java.lang.Exception e) {
  17860.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.pre-in-response': "+e.getMessage(),e);
  17861.                 this.tipiPreInResponseHandler = null;
  17862.             }   
  17863.             this.tipiPreInResponseHandlerRead = true;
  17864.         }

  17866.         return this.tipiPreInResponseHandler;
  17867.     }
  17868.     
  17869.     /**
  17870.      * Restituisce l'elenco degli handlers di tipo InResponseHandler
  17871.      * 
  17872.      * @return  Restituisce l'elenco degli handlers di tipo InResponseHandler
  17873.      */
  17874.     private String[] tipiInResponseHandler = null;
  17875.     private boolean tipiInResponseHandlerRead = false;
  17876.     public String[] getInResponseHandler() {
  17877.         if(this.tipiInResponseHandlerRead == false){
  17878.             try{ 
  17879.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.in-response");
  17880.                 if(value!=null){
  17881.                     value = value.trim();
  17882.                     String [] r = value.split(",");
  17883.                     this.tipiInResponseHandler = r;
  17884.                 }else{
  17885.                     this.tipiInResponseHandler = null;
  17886.                 }
  17887.             }catch(java.lang.Exception e) {
  17888.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.in-response': "+e.getMessage(),e);
  17889.                 this.tipiInResponseHandler = null;
  17890.             }   
  17891.             this.tipiInResponseHandlerRead = true;
  17892.         }

  17894.         return this.tipiInResponseHandler;
  17895.     }
  17896.     
  17897.     /**
  17898.      * Restituisce l'elenco degli handlers di tipo OutResponseHandler
  17899.      * 
  17900.      * @return  Restituisce l'elenco degli handlers di tipo OutResponseHandler
  17901.      */
  17902.     private String[] tipiOutResponseHandler = null;
  17903.     private boolean tipiOutResponseHandlerRead = false;
  17904.     public String[] getOutResponseHandler() {
  17905.         if(this.tipiOutResponseHandlerRead == false){
  17906.             try{ 
  17907.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.out-response");
  17908.                 if(value!=null){
  17909.                     value = value.trim();
  17910.                     String [] r = value.split(",");
  17911.                     this.tipiOutResponseHandler = r;
  17912.                 }else{
  17913.                     this.tipiOutResponseHandler = null;
  17914.                 }
  17915.             }catch(java.lang.Exception e) {
  17916.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.out-response': "+e.getMessage(),e);
  17917.                 this.tipiOutResponseHandler = null;
  17918.             }   
  17919.             this.tipiOutResponseHandlerRead = true;
  17920.         }

  17922.         return this.tipiOutResponseHandler;
  17923.     }
  17924.     
  17925.     /**
  17926.      * Restituisce l'elenco degli handlers di tipo PostOutResponseHandler
  17927.      * 
  17928.      * @return  Restituisce l'elenco degli handlers di tipo PostOutResponseHandler
  17929.      */
  17930.     private String[] tipiPostOutResponseHandler = null;
  17931.     private boolean tipiPostOutResponseHandlerRead = false;
  17932.     public String[] getPostOutResponseHandler() {
  17933.         if(this.tipiPostOutResponseHandlerRead == false){
  17934.             try{ 
  17935.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.post-out-response");
  17936.                 if(value!=null){
  17937.                     value = value.trim();
  17938.                     String [] r = value.split(",");
  17939.                     this.tipiPostOutResponseHandler = r;
  17940.                 }else{
  17941.                     this.tipiPostOutResponseHandler = null;
  17942.                 }
  17943.             }catch(java.lang.Exception e) {
  17944.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.post-out-response': "+e.getMessage(),e);
  17945.                 this.tipiPostOutResponseHandler = null;
  17946.             }   
  17947.             this.tipiPostOutResponseHandlerRead = true;
  17948.         }

  17950.         return this.tipiPostOutResponseHandler;
  17951.     }

  17953.     /**
  17954.      * Restituisce l'elenco degli handlers di tipo IntegrationManagerRequestHandler
  17955.      * 
  17956.      * @return  Restituisce l'elenco degli handlers di tipo IntegrationManagerRequestHandler
  17957.      */
  17958.     private String[] tipiIntegrationManagerRequestHandler = null;
  17959.     private boolean tipiIntegrationManagerRequestHandlerRead = false;
  17960.     public String[] getIntegrationManagerRequestHandler() {
  17961.         if(this.tipiIntegrationManagerRequestHandlerRead == false){
  17962.             try{ 
  17963.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.handler.request");
  17964.                 if(value!=null){
  17965.                     value = value.trim();
  17966.                     String [] r = value.split(",");
  17967.                     this.tipiIntegrationManagerRequestHandler = r;
  17968.                 }else{
  17969.                     this.tipiIntegrationManagerRequestHandler = null;
  17970.                 }
  17971.             }catch(java.lang.Exception e) {
  17972.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.integrationManager.handler.request': "+e.getMessage(),e);
  17973.                 this.tipiIntegrationManagerRequestHandler = null;
  17974.             }   
  17975.             this.tipiIntegrationManagerRequestHandlerRead = true;
  17976.         }

  17978.         return this.tipiIntegrationManagerRequestHandler;
  17979.     }
  17980.     
  17981.     /**
  17982.      * Restituisce l'elenco degli handlers di tipo IntegrationManagerResponseHandler
  17983.      * 
  17984.      * @return  Restituisce l'elenco degli handlers di tipo IntegrationManagerResponseHandler
  17985.      */
  17986.     private String[] tipiIntegrationManagerResponseHandler = null;
  17987.     private boolean tipiIntegrationManagerResponseHandlerRead = false;
  17988.     public String[] getIntegrationManagerResponseHandler() {
  17989.         if(this.tipiIntegrationManagerResponseHandlerRead == false){
  17990.             try{ 
  17991.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.handler.response");
  17992.                 if(value!=null){
  17993.                     value = value.trim();
  17994.                     String [] r = value.split(",");
  17995.                     this.tipiIntegrationManagerResponseHandler = r;
  17996.                 }else{
  17997.                     this.tipiIntegrationManagerResponseHandler = null;
  17998.                 }
  17999.             }catch(java.lang.Exception e) {
  18000.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.integrationManager.handler.response': "+e.getMessage(),e);
  18001.                 this.tipiIntegrationManagerResponseHandler = null;
  18002.             }   
  18003.             this.tipiIntegrationManagerResponseHandlerRead = true;
  18004.         }

  18006.         return this.tipiIntegrationManagerResponseHandler;
  18007.     }









  18017.     /* ----------- MessageSecurity --------------------- */
  18018.     
  18019.     private Boolean isLoadApacheXMLDSig = null;
  18020.     public boolean isLoadApacheXMLDSig(){

  18022.         String pName = "org.openspcoop2.pdd.security.addApacheXMLDSigProvider";
  18023.         if(this.isLoadApacheXMLDSig==null){
  18024.             try{  
  18025.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18027.                 if (value != null){
  18028.                     value = value.trim();
  18029.                     this.isLoadApacheXMLDSig = Boolean.parseBoolean(value);
  18030.                 }else{
  18031.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  18032.                     this.isLoadApacheXMLDSig = true;
  18033.                 }

  18035.             }catch(java.lang.Exception e) {
  18036.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  18037.                 this.isLoadApacheXMLDSig = true;
  18038.             }
  18039.         }

  18041.         return this.isLoadApacheXMLDSig;
  18042.     }
  18043.     
  18044.     private Boolean isLoadBouncyCastle = null;
  18045.     public boolean isLoadBouncyCastle(){

  18047.         if(this.isLoadBouncyCastle==null){
  18048.             try{  
  18049.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.security.addBouncyCastleProvider"); 

  18051.                 if (value != null){
  18052.                     value = value.trim();
  18053.                     this.isLoadBouncyCastle = Boolean.parseBoolean(value);
  18054.                 }else{
  18055.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.security.addBouncyCastleProvider' non impostata, viene utilizzato il default=true");
  18056.                     this.isLoadBouncyCastle = true;
  18057.                 }

  18059.             }catch(java.lang.Exception e) {
  18060.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.security.addBouncyCastleProvider' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  18061.                 this.isLoadBouncyCastle = true;
  18062.             }
  18063.         }

  18065.         return this.isLoadBouncyCastle;
  18066.     }
  18067.     
  18068.     private Boolean secureRandomBouncyCastle_read = null;
  18069.     private String bouncyCastleSecureRandomAlgo = null;
  18070.     public String getBouncyCastleSecureRandomAlgorithm(){

  18072.         String pName = "org.openspcoop2.pdd.security.bouncyCastleProvider.secureRandomAlgorithm";
  18073.         if(this.secureRandomBouncyCastle_read==null){
  18074.             try{  
  18075.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18077.                 if (value != null){
  18078.                     value = value.trim();
  18079.                     this.bouncyCastleSecureRandomAlgo = value;
  18080.                 }

  18082.             }catch(java.lang.Exception e) {
  18083.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  18084.                 this.bouncyCastleSecureRandomAlgo = null;
  18085.             }
  18086.             
  18087.             this.secureRandomBouncyCastle_read = true;
  18088.         }

  18090.         return this.bouncyCastleSecureRandomAlgo;
  18091.     }
  18092.     
  18093.     private Boolean isUseBouncyCastleProviderForCertificate = null;
  18094.     public boolean isUseBouncyCastleProviderForCertificate(){

  18096.         if(this.isUseBouncyCastleProviderForCertificate==null){
  18097.             String pName = "org.openspcoop2.pdd.security.cert.useBouncyCastleProvider";
  18098.             try{  
  18099.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18101.                 if (value != null){
  18102.                     value = value.trim();
  18103.                     this.isUseBouncyCastleProviderForCertificate = Boolean.parseBoolean(value);
  18104.                 }else{
  18105.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  18106.                     this.isUseBouncyCastleProviderForCertificate = true;
  18107.                 }

  18109.             }catch(java.lang.Exception e) {
  18110.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  18111.                 this.isUseBouncyCastleProviderForCertificate = true;
  18112.             }
  18113.         }

  18115.         return this.isUseBouncyCastleProviderForCertificate;
  18116.     }
  18117.     
  18118.     private Boolean isUseBouncyCastleProviderForMessageDigest = null;
  18119.     public boolean isUseBouncyCastleProviderForMessageDigest(){

  18121.         if(this.isUseBouncyCastleProviderForMessageDigest==null){
  18122.             String pName = "org.openspcoop2.pdd.security.digest.useBouncyCastleProvider";
  18123.             try{  
  18124.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18126.                 if (value != null){
  18127.                     value = value.trim();
  18128.                     this.isUseBouncyCastleProviderForMessageDigest = Boolean.parseBoolean(value);
  18129.                 }else{
  18130.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  18131.                     this.isUseBouncyCastleProviderForMessageDigest = true;
  18132.                 }

  18134.             }catch(java.lang.Exception e) {
  18135.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  18136.                 this.isUseBouncyCastleProviderForMessageDigest = true;
  18137.             }
  18138.         }

  18140.         return this.isUseBouncyCastleProviderForMessageDigest;
  18141.     }
  18142.     
  18143.     private Boolean isUseBouncyCastleProviderForWss4jCryptoMerlin = null;
  18144.     public boolean isUseBouncyCastleProviderForWss4jCryptoMerlin(){

  18146.         if(this.isUseBouncyCastleProviderForWss4jCryptoMerlin==null){
  18147.             String pName = "org.openspcoop2.pdd.security.wss4jCryptoMerlin.useBouncyCastleProvider";
  18148.             try{  
  18149.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18151.                 if (value != null){
  18152.                     value = value.trim();
  18153.                     this.isUseBouncyCastleProviderForWss4jCryptoMerlin = Boolean.parseBoolean(value);
  18154.                 }else{
  18155.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  18156.                     this.isUseBouncyCastleProviderForWss4jCryptoMerlin = true;
  18157.                 }

  18159.             }catch(java.lang.Exception e) {
  18160.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  18161.                 this.isUseBouncyCastleProviderForWss4jCryptoMerlin = true;
  18162.             }
  18163.         }

  18165.         return this.isUseBouncyCastleProviderForWss4jCryptoMerlin;
  18166.     }
  18167.     
  18168.     private Boolean securityEgd_read = null;
  18169.     private String securityEgd = null;
  18170.     public String getSecurityEgd(){

  18172.         String pName = "org.openspcoop2.pdd.security.egd";
  18173.         if(this.securityEgd_read==null){
  18174.             try{  
  18175.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18177.                 if (value != null){
  18178.                     value = value.trim();
  18179.                     this.securityEgd = value;
  18180.                 }

  18182.             }catch(java.lang.Exception e) {
  18183.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  18184.                 this.securityEgd = null;
  18185.             }
  18186.             
  18187.             this.securityEgd_read = true;
  18188.         }

  18190.         return this.securityEgd;
  18191.     }
  18192.     
  18193.     /**
  18194.      * Indicazione se generare un actor di default
  18195.      *   
  18196.      * @return Indicazione se generare un actor di default
  18197.      * 
  18198.      */
  18199.     private Boolean isGenerazioneActorDefault = null;
  18200.     public boolean isGenerazioneActorDefault(String implementazionePdDSoggetto){

  18202.         // ovverriding per implementazione porta di dominio
  18203.         if(this.pddReader!=null){
  18204.             String tipo = this.pddReader.getMessageSecurity_ActorDefaultEnable(implementazionePdDSoggetto);
  18205.             if(tipo!=null && ( 
  18206.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  18207.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  18208.             ){
  18209.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  18210.                     return true;
  18211.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  18212.                     return false;
  18213.             }
  18214.         }

  18216.         if(this.isGenerazioneActorDefault==null){
  18217.             try{  
  18218.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.actorDefault.enable"); 

  18220.                 if (value != null){
  18221.                     value = value.trim();
  18222.                     this.isGenerazioneActorDefault = Boolean.parseBoolean(value);
  18223.                 }else{
  18224.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.actorDefault.enable' non impostata, viene utilizzato il default=true");
  18225.                     this.isGenerazioneActorDefault = true;
  18226.                 }

  18228.             }catch(java.lang.Exception e) {
  18229.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.actorDefault.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  18230.                 this.isGenerazioneActorDefault = true;
  18231.             }
  18232.         }

  18234.         return this.isGenerazioneActorDefault;
  18235.     }


  18238.     /**
  18239.      * Actor di default
  18240.      *   
  18241.      * @return actor di default
  18242.      * 
  18243.      */
  18244.     private String actorDefault = null;
  18245.     public String getActorDefault(String implementazionePdDSoggetto){

  18247.         // ovverriding per implementazione porta di dominio
  18248.         if(this.pddReader!=null){
  18249.             String valore = this.pddReader.getMessageSecurity_ActorDefaultValue(implementazionePdDSoggetto);
  18250.             if(valore!=null){
  18251.                 return valore;
  18252.             }
  18253.         }

  18255.         if(this.actorDefault==null){
  18256.             try{  
  18257.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.actorDefault.valore"); 

  18259.                 if (value != null){
  18260.                     value = value.trim();
  18261.                     this.actorDefault = value;
  18262.                 }else{
  18263.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.actorDefault.valore' non impostata, viene utilizzato il default=openspcoop");
  18264.                     this.actorDefault = "openspcoop";
  18265.                 }

  18267.             }catch(java.lang.Exception e) {
  18268.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.actorDefault.valore' non impostata, viene utilizzato il default=openspcoop, errore:"+e.getMessage(),e);
  18269.                 this.actorDefault = "openspcoop";
  18270.             }
  18271.         }

  18273.         return this.actorDefault;
  18274.     }
  18275.     
  18276.     /**
  18277.      * WsuId prefix associato agli id delle reference utilizzate dagli header di MessageSecurity
  18278.      *   
  18279.      * @return prefix
  18280.      * 
  18281.      */
  18282.     private String prefixWsuId = null;
  18283.     public String getPrefixWsuId(){

  18285.         if(this.prefixWsuId==null){
  18286.             try{  
  18287.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.prefixWsuId"); 

  18289.                 if (value != null){
  18290.                     value = value.trim();
  18291.                     this.prefixWsuId = value;
  18292.                 }else{
  18293.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.prefixWsuId' non impostata, viene utilizzato il default di MessageSecurity");
  18294.                     this.prefixWsuId = "";
  18295.                 }

  18297.             }catch(java.lang.Exception e) {
  18298.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.prefixWsuId' non impostata, viene utilizzato il default di MessageSecurity, errore:"+e.getMessage(),e);
  18299.                 this.prefixWsuId = "";
  18300.             }
  18301.         }

  18303.         return this.prefixWsuId;
  18304.     }
  18305.     
  18306.     private Boolean secureRandomWsuId_read = null;
  18307.     private String wsuIdSecureRandomAlgo = null;
  18308.     public String getWsuIdSecureRandomAlgorithm(){

  18310.         String pName = "org.openspcoop2.pdd.messageSecurity.wsuId.secureRandomAlgorithm";
  18311.         if(this.secureRandomWsuId_read==null){
  18312.             try{  
  18313.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18315.                 if (value != null){
  18316.                     value = value.trim();
  18317.                     this.wsuIdSecureRandomAlgo = value;
  18318.                 }

  18320.             }catch(java.lang.Exception e) {
  18321.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  18322.                 this.wsuIdSecureRandomAlgo = null;
  18323.             }
  18324.             
  18325.             this.secureRandomWsuId_read = true;
  18326.         }

  18328.         return this.wsuIdSecureRandomAlgo;
  18329.     }
  18330.     
  18331.     private Boolean removeAllWsuIdRef = null;
  18332.     public boolean isRemoveAllWsuIdRef(){

  18334.         if(this.removeAllWsuIdRef==null){
  18335.             try{  
  18336.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.removeAllWsuIdRef"); 

  18338.                 if (value != null){
  18339.                     value = value.trim();
  18340.                     this.removeAllWsuIdRef = Boolean.parseBoolean(value);
  18341.                 }else{
  18342.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.removeAllWsuIdRef' non impostata, viene utilizzato il default 'false'");
  18343.                     this.removeAllWsuIdRef = false;
  18344.                 }

  18346.             }catch(java.lang.Exception e) {
  18347.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.removeAllWsuIdRef' non impostata, viene utilizzato il default 'false', errore:"+e.getMessage(),e);
  18348.                 this.removeAllWsuIdRef = false;
  18349.             }
  18350.         }

  18352.         return this.removeAllWsuIdRef;
  18353.     }
  18354.     
  18355.     private String externalPWCallback = null;
  18356.     private Boolean externalPWCallbackReaded = null;
  18357.     public String getExternalPWCallbackPropertyFile(){

  18359.         if(this.externalPWCallbackReaded==null){
  18360.             try{  
  18361.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.externalPWCallback.propertiesFile"); 

  18363.                 if (value != null){
  18364.                     value = value.trim();
  18365.                     this.externalPWCallback = value;
  18366.                 }else{
  18367.                     this.logDebug("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.externalPWCallback.propertiesFile' non impostata");
  18368.                     this.externalPWCallback = null;
  18369.                 }
  18370.                 this.externalPWCallbackReaded = true;

  18372.             }catch(java.lang.Exception e) {
  18373.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.externalPWCallback.propertiesFile' non impostata, errore:"+e.getMessage(),e);
  18374.                 this.externalPWCallback = null;
  18375.                 this.externalPWCallbackReaded = true;
  18376.             }
  18377.         }

  18379.         return this.externalPWCallback;
  18380.     }


  18383.     /**
  18384.      * Restituisce l'indicazione se la cache messageSecurity e' abilitata
  18385.      *
  18386.      * @return Restituisce l'indicazione se la cache messageSecurity e' abilitata
  18387.      */
  18388.     private Boolean isAbilitataCacheMessageSecurityKeystore_value = null;
  18389.     public boolean isAbilitataCacheMessageSecurityKeystore() {
  18390.         if(this.isAbilitataCacheMessageSecurityKeystore_value==null){
  18391.             try{  
  18392.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.keystore.cache.enable"); 
  18393.                 if(value!=null){
  18394.                     value = value.trim();
  18395.                     this.isAbilitataCacheMessageSecurityKeystore_value = Boolean.parseBoolean(value);
  18396.                 }else{
  18397.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.keystore.cache.enable' non impostata, viene utilizzato il default=false");
  18398.                     this.isAbilitataCacheMessageSecurityKeystore_value = false;
  18399.                 }
  18400.             }catch(java.lang.Exception e) {
  18401.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.keystore.cache.enable' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  18402.                 this.isAbilitataCacheMessageSecurityKeystore_value = false;
  18403.             }
  18404.         }

  18406.         return this.isAbilitataCacheMessageSecurityKeystore_value;
  18407.     }

  18409.     /**
  18410.      * Restituisce la dimensione della cache messageSecurity 
  18411.      *
  18412.      * @return Restituisce la dimensione della cache messageSecurity 
  18413.      */
  18414.     private Integer dimensioneCacheMessageSecurityKeystore_value = null;
  18415.     public int getDimensioneCacheMessageSecurityKeystore() throws OpenSPCoop2ConfigurationException{    
  18416.         if(this.dimensioneCacheMessageSecurityKeystore_value==null){
  18417.             try{  
  18418.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.keystore.cache.dimensione"); 
  18419.                 if(value!=null){
  18420.                     value = value.trim();
  18421.                     this.dimensioneCacheMessageSecurityKeystore_value = Integer.parseInt(value);
  18422.                 }else{
  18423.                     this.dimensioneCacheMessageSecurityKeystore_value = -1;
  18424.                 }
  18425.             }catch(java.lang.Exception e) {
  18426.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.keystore.cache.dimensione': "+e.getMessage(),e);
  18427.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop  'org.openspcoop2.pdd.messageSecurity.keystore.cache.dimensione'",e);
  18428.             }
  18429.         }

  18431.         return this.dimensioneCacheMessageSecurityKeystore_value;
  18432.     }

  18434.     /**
  18435.      * Restituisce la  itemLifeSecond della cache messageSecurity
  18436.      *
  18437.      * @return Restituisce la itemLifeSecond della cache messageSecurity
  18438.      */
  18439.     private Integer itemLifeSecondCacheMessageSecurityKeystore_value = null;
  18440.     public int getItemLifeSecondCacheMessageSecurityKeystore() throws OpenSPCoop2ConfigurationException{
  18441.         if(this.itemLifeSecondCacheMessageSecurityKeystore_value==null){
  18442.             try{  
  18443.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.keystore.cache.itemLifeSecond"); 
  18444.                 if(value!=null){
  18445.                     value = value.trim();
  18446.                     this.itemLifeSecondCacheMessageSecurityKeystore_value = Integer.parseInt(value);
  18447.                 }else{
  18448.                     this.itemLifeSecondCacheMessageSecurityKeystore_value = -1;
  18449.                 }
  18450.             }catch(java.lang.Exception e) {
  18451.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.keystore.cache.itemLifeSecond': "+e.getMessage(),e);
  18452.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop  'org.openspcoop2.pdd.messageSecurity.keystore.cache.itemLifeSecond'",e);
  18453.             }
  18454.         }

  18456.         return this.itemLifeSecondCacheMessageSecurityKeystore_value;
  18457.     }
  18458.     
  18459.     
  18460.     
  18461.     
  18462.     
  18463.     
  18464.     /* ********  Gestore Credenziali  ******** */

  18466.     private Boolean getAutenticazioneLockPermitsRead = null;
  18467.     private Integer getAutenticazioneLockPermits = null;
  18468.     public Integer getAutenticazioneLockPermits() {

  18470.         String pName = "org.openspcoop2.pdd.core.autenticazione.lock.permits";
  18471.         if(this.getAutenticazioneLockPermitsRead==null){
  18472.             try{  
  18473.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18475.                 if (value != null){
  18476.                     value = value.trim();
  18477.                     int permits = Integer.parseInt(value); 
  18478.                     if(permits>1) {
  18479.                         // altrimenti è un normale semaphore binario
  18480.                         this.getAutenticazioneLockPermits = permits;
  18481.                     }
  18482.                 }
  18483.                 
  18484.                 
  18485.             }catch(java.lang.Exception e) {
  18486.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  18487.             }
  18488.             
  18489.             this.getAutenticazioneLockPermitsRead = true;
  18490.         }

  18492.         return this.getAutenticazioneLockPermits;
  18493.     }
  18494.     
  18495.     private Map<String, Integer> getTipoAutenticazioneLockPermits = null;
  18496.     public Integer getAutenticazioneLockPermits(String tipoAutenticazione) { 

  18498.         String pName = "org.openspcoop2.pdd.core.autenticazione.lock.permits.";
  18499.         if(this.getTipoAutenticazioneLockPermits==null){
  18500.             
  18501.             this.getTipoAutenticazioneLockPermits = new HashMap<>();
  18502.             
  18503.             try{  
  18504.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  18505.                 processAutenticazioneLockPermits(p);
  18506.             }catch(java.lang.Exception e) {
  18507.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  18508.             }
  18509.             
  18510.         }

  18512.         return this.getTipoAutenticazioneLockPermits.get(tipoAutenticazione);
  18513.     }
  18514.     private void processAutenticazioneLockPermits(Properties p) {
  18515.         if(p!=null && !p.isEmpty()) {
  18516.             for (Object oKey : p.keySet()) {
  18517.                 if(oKey!=null) {
  18518.                     String key = (String) oKey;
  18519.                     String value = p.getProperty(key);
  18520.                     processAutenticazioneLockPermits(key, value);
  18521.                 }
  18522.             }
  18523.         }
  18524.     }
  18525.     private void processAutenticazioneLockPermits(String key, String value) {
  18526.         if(value!=null) {
  18527.             int permits = Integer.parseInt(value);
  18528.             if(permits>1) {
  18529.                 // altrimenti è un normale semaphore binario
  18530.                 this.getTipoAutenticazioneLockPermits.put(key, permits);
  18531.             }
  18532.         }
  18533.     }
  18534.     
  18535.     private Boolean isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed = null;
  18536.     public boolean isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed(){

  18538.         if(this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed==null){
  18539.             String pName = "org.openspcoop2.pdd.core.autenticazione.gestioneToken.saveAuthenticationInfo.authenticationFailed";
  18540.             try{  
  18541.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18543.                 if (value != null){
  18544.                     value = value.trim();
  18545.                     this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed = Boolean.parseBoolean(value);
  18546.                 }else{
  18547.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  18548.                     this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed = true;
  18549.                 }

  18551.             }catch(java.lang.Exception e) {
  18552.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  18553.                 this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed = true;
  18554.             }
  18555.         }

  18557.         return this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed;
  18558.     }
  18559.     
  18560.     private CryptConfig getCryptConfigAutenticazioneApplicativi = null;
  18561.     public CryptConfig getCryptConfigAutenticazioneApplicativi() {
  18562.         if(this.getCryptConfigAutenticazioneApplicativi == null){
  18563.             try{  
  18564.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.autenticazione.applicativi.password"); 
  18565.                 if(value!=null){
  18566.                     value = value.trim();
  18567.                     this.getCryptConfigAutenticazioneApplicativi = new CryptConfig(value);
  18568.                 }
  18569.             }catch(java.lang.Exception e) {
  18570.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.core.autenticazione.applicativi.password': "+e.getMessage(),e);
  18571.                 return null;
  18572.             }
  18573.         }

  18575.         return this.getCryptConfigAutenticazioneApplicativi;
  18576.     }
  18577.     
  18578.     private CryptConfig getCryptConfigAutenticazioneSoggetti = null;
  18579.     public CryptConfig getCryptConfigAutenticazioneSoggetti() {
  18580.         if(this.getCryptConfigAutenticazioneSoggetti == null){
  18581.             try{  
  18582.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.autenticazione.soggetti.password"); 
  18583.                 if(value!=null){
  18584.                     value = value.trim();
  18585.                     this.getCryptConfigAutenticazioneSoggetti = new CryptConfig(value);
  18586.                 }
  18587.             }catch(java.lang.Exception e) {
  18588.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.core.autenticazione.soggetti.password': "+e.getMessage(),e);
  18589.                 return null;
  18590.             }
  18591.         }

  18593.         return this.getCryptConfigAutenticazioneSoggetti;
  18594.     }

  18596.     private Boolean isAutenticazioneBasicLogPassword = null;
  18597.     public boolean isAutenticazioneBasicLogPassword() {
  18598.         String pName = "org.openspcoop2.pdd.core.autenticazione.basic.invalidCredentials.logPassword";
  18599.         if(this.isAutenticazioneBasicLogPassword == null){
  18600.             try{  
  18601.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18602.                 if(value!=null){
  18603.                     value = value.trim();
  18604.                     this.isAutenticazioneBasicLogPassword = Boolean.valueOf(value);
  18605.                 }
  18606.                 else {
  18607.                     this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=false");
  18608.                     this.isAutenticazioneBasicLogPassword = false;
  18609.                 }
  18610.             }catch(java.lang.Exception e) {
  18611.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=false. Errore: "+e.getMessage(),e);
  18612.                 this.isAutenticazioneBasicLogPassword = false;
  18613.             }
  18614.         }

  18616.         return this.isAutenticazioneBasicLogPassword;
  18617.     }
  18618.     
  18619.     private WWWAuthenticateConfig getRealmAutenticazioneBasicWWWAuthenticateConfig = null;
  18620.     private boolean getRealmAutenticazioneBasicWWWAuthenticateConfig_read = false;
  18621.     public WWWAuthenticateConfig getRealmAutenticazioneBasicWWWAuthenticateConfig() {
  18622.         if(this.getRealmAutenticazioneBasicWWWAuthenticateConfig_read == false){
  18623.             
  18624. //          String pNameAuth = "org.openspcoop2.pdd.core.autenticazione.basic.authType";
  18625. //          String authType = null;
  18626. //          try{  
  18627. //              authType = this.reader.getValue_convertEnvProperties(pNameAuth); 
  18628. //              if(authType!=null){
  18629. //                  authType = authType.trim();
  18630. //              }
  18631. //          }catch(java.lang.Exception e) {
  18632. //              this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameAuth+"': "+e.getMessage(),e);
  18633. //          }
  18634.             String authType = HttpConstants.AUTHENTICATION_BASIC;
  18635.             
  18636.             String pNameRealm = "org.openspcoop2.pdd.core.autenticazione.basic.realm";
  18637.             String realm = null;
  18638.             try {
  18639.                 realm = this.reader.getValueConvertEnvProperties(pNameRealm); 
  18640.                 if(realm!=null){
  18641.                     realm = realm.trim();
  18642.                 }
  18643.             }catch(java.lang.Exception e) {
  18644.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameRealm+"': "+e.getMessage(),e);
  18645.             }
  18646.             
  18647.             if(authType!=null && !"".equals(authType) && realm!=null && !"".equals(realm)) {
  18648.                 this.getRealmAutenticazioneBasicWWWAuthenticateConfig = new WWWAuthenticateConfig();
  18649.                 this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setAuthType(authType);
  18650.                 this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setRealm(realm);
  18651.                 
  18652.                 String pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.basic.error_description.notFound";
  18653.                 String error_description = null;
  18654.                 try {
  18655.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  18656.                     if(error_description!=null){
  18657.                         error_description = error_description.trim();
  18658.                         if(!"".equals(error_description)) {
  18659.                             this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setNotFound_error(WWWAuthenticateErrorCode.invalid_request.name());
  18660.                             this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setNotFound_error_description(error_description);
  18661.                         }
  18662.                     }
  18663.                 }catch(java.lang.Exception e) {
  18664.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  18665.                 }
  18666.                 
  18667.                 pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.basic.error_description.invalid";
  18668.                 error_description = null;
  18669.                 try {
  18670.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  18671.                     if(error_description!=null){
  18672.                         error_description = error_description.trim();
  18673.                         if(!"".equals(error_description)) {
  18674.                             this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setInvalid_error(WWWAuthenticateErrorCode.invalid_request.name());
  18675.                             this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setInvalid_error_description(error_description);
  18676.                         }
  18677.                     }
  18678.                 }catch(java.lang.Exception e) {
  18679.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  18680.                 }
  18681.             }
  18682.             
  18683.             this.getRealmAutenticazioneBasicWWWAuthenticateConfig_read = true;
  18684.         }

  18686.         return this.getRealmAutenticazioneBasicWWWAuthenticateConfig;
  18687.     }
  18688.     
  18689.     private WWWAuthenticateConfig getRealmAutenticazioneApiKeyWWWAuthenticateConfig = null;
  18690.     private boolean getRealmAutenticazioneApiKeyWWWAuthenticateConfig_read = false;
  18691.     public WWWAuthenticateConfig getRealmAutenticazioneApiKeyWWWAuthenticateConfig() {
  18692.         if(this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig_read == false){
  18693.             
  18694.             String pNameAuth = "org.openspcoop2.pdd.core.autenticazione.apiKey.authType";
  18695.             String authType = null;
  18696.             try{  
  18697.                 authType = this.reader.getValueConvertEnvProperties(pNameAuth); 
  18698.                 if(authType!=null){
  18699.                     authType = authType.trim();
  18700.                 }
  18701.             }catch(java.lang.Exception e) {
  18702.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameAuth+"': "+e.getMessage(),e);
  18703.             }
  18704.             
  18705.             String pNameRealm = "org.openspcoop2.pdd.core.autenticazione.apiKey.realm";
  18706.             String realm = null;
  18707.             try {
  18708.                 realm = this.reader.getValueConvertEnvProperties(pNameRealm); 
  18709.                 if(realm!=null){
  18710.                     realm = realm.trim();
  18711.                 }
  18712.             }catch(java.lang.Exception e) {
  18713.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameRealm+"': "+e.getMessage(),e);
  18714.             }
  18715.             
  18716.             if(authType!=null && !"".equals(authType) && realm!=null && !"".equals(realm)) {
  18717.                 this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig = new WWWAuthenticateConfig();
  18718.                 this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setAuthType(authType);
  18719.                 this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setRealm(realm);
  18720.                 
  18721.                 String pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.apiKey.error_description.notFound";
  18722.                 String error_description = null;
  18723.                 try {
  18724.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  18725.                     if(error_description!=null){
  18726.                         error_description = error_description.trim();
  18727.                         if(!"".equals(error_description)) {
  18728.                             this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setNotFound_error(WWWAuthenticateErrorCode.invalid_request.name());
  18729.                             this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setNotFound_error_description(error_description);
  18730.                         }
  18731.                     }
  18732.                 }catch(java.lang.Exception e) {
  18733.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  18734.                 }
  18735.                 
  18736.                 pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.apiKey.error_description.invalid";
  18737.                 error_description = null;
  18738.                 try {
  18739.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  18740.                     if(error_description!=null){
  18741.                         error_description = error_description.trim();
  18742.                         if(!"".equals(error_description)) {
  18743.                             this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setInvalid_error(WWWAuthenticateErrorCode.invalid_request.name());
  18744.                             this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setInvalid_error_description(error_description);
  18745.                         }
  18746.                     }
  18747.                 }catch(java.lang.Exception e) {
  18748.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  18749.                 }
  18750.             }
  18751.             
  18752.             this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig_read = true;
  18753.         }

  18755.         return this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig;
  18756.     }
  18757.     
  18758.     private Boolean isAutenticazioneHttpsPortaDelegataValidityCheck = null;
  18759.     public boolean isAutenticazioneHttpsPortaDelegataValidityCheck() {
  18760.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.validityCheck";
  18761.         if(this.isAutenticazioneHttpsPortaDelegataValidityCheck == null){
  18762.             try{  
  18763.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18764.                 if(value!=null){
  18765.                     value = value.trim();
  18766.                     this.isAutenticazioneHttpsPortaDelegataValidityCheck = Boolean.valueOf(value);
  18767.                 }
  18768.                 else {
  18769.                     this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
  18770.                     this.isAutenticazioneHttpsPortaDelegataValidityCheck = true;
  18771.                 }
  18772.             }catch(java.lang.Exception e) {
  18773.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
  18774.                 this.isAutenticazioneHttpsPortaDelegataValidityCheck = true;
  18775.             }
  18776.         }

  18778.         return this.isAutenticazioneHttpsPortaDelegataValidityCheck;
  18779.     }
  18780.     
  18781.     private File getAutenticazioneHttpsPortaDelegataTruststorePath = null;
  18782.     private Boolean getAutenticazioneHttpsPortaDelegataTruststorePath_read = null;
  18783.     public File getAutenticazioneHttpsPortaDelegataTruststorePath() throws CoreException {
  18784.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.path";
  18785.         if(this.getAutenticazioneHttpsPortaDelegataTruststorePath_read == null){
  18786.             try{  
  18787.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18788.                 if(value!=null){
  18789.                     value = value.trim();
  18790.                     this.getAutenticazioneHttpsPortaDelegataTruststorePath = new File(value);
  18791.                     if(this.getAutenticazioneHttpsPortaDelegataTruststorePath.exists()) {
  18792.                         if(!this.getAutenticazioneHttpsPortaDelegataTruststorePath.isFile()) {
  18793.                             throw newCoreExceptionNotFile(this.getAutenticazioneHttpsPortaDelegataTruststorePath, false);
  18794.                         }
  18795.                         if(!this.getAutenticazioneHttpsPortaDelegataTruststorePath.canRead()) {
  18796.                             throw newCoreExceptionCannotRead(this.getAutenticazioneHttpsPortaDelegataTruststorePath,false);
  18797.                         }
  18798.                     }
  18799.                     else {
  18800.                         this.getAutenticazioneHttpsPortaDelegataTruststorePath=null;
  18801.                     }
  18802.                 }
  18803.             }catch(java.lang.Exception e) {
  18804.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18805.             }
  18806.             this.getAutenticazioneHttpsPortaDelegataTruststorePath_read = true;
  18807.         }

  18809.         return this.getAutenticazioneHttpsPortaDelegataTruststorePath;
  18810.     }
  18811.     
  18812.     private String getAutenticazioneHttpsPortaDelegataTruststorePassword = null;
  18813.     private Boolean getAutenticazioneHttpsPortaDelegataTruststorePassword_read = null;
  18814.     public String getAutenticazioneHttpsPortaDelegataTruststorePassword() throws CoreException {
  18815.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.password";
  18816.         if(this.getAutenticazioneHttpsPortaDelegataTruststorePassword_read == null){
  18817.             try{  
  18818.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18819.                 if(value!=null){
  18820.                     value = value.trim();
  18821.                     this.getAutenticazioneHttpsPortaDelegataTruststorePassword = value;
  18822.                 }
  18823.             }catch(java.lang.Exception e) {
  18824.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18825.             }
  18826.             this.getAutenticazioneHttpsPortaDelegataTruststorePassword_read = true;
  18827.         }

  18829.         return this.getAutenticazioneHttpsPortaDelegataTruststorePassword;
  18830.     }
  18831.     
  18832.     private String getAutenticazioneHttpsPortaDelegataTruststoreType = null;
  18833.     public String getAutenticazioneHttpsPortaDelegataTruststoreType() throws CoreException {
  18834.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.type";
  18835.         if(this.getAutenticazioneHttpsPortaDelegataTruststoreType == null){
  18836.             try{  
  18837.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18838.                 if(value!=null){
  18839.                     value = value.trim();
  18840.                     this.getAutenticazioneHttpsPortaDelegataTruststoreType = value;
  18841.                 }
  18842.                 else {
  18843.                     this.getAutenticazioneHttpsPortaDelegataTruststoreType = KeystoreType.JKS.getNome();
  18844.                 }
  18845.             }catch(java.lang.Exception e) {
  18846.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18847.             }
  18848.         }

  18850.         return this.getAutenticazioneHttpsPortaDelegataTruststoreType;
  18851.     }
  18852.     
  18853.     private String getAutenticazioneHttpsPortaDelegataTruststoreCRLs = null;
  18854.     private Boolean getAutenticazioneHttpsPortaDelegataTruststoreCRLs_read = null;
  18855.     public String getAutenticazioneHttpsPortaDelegataTruststoreCRLs() throws CoreException {
  18856.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.crls";
  18857.         if(this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs_read == null){
  18858.             try{  
  18859.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18860.                 if(value!=null){
  18861.                     value = value.trim();
  18862.                     this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs = value;
  18863.                 }
  18864.             }catch(java.lang.Exception e) {
  18865.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18866.             }
  18867.             this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs_read = true;
  18868.         }

  18870.         return this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs;
  18871.     }
  18872.     
  18873.     private String getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy = null;
  18874.     private Boolean getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy_read = null;
  18875.     public String getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy() throws CoreException {
  18876.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.ocspPolicy";
  18877.         if(this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy_read == null){
  18878.             try{  
  18879.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18880.                 if(value!=null){
  18881.                     value = value.trim();
  18882.                     this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy = value;
  18883.                 }
  18884.             }catch(java.lang.Exception e) {
  18885.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18886.             }
  18887.             this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy_read = true;
  18888.         }

  18890.         return this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy;
  18891.     }
  18892.     
  18893.     private Boolean isAutenticazioneHttpsPortaApplicativaValidityCheck = null;
  18894.     public boolean isAutenticazioneHttpsPortaApplicativaValidityCheck() {
  18895.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.validityCheck";
  18896.         if(this.isAutenticazioneHttpsPortaApplicativaValidityCheck == null){
  18897.             try{  
  18898.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18899.                 if(value!=null){
  18900.                     value = value.trim();
  18901.                     this.isAutenticazioneHttpsPortaApplicativaValidityCheck = Boolean.valueOf(value);
  18902.                 }
  18903.                 else {
  18904.                     this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
  18905.                     this.isAutenticazioneHttpsPortaApplicativaValidityCheck = true;
  18906.                 }
  18907.             }catch(java.lang.Exception e) {
  18908.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
  18909.                 this.isAutenticazioneHttpsPortaApplicativaValidityCheck = true;
  18910.             }
  18911.         }

  18913.         return this.isAutenticazioneHttpsPortaApplicativaValidityCheck;
  18914.     }
  18915.     
  18916.     private File getAutenticazioneHttpsPortaApplicativaTruststorePath = null;
  18917.     private Boolean getAutenticazioneHttpsPortaApplicativaTruststorePath_read = null;
  18918.     public File getAutenticazioneHttpsPortaApplicativaTruststorePath() throws CoreException {
  18919.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.path";
  18920.         if(this.getAutenticazioneHttpsPortaApplicativaTruststorePath_read == null){
  18921.             try{  
  18922.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18923.                 if(value!=null){
  18924.                     value = value.trim();
  18925.                     this.getAutenticazioneHttpsPortaApplicativaTruststorePath = new File(value);
  18926.                     if(this.getAutenticazioneHttpsPortaApplicativaTruststorePath.exists()) {
  18927.                         if(!this.getAutenticazioneHttpsPortaApplicativaTruststorePath.isFile()) {
  18928.                             throw newCoreExceptionNotFile(this.getAutenticazioneHttpsPortaApplicativaTruststorePath, false);
  18929.                         }
  18930.                         if(!this.getAutenticazioneHttpsPortaApplicativaTruststorePath.canRead()) {
  18931.                             throw newCoreExceptionCannotRead(this.getAutenticazioneHttpsPortaApplicativaTruststorePath, false);
  18932.                         }
  18933.                     }
  18934.                     else {
  18935.                         this.getAutenticazioneHttpsPortaApplicativaTruststorePath=null;
  18936.                     }
  18937.                 }
  18938.             }catch(java.lang.Exception e) {
  18939.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18940.             }
  18941.             this.getAutenticazioneHttpsPortaApplicativaTruststorePath_read = true;
  18942.         }

  18944.         return this.getAutenticazioneHttpsPortaApplicativaTruststorePath;
  18945.     }
  18946.     
  18947.     private String getAutenticazioneHttpsPortaApplicativaTruststorePassword = null;
  18948.     private Boolean getAutenticazioneHttpsPortaApplicativaTruststorePassword_read = null;
  18949.     public String getAutenticazioneHttpsPortaApplicativaTruststorePassword() throws CoreException {
  18950.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.password";
  18951.         if(this.getAutenticazioneHttpsPortaApplicativaTruststorePassword_read == null){
  18952.             try{  
  18953.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18954.                 if(value!=null){
  18955.                     value = value.trim();
  18956.                     this.getAutenticazioneHttpsPortaApplicativaTruststorePassword = value;
  18957.                 }
  18958.             }catch(java.lang.Exception e) {
  18959.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18960.             }
  18961.             this.getAutenticazioneHttpsPortaApplicativaTruststorePassword_read = true;
  18962.         }

  18964.         return this.getAutenticazioneHttpsPortaApplicativaTruststorePassword;
  18965.     }
  18966.     
  18967.     private String getAutenticazioneHttpsPortaApplicativaTruststoreType = null;
  18968.     public String getAutenticazioneHttpsPortaApplicativaTruststoreType() throws CoreException {
  18969.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.type";
  18970.         if(this.getAutenticazioneHttpsPortaApplicativaTruststoreType == null){
  18971.             try{  
  18972.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18973.                 if(value!=null){
  18974.                     value = value.trim();
  18975.                     this.getAutenticazioneHttpsPortaApplicativaTruststoreType = value;
  18976.                 }
  18977.                 else {
  18978.                     this.getAutenticazioneHttpsPortaApplicativaTruststoreType = KeystoreType.JKS.getNome();
  18979.                 }
  18980.             }catch(java.lang.Exception e) {
  18981.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18982.             }
  18983.         }

  18985.         return this.getAutenticazioneHttpsPortaApplicativaTruststoreType;
  18986.     }
  18987.     
  18988.     private String getAutenticazioneHttpsPortaApplicativaTruststoreCRLs = null;
  18989.     private Boolean getAutenticazioneHttpsPortaApplicativaTruststoreCRLs_read = null;
  18990.     public String getAutenticazioneHttpsPortaApplicativaTruststoreCRLs() throws CoreException {
  18991.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.crls";
  18992.         if(this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs_read == null){
  18993.             try{  
  18994.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18995.                 if(value!=null){
  18996.                     value = value.trim();
  18997.                     this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs = value;
  18998.                 }
  18999.             }catch(java.lang.Exception e) {
  19000.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  19001.             }
  19002.             this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs_read = true;
  19003.         }

  19005.         return this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs;
  19006.     }
  19007.     
  19008.     private String getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy = null;
  19009.     private Boolean getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy_read = null;
  19010.     public String getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy() throws CoreException {
  19011.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.ocspPolicy";
  19012.         if(this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy_read == null){
  19013.             try{  
  19014.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  19015.                 if(value!=null){
  19016.                     value = value.trim();
  19017.                     this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy = value;
  19018.                 }
  19019.             }catch(java.lang.Exception e) {
  19020.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  19021.             }
  19022.             this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy_read = true;
  19023.         }

  19025.         return this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy;
  19026.     }
  19027.     
  19028.     
  19029.     private Boolean isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari = null;
  19030.     public boolean isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari() {
  19031.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.portaDelegata.checkSoggettiProprietari";
  19032.         if(this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari == null){
  19033.             try{  
  19034.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  19035.                 if(value!=null){
  19036.                     value = value.trim();
  19037.                     this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari = Boolean.valueOf(value);
  19038.                 }
  19039.                 else {
  19040.                     this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
  19041.                     this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari = true;
  19042.                 }
  19043.             }catch(java.lang.Exception e) {
  19044.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
  19045.                 this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari = true;
  19046.             }
  19047.         }

  19049.         return this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari;
  19050.     }
  19051.     
  19052.     private WWWAuthenticateConfig getRealmAutenticazioneHttpsWWWAuthenticateConfig = null;
  19053.     private boolean getRealmAutenticazioneHttpsWWWAuthenticateConfig_read = false;
  19054.     public WWWAuthenticateConfig getRealmAutenticazioneHttpsWWWAuthenticateConfig() {
  19055.         if(this.getRealmAutenticazioneHttpsWWWAuthenticateConfig_read == false){
  19056.             
  19057.             String pNameAuth = "org.openspcoop2.pdd.core.autenticazione.https.authType";
  19058.             String authType = null;
  19059.             try{  
  19060.                 authType = this.reader.getValueConvertEnvProperties(pNameAuth); 
  19061.                 if(authType!=null){
  19062.                     authType = authType.trim();
  19063.                 }
  19064.             }catch(java.lang.Exception e) {
  19065.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameAuth+"': "+e.getMessage(),e);
  19066.             }
  19067.             
  19068.             String pNameRealm = "org.openspcoop2.pdd.core.autenticazione.https.realm";
  19069.             String realm = null;
  19070.             try {
  19071.                 realm = this.reader.getValueConvertEnvProperties(pNameRealm); 
  19072.                 if(realm!=null){
  19073.                     realm = realm.trim();
  19074.                 }
  19075.             }catch(java.lang.Exception e) {
  19076.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameRealm+"': "+e.getMessage(),e);
  19077.             }
  19078.             
  19079.             if(authType!=null && !"".equals(authType) && realm!=null && !"".equals(realm)) {
  19080.                 this.getRealmAutenticazioneHttpsWWWAuthenticateConfig = new WWWAuthenticateConfig();
  19081.                 this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setAuthType(authType);
  19082.                 this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setRealm(realm);
  19083.                 
  19084.                 String pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.https.error_description.notFound";
  19085.                 String error_description = null;
  19086.                 try {
  19087.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  19088.                     if(error_description!=null){
  19089.                         error_description = error_description.trim();
  19090.                         if(!"".equals(error_description)) {
  19091.                             this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setNotFound_error(WWWAuthenticateErrorCode.invalid_request.name());
  19092.                             this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setNotFound_error_description(error_description);
  19093.                         }
  19094.                     }
  19095.                 }catch(java.lang.Exception e) {
  19096.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  19097.                 }
  19098.                 
  19099.                 pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.https.error_description.invalid";
  19100.                 error_description = null;
  19101.                 try {
  19102.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  19103.                     if(error_description!=null){
  19104.                         error_description = error_description.trim();
  19105.                         if(!"".equals(error_description)) {
  19106.                             this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setInvalid_error(WWWAuthenticateErrorCode.invalid_request.name());
  19107.                             this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setInvalid_error_description(error_description);
  19108.                         }
  19109.                     }
  19110.                 }catch(java.lang.Exception e) {
  19111.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  19112.                 }
  19113.             }
  19114.             
  19115.             this.getRealmAutenticazioneHttpsWWWAuthenticateConfig_read = true;
  19116.         }

  19118.         return this.getRealmAutenticazioneHttpsWWWAuthenticateConfig;
  19119.     }
  19120.     
  19121.     private Boolean isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari = null;
  19122.     public boolean isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari() {
  19123.         String pName = "org.openspcoop2.pdd.core.autenticazione.principal.portaDelegata.checkSoggettiProprietari";
  19124.         if(this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari == null){
  19125.             try{  
  19126.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  19127.                 if(value!=null){
  19128.                     value = value.trim();
  19129.                     this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari = Boolean.valueOf(value);
  19130.                 }
  19131.                 else {
  19132.                     this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
  19133.                     this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari = true;
  19134.                 }
  19135.             }catch(java.lang.Exception e) {
  19136.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
  19137.                 this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari = true;
  19138.             }
  19139.         }

  19141.         return this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari;
  19142.     }
  19143.     
  19144.     private Map<TipoAutenticazionePrincipal, WWWAuthenticateConfig> getRealmAutenticazionePrincipalWWWAuthenticateConfig = new HashMap<TipoAutenticazionePrincipal, WWWAuthenticateConfig>();
  19145.     public WWWAuthenticateConfig getRealmAutenticazionePrincipalWWWAuthenticateConfig(TipoAutenticazionePrincipal principal) {
  19146.         if(!this.getRealmAutenticazionePrincipalWWWAuthenticateConfig.containsKey(principal)){
  19147.             
  19148.             String pNameAuth = "org.openspcoop2.pdd.core.autenticazione.principal."+principal.getValue()+".authType";
  19149.             String authType = null;
  19150.             try{  
  19151.                 authType = this.reader.getValueConvertEnvProperties(pNameAuth); 
  19152.                 if(authType!=null){
  19153.                     authType = authType.trim();
  19154.                 }
  19155.             }catch(java.lang.Exception e) {
  19156.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameAuth+"': "+e.getMessage(),e);
  19157.             }
  19158.             
  19159.             String pNameRealm = "org.openspcoop2.pdd.core.autenticazione.principal."+principal.getValue()+".realm";
  19160.             String realm = null;
  19161.             try {
  19162.                 realm = this.reader.getValueConvertEnvProperties(pNameRealm); 
  19163.                 if(realm!=null){
  19164.                     realm = realm.trim();
  19165.                 }
  19166.             }catch(java.lang.Exception e) {
  19167.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameRealm+"': "+e.getMessage(),e);
  19168.             }
  19169.             
  19170.             WWWAuthenticateConfig wwwConfig = null;
  19171.             if(authType!=null && !"".equals(authType) && realm!=null && !"".equals(realm)) {
  19172.                 
  19173.                 wwwConfig = new WWWAuthenticateConfig();
  19174.                 wwwConfig.setAuthType(authType);
  19175.                 wwwConfig.setRealm(realm);
  19176.                 
  19177.                 String pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.principal."+principal.getValue()+".error_description.notFound";
  19178.                 String error_description = null;
  19179.                 try {
  19180.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  19181.                     if(error_description!=null){
  19182.                         error_description = error_description.trim();
  19183.                         if(!"".equals(error_description)) {
  19184.                             wwwConfig.setNotFound_error(WWWAuthenticateErrorCode.invalid_request.name());
  19185.                             wwwConfig.setNotFound_error_description(error_description);
  19186.                         }
  19187.                     }
  19188.                 }catch(java.lang.Exception e) {
  19189.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  19190.                 }
  19191.                 
  19192.                 pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.principal."+principal.getValue()+".error_description.invalid";
  19193.                 error_description = null;
  19194.                 try {
  19195.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  19196.                     if(error_description!=null){
  19197.                         error_description = error_description.trim();
  19198.                         if(!"".equals(error_description)) {
  19199.                             wwwConfig.setInvalid_error(WWWAuthenticateErrorCode.invalid_request.name());
  19200.                             wwwConfig.setInvalid_error_description(error_description);
  19201.                         }
  19202.                     }
  19203.                 }catch(java.lang.Exception e) {
  19204.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  19205.                 }
  19206.                 
  19207.             }
  19208.             
  19209.             this.getRealmAutenticazionePrincipalWWWAuthenticateConfig.put(principal, wwwConfig);
  19210.         }

  19212.         return this.getRealmAutenticazionePrincipalWWWAuthenticateConfig.get(principal);
  19213.     }
  19214.     
  19215.     private Boolean isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari = null;
  19216.     public boolean isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari() {
  19217.         String pName = "org.openspcoop2.pdd.core.autenticazione.token.portaDelegata.checkSoggettiProprietari";
  19218.         if(this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari == null){
  19219.             try{  
  19220.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  19221.                 if(value!=null){
  19222.                     value = value.trim();
  19223.                     this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari = Boolean.valueOf(value);
  19224.                 }
  19225.                 else {
  19226.                     this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
  19227.                     this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari = true;
  19228.                 }
  19229.             }catch(java.lang.Exception e) {
  19230.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
  19231.                 this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari = true;
  19232.             }
  19233.         }

  19235.         return this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari;
  19236.     }
  19237.     
  19238.     /**
  19239.      * Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare lato Porta Delegata
  19240.      * 
  19241.      * @return Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare lato Porta Delegata
  19242.      */
  19243.     private String[] tipoGestoreCredenzialiPD = null;
  19244.     private boolean tipoGestoreCredenzialiPDRead = false;
  19245.     public String[] getTipoGestoreCredenzialiPD() {
  19246.         if(this.tipoGestoreCredenzialiPDRead == false){
  19247.             try{  
  19248.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.pd.gestoriCredenziali"); 
  19249.                 if(value!=null){
  19250.                     value = value.trim();
  19251.                     String [] r = value.split(",");
  19252.                     this.tipoGestoreCredenzialiPD = r;
  19253.                 }
  19254.             }catch(java.lang.Exception e) {
  19255.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.services.pd.gestoriCredenziali': "+e.getMessage(),e);
  19256.                 this.tipoGestoreCredenzialiPD = null;
  19257.             }
  19258.             this.tipoGestoreCredenzialiPDRead = true;
  19259.         }

  19261.         return this.tipoGestoreCredenzialiPD;
  19262.     }
  19263.     
  19264.     /**
  19265.      * Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare lato Porta Applicativa
  19266.      * 
  19267.      * @return Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare lato Porta Applicativa
  19268.      */
  19269.     private String[] tipoGestoreCredenzialiPA = null;
  19270.     private boolean tipoGestoreCredenzialiPARead = false;
  19271.     public String[] getTipoGestoreCredenzialiPA() {
  19272.         if(this.tipoGestoreCredenzialiPARead == false){
  19273.             try{  
  19274.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.pa.gestoriCredenziali"); 
  19275.                 if(value!=null){
  19276.                     value = value.trim();
  19277.                     String [] r = value.split(",");
  19278.                     this.tipoGestoreCredenzialiPA = r;
  19279.                 }
  19280.             }catch(java.lang.Exception e) {
  19281.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.services.pa.gestoriCredenziali': "+e.getMessage(),e);
  19282.                 this.tipoGestoreCredenzialiPA = null;
  19283.             }
  19284.             this.tipoGestoreCredenzialiPARead = true;
  19285.         }

  19287.         return this.tipoGestoreCredenzialiPA;
  19288.     }
  19289.     
  19290.     /**
  19291.      * Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare sul servizio di IntegrationManager
  19292.      * 
  19293.      * @return Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare sul servizio di IntegrationManager
  19294.      */
  19295.     private String[] tipoGestoreCredenzialiIM = null;
  19296.     private boolean tipoGestoreCredenzialiIMRead = false;
  19297.     public String[] getTipoGestoreCredenzialiIM() {
  19298.         if(this.tipoGestoreCredenzialiIMRead == false){
  19299.             try{  
  19300.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.integrationManager.gestoriCredenziali"); 
  19301.                 if(value!=null){
  19302.                     value = value.trim();
  19303.                     String [] r = value.split(",");
  19304.                     this.tipoGestoreCredenzialiIM = r;
  19305.                 }
  19306.             }catch(java.lang.Exception e) {
  19307.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.services.integrationManager.gestoriCredenziali': "+e.getMessage(),e);
  19308.                 this.tipoGestoreCredenzialiIM = null;
  19309.             }
  19310.             this.tipoGestoreCredenzialiIMRead = true;
  19311.         }

  19313.         return this.tipoGestoreCredenzialiIM;
  19314.     }
  19315.     
  19316.     
  19317.     
  19318.     
  19319.     
  19320.     




  19325.     /* ----------- Accesso Registro Servizi --------------------- */
  19326.     /**
  19327.      * Indicazione se la porta di dominio deve processare gli accordi di servizio, i servizi e i fruitori ancora in stato di bozza
  19328.      *   
  19329.      * @return Indicazione se la porta di dominio deve processare gli accordi di servizio, i servizi e i fruitori ancora in stato di bozza
  19330.      * 
  19331.      */
  19332.     private Boolean isReadObjectStatoBozza = null;
  19333.     public boolean isReadObjectStatoBozza(){

  19335.         if(this.isReadObjectStatoBozza==null){
  19336.             try{  
  19337.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.registroServizi.readObjectStatoBozza"); 

  19339.                 if (value != null){
  19340.                     value = value.trim();
  19341.                     this.isReadObjectStatoBozza = Boolean.parseBoolean(value);
  19342.                 }else{
  19343.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.registroServizi.readObjectStatoBozza' non impostata, viene utilizzato il default=true");
  19344.                     this.isReadObjectStatoBozza = false;
  19345.                 }

  19347.             }catch(java.lang.Exception e) {
  19348.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.registroServizi.readObjectStatoBozza' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  19349.                 this.isReadObjectStatoBozza = false;
  19350.             }
  19351.         }

  19353.         return this.isReadObjectStatoBozza;
  19354.     }
  19355.     
  19356.     
  19357.     
  19358.     
  19359.     
  19360.     
  19361.     /* ----------- Tracce --------------------- */
  19362.     /**
  19363.      * Indicazione se la porta di dominio deve generare un errore in caso di tracciamento non riuscito
  19364.      *   
  19365.      * @return Indicazione se la porta di dominio deve generare un errore in caso di tracciamento non riuscito
  19366.      * 
  19367.      */
  19368.     private Boolean isTracciaturaFallita_BloccaCooperazioneInCorso = null;
  19369.     public boolean isTracciaturaFallita_BloccaCooperazioneInCorso(){

  19371.         if(this.isTracciaturaFallita_BloccaCooperazioneInCorso==null){
  19372.             try{  
  19373.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.tracciamento.registrazioneFallita.bloccaCooperazioneInCorso"); 

  19375.                 if (value != null){
  19376.                     value = value.trim();
  19377.                     this.isTracciaturaFallita_BloccaCooperazioneInCorso = Boolean.parseBoolean(value);
  19378.                 }else{
  19379.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.tracciamento.registrazioneFallita.bloccaCooperazioneInCorso' non impostata, viene utilizzato il default=true");
  19380.                     this.isTracciaturaFallita_BloccaCooperazioneInCorso = true;
  19381.                 }

  19383.             }catch(java.lang.Exception e) {
  19384.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.tracciamento.registrazioneFallita.bloccaCooperazioneInCorso' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  19385.                 this.isTracciaturaFallita_BloccaCooperazioneInCorso = true;
  19386.             }
  19387.         }

  19389.         return this.isTracciaturaFallita_BloccaCooperazioneInCorso;
  19390.     }
  19391.     /**
  19392.      * 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.
  19393.      *   
  19394.      * @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.
  19395.      * 
  19396.      */
  19397.     private Boolean isTracciaturaFallita_BloccoServiziPdD = null;
  19398.     public boolean isTracciaturaFallita_BloccoServiziPdD(){

  19400.         if(this.isTracciaturaFallita_BloccoServiziPdD==null){
  19401.             try{  
  19402.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.tracciamento.registrazione.bloccoServiziPdD"); 

  19404.                 if (value != null){
  19405.                     value = value.trim();
  19406.                     this.isTracciaturaFallita_BloccoServiziPdD = Boolean.parseBoolean(value);
  19407.                 }else{
  19408.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.tracciamento.registrazione.bloccoServiziPdD' non impostata, viene utilizzato il default=false");
  19409.                     this.isTracciaturaFallita_BloccoServiziPdD = false;
  19410.                 }

  19412.             }catch(java.lang.Exception e) {
  19413.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.tracciamento.registrazione.bloccoServiziPdD' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  19414.                 this.isTracciaturaFallita_BloccoServiziPdD = false;
  19415.             }
  19416.         }

  19418.         return this.isTracciaturaFallita_BloccoServiziPdD;
  19419.     }
  19420.     
  19421.     
  19422.     
  19423.     
  19424.     
  19425.     
  19426.     
  19427.     
  19428.     
  19429.     
  19430.     
  19431.     /* ----------- MsgDiagnostici --------------------- */
  19432.     
  19433.     private Boolean isRegistrazioneDiagnosticaFile_intestazione_formatValues = null;
  19434.     public boolean isRegistrazioneDiagnosticaFile_intestazione_formatValues(){

  19436.         if(this.isRegistrazioneDiagnosticaFile_intestazione_formatValues==null){
  19437.             try{  
  19438.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.msgDiagnostici.file.header.formatValues"); 

  19440.                 if (value != null){
  19441.                     value = value.trim();
  19442.                     this.isRegistrazioneDiagnosticaFile_intestazione_formatValues = Boolean.parseBoolean(value);
  19443.                 }else{
  19444.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.msgDiagnostici.file.header.formatValues' non impostata, viene utilizzato il default=true");
  19445.                     this.isRegistrazioneDiagnosticaFile_intestazione_formatValues = true;
  19446.                 }

  19448.             }catch(java.lang.Exception e) {
  19449.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.msgDiagnostici.file.header.formatValues' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  19450.                 this.isRegistrazioneDiagnosticaFile_intestazione_formatValues = true;
  19451.             }
  19452.         }

  19454.         return this.isRegistrazioneDiagnosticaFile_intestazione_formatValues;
  19455.     }
  19456.     
  19457.     /**
  19458.      * 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.
  19459.      *   
  19460.      * @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.
  19461.      * 
  19462.      */
  19463.     private Boolean isRegistrazioneDiagnosticaFallita_BloccoServiziPdD = null;
  19464.     public boolean isRegistrazioneDiagnosticaFallita_BloccoServiziPdD(){

  19466.         if(this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD==null){
  19467.             try{  
  19468.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.msgDiagnostici.emissioneFallita.bloccoServiziPdD"); 

  19470.                 if (value != null){
  19471.                     value = value.trim();
  19472.                     this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD = Boolean.parseBoolean(value);
  19473.                 }else{
  19474.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.msgDiagnostici.emissioneFallita.bloccoServiziPdD' non impostata, viene utilizzato il default=false");
  19475.                     this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD = false;
  19476.                 }

  19478.             }catch(java.lang.Exception e) {
  19479.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.msgDiagnostici.emissioneFallita.bloccoServiziPdD' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  19480.                 this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD = false;
  19481.             }
  19482.         }

  19484.         return this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD;
  19485.     }
  19486.     
  19487.     private Boolean isLoggerSaajDisabilitato = null;
  19488.     public boolean isLoggerSaajDisabilitato(){

  19490.         if(this.isLoggerSaajDisabilitato==null){
  19491.             try{  
  19492.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.com.sun.xml.messaging.saaj.disabled"); 

  19494.                 if (value != null){
  19495.                     value = value.trim();
  19496.                     this.isLoggerSaajDisabilitato = Boolean.parseBoolean(value);
  19497.                 }else{
  19498.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.com.sun.xml.messaging.saaj.disabled' non impostata, viene utilizzato il default=true");
  19499.                     this.isLoggerSaajDisabilitato = true;
  19500.                 }

  19502.             }catch(java.lang.Exception e) {
  19503.                 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);
  19504.                 this.isLoggerSaajDisabilitato = true;
  19505.             }
  19506.         }

  19508.         return this.isLoggerSaajDisabilitato;
  19509.     }
  19510.     
  19511.     
  19512.     
  19513.     
  19514.     
  19515.     
  19516.     
  19517.     
  19518.     /* ----------- Dump --------------------- */
  19519.     
  19520.     private String getDumpBufferImpl = null;
  19521.     private Boolean getDumpBufferImplRead = null;
  19522.     public String getDumpBufferImpl() { 
  19523.         if(this.getDumpBufferImplRead==null){
  19524.             String pName = "org.openspcoop2.pdd.logger.dump.buffer.impl";
  19525.             
  19526.             try{ 
  19527.                 String name = null;
  19528.                 name = this.reader.getValueConvertEnvProperties(pName);
  19529.                 if(name!=null){
  19530.                     name = name.trim();
  19531.                     this.getDumpBufferImpl = name;
  19532.                 }
  19533.                 
  19534.                 this.getDumpBufferImplRead = true;
  19535.                 
  19536.             } catch(java.lang.Exception e) {
  19537.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  19538.             }    
  19539.         }

  19541.         return this.getDumpBufferImpl;
  19542.     }
  19543.     
  19544.     /**
  19545.      * Indicazione se la porta di dominio deve registrare tutti gli attachments (in caso di dump abilitato) o solo quelli "visualizzabili"
  19546.      *   
  19547.      * @return Indicazione se la porta di dominio deve registrare tutti gli attachments (in caso di dump abilitato) o solo quelli "visualizzabili"
  19548.      * 
  19549.      */
  19550.     private Boolean isDumpAllAttachments = null;
  19551.     public boolean isDumpAllAttachments(){

  19553.         if(this.isDumpAllAttachments==null){
  19554.             try{  
  19555.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.dump.allAttachments"); 

  19557.                 if (value != null){
  19558.                     value = value.trim();
  19559.                     this.isDumpAllAttachments = Boolean.parseBoolean(value);
  19560.                 }else{
  19561.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.allAttachments' non impostata, viene utilizzato il default=true");
  19562.                     this.isDumpAllAttachments = true;
  19563.                 }

  19565.             }catch(java.lang.Exception e) {
  19566.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.registroServizi.readObjectStatoBozza' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  19567.                 this.isDumpAllAttachments = true;
  19568.             }
  19569.         }

  19571.         return this.isDumpAllAttachments;
  19572.     }
  19573.     
  19574.     /**
  19575.      * 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
  19576.      *   
  19577.      * @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
  19578.      * 
  19579.      */
  19580.     private Boolean isDumpFallitoBloccaCooperazioneInCorso = null;
  19581.     public boolean isDumpFallitoBloccaCooperazioneInCorso(){

  19583.         if(this.isDumpFallitoBloccaCooperazioneInCorso==null){
  19584.             try{  
  19585.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.dump.registrazioneFallita.bloccaCooperazioneInCorso"); 

  19587.                 if (value != null){
  19588.                     value = value.trim();
  19589.                     this.isDumpFallitoBloccaCooperazioneInCorso = Boolean.parseBoolean(value);
  19590.                 }else{
  19591.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.registrazioneFallita.bloccaCooperazioneInCorso' non impostata, viene utilizzato il default=false");
  19592.                     this.isDumpFallitoBloccaCooperazioneInCorso = false;
  19593.                 }

  19595.             }catch(java.lang.Exception e) {
  19596.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.registrazioneFallita.bloccaCooperazioneInCorso' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  19597.                 this.isDumpFallitoBloccaCooperazioneInCorso = false;
  19598.             }
  19599.         }

  19601.         return this.isDumpFallitoBloccaCooperazioneInCorso;
  19602.     }
  19603.     /**
  19604.      * 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.
  19605.      *   
  19606.      * @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.
  19607.      * 
  19608.      */
  19609.     private Boolean isDumpFallitoBloccoServiziPdD = null;
  19610.     public boolean isDumpFallitoBloccoServiziPdD(){

  19612.         if(this.isDumpFallitoBloccoServiziPdD==null){
  19613.             try{  
  19614.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.dump.registrazione.bloccoServiziPdD"); 

  19616.                 if (value != null){
  19617.                     value = value.trim();
  19618.                     this.isDumpFallitoBloccoServiziPdD = Boolean.parseBoolean(value);
  19619.                 }else{
  19620.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.registrazione.bloccoServiziPdD' non impostata, viene utilizzato il default=false");
  19621.                     this.isDumpFallitoBloccoServiziPdD = false;
  19622.                 }

  19624.             }catch(java.lang.Exception e) {
  19625.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.registrazione.bloccoServiziPdD' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  19626.                 this.isDumpFallitoBloccoServiziPdD = false;
  19627.             }
  19628.         }

  19630.         return this.isDumpFallitoBloccoServiziPdD;
  19631.     }

  19633.     private List<String> getDumpHeaderWhiteList = null;
  19634.     public List<String> getDumpHeaderWhiteList(){

  19636.         if(this.getDumpHeaderWhiteList==null){
  19637.             String pName = "org.openspcoop2.pdd.logger.dump.header.whiteList";
  19638.             try{
  19639.                 this.getDumpHeaderWhiteList = new ArrayList<>();
  19640.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19641.                 initDumpList(this.getDumpHeaderWhiteList, tmp);
  19642.             }catch(java.lang.Exception e) {
  19643.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19644.             }
  19645.         }

  19647.         return this.getDumpHeaderWhiteList;
  19648.     }
  19649.     
  19650.     private List<String> getDumpHeaderBlackList = null;
  19651.     public List<String> getDumpHeaderBlackList(){

  19653.         if(this.getDumpHeaderBlackList==null){
  19654.             String pName = "org.openspcoop2.pdd.logger.dump.header.blackList";
  19655.             try{
  19656.                 this.getDumpHeaderBlackList = new ArrayList<>();
  19657.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19658.                 initDumpList(this.getDumpHeaderBlackList, tmp);
  19659.             }catch(java.lang.Exception e) {
  19660.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19661.             }
  19662.         }

  19664.         return this.getDumpHeaderBlackList;
  19665.     }
  19666.     
  19667.     private List<String> getDumpHeaderErogazioniWhiteList = null;
  19668.     public List<String> getDumpHeaderErogazioniWhiteList(){

  19670.         if(this.getDumpHeaderErogazioniWhiteList==null){
  19671.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.whiteList";
  19672.             try{
  19673.                 this.getDumpHeaderErogazioniWhiteList = new ArrayList<>();
  19674.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19675.                 initDumpList(this.getDumpHeaderErogazioniWhiteList, tmp);
  19676.             }catch(java.lang.Exception e) {
  19677.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19678.             }
  19679.         }

  19681.         return this.getDumpHeaderErogazioniWhiteList;
  19682.     }
  19683.     
  19684.     private List<String> getDumpHeaderErogazioniBlackList = null;
  19685.     public List<String> getDumpHeaderErogazioniBlackList(){

  19687.         if(this.getDumpHeaderErogazioniBlackList==null){
  19688.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.blackList";
  19689.             try{
  19690.                 this.getDumpHeaderErogazioniBlackList = new ArrayList<>();
  19691.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19692.                 initDumpList(this.getDumpHeaderErogazioniBlackList, tmp);
  19693.             }catch(java.lang.Exception e) {
  19694.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19695.             }
  19696.         }

  19698.         return this.getDumpHeaderErogazioniBlackList;
  19699.     }
  19700.     
  19701.     private List<String> getDumpHeaderFruizioniWhiteList = null;
  19702.     public List<String> getDumpHeaderFruizioniWhiteList(){

  19704.         if(this.getDumpHeaderFruizioniWhiteList==null){
  19705.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.whiteList";
  19706.             try{
  19707.                 this.getDumpHeaderFruizioniWhiteList = new ArrayList<>();
  19708.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19709.                 initDumpList(this.getDumpHeaderFruizioniWhiteList, tmp);
  19710.             }catch(java.lang.Exception e) {
  19711.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19712.             }
  19713.         }

  19715.         return this.getDumpHeaderFruizioniWhiteList;
  19716.     }
  19717.     
  19718.     private List<String> getDumpHeaderFruizioniBlackList = null;
  19719.     public List<String> getDumpHeaderFruizioniBlackList(){

  19721.         if(this.getDumpHeaderFruizioniBlackList==null){
  19722.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.blackList";
  19723.             try{
  19724.                 this.getDumpHeaderFruizioniBlackList = new ArrayList<>();
  19725.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19726.                 initDumpList(this.getDumpHeaderFruizioniBlackList, tmp);
  19727.             }catch(java.lang.Exception e) {
  19728.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19729.             }
  19730.         }

  19732.         return this.getDumpHeaderFruizioniBlackList;
  19733.     }
  19734.     
  19735.     private List<String> getDumpHeaderErogazioniRichiestaIngressoWhiteList = null;
  19736.     public List<String> getDumpHeaderErogazioniRichiestaIngressoWhiteList(){

  19738.         if(this.getDumpHeaderErogazioniRichiestaIngressoWhiteList==null){
  19739.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.richiesta-ingresso.whiteList";
  19740.             try{
  19741.                 this.getDumpHeaderErogazioniRichiestaIngressoWhiteList = new ArrayList<>();
  19742.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19743.                 initDumpList(this.getDumpHeaderErogazioniRichiestaIngressoWhiteList, tmp);
  19744.             }catch(java.lang.Exception e) {
  19745.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19746.             }
  19747.         }

  19749.         return this.getDumpHeaderErogazioniRichiestaIngressoWhiteList;
  19750.     }
  19751.     
  19752.     private List<String> getDumpHeaderErogazioniRichiestaIngressoBlackList = null;
  19753.     public List<String> getDumpHeaderErogazioniRichiestaIngressoBlackList(){

  19755.         if(this.getDumpHeaderErogazioniRichiestaIngressoBlackList==null){
  19756.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.richiesta-ingresso.blackList";
  19757.             try{
  19758.                 this.getDumpHeaderErogazioniRichiestaIngressoBlackList = new ArrayList<>();
  19759.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19760.                 initDumpList(this.getDumpHeaderErogazioniRichiestaIngressoBlackList, tmp);
  19761.             }catch(java.lang.Exception e) {
  19762.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19763.             }
  19764.         }

  19766.         return this.getDumpHeaderErogazioniRichiestaIngressoBlackList;
  19767.     }
  19768.     
  19769.     private List<String> getDumpHeaderErogazioniRichiestaUscitaWhiteList = null;
  19770.     public List<String> getDumpHeaderErogazioniRichiestaUscitaWhiteList(){

  19772.         if(this.getDumpHeaderErogazioniRichiestaUscitaWhiteList==null){
  19773.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.richiesta-uscita.whiteList";
  19774.             try{
  19775.                 this.getDumpHeaderErogazioniRichiestaUscitaWhiteList = new ArrayList<>();
  19776.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19777.                 initDumpList(this.getDumpHeaderErogazioniRichiestaUscitaWhiteList, tmp);
  19778.             }catch(java.lang.Exception e) {
  19779.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19780.             }
  19781.         }

  19783.         return this.getDumpHeaderErogazioniRichiestaUscitaWhiteList;
  19784.     }
  19785.     
  19786.     private List<String> getDumpHeaderErogazioniRichiestaUscitaBlackList = null;
  19787.     public List<String> getDumpHeaderErogazioniRichiestaUscitaBlackList(){

  19789.         if(this.getDumpHeaderErogazioniRichiestaUscitaBlackList==null){
  19790.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.richiesta-uscita.blackList";
  19791.             try{
  19792.                 this.getDumpHeaderErogazioniRichiestaUscitaBlackList = new ArrayList<>();
  19793.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19794.                 initDumpList(this.getDumpHeaderErogazioniRichiestaUscitaBlackList, tmp);
  19795.             }catch(java.lang.Exception e) {
  19796.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19797.             }
  19798.         }

  19800.         return this.getDumpHeaderErogazioniRichiestaUscitaBlackList;
  19801.     }
  19802.     
  19803.     private List<String> getDumpHeaderErogazioniRispostaIngressoWhiteList = null;
  19804.     public List<String> getDumpHeaderErogazioniRispostaIngressoWhiteList(){

  19806.         if(this.getDumpHeaderErogazioniRispostaIngressoWhiteList==null){
  19807.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.risposta-ingresso.whiteList";
  19808.             try{
  19809.                 this.getDumpHeaderErogazioniRispostaIngressoWhiteList = new ArrayList<>();
  19810.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19811.                 initDumpList(this.getDumpHeaderErogazioniRispostaIngressoWhiteList, tmp);
  19812.             }catch(java.lang.Exception e) {
  19813.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19814.             }
  19815.         }

  19817.         return this.getDumpHeaderErogazioniRispostaIngressoWhiteList;
  19818.     }
  19819.     
  19820.     private List<String> getDumpHeaderErogazioniRispostaIngressoBlackList = null;
  19821.     public List<String> getDumpHeaderErogazioniRispostaIngressoBlackList(){

  19823.         if(this.getDumpHeaderErogazioniRispostaIngressoBlackList==null){
  19824.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.risposta-ingresso.blackList";
  19825.             try{
  19826.                 this.getDumpHeaderErogazioniRispostaIngressoBlackList = new ArrayList<>();
  19827.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19828.                 initDumpList(this.getDumpHeaderErogazioniRispostaIngressoBlackList, tmp);
  19829.             }catch(java.lang.Exception e) {
  19830.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19831.             }
  19832.         }

  19834.         return this.getDumpHeaderErogazioniRispostaIngressoBlackList;
  19835.     }
  19836.     
  19837.     private List<String> getDumpHeaderErogazioniRispostaUscitaWhiteList = null;
  19838.     public List<String> getDumpHeaderErogazioniRispostaUscitaWhiteList(){

  19840.         if(this.getDumpHeaderErogazioniRispostaUscitaWhiteList==null){
  19841.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.risposta-uscita.whiteList";
  19842.             try{
  19843.                 this.getDumpHeaderErogazioniRispostaUscitaWhiteList = new ArrayList<>();
  19844.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19845.                 initDumpList(this.getDumpHeaderErogazioniRispostaUscitaWhiteList, tmp);
  19846.             }catch(java.lang.Exception e) {
  19847.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19848.             }
  19849.         }

  19851.         return this.getDumpHeaderErogazioniRispostaUscitaWhiteList;
  19852.     }
  19853.     
  19854.     private List<String> getDumpHeaderErogazioniRispostaUscitaBlackList = null;
  19855.     public List<String> getDumpHeaderErogazioniRispostaUscitaBlackList(){

  19857.         if(this.getDumpHeaderErogazioniRispostaUscitaBlackList==null){
  19858.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.risposta-uscita.blackList";
  19859.             try{
  19860.                 this.getDumpHeaderErogazioniRispostaUscitaBlackList = new ArrayList<>();
  19861.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19862.                 initDumpList(this.getDumpHeaderErogazioniRispostaUscitaBlackList, tmp);
  19863.             }catch(java.lang.Exception e) {
  19864.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19865.             }
  19866.         }

  19868.         return this.getDumpHeaderErogazioniRispostaUscitaBlackList;
  19869.     }
  19870.     
  19871.     private List<String> getDumpHeaderFruizioniRichiestaIngressoWhiteList = null;
  19872.     public List<String> getDumpHeaderFruizioniRichiestaIngressoWhiteList(){

  19874.         if(this.getDumpHeaderFruizioniRichiestaIngressoWhiteList==null){
  19875.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.richiesta-ingresso.whiteList";
  19876.             try{
  19877.                 this.getDumpHeaderFruizioniRichiestaIngressoWhiteList = new ArrayList<>();
  19878.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19879.                 initDumpList(this.getDumpHeaderFruizioniRichiestaIngressoWhiteList, tmp);
  19880.             }catch(java.lang.Exception e) {
  19881.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19882.             }
  19883.         }

  19885.         return this.getDumpHeaderFruizioniRichiestaIngressoWhiteList;
  19886.     }
  19887.     
  19888.     private List<String> getDumpHeaderFruizioniRichiestaIngressoBlackList = null;
  19889.     public List<String> getDumpHeaderFruizioniRichiestaIngressoBlackList(){

  19891.         if(this.getDumpHeaderFruizioniRichiestaIngressoBlackList==null){
  19892.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.richiesta-ingresso.blackList";
  19893.             try{
  19894.                 this.getDumpHeaderFruizioniRichiestaIngressoBlackList = new ArrayList<>();
  19895.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19896.                 initDumpList(this.getDumpHeaderFruizioniRichiestaIngressoBlackList, tmp);
  19897.             }catch(java.lang.Exception e) {
  19898.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19899.             }
  19900.         }

  19902.         return this.getDumpHeaderFruizioniRichiestaIngressoBlackList;
  19903.     }
  19904.     
  19905.     private List<String> getDumpHeaderFruizioniRichiestaUscitaWhiteList = null;
  19906.     public List<String> getDumpHeaderFruizioniRichiestaUscitaWhiteList(){

  19908.         if(this.getDumpHeaderFruizioniRichiestaUscitaWhiteList==null){
  19909.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.richiesta-uscita.whiteList";
  19910.             try{
  19911.                 this.getDumpHeaderFruizioniRichiestaUscitaWhiteList = new ArrayList<>();
  19912.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19913.                 initDumpList(this.getDumpHeaderFruizioniRichiestaUscitaWhiteList, tmp);
  19914.             }catch(java.lang.Exception e) {
  19915.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19916.             }
  19917.         }

  19919.         return this.getDumpHeaderFruizioniRichiestaUscitaWhiteList;
  19920.     }
  19921.     
  19922.     private List<String> getDumpHeaderFruizioniRichiestaUscitaBlackList = null;
  19923.     public List<String> getDumpHeaderFruizioniRichiestaUscitaBlackList(){

  19925.         if(this.getDumpHeaderFruizioniRichiestaUscitaBlackList==null){
  19926.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.richiesta-uscita.blackList";
  19927.             try{
  19928.                 this.getDumpHeaderFruizioniRichiestaUscitaBlackList = new ArrayList<>();
  19929.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19930.                 initDumpList(this.getDumpHeaderFruizioniRichiestaUscitaBlackList, tmp);
  19931.             }catch(java.lang.Exception e) {
  19932.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19933.             }
  19934.         }

  19936.         return this.getDumpHeaderFruizioniRichiestaUscitaBlackList;
  19937.     }
  19938.     
  19939.     private List<String> getDumpHeaderFruizioniRispostaIngressoWhiteList = null;
  19940.     public List<String> getDumpHeaderFruizioniRispostaIngressoWhiteList(){

  19942.         if(this.getDumpHeaderFruizioniRispostaIngressoWhiteList==null){
  19943.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.risposta-ingresso.whiteList";
  19944.             try{
  19945.                 this.getDumpHeaderFruizioniRispostaIngressoWhiteList = new ArrayList<>();
  19946.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19947.                 initDumpList(this.getDumpHeaderFruizioniRispostaIngressoWhiteList, tmp);
  19948.             }catch(java.lang.Exception e) {
  19949.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19950.             }
  19951.         }

  19953.         return this.getDumpHeaderFruizioniRispostaIngressoWhiteList;
  19954.     }
  19955.     
  19956.     private List<String> getDumpHeaderFruizioniRispostaIngressoBlackList = null;
  19957.     public List<String> getDumpHeaderFruizioniRispostaIngressoBlackList(){

  19959.         if(this.getDumpHeaderFruizioniRispostaIngressoBlackList==null){
  19960.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.risposta-ingresso.blackList";
  19961.             try{
  19962.                 this.getDumpHeaderFruizioniRispostaIngressoBlackList = new ArrayList<>();
  19963.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19964.                 initDumpList(this.getDumpHeaderFruizioniRispostaIngressoBlackList, tmp);
  19965.             }catch(java.lang.Exception e) {
  19966.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19967.             }
  19968.         }

  19970.         return this.getDumpHeaderFruizioniRispostaIngressoBlackList;
  19971.     }
  19972.     
  19973.     private List<String> getDumpHeaderFruizioniRispostaUscitaWhiteList = null;
  19974.     public List<String> getDumpHeaderFruizioniRispostaUscitaWhiteList(){

  19976.         if(this.getDumpHeaderFruizioniRispostaUscitaWhiteList==null){
  19977.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.risposta-uscita.whiteList";
  19978.             try{
  19979.                 this.getDumpHeaderFruizioniRispostaUscitaWhiteList = new ArrayList<>();
  19980.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19981.                 initDumpList(this.getDumpHeaderFruizioniRispostaUscitaWhiteList, tmp);
  19982.             }catch(java.lang.Exception e) {
  19983.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19984.             }
  19985.         }

  19987.         return this.getDumpHeaderFruizioniRispostaUscitaWhiteList;
  19988.     }
  19989.     
  19990.     private List<String> getDumpHeaderFruizioniRispostaUscitaBlackList = null;
  19991.     public List<String> getDumpHeaderFruizioniRispostaUscitaBlackList(){

  19993.         if(this.getDumpHeaderFruizioniRispostaUscitaBlackList==null){
  19994.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.risposta-uscita.blackList";
  19995.             try{
  19996.                 this.getDumpHeaderFruizioniRispostaUscitaBlackList = new ArrayList<>();
  19997.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19998.                 initDumpList(this.getDumpHeaderFruizioniRispostaUscitaBlackList, tmp);
  19999.             }catch(java.lang.Exception e) {
  20000.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  20001.             }
  20002.         }

  20004.         return this.getDumpHeaderFruizioniRispostaUscitaBlackList;
  20005.     }
  20006.     
  20007.     private void initDumpList(List<String> list, String tmp) {
  20008.         if(tmp!=null && !"".equals(tmp.trim())) {
  20009.             tmp = tmp.trim();
  20010.             if(tmp.contains(",")) {
  20011.                 String [] split = tmp.split(",");
  20012.                 initDumpList(list, split);
  20013.             }
  20014.             else {
  20015.                 list.add(tmp);
  20016.             }
  20017.         }
  20018.     }
  20019.     private void initDumpList(List<String> list, String [] split) {
  20020.         if(split!=null && split.length>0) {
  20021.             for (String s : split) {
  20022.                 if(s!=null) {
  20023.                     s = s.trim();
  20024.                     if(!"".equals(s)) {
  20025.                         list.add(s);
  20026.                     }
  20027.                 }
  20028.             }
  20029.         }
  20030.     }
  20031.     
  20032.     
  20033.     private Boolean isDumpEmitDiagnostic = null;
  20034.     public boolean isDumpEmitDiagnostic(){

  20036.         if(this.isDumpEmitDiagnostic==null){
  20037.             String pName = "org.openspcoop2.pdd.logger.dump.emitDiagnostic";
  20038.             try{  
  20039.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  20041.                 if (value != null){
  20042.                     value = value.trim();
  20043.                     this.isDumpEmitDiagnostic = Boolean.parseBoolean(value);
  20044.                 }else{
  20045.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  20046.                     this.isDumpEmitDiagnostic = true;
  20047.                 }

  20049.             }catch(java.lang.Exception e) {
  20050.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  20051.                 this.isDumpEmitDiagnostic = true;
  20052.             }
  20053.         }

  20055.         return this.isDumpEmitDiagnostic;
  20056.     }
  20057.     
  20058.     
  20059.     /* ----------- Dump (Binario) --------------------- */
  20060.     
  20061.     private Boolean isDumpBinarioRegistrazioneDatabase = null;
  20062.     public boolean isDumpBinarioRegistrazioneDatabase(){

  20064.         if(this.isDumpBinarioRegistrazioneDatabase==null){
  20065.             try{  
  20066.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.dumpBinario.registrazioneDatabase"); 

  20068.                 if (value != null){
  20069.                     value = value.trim();
  20070.                     this.isDumpBinarioRegistrazioneDatabase = Boolean.parseBoolean(value);
  20071.                 }else{
  20072.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dumpBinario.registrazioneDatabase' non impostata, viene utilizzato il default=false");
  20073.                     this.isDumpBinarioRegistrazioneDatabase = false;
  20074.                 }

  20076.             }catch(java.lang.Exception e) {
  20077.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dumpBinario.registrazioneDatabase' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  20078.                 this.isDumpBinarioRegistrazioneDatabase = false;
  20079.             }
  20080.         }

  20082.         return this.isDumpBinarioRegistrazioneDatabase;
  20083.     }
  20084.     
  20085.     private Integer getDumpBinarioInMemoryThreshold = null;
  20086.     public int getDumpBinarioInMemoryThreshold() {  
  20087.         String pName = "org.openspcoop2.pdd.logger.dumpBinario.inMemory.threshold";
  20088.         if(this.getDumpBinarioInMemoryThreshold==null){
  20089.             try{ 
  20090.                 String name = null;
  20091.                 name = this.reader.getValueConvertEnvProperties(pName);
  20092.                 if(name!=null){
  20093.                     name = name.trim();
  20094.                     this.getDumpBinarioInMemoryThreshold = java.lang.Integer.parseInt(name);
  20095.                 }else{
  20096.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.DUMP_BINARIO_THRESHOLD));
  20097.                     this.getDumpBinarioInMemoryThreshold = CostantiPdD.DUMP_BINARIO_THRESHOLD;
  20098.                 }
  20099.             }catch(java.lang.Exception e) {
  20100.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.DUMP_BINARIO_THRESHOLD),e);
  20101.                 this.getDumpBinarioInMemoryThreshold = CostantiPdD.DUMP_BINARIO_THRESHOLD;
  20102.             }  
  20103.         }

  20105.         return this.getDumpBinarioInMemoryThreshold;
  20106.     }
  20107.     
  20108.     private File getDumpBinarioRepository = null;
  20109.     public File getDumpBinarioRepository() throws CoreException {   
  20110.         String pName = "org.openspcoop2.pdd.logger.dumpBinario.msgRepository";
  20111.         if(this.getDumpBinarioRepository==null){
  20112.             try{ 
  20113.                 String name = null;
  20114.                 name = this.reader.getValueConvertEnvProperties(pName);
  20115.                 if(name==null){
  20116.                     throw new CoreException("Proprieta' non impostata");
  20117.                 }
  20118.                 name = LoggerWrapperFactory.applyClusterIdStrategy(name.trim(), "dumpBinario");
  20119.                 this.getDumpBinarioRepository = new File(name);
  20120.                 checkDumpBinarioRepository();
  20121.             } catch(java.lang.Exception e) {
  20122.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  20123.                 throw new CoreException(e.getMessage(),e);
  20124.             }    
  20125.         }

  20127.         return this.getDumpBinarioRepository;
  20128.     }
  20129.     private void checkDumpBinarioRepository() throws CoreException {
  20130.         if(this.getDumpBinarioRepository.exists()) {
  20131.             if(!this.getDumpBinarioRepository.isDirectory()) {
  20132.                 throw newCoreExceptionNotDir(this.getDumpBinarioRepository,true);
  20133.             }
  20134.             if(!this.getDumpBinarioRepository.canRead()) {
  20135.                 throw newCoreExceptionCannotRead(this.getDumpBinarioRepository, true);
  20136.             }
  20137.             if(!this.getDumpBinarioRepository.canWrite()) {
  20138.                 throw newCoreExceptionCannotWrite(this.getDumpBinarioRepository, true);
  20139.             }
  20140.         }
  20141.         else {
  20142.             // viene creata automaticamente
  20143.         }
  20144.     }
  20145.     
  20146.     
  20147.     
  20148.     
  20149.     /* ----------- Dump (NonRealtime) --------------------- */
  20150.     
  20151.     private Integer getDumpNonRealtimeInMemoryThreshold = null;
  20152.     public int getDumpNonRealtimeInMemoryThreshold() {  
  20153.         if(this.getDumpNonRealtimeInMemoryThreshold==null){
  20154.             try{ 
  20155.                 String name = null;
  20156.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dump.nonRealTime.inMemory.threshold");
  20157.                 if(name!=null){
  20158.                     name = name.trim();
  20159.                     this.getDumpNonRealtimeInMemoryThreshold = java.lang.Integer.parseInt(name);
  20160.                 }else{
  20161.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.inMemory.threshold' non impostata, viene utilizzato il default="+CostantiPdD.DUMP_NON_REALTIME_THRESHOLD);
  20162.                     this.getDumpNonRealtimeInMemoryThreshold = CostantiPdD.DUMP_NON_REALTIME_THRESHOLD;
  20163.                 }
  20164.             }catch(java.lang.Exception e) {
  20165.                 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);
  20166.                 this.getDumpNonRealtimeInMemoryThreshold = CostantiPdD.DUMP_NON_REALTIME_THRESHOLD;
  20167.             }  
  20168.         }

  20170.         return this.getDumpNonRealtimeInMemoryThreshold;
  20171.     }
  20172.     
  20173.     private String getDumpNonRealtimeMode = null;
  20174.     private String getDumpNonRealtimeMode() throws CoreException {  
  20175.         if(this.getDumpNonRealtimeMode==null){
  20176.             try{ 
  20177.                 String name = null;
  20178.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dump.nonRealTime.mode");
  20179.                 if(name!=null){
  20180.                     name = name.trim();
  20181.                     if(!CostantiPdD.DUMP_NON_REALTIME_MODE_DB.equalsIgnoreCase(name) && 
  20182.                             !CostantiPdD.DUMP_NON_REALTIME_MODE_FILE_SYSTEM.equalsIgnoreCase(name) && 
  20183.                             !CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO.equalsIgnoreCase(name) ) {
  20184.                         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+")");
  20185.                     }
  20186.                     this.getDumpNonRealtimeMode = name;
  20187.                 }else{
  20188.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.mode' non impostata, viene utilizzato il default="+CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO);
  20189.                     this.getDumpNonRealtimeMode = CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO;
  20190.                 }
  20191.             }catch(java.lang.Exception e) {
  20192.                 this.logError("Proprieta' di openspcoop ''org.openspcoop2.pdd.dump.nonRealTime.mode' non impostata, errore:"+e.getMessage(),e);
  20193.                 throw new CoreException(e.getMessage(),e);
  20194.             }  
  20195.             
  20196.             checkDumpNonRealtimeMode();
  20197.         }

  20199.         return this.getDumpNonRealtimeMode;
  20200.     }
  20201.     private void checkDumpNonRealtimeMode() throws CoreException {  
  20202.         if(CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO.equalsIgnoreCase(this.getDumpNonRealtimeMode)) {
  20203.             String databaseTypeCheck = this.getDatabaseType();
  20204.             if(databaseTypeCheck==null) {
  20205.                 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'");
  20206.             }
  20207.             if(TipiDatabase.POSTGRESQL.getNome().equalsIgnoreCase(databaseTypeCheck) || TipiDatabase.HSQL.getNome().equalsIgnoreCase(databaseTypeCheck)) {
  20208.                 // 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
  20209.                 this.getDumpNonRealtimeMode = CostantiPdD.DUMP_NON_REALTIME_MODE_FILE_SYSTEM;
  20210.             }
  20211.             else {
  20212.                 this.getDumpNonRealtimeMode = CostantiPdD.DUMP_NON_REALTIME_MODE_DB;
  20213.             }
  20214.         }
  20215.     }
  20216.     
  20217.     public boolean isDumpNonRealtimeDatabaseMode() {
  20218.         return CostantiPdD.DUMP_NON_REALTIME_MODE_DB.equalsIgnoreCase(this.getDumpNonRealtimeMode);
  20219.     }
  20220.     public boolean isDumpNonRealtimeFileSystemMode() {
  20221.         return CostantiPdD.DUMP_NON_REALTIME_MODE_FILE_SYSTEM.equalsIgnoreCase(this.getDumpNonRealtimeMode);
  20222.     }
  20223.     
  20224.     private File getDumpNonRealtimeRepository = null;
  20225.     public File getDumpNonRealtimeRepository() throws CoreException {   
  20226.         if(this.getDumpNonRealtimeRepository==null){
  20227.             try{ 
  20228.                 String name = null;
  20229.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dump.nonRealTime.msgRepository");
  20230.                 if(name==null){
  20231.                     throw new CoreException("Proprieta' non impostata");
  20232.                 }
  20233.                 name = LoggerWrapperFactory.applyClusterIdStrategy(name.trim(), "dumpNonRealTime");
  20234.                 this.getDumpNonRealtimeRepository = new File(name);
  20235.                 checkDumpNonRealtimeRepository();
  20236.             } catch(java.lang.Exception e) {
  20237.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.msgRepository': "+e.getMessage(),e);
  20238.                 throw new CoreException(e.getMessage(),e);
  20239.             }    
  20240.         }

  20242.         return this.getDumpNonRealtimeRepository;
  20243.     }
  20244.     private void checkDumpNonRealtimeRepository() throws CoreException {    
  20245.         if(this.getDumpNonRealtimeRepository.exists()) {
  20246.             if(!this.getDumpNonRealtimeRepository.isDirectory()) {
  20247.                 throw newCoreExceptionNotDir(this.getDumpNonRealtimeRepository,true);
  20248.             }
  20249.             if(!this.getDumpNonRealtimeRepository.canRead()) {
  20250.                 throw newCoreExceptionCannotRead(this.getDumpNonRealtimeRepository, true);
  20251.             }
  20252.             if(!this.getDumpNonRealtimeRepository.canWrite()) {
  20253.                 throw newCoreExceptionCannotWrite(this.getDumpNonRealtimeRepository, true);
  20254.             }
  20255.         }
  20256.         else {
  20257.             // viene creata automaticamente
  20258.         }
  20259.     }
  20260.     
  20261.     private Boolean isDumpNonRealtimeThrowStreamingHandlerException = null;
  20262.     public boolean isDumpNonRealtimeThrowStreamingHandlerException(){

  20264.         if(this.isDumpNonRealtimeThrowStreamingHandlerException==null){
  20265.             try{  
  20266.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dump.nonRealTime.throwStreamingHandlerException"); 

  20268.                 if (value != null){
  20269.                     value = value.trim();
  20270.                     this.isDumpNonRealtimeThrowStreamingHandlerException = Boolean.parseBoolean(value);
  20271.                 }else{
  20272.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.throwStreamingHandlerException' non impostata, viene utilizzato il default=true");
  20273.                     this.isDumpNonRealtimeThrowStreamingHandlerException = true;
  20274.                 }

  20276.             }catch(java.lang.Exception e) {
  20277.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.throwStreamingHandlerException' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  20278.                 this.isDumpNonRealtimeThrowStreamingHandlerException = true;
  20279.             }
  20280.         }

  20282.         return this.isDumpNonRealtimeThrowStreamingHandlerException;
  20283.     }
  20284.     
  20285.     
  20286.     
  20287.     
  20288.     
  20289.     /* ------------- ID ---------------------*/
  20290.     /**
  20291.      * Restituisce il tipo di generatore id identificativi unici
  20292.      *
  20293.      * @return il tipo di generatore id identificativi unici
  20294.      * 
  20295.      */
  20296.     private String tipoIDManager = null;
  20297.     public String getTipoIDManager() {  
  20298.         if(this.tipoIDManager==null){
  20299.             try{ 
  20300.                 String name = null;
  20301.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.idGenerator");
  20302.                 if(name!=null){
  20303.                     name = name.trim();
  20304.                     this.tipoIDManager = name;
  20305.                 }else{
  20306.                     this.tipoIDManager = CostantiConfigurazione.NONE;
  20307.                 }
  20308.             }catch(java.lang.Exception e) {
  20309.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.idGenerator': "+e.getMessage(),e);
  20310.                 this.tipoIDManager = CostantiConfigurazione.NONE;
  20311.             }    
  20312.         }

  20314.         return this.tipoIDManager;
  20315.     }
  20316.     
  20317.     private Boolean useIDManagerWithThreadLocal = null;
  20318.     public boolean useIDManagerWithThreadLocal(){

  20320.         String pName = "org.openspcoop2.pdd.idGenerator.useThreadLocal";
  20321.         if(this.useIDManagerWithThreadLocal==null){
  20322.             try{  
  20323.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  20325.                 if (value != null){
  20326.                     value = value.trim();
  20327.                     this.useIDManagerWithThreadLocal = Boolean.parseBoolean(value);
  20328.                 }else{
  20329.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  20330.                     this.useIDManagerWithThreadLocal = false;
  20331.                 }

  20333.             }catch(java.lang.Exception e) {
  20334.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  20335.                 this.useIDManagerWithThreadLocal = false;
  20336.             }
  20337.         }

  20339.         return this.useIDManagerWithThreadLocal;
  20340.     }
  20341.     
  20342.     private Boolean listIDManagerParametersRead = null;
  20343.     private List<String> listIDManagerParameters = null;
  20344.     public List<String> getIDManagerParameters(){

  20346.         String pName = "org.openspcoop2.pdd.idGenerator."+this.getTipoIDManager()+".parameters";
  20347.         if(this.listIDManagerParametersRead==null){
  20348.             try{  
  20349.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  20351.                 initIDManagerParameters(value);

  20353.             }catch(java.lang.Exception e) {
  20354.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  20355.             }
  20356.             this.listIDManagerParametersRead = true;
  20357.         }

  20359.         return this.listIDManagerParameters;
  20360.     }
  20361.     private void initIDManagerParameters(String value){
  20362.         if (value != null){
  20363.             value = value.trim();
  20364.             
  20365.             if(value.contains(",")) {
  20366.                 String [] tmp = value.split(",");
  20367.                 if(tmp!=null && tmp.length>0) {
  20368.                     this.listIDManagerParameters = new ArrayList<>();
  20369.                     for (String v : tmp) {
  20370.                         this.listIDManagerParameters.add(v);
  20371.                     }
  20372.                 }
  20373.             }
  20374.             else {
  20375.                 this.listIDManagerParameters = new ArrayList<>();
  20376.                 this.listIDManagerParameters.add(value);
  20377.             }
  20378.         }
  20379.     }
  20380.     
  20381.     private Integer getIDManagerBufferSize = null;
  20382.     public int getIDManagerBufferSize(){

  20384.         String pName = "org.openspcoop2.pdd.idGenerator.buffer";
  20385.         if(this.getIDManagerBufferSize==null){
  20386.             try{  
  20387.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  20389.                 if (value != null){
  20390.                     value = value.trim();
  20391.                     this.getIDManagerBufferSize = Integer.parseInt(value);
  20392.                 }else{
  20393.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=-1");
  20394.                     this.getIDManagerBufferSize = -1;
  20395.                 }

  20397.             }catch(java.lang.Exception e) {
  20398.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=-1, errore:"+e.getMessage(),e);
  20399.                 this.getIDManagerBufferSize = -1;
  20400.             }
  20401.         }

  20403.         return this.getIDManagerBufferSize;
  20404.     }
  20405.     
  20406.     
  20407.     
  20408.     
  20409.     
  20410.     /* ------------- DEMO Mode ---------------------*/
  20411.     private Boolean generazioneDateCasualiLogAbilitato = null;
  20412.     private Date generazioneDateCasualiLogDataInizioIntervallo = null;
  20413.     private Date generazioneDateCasualiLogDataFineIntervallo = null;
  20414.     public Date getGenerazioneDateCasualiLogDataInizioIntervallo() {
  20415.         return this.generazioneDateCasualiLogDataInizioIntervallo;
  20416.     }
  20417.     public Date getGenerazioneDateCasualiLogDataFineIntervallo() {
  20418.         return this.generazioneDateCasualiLogDataFineIntervallo;
  20419.     }
  20420.     public boolean generazioneDateCasualiLogAbilitato() {   
  20421.         if(this.generazioneDateCasualiLogAbilitato==null){
  20422.             try{ 
  20423.                 String name = null;
  20424.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.generazioneDateCasuali.enabled");
  20425.                 if(name!=null){
  20426.                     name = name.trim();
  20427.                     this.generazioneDateCasualiLogAbilitato = Boolean.parseBoolean(name);
  20428.                     
  20429.                     initDateCasualiLogAbilitato();
  20430.                     
  20431.                 }else{
  20432.                     this.generazioneDateCasualiLogAbilitato = false; //default, anche senza che sia definita la proprieta'
  20433.                 }
  20434.             }catch(java.lang.Exception e) {
  20435.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.generazioneDateCasuali.enabled' non impostata correttamente,  errore:"+e.getMessage(),e);
  20436.                 this.generazioneDateCasualiLogAbilitato = false;
  20437.             }    
  20438.         }

  20440.         return this.generazioneDateCasualiLogAbilitato;
  20441.     }
  20442.     private void initDateCasualiLogAbilitato() throws CoreException, UtilsException, ParseException {   
  20443.         if(this.generazioneDateCasualiLogAbilitato.booleanValue()){
  20444.             
  20445.             if(getTipoIDManager()==null || CostantiConfigurazione.NONE.equals(getTipoIDManager())){
  20446.                 throw new CoreException("Non e' possibile utilizzare la modalita' di generazione casuale delle date, se non si abilita la generazione di un ID");
  20447.             }
  20448.             
  20449.             String inizioIntervallo = this.reader.getValueConvertEnvProperties("org.openspcoop2.generazioneDateCasuali.inizioIntervallo");
  20450.             String fineIntervallo = this.reader.getValueConvertEnvProperties("org.openspcoop2.generazioneDateCasuali.fineIntervallo");
  20451.             SimpleDateFormat sdf = DateUtils.getDefaultDateTimeFormatter("yyyy-MM-dd hh:mm");
  20452.             if(inizioIntervallo==null){
  20453.                 throw new CoreException("Non e' stato definito l'intervallo di inizio per la modalita' di generazione casuale delle date");
  20454.             }
  20455.             else{inizioIntervallo=inizioIntervallo.trim();}
  20456.             this.generazioneDateCasualiLogDataInizioIntervallo = sdf.parse(inizioIntervallo);
  20457.             if(fineIntervallo==null){
  20458.                 throw new CoreException("Non e' stato definito l'intervallo di fine per la modalita' di generazione casuale delle date");
  20459.             }
  20460.             else{fineIntervallo=fineIntervallo.trim();}
  20461.             this.generazioneDateCasualiLogDataFineIntervallo = sdf.parse(fineIntervallo);
  20462.             
  20463.             if(this.generazioneDateCasualiLogDataInizioIntervallo.after(this.generazioneDateCasualiLogDataFineIntervallo)){
  20464.                 throw new CoreException("Non e' stato definito un intervallo di generazione casuale delle date corretto (inizioIntervallo>fineIntervallo)");
  20465.             }
  20466.         }
  20467.     }
  20468.     
  20469.     
  20470.     
  20471.     
  20472.     
  20473.     /* ------------- Factory ---------------------*/
  20474.     
  20475.     private Boolean openspcoop2MessageFactoryRead = null;
  20476.     private String openspcoop2MessageFactory = null;
  20477.     public String getOpenspcoop2MessageFactory() {  
  20478.         if(this.openspcoop2MessageFactoryRead==null){
  20479.             try{ 
  20480.                 String v = null;
  20481.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messagefactory");
  20482.                 if(v!=null){
  20483.                     v = v.trim();
  20484.                     this.openspcoop2MessageFactory = v;
  20485.                 } else{
  20486.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messagefactory' non impostata, viene utilizzato il default="+OpenSPCoop2MessageFactory.messageFactoryImpl);
  20487.                 }
  20488.             }catch(java.lang.Exception e) {
  20489.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messagefactory' non impostata correttamente,  errore:"+e.getMessage(),e);
  20490.             } 
  20491.         }
  20492.         this.openspcoop2MessageFactoryRead = true;
  20493.         return this.openspcoop2MessageFactory;
  20494.     }
  20495.     
  20496.     private Boolean messageSecurityContextRead = null;
  20497.     private String messageSecurityContext = null;
  20498.     public String getMessageSecurityContext() { 
  20499.         if(this.messageSecurityContextRead==null){
  20500.             try{ 
  20501.                 String v = null;
  20502.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.context");
  20503.                 if(v!=null){
  20504.                     v = v.trim();
  20505.                     this.messageSecurityContext = v;
  20506.                 } else{
  20507.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.context' non impostata, viene utilizzato il default="+MessageSecurityFactory.messageSecurityContextImplClass);
  20508.                 }
  20509.             } catch(java.lang.Exception e) {
  20510.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.context' non impostata correttamente,  errore:"+e.getMessage(),e);
  20511.             } 
  20512.         }
  20513.         this.messageSecurityContextRead = true;
  20514.         return this.messageSecurityContext;
  20515.     }
  20516.     
  20517.     private Boolean messageSecurityDigestReaderRead = null;
  20518.     private String messageSecurityDigestReader = null;
  20519.     public String getMessageSecurityDigestReader() {    
  20520.         if(this.messageSecurityDigestReaderRead==null){
  20521.             try{ 
  20522.                 String v = null;
  20523.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.digestReader");
  20524.                 if(v!=null){
  20525.                     v = v.trim();
  20526.                     this.messageSecurityDigestReader = v;
  20527.                 } else{
  20528.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.digestReader' non impostata, viene utilizzato il default="+MessageSecurityFactory.messageSecurityDigestReaderImplClass);
  20529.                 }
  20530.             } catch(java.lang.Exception e) {
  20531.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.digestReader' non impostata correttamente,  errore:"+e.getMessage(),e);
  20532.             } 
  20533.         }
  20534.         this.messageSecurityDigestReaderRead = true;
  20535.         return this.messageSecurityDigestReader;
  20536.     }
  20537.     
  20538.     private Boolean printInfoFactory = null;
  20539.     public boolean isPrintInfoFactory() {   
  20540.         if(this.printInfoFactory==null){
  20541.             try{ 
  20542.                 String v = null;
  20543.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messagefactory.printInfo");
  20544.                 if(v!=null){
  20545.                     v = v.trim();
  20546.                     this.printInfoFactory = Boolean.parseBoolean(v);
  20547.                 } 
  20548.                 else{
  20549.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messagefactory.printInfo' non impostata, viene utilizzato il default="+true);
  20550.                     this.printInfoFactory = true;
  20551.                 }
  20552.             }catch(java.lang.Exception e) {
  20553.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messagefactory.printInfo' non impostata correttamente,  errore:"+e.getMessage(),e);
  20554.             } 
  20555.         }
  20556.         return this.printInfoFactory;
  20557.     }
  20558.         
  20559.     private Boolean printInfoMessageSecurity = null;
  20560.     public boolean isPrintInfoMessageSecurity() {   
  20561.         if(this.printInfoMessageSecurity==null){
  20562.             try{ 
  20563.                 String v = null;
  20564.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.printInfo");
  20565.                 if(v!=null){
  20566.                     v = v.trim();
  20567.                     this.printInfoMessageSecurity = Boolean.parseBoolean(v);
  20568.                 } 
  20569.                 else{
  20570.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.printInfo' non impostata, viene utilizzato il default="+true);
  20571.                     this.printInfoMessageSecurity = true;
  20572.                 }
  20573.             }catch(java.lang.Exception e) {
  20574.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.printInfo' non impostata correttamente,  errore:"+e.getMessage(),e);
  20575.             } 
  20576.         }
  20577.         return this.printInfoMessageSecurity;
  20578.     }
  20579.     
  20580.     
  20581.     
  20582.     /* ------------- Utility ---------------------*/
  20583.     
  20584.     private Boolean freeMemoryLog = null;
  20585.     public boolean getFreeMemoryLog() { 
  20586.         if(this.freeMemoryLog==null){
  20587.             try{ 
  20588.                 String v = null;
  20589.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.freememorylog");
  20590.                 if(v!=null){
  20591.                     v = v.trim();
  20592.                     this.freeMemoryLog = Boolean.parseBoolean(v);
  20593.                 } 
  20594.                 else{
  20595.                     this.freeMemoryLog = false;
  20596.                 }
  20597.             }catch(java.lang.Exception e) {
  20598.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.freememorylog' non impostata correttamente. Assumo valore di default 'false'.");
  20599.                 this.freeMemoryLog = false;
  20600.             } 
  20601.         }
  20602.         return this.freeMemoryLog;
  20603.     }
  20604.     
  20605.     
  20606.     
  20607.     
  20608.     
  20609.     
  20610.     /* ------------- Protocol ---------------------*/
  20611.     
  20612.     private String defaultProtocolName = null;      
  20613.     public String getDefaultProtocolName(){
  20614.         if(this.defaultProtocolName==null){
  20615.             try{ 
  20616.                 this.defaultProtocolName = this.reader.getValue("org.openspcoop2.pdd.services.defaultProtocol");
  20617.                 if(this.defaultProtocolName!=null){
  20618.                     this.defaultProtocolName = this.defaultProtocolName.trim();
  20619.                 }
  20620.             } catch(java.lang.Exception e) {
  20621.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.defaultProtocol' non impostata correttamente,  errore:"+e.getMessage(),e);
  20622.             } 
  20623.         }
  20624.         return this.defaultProtocolName;
  20625.     }

  20627.     
  20628.         
  20629.     
  20630.     /* ------------- Soggetti Virtuali ---------------------*/
  20631.     
  20632.     private Boolean isSoggettiVirtualiEnabled = null;
  20633.     public boolean isSoggettiVirtualiEnabled() {    
  20634.         if(this.isSoggettiVirtualiEnabled==null){
  20635.             String pName = "org.openspcoop2.pdd.SoggettiVirtuali.enabled";
  20636.             try{ 
  20637.                 String name = null;
  20638.                 name = this.reader.getValueConvertEnvProperties(pName);
  20639.                 if(name==null){
  20640.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  20641.                     name="false";
  20642.                 }
  20643.                 name = name.trim();
  20644.                 this.isSoggettiVirtualiEnabled = Boolean.parseBoolean(name);
  20645.             } catch(java.lang.Exception e) {
  20646.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  20647.                 this.isSoggettiVirtualiEnabled = false;
  20648.             }    
  20649.         }

  20651.         return this.isSoggettiVirtualiEnabled;
  20652.     }
  20653.     
  20654.     
  20655.     /* ------------- Generazione Errore Protocol non supportato ---------------------*/
  20656.     
  20657.     private Boolean isGenerazioneErroreProtocolloNonSupportato = null;
  20658.     public boolean isGenerazioneErroreProtocolloNonSupportato() {   
  20659.         if(this.isGenerazioneErroreProtocolloNonSupportato==null){
  20660.             try{ 
  20661.                 String name = null;
  20662.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.protocolNotSupported.generateErrorMessage");
  20663.                 if(name==null){
  20664.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.protocolNotSupported.generateErrorMessage' non impostata, viene utilizzato il default=false");
  20665.                     name="false";
  20666.                 }
  20667.                 name = name.trim();
  20668.                 this.isGenerazioneErroreProtocolloNonSupportato = Boolean.parseBoolean(name);
  20669.             } catch(java.lang.Exception e) {
  20670.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.protocolNotSupported.generateErrorMessage': "+e.getMessage(),e);
  20671.                 this.isGenerazioneErroreProtocolloNonSupportato = false;
  20672.             }    
  20673.         }

  20675.         return this.isGenerazioneErroreProtocolloNonSupportato;
  20676.     }
  20677.     
  20678.     
  20679.     
  20680.     
  20681.     /* ------------- Generazione Errore HttpMethodUnsupported ---------------------*/
  20682.     
  20683.     private Boolean isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled = null;
  20684.     public boolean isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled() { 
  20685.         if(this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled==null){
  20686.             try{ 
  20687.                 String name = null;
  20688.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pd.httpMethodUnsupported.generateErrorMessage");
  20689.                 if(name==null){
  20690.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pd.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
  20691.                     name="true";
  20692.                 }
  20693.                 name = name.trim();
  20694.                 this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled = Boolean.parseBoolean(name);
  20695.             } catch(java.lang.Exception e) {
  20696.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pd.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
  20697.                 this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled = true;
  20698.             }    
  20699.         }

  20701.         return this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled;
  20702.     }
  20703.     
  20704.     private Boolean isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled = null;
  20705.     public boolean isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled() { 
  20706.         if(this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled==null){
  20707.             try{ 
  20708.                 String name = null;
  20709.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pdToSoap.httpMethodUnsupported.generateErrorMessage");
  20710.                 if(name==null){
  20711.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pdToSoap.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
  20712.                     name="true";
  20713.                 }
  20714.                 name = name.trim();
  20715.                 this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled = Boolean.parseBoolean(name);
  20716.             } catch(java.lang.Exception e) {
  20717.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pdToSoap.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
  20718.                 this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled = true;
  20719.             }    
  20720.         }

  20722.         return this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled;
  20723.     }
  20724.     
  20725.     private Boolean isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled = null;
  20726.     public boolean isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled() {  
  20727.         if(this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled==null){
  20728.             try{ 
  20729.                 String name = null;
  20730.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pa.httpMethodUnsupported.generateErrorMessage");
  20731.                 if(name==null){
  20732.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pa.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
  20733.                     name="true";
  20734.                 }
  20735.                 name = name.trim();
  20736.                 this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled = Boolean.parseBoolean(name);
  20737.             } catch(java.lang.Exception e) {
  20738.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pa.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
  20739.                 this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled = true;
  20740.             }    
  20741.         }

  20743.         return this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled;
  20744.     }
  20745.     
  20746.     private Boolean isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled = null;
  20747.     public boolean isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled() {    
  20748.         if(this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled==null){
  20749.             try{ 
  20750.                 String name = null;
  20751.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.im.httpMethodUnsupported.generateErrorMessage");
  20752.                 if(name==null){
  20753.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.im.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
  20754.                     name="true";
  20755.                 }
  20756.                 name = name.trim();
  20757.                 this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled = Boolean.parseBoolean(name);
  20758.             } catch(java.lang.Exception e) {
  20759.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.im.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
  20760.                 this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled = true;
  20761.             }    
  20762.         }

  20764.         return this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled;
  20765.     }
  20766.     
  20767.     private Boolean isGenerazioneErroreHttpMethodUnsupportedCheckEnabled = null;
  20768.     public boolean isGenerazioneErroreHttpMethodUnsupportedCheckEnabled() { 
  20769.         if(this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled==null){
  20770.             try{ 
  20771.                 String name = null;
  20772.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.httpMethodUnsupported.generateErrorMessage");
  20773.                 if(name==null){
  20774.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.check.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
  20775.                     name="true";
  20776.                 }
  20777.                 name = name.trim();
  20778.                 this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled = Boolean.parseBoolean(name);
  20779.             } catch(java.lang.Exception e) {
  20780.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
  20781.                 this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled = true;
  20782.             }    
  20783.         }

  20785.         return this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled;
  20786.     }
  20787.     
  20788.     private Boolean isGenerazioneErroreHttpMethodUnsupportedProxyEnabled = null;
  20789.     public boolean isGenerazioneErroreHttpMethodUnsupportedProxyEnabled() { 
  20790.         if(this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled==null){
  20791.             try{ 
  20792.                 String name = null;
  20793.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxy.httpMethodUnsupported.generateErrorMessage");
  20794.                 if(name==null){
  20795.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxy.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
  20796.                     name="true";
  20797.                 }
  20798.                 name = name.trim();
  20799.                 this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled = Boolean.parseBoolean(name);
  20800.             } catch(java.lang.Exception e) {
  20801.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxy.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
  20802.                 this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled = true;
  20803.             }    
  20804.         }

  20806.         return this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled;
  20807.     }
  20808.     
  20809.     
  20810.     
  20811.     
  20812.     /* ------------- Generazione WSDL ---------------------*/
  20813.     
  20814.     private Boolean isGenerazioneWsdlPortaDelegataEnabled = null;
  20815.     public boolean isGenerazioneWsdlPortaDelegataEnabled() {    
  20816.         if(this.isGenerazioneWsdlPortaDelegataEnabled==null){
  20817.             try{ 
  20818.                 String name = null;
  20819.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pd.generateWsdl");
  20820.                 if(name==null){
  20821.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pd.generateWsdl' non impostata, viene utilizzato il default=false");
  20822.                     name="false";
  20823.                 }
  20824.                 name = name.trim();
  20825.                 this.isGenerazioneWsdlPortaDelegataEnabled = Boolean.parseBoolean(name);
  20826.             } catch(java.lang.Exception e) {
  20827.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pd.generateWsdl': "+e.getMessage(),e);
  20828.                 this.isGenerazioneWsdlPortaDelegataEnabled = false;
  20829.             }    
  20830.         }

  20832.         return this.isGenerazioneWsdlPortaDelegataEnabled;
  20833.     }
  20834.     
  20835.     private Boolean isGenerazioneWsdlPortaApplicativaEnabled = null;
  20836.     public boolean isGenerazioneWsdlPortaApplicativaEnabled() { 
  20837.         if(this.isGenerazioneWsdlPortaApplicativaEnabled==null){
  20838.             try{ 
  20839.                 String name = null;
  20840.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pa.generateWsdl");
  20841.                 if(name==null){
  20842.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pa.generateWsdl' non impostata, viene utilizzato il default=false");
  20843.                     name="false";
  20844.                 }
  20845.                 name = name.trim();
  20846.                 this.isGenerazioneWsdlPortaApplicativaEnabled = Boolean.parseBoolean(name);
  20847.             } catch(java.lang.Exception e) {
  20848.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pa.generateWsdl': "+e.getMessage(),e);
  20849.                 this.isGenerazioneWsdlPortaApplicativaEnabled = false;
  20850.             }    
  20851.         }

  20853.         return this.isGenerazioneWsdlPortaApplicativaEnabled;
  20854.     }
  20855.     
  20856.     private Boolean isGenerazioneWsdlIntegrationManagerEnabled = null;
  20857.     public boolean isGenerazioneWsdlIntegrationManagerEnabled() {   
  20858.         if(this.isGenerazioneWsdlIntegrationManagerEnabled==null){
  20859.             try{ 
  20860.                 String name = null;
  20861.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.im.generateWsdl");
  20862.                 if(name==null){
  20863.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.im.generateWsdl' non impostata, viene utilizzato il default=true");
  20864.                     name="true";
  20865.                 }
  20866.                 name = name.trim();
  20867.                 this.isGenerazioneWsdlIntegrationManagerEnabled = Boolean.parseBoolean(name);
  20868.             } catch(java.lang.Exception e) {
  20869.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.im.generateWsdl': "+e.getMessage(),e);
  20870.                 this.isGenerazioneWsdlIntegrationManagerEnabled = true;
  20871.             }    
  20872.         }

  20874.         return this.isGenerazioneWsdlIntegrationManagerEnabled;
  20875.     }
  20876.     
  20877.     
  20878.     
  20879.     
  20880.     /* ------------- Check Reader Risorse JMX ---------------------*/
  20881.     
  20882.     private Boolean isCheckEnabled = null;
  20883.     public boolean isCheckEnabled() {   
  20884.         if(this.isCheckEnabled==null){
  20885.             try{ 
  20886.                 String name = null;
  20887.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.enabled");
  20888.                 if(name==null){
  20889.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.check.enabled' non impostata, viene utilizzato il default=true");
  20890.                     name="true";
  20891.                 }
  20892.                 name = name.trim();
  20893.                 this.isCheckEnabled = Boolean.parseBoolean(name);
  20894.             } catch(java.lang.Exception e) {
  20895.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.enabled': "+e.getMessage(),e);
  20896.                 this.isCheckEnabled = true;
  20897.             }    
  20898.         }

  20900.         return this.isCheckEnabled;
  20901.     }
  20902.     
  20903.     private Boolean isCheckHealthCheckApiRestEnabled = null;
  20904.     public boolean isCheckHealthCheckApiRestEnabled() { 
  20905.         if(this.isCheckHealthCheckApiRestEnabled==null){
  20906.             String pName = "org.openspcoop2.pdd.check.healthCheck.apiRest.enabled";
  20907.             try{ 
  20908.                 String name = null;
  20909.                 name = this.reader.getValueConvertEnvProperties(pName);
  20910.                 if(name==null){
  20911.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  20912.                     name="false";
  20913.                 }
  20914.                 name = name.trim();
  20915.                 this.isCheckHealthCheckApiRestEnabled = Boolean.parseBoolean(name);
  20916.             } catch(java.lang.Exception e) {
  20917.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  20918.                 this.isCheckHealthCheckApiRestEnabled = false;
  20919.             }    
  20920.         }

  20922.         return this.isCheckHealthCheckApiRestEnabled;
  20923.     }
  20924.     
  20925.     private String getCheckHealthCheckApiRestEndpoint = null;
  20926.     public String getCheckHealthCheckApiRestEndpoint() {    
  20927.         if(this.getCheckHealthCheckApiRestEndpoint==null){
  20928.             String pName = "org.openspcoop2.pdd.check.healthCheck.apiRest.endpoint";
  20929.             try{ 
  20930.                 String name = null;
  20931.                 name = this.reader.getValueConvertEnvProperties(pName);
  20932.                 if(name==null){
  20933.                     throw new CoreException("Non definita");
  20934.                 }
  20935.                 name = name.trim();
  20936.                 this.getCheckHealthCheckApiRestEndpoint = name;
  20937.             } catch(java.lang.Exception e) {
  20938.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  20939.                 this.getCheckHealthCheckApiRestEndpoint = null;
  20940.             }    
  20941.         }

  20943.         return this.getCheckHealthCheckApiRestEndpoint;
  20944.     }
  20945.     
  20946.     private Boolean isCheckHealthCheckApiSoapEnabled = null;
  20947.     public boolean isCheckHealthCheckApiSoapEnabled() { 
  20948.         if(this.isCheckHealthCheckApiSoapEnabled==null){
  20949.             String pName = "org.openspcoop2.pdd.check.healthCheck.apiSoap.enabled";
  20950.             try{ 
  20951.                 String name = null;
  20952.                 name = this.reader.getValueConvertEnvProperties(pName);
  20953.                 if(name==null){
  20954.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  20955.                     name="false";
  20956.                 }
  20957.                 name = name.trim();
  20958.                 this.isCheckHealthCheckApiSoapEnabled = Boolean.parseBoolean(name);
  20959.             } catch(java.lang.Exception e) {
  20960.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  20961.                 this.isCheckHealthCheckApiSoapEnabled = false;
  20962.             }    
  20963.         }

  20965.         return this.isCheckHealthCheckApiSoapEnabled;
  20966.     }
  20967.     
  20968.     private String getCheckHealthCheckApiSoapEndpoint = null;
  20969.     public String getCheckHealthCheckApiSoapEndpoint() {    
  20970.         if(this.getCheckHealthCheckApiSoapEndpoint==null){
  20971.             String pName = "org.openspcoop2.pdd.check.healthCheck.apiSoap.endpoint";
  20972.             try{ 
  20973.                 String name = null;
  20974.                 name = this.reader.getValueConvertEnvProperties(pName);
  20975.                 if(name==null){
  20976.                     throw new CoreException("Non definita");
  20977.                 }
  20978.                 name = name.trim();
  20979.                 this.getCheckHealthCheckApiSoapEndpoint = name;
  20980.             } catch(java.lang.Exception e) {
  20981.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  20982.                 this.getCheckHealthCheckApiSoapEndpoint = null;
  20983.             }    
  20984.         }

  20986.         return this.getCheckHealthCheckApiSoapEndpoint;
  20987.     }
  20988.     
  20989.     private Boolean isCheckHealthCheckStatsEnabled = null;
  20990.     public boolean isCheckHealthCheckStatsEnabled() {   
  20991.         if(this.isCheckHealthCheckStatsEnabled==null){
  20992.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.enabled";
  20993.             try{ 
  20994.                 String name = null;
  20995.                 name = this.reader.getValueConvertEnvProperties(pName);
  20996.                 if(name==null){
  20997.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  20998.                     name="false";
  20999.                 }
  21000.                 name = name.trim();
  21001.                 this.isCheckHealthCheckStatsEnabled = Boolean.parseBoolean(name);
  21002.             } catch(java.lang.Exception e) {
  21003.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21004.                 this.isCheckHealthCheckStatsEnabled = false;
  21005.             }    
  21006.         }

  21008.         return this.isCheckHealthCheckStatsEnabled;
  21009.     }
  21010.     
  21011.     private Boolean isCheckHealthCheckStatsHourlyEnabled = null;
  21012.     public boolean isCheckHealthCheckStatsHourlyEnabled() { 
  21013.         if(this.isCheckHealthCheckStatsHourlyEnabled==null){
  21014.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloOrario.verifica";
  21015.             try{ 
  21016.                 String name = null;
  21017.                 name = this.reader.getValueConvertEnvProperties(pName);
  21018.                 if(name==null){
  21019.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  21020.                     name="false";
  21021.                 }
  21022.                 name = name.trim();
  21023.                 this.isCheckHealthCheckStatsHourlyEnabled = Boolean.parseBoolean(name);
  21024.             } catch(java.lang.Exception e) {
  21025.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21026.                 this.isCheckHealthCheckStatsHourlyEnabled = false;
  21027.             }    
  21028.         }

  21030.         return this.isCheckHealthCheckStatsHourlyEnabled;
  21031.     }
  21032.     
  21033.     private Integer getCheckHealthCheckStatsHourlyThreshold = null;
  21034.     public int getCheckHealthCheckStatsHourlyThreshold() {  
  21035.         if(this.getCheckHealthCheckStatsHourlyThreshold==null){
  21036.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloOrario.soglia";
  21037.             try{ 
  21038.                 String name = null;
  21039.                 name = this.reader.getValueConvertEnvProperties(pName);
  21040.                 if(name==null){
  21041.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, 1));
  21042.                     name="1";
  21043.                 }
  21044.                 name = name.trim();
  21045.                 this.getCheckHealthCheckStatsHourlyThreshold = Integer.valueOf(name);
  21046.             } catch(java.lang.Exception e) {
  21047.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21048.                 this.getCheckHealthCheckStatsHourlyThreshold = -1;
  21049.             }    
  21050.         }

  21052.         return this.getCheckHealthCheckStatsHourlyThreshold;
  21053.     }
  21054.     
  21055.         
  21056.     private Boolean isCheckHealthCheckStatsDailyEnabled = null;
  21057.     public boolean isCheckHealthCheckStatsDailyEnabled() {  
  21058.         if(this.isCheckHealthCheckStatsDailyEnabled==null){
  21059.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloGiornaliero.verifica";
  21060.             try{ 
  21061.                 String name = null;
  21062.                 name = this.reader.getValueConvertEnvProperties(pName);
  21063.                 if(name==null){
  21064.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  21065.                     name="false";
  21066.                 }
  21067.                 name = name.trim();
  21068.                 this.isCheckHealthCheckStatsDailyEnabled = Boolean.parseBoolean(name);
  21069.             } catch(java.lang.Exception e) {
  21070.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21071.                 this.isCheckHealthCheckStatsDailyEnabled = false;
  21072.             }    
  21073.         }

  21075.         return this.isCheckHealthCheckStatsDailyEnabled;
  21076.     }
  21077.     
  21078.     private Integer getCheckHealthCheckStatsDailyThreshold = null;
  21079.     public int getCheckHealthCheckStatsDailyThreshold() {   
  21080.         if(this.getCheckHealthCheckStatsDailyThreshold==null){
  21081.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloGiornaliero.soglia";
  21082.             try{ 
  21083.                 String name = null;
  21084.                 name = this.reader.getValueConvertEnvProperties(pName);
  21085.                 if(name==null){
  21086.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, 1));
  21087.                     name="1";
  21088.                 }
  21089.                 name = name.trim();
  21090.                 this.getCheckHealthCheckStatsDailyThreshold = Integer.valueOf(name);
  21091.             } catch(java.lang.Exception e) {
  21092.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21093.                 this.getCheckHealthCheckStatsDailyThreshold = -1;
  21094.             }    
  21095.         }

  21097.         return this.getCheckHealthCheckStatsDailyThreshold;
  21098.     }
  21099.     
  21100.     private Boolean isCheckHealthCheckStatsWeeklyEnabled = null;
  21101.     public boolean isCheckHealthCheckStatsWeeklyEnabled() { 
  21102.         if(this.isCheckHealthCheckStatsWeeklyEnabled==null){
  21103.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloSettimanale.verifica";
  21104.             try{ 
  21105.                 String name = null;
  21106.                 name = this.reader.getValueConvertEnvProperties(pName);
  21107.                 if(name==null){
  21108.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  21109.                     name="false";
  21110.                 }
  21111.                 name = name.trim();
  21112.                 this.isCheckHealthCheckStatsWeeklyEnabled = Boolean.parseBoolean(name);
  21113.             } catch(java.lang.Exception e) {
  21114.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21115.                 this.isCheckHealthCheckStatsWeeklyEnabled = false;
  21116.             }    
  21117.         }

  21119.         return this.isCheckHealthCheckStatsWeeklyEnabled;
  21120.     }
  21121.     
  21122.     private Integer getCheckHealthCheckStatsWeeklyThreshold = null;
  21123.     public int getCheckHealthCheckStatsWeeklyThreshold() {  
  21124.         if(this.getCheckHealthCheckStatsWeeklyThreshold==null){
  21125.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloSettimanale.soglia";
  21126.             try{ 
  21127.                 String name = null;
  21128.                 name = this.reader.getValueConvertEnvProperties(pName);
  21129.                 if(name==null){
  21130.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, 1));
  21131.                     name="1";
  21132.                 }
  21133.                 name = name.trim();
  21134.                 this.getCheckHealthCheckStatsWeeklyThreshold = Integer.valueOf(name);
  21135.             } catch(java.lang.Exception e) {
  21136.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21137.                 this.getCheckHealthCheckStatsWeeklyThreshold = -1;
  21138.             }    
  21139.         }

  21141.         return this.getCheckHealthCheckStatsWeeklyThreshold;
  21142.     }
  21143.     

  21145.     
  21146.     private Boolean isCheckHealthCheckStatsMonthlyEnabled = null;
  21147.     public boolean isCheckHealthCheckStatsMonthlyEnabled() {    
  21148.         if(this.isCheckHealthCheckStatsMonthlyEnabled==null){
  21149.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloMensile.verifica";
  21150.             try{ 
  21151.                 String name = null;
  21152.                 name = this.reader.getValueConvertEnvProperties(pName);
  21153.                 if(name==null){
  21154.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  21155.                     name="false";
  21156.                 }
  21157.                 name = name.trim();
  21158.                 this.isCheckHealthCheckStatsMonthlyEnabled = Boolean.parseBoolean(name);
  21159.             } catch(java.lang.Exception e) {
  21160.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21161.                 this.isCheckHealthCheckStatsMonthlyEnabled = false;
  21162.             }    
  21163.         }

  21165.         return this.isCheckHealthCheckStatsMonthlyEnabled;
  21166.     }
  21167.     
  21168.     private Integer getCheckHealthCheckStatsMonthlyThreshold = null;
  21169.     public int getCheckHealthCheckStatsMonthlyThreshold() { 
  21170.         if(this.getCheckHealthCheckStatsMonthlyThreshold==null){
  21171.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloMensile.soglia";
  21172.             try{ 
  21173.                 String name = null;
  21174.                 name = this.reader.getValueConvertEnvProperties(pName);
  21175.                 if(name==null){
  21176.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, 1));
  21177.                     name="1";
  21178.                 }
  21179.                 name = name.trim();
  21180.                 this.getCheckHealthCheckStatsMonthlyThreshold = Integer.valueOf(name);
  21181.             } catch(java.lang.Exception e) {
  21182.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21183.                 this.getCheckHealthCheckStatsMonthlyThreshold = -1;
  21184.             }    
  21185.         }

  21187.         return this.getCheckHealthCheckStatsMonthlyThreshold;
  21188.     }
  21189.     
  21190.     private Boolean isCheckReadJMXResourcesEnabled = null;
  21191.     public boolean isCheckReadJMXResourcesEnabled() {   
  21192.         if(this.isCheckReadJMXResourcesEnabled==null){
  21193.             try{ 
  21194.                 String name = null;
  21195.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.readJMXResources.enabled");
  21196.                 if(name==null){
  21197.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.check.readJMXResources.enabled' non impostata, viene utilizzato il default=false");
  21198.                     name="false";
  21199.                 }
  21200.                 name = name.trim();
  21201.                 this.isCheckReadJMXResourcesEnabled = Boolean.parseBoolean(name);
  21202.             } catch(java.lang.Exception e) {
  21203.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.readJMXResources.enabled': "+e.getMessage(),e);
  21204.                 this.isCheckReadJMXResourcesEnabled = false;
  21205.             }    
  21206.         }

  21208.         return this.isCheckReadJMXResourcesEnabled;
  21209.     }
  21210.     
  21211.     private String getCheckReadJMXResourcesUsername = null;
  21212.     private Boolean getCheckReadJMXResourcesUsernameRead = null;
  21213.     public String getCheckReadJMXResourcesUsername() {  
  21214.         if(this.getCheckReadJMXResourcesUsernameRead==null){
  21215.             try{ 
  21216.                 String name = null;
  21217.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.readJMXResources.username");
  21218.                 if(name!=null){
  21219.                     name = name.trim();
  21220.                 }
  21221.                 this.getCheckReadJMXResourcesUsernameRead = true;
  21222.                 this.getCheckReadJMXResourcesUsername = name;
  21223.             } catch(java.lang.Exception e) {
  21224.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.readJMXResources.username': "+e.getMessage(),e);
  21225.             }    
  21226.         }
  21227.         return this.getCheckReadJMXResourcesUsername;
  21228.     }
  21229.     
  21230.     private String getCheckReadJMXResourcesPassword = null;
  21231.     private Boolean getCheckReadJMXResourcesPasswordRead = null;
  21232.     public String getCheckReadJMXResourcesPassword() {  
  21233.         if(this.getCheckReadJMXResourcesPasswordRead==null){
  21234.             try{ 
  21235.                 String name = null;
  21236.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.readJMXResources.password");
  21237.                 if(name!=null){
  21238.                     name = name.trim();
  21239.                 }
  21240.                 this.getCheckReadJMXResourcesPasswordRead = true;
  21241.                 this.getCheckReadJMXResourcesPassword = name;
  21242.             } catch(java.lang.Exception e) {
  21243.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.readJMXResources.password': "+e.getMessage(),e);
  21244.             }    
  21245.         }
  21246.         return this.getCheckReadJMXResourcesPassword;
  21247.     }
  21248.     
  21249.     
  21250.     private Boolean isProxyReadJMXResourcesEnabled = null;
  21251.     public boolean isProxyReadJMXResourcesEnabled() {   
  21252.         if(this.isProxyReadJMXResourcesEnabled==null){
  21253.             try{ 
  21254.                 String name = null;
  21255.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.enabled");
  21256.                 if(name==null){
  21257.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.enabled' non impostata, viene utilizzato il default=false");
  21258.                     name="false";
  21259.                 }
  21260.                 name = name.trim();
  21261.                 this.isProxyReadJMXResourcesEnabled = Boolean.parseBoolean(name);
  21262.             } catch(java.lang.Exception e) {
  21263.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.enabled': "+e.getMessage(),e);
  21264.                 this.isProxyReadJMXResourcesEnabled = false;
  21265.             }    
  21266.         }

  21268.         return this.isProxyReadJMXResourcesEnabled;
  21269.     }
  21270.     
  21271.     private Boolean isProxyReadJMXResourcesAsyncProcessByTimer = null;
  21272.     public boolean isProxyReadJMXResourcesAsyncProcessByTimer() {   
  21273.         if(this.isProxyReadJMXResourcesAsyncProcessByTimer==null){
  21274.             try{ 
  21275.                 String name = null;
  21276.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate");
  21277.                 if(name==null){
  21278.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate' non impostata, viene utilizzato il default=false");
  21279.                     name="false";
  21280.                 }
  21281.                 name = name.trim();
  21282.                 this.isProxyReadJMXResourcesAsyncProcessByTimer = Boolean.parseBoolean(name);
  21283.             } catch(java.lang.Exception e) {
  21284.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate': "+e.getMessage(),e);
  21285.                 this.isProxyReadJMXResourcesAsyncProcessByTimer = false;
  21286.             }    
  21287.         }

  21289.         return this.isProxyReadJMXResourcesAsyncProcessByTimer;
  21290.     }
  21291.     
  21292.     private String getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass = null;
  21293.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClassRead = null;
  21294.     public String getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass() {   
  21295.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClassRead==null){
  21296.             try{ 
  21297.                 String name = null;
  21298.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.serviceClass");
  21299.                 if(name!=null){
  21300.                     name = name.trim();
  21301.                 }
  21302.                 this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClassRead = true;
  21303.                 this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass = name;
  21304.             } catch(java.lang.Exception e) {
  21305.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.serviceClass': "+e.getMessage(),e);
  21306.             }    
  21307.         }
  21308.         return this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass;
  21309.     }
  21310.     
  21311.     private Boolean isProxyReadJMXResourcesAsyncProcessByTimerDebug = null;
  21312.     public boolean isProxyReadJMXResourcesAsyncProcessByTimerDebug() {  
  21313.         if(this.isProxyReadJMXResourcesAsyncProcessByTimerDebug==null){
  21314.             String pName = "org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.debug";
  21315.             try{ 
  21316.                 String name = null;
  21317.                 name = this.reader.getValueConvertEnvProperties(pName);
  21318.                 if(name==null){
  21319.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  21320.                     name="true";
  21321.                 }
  21322.                 name = name.trim();
  21323.                 this.isProxyReadJMXResourcesAsyncProcessByTimerDebug = Boolean.parseBoolean(name);
  21324.             } catch(java.lang.Exception e) {
  21325.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  21326.                 this.isProxyReadJMXResourcesAsyncProcessByTimerDebug = true;
  21327.             }    
  21328.         }

  21330.         return this.isProxyReadJMXResourcesAsyncProcessByTimerDebug;
  21331.     }
  21332.     
  21333.     private String getProxyReadJMXResourcesAsyncProcessByTimerHostname = null;
  21334.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerHostnameRead = null;
  21335.     public String getProxyReadJMXResourcesAsyncProcessByTimerHostname() {   
  21336.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerHostnameRead==null){
  21337.             try{ 
  21338.                 String name = null;
  21339.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.hostname");
  21340.                 if(name!=null){
  21341.                     name = name.trim();
  21342.                 }
  21343.                 this.getProxyReadJMXResourcesAsyncProcessByTimerHostnameRead = true;
  21344.                 this.getProxyReadJMXResourcesAsyncProcessByTimerHostname = name;
  21345.             } catch(java.lang.Exception e) {
  21346.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.hostname': "+e.getMessage(),e);
  21347.             }    
  21348.         }
  21349.         return this.getProxyReadJMXResourcesAsyncProcessByTimerHostname;
  21350.     }
  21351.     
  21352.     private String getProxyReadJMXResourcesAsyncProcessByTimerSchema = null;
  21353.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerSchemaRead = null;
  21354.     public String getProxyReadJMXResourcesAsyncProcessByTimerSchema() { 
  21355.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerSchemaRead==null){
  21356.             try{ 
  21357.                 String name = null;
  21358.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.schema");
  21359.                 if(name!=null){
  21360.                     name = name.trim();
  21361.                 }
  21362.                 this.getProxyReadJMXResourcesAsyncProcessByTimerSchemaRead = true;
  21363.                 this.getProxyReadJMXResourcesAsyncProcessByTimerSchema = name;
  21364.             } catch(java.lang.Exception e) {
  21365.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.schema': "+e.getMessage(),e);
  21366.             }    
  21367.         }
  21368.         return this.getProxyReadJMXResourcesAsyncProcessByTimerSchema;
  21369.     }
  21370.     
  21371.     private Integer getProxyReadJMXResourcesAsyncProcessByTimerPort = null;
  21372.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerPortRead = null;
  21373.     public Integer getProxyReadJMXResourcesAsyncProcessByTimerPort() {  
  21374.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerPortRead==null){
  21375.             try{ 
  21376.                 String name = null;
  21377.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.port");
  21378.                 if(name!=null){
  21379.                     name = name.trim();
  21380.                     this.getProxyReadJMXResourcesAsyncProcessByTimerPort = Integer.valueOf(name);
  21381.                 }
  21382.                 this.getProxyReadJMXResourcesAsyncProcessByTimerPortRead = true;
  21383.             } catch(java.lang.Exception e) {
  21384.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.port': "+e.getMessage(),e);
  21385.             }    
  21386.         }
  21387.         return this.getProxyReadJMXResourcesAsyncProcessByTimerPort;
  21388.     }
  21389.     
  21390.     private Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval = null;
  21391.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerCheckIntervalRead = null;
  21392.     public Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval() { 
  21393.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerCheckIntervalRead==null){
  21394.             try{ 
  21395.                 String name = null;
  21396.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.checkInterval");
  21397.                 if(name!=null){
  21398.                     name = name.trim();
  21399.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval = Integer.valueOf(name);
  21400.                 }
  21401.                 else {
  21402.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.checkInterval' non impostata, viene utilizzato il default=60");
  21403.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval = 60;
  21404.                 }
  21405.             } catch(java.lang.Exception e) {
  21406.                 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);
  21407.                 this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval = 60;
  21408.             }
  21409.             this.getProxyReadJMXResourcesAsyncProcessByTimerCheckIntervalRead = true;
  21410.         }
  21411.         return this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval;
  21412.     }
  21413.     
  21414.     private Integer getProxyReadJMXResourcesAsyncProcessByTimerLimit = null;
  21415.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerLimitRead = null;
  21416.     public Integer getProxyReadJMXResourcesAsyncProcessByTimerLimit() { 
  21417.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerLimitRead==null){
  21418.             try{ 
  21419.                 String name = null;
  21420.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.limit");
  21421.                 if(name!=null){
  21422.                     name = name.trim();
  21423.                     this.getProxyReadJMXResourcesAsyncProcessByTimerLimit = Integer.valueOf(name);
  21424.                 }
  21425.                 else {
  21426.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.limit' non impostata, viene utilizzato il default=100");
  21427.                     this.getProxyReadJMXResourcesAsyncProcessByTimerLimit = 100;
  21428.                 }
  21429.             } catch(java.lang.Exception e) {
  21430.                 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);
  21431.                 this.getProxyReadJMXResourcesAsyncProcessByTimerLimit = 100;
  21432.             }
  21433.             this.getProxyReadJMXResourcesAsyncProcessByTimerLimitRead = true;
  21434.         }
  21435.         return this.getProxyReadJMXResourcesAsyncProcessByTimerLimit;
  21436.     }
  21437.     
  21438.     private Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval = null;
  21439.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordIntervalRead = null;
  21440.     public Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval() {    
  21441.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordIntervalRead==null){
  21442.             try{ 
  21443.                 String name = null;
  21444.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.checkInterval");
  21445.                 if(name!=null){
  21446.                     name = name.trim();
  21447.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval = Integer.valueOf(name);
  21448.                 }
  21449.                 else {
  21450.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.checkInterval' non impostata, viene utilizzato il default=3600");
  21451.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval = 3600;
  21452.                 }
  21453.             } catch(java.lang.Exception e) {
  21454.                 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);
  21455.                 this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval = 3600;
  21456.             }
  21457.             this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordIntervalRead = true;
  21458.         }
  21459.         return this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval;
  21460.     }
  21461.     
  21462.     private Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes = null;
  21463.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutesRead = null;
  21464.     public Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes() {  
  21465.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutesRead==null){
  21466.             try{ 
  21467.                 String name = null;
  21468.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.olderThanMinutes");
  21469.                 if(name!=null){
  21470.                     name = name.trim();
  21471.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes = Integer.valueOf(name);
  21472.                 }
  21473.                 else {
  21474.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.olderThanMinutes' non impostata, viene utilizzato il default=60");
  21475.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes = 60;
  21476.                 }
  21477.             } catch(java.lang.Exception e) {
  21478.                 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);
  21479.                 this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes = 60;
  21480.             }
  21481.             this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutesRead = true;
  21482.         }
  21483.         return this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes;
  21484.     }
  21485.     
  21486.     private String getProxyReadJMXResourcesSchema = null;
  21487.     private Boolean getProxyReadJMXResourcesSchemaRead = null;
  21488.     public String getProxyReadJMXResourcesSchema() {    
  21489.         if(this.getProxyReadJMXResourcesSchemaRead==null){
  21490.             try{ 
  21491.                 String name = null;
  21492.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.schema");
  21493.                 if(name!=null){
  21494.                     name = name.trim();
  21495.                 }
  21496.                 this.getProxyReadJMXResourcesSchemaRead = true;
  21497.                 this.getProxyReadJMXResourcesSchema = name;
  21498.             } catch(java.lang.Exception e) {
  21499.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.schema': "+e.getMessage(),e);
  21500.             }    
  21501.         }
  21502.         return this.getProxyReadJMXResourcesSchema;
  21503.     }
  21504.     
  21505.     private Integer getProxyReadJMXResourcesPort = null;
  21506.     private Boolean getProxyReadJMXResourcesPortRead = null;
  21507.     public Integer getProxyReadJMXResourcesPort() { 
  21508.         if(this.getProxyReadJMXResourcesPortRead==null){
  21509.             try{ 
  21510.                 String name = null;
  21511.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.port");
  21512.                 if(name!=null){
  21513.                     name = name.trim();
  21514.                     this.getProxyReadJMXResourcesPort = Integer.valueOf(name);
  21515.                 }
  21516.                 this.getProxyReadJMXResourcesPortRead = true;
  21517.             } catch(java.lang.Exception e) {
  21518.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.port': "+e.getMessage(),e);
  21519.             }    
  21520.         }
  21521.         return this.getProxyReadJMXResourcesPort;
  21522.     }
  21523.     
  21524.     // utile per debug: invoco tutte le volte
  21525.     public Integer getProxyReadJMXResourcesPort(String hostname) {  
  21526.         try{ 
  21527.             String name = null;
  21528.             name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.port."+hostname);
  21529.             if(name!=null){
  21530.                 name = name.trim();
  21531.                 return Integer.valueOf(name);
  21532.             }
  21533.         } catch(java.lang.Exception e) {
  21534.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.port."+hostname+"': "+e.getMessage(),e);
  21535.         }    
  21536.         return null;
  21537.     }
  21538.     
  21539.     private String getProxyReadJMXResourcesUsername = null;
  21540.     private Boolean getProxyReadJMXResourcesUsernameRead = null;
  21541.     public String getProxyReadJMXResourcesUsername() {  
  21542.         if(this.getProxyReadJMXResourcesUsernameRead==null){
  21543.             try{ 
  21544.                 String name = null;
  21545.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.username");
  21546.                 if(name!=null){
  21547.                     name = name.trim();
  21548.                 }
  21549.                 this.getProxyReadJMXResourcesUsernameRead = true;
  21550.                 this.getProxyReadJMXResourcesUsername = name;
  21551.             } catch(java.lang.Exception e) {
  21552.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.username': "+e.getMessage(),e);
  21553.             }    
  21554.         }
  21555.         return this.getProxyReadJMXResourcesUsername;
  21556.     }
  21557.     
  21558.     private String getProxyReadJMXResourcesPassword = null;
  21559.     private Boolean getProxyReadJMXResourcesPasswordRead = null;
  21560.     public String getProxyReadJMXResourcesPassword() {  
  21561.         if(this.getProxyReadJMXResourcesPasswordRead==null){
  21562.             try{ 
  21563.                 String name = null;
  21564.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.password");
  21565.                 if(name!=null){
  21566.                     name = name.trim();
  21567.                 }
  21568.                 this.getProxyReadJMXResourcesPasswordRead = true;
  21569.                 this.getProxyReadJMXResourcesPassword = name;
  21570.             } catch(java.lang.Exception e) {
  21571.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.password': "+e.getMessage(),e);
  21572.             }    
  21573.         }
  21574.         return this.getProxyReadJMXResourcesPassword;
  21575.     }
  21576.     
  21577.     private Boolean isProxyReadJMXResourcesHttpsEnabled = null;
  21578.     public boolean isProxyReadJMXResourcesHttpsEnabled() {  
  21579.         if(this.isProxyReadJMXResourcesHttpsEnabled==null){
  21580.             String pName = "org.openspcoop2.pdd.proxyJMXResources.https";
  21581.             try{ 
  21582.                 String name = null;
  21583.                 name = this.reader.getValueConvertEnvProperties(pName);
  21584.                 if(name==null){
  21585.                     this.logDebug(getMessaggioProprietaNonImpostata(pName, false));
  21586.                     name="false";
  21587.                 }
  21588.                 name = name.trim();
  21589.                 this.isProxyReadJMXResourcesHttpsEnabled = Boolean.parseBoolean(name);
  21590.             } catch(java.lang.Exception e) {
  21591.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21592.                 this.isProxyReadJMXResourcesHttpsEnabled = false;
  21593.             }    
  21594.         }

  21596.         return this.isProxyReadJMXResourcesHttpsEnabled;
  21597.     }
  21598.     
  21599.     private Boolean isProxyReadJMXResourcesHttpsEnabledVerificaHostName = null;
  21600.     public boolean isProxyReadJMXResourcesHttpsEnabledVerificaHostName() {  
  21601.         if(this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName==null){
  21602.             String pName = "org.openspcoop2.pdd.proxyJMXResources.https.verificaHostName";
  21603.             try{ 
  21604.                 String name = null;
  21605.                 name = this.reader.getValueConvertEnvProperties(pName);
  21606.                 if(name==null){
  21607.                     this.logDebug(getMessaggioProprietaNonImpostata(pName, true));
  21608.                     name="true";
  21609.                 }
  21610.                 name = name.trim();
  21611.                 this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName = Boolean.parseBoolean(name);
  21612.             } catch(java.lang.Exception e) {
  21613.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21614.                 this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName = true;
  21615.             }    
  21616.         }

  21618.         return this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName;
  21619.     }
  21620.     
  21621.     private Boolean isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer = null;
  21622.     public boolean isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer() {  
  21623.         if(this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer==null){
  21624.             String pName = "org.openspcoop2.pdd.proxyJMXResources.https.autenticazioneServer";
  21625.             try{ 
  21626.                 String name = null;
  21627.                 name = this.reader.getValueConvertEnvProperties(pName);
  21628.                 if(name==null){
  21629.                     this.logDebug(getMessaggioProprietaNonImpostata(pName, true));
  21630.                     name="true";
  21631.                 }
  21632.                 name = name.trim();
  21633.                 this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer = Boolean.parseBoolean(name);
  21634.             } catch(java.lang.Exception e) {
  21635.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21636.                 this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer = true;
  21637.             }    
  21638.         }

  21640.         return this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer;
  21641.     }
  21642.     
  21643.     private String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath = null;
  21644.     private Boolean getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePathRead = null;
  21645.     public String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath() {    
  21646.         if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePathRead==null){
  21647.             String pName = "org.openspcoop2.pdd.proxyJMXResources.https.autenticazioneServer.truststorePath";
  21648.             try{ 
  21649.                 String name = null;
  21650.                 name = this.reader.getValueConvertEnvProperties(pName);
  21651.                 if(name!=null){
  21652.                     name = name.trim();
  21653.                 }
  21654.                 else {
  21655.                     throw new CoreException(NON_DEFINITA);
  21656.                 }
  21657.                 this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePathRead = true;
  21658.                 this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath = name;
  21659.             } catch(java.lang.Exception e) {
  21660.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21661.             }    
  21662.         }
  21663.         return this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath;
  21664.     }
  21665.     
  21666.     private String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType = null;
  21667.     private Boolean getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreTypeRead = null;
  21668.     public String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType() {    
  21669.         if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreTypeRead==null){
  21670.             String pName = "org.openspcoop2.pdd.proxyJMXResources.https.autenticazioneServer.truststoreType";
  21671.             try{ 
  21672.                 String name = null;
  21673.                 name = this.reader.getValueConvertEnvProperties(pName);
  21674.                 if(name!=null){
  21675.                     name = name.trim();
  21676.                 }
  21677.                 else {
  21678.                     throw new CoreException(NON_DEFINITA);
  21679.                 }
  21680.                 this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreTypeRead = true;
  21681.                 this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType = name;
  21682.             } catch(java.lang.Exception e) {
  21683.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21684.             }    
  21685.         }
  21686.         return this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType;
  21687.     }
  21688.     
  21689.     private String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword = null;
  21690.     private Boolean getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePasswordRead = null;
  21691.     public String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword() {    
  21692.         if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePasswordRead==null){
  21693.             String pName = "org.openspcoop2.pdd.proxyJMXResources.https.autenticazioneServer.truststorePassword";
  21694.             try{ 
  21695.                 String name = null;
  21696.                 name = this.reader.getValueConvertEnvProperties(pName);
  21697.                 if(name!=null){
  21698.                     name = name.trim();
  21699.                 }
  21700.                 else {
  21701.                     throw new CoreException(NON_DEFINITA);
  21702.                 }
  21703.                 this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePasswordRead = true;
  21704.                 this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword = name;
  21705.             } catch(java.lang.Exception e) {
  21706.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21707.             }    
  21708.         }
  21709.         return this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword;
  21710.     }
  21711.     
  21712.     private Integer getProxyReadJMXResourcesConnectionTimeout = null;
  21713.     public Integer getProxyReadJMXResourcesConnectionTimeout() {    
  21714.         if(this.getProxyReadJMXResourcesConnectionTimeout==null){
  21715.             try{ 
  21716.                 String name = null;
  21717.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.connection.timeout");
  21718.                 if(name!=null){
  21719.                     name = name.trim();
  21720.                 }
  21721.                 else {
  21722.                     throw new CoreException("non esistente");
  21723.                 }
  21724.                 this.getProxyReadJMXResourcesConnectionTimeout = Integer.valueOf(name);
  21725.             } catch(java.lang.Exception e) {
  21726.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.connection.timeout': "+e.getMessage(),e);
  21727.             }    
  21728.         }
  21729.         return this.getProxyReadJMXResourcesConnectionTimeout;
  21730.     }
  21731.     
  21732.     private Integer getProxyReadJMXResourcesReadTimeout = null;
  21733.     public Integer getProxyReadJMXResourcesReadTimeout() {  
  21734.         if(this.getProxyReadJMXResourcesReadTimeout==null){
  21735.             try{ 
  21736.                 String name = null;
  21737.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.readConnection.timeout");
  21738.                 if(name!=null){
  21739.                     name = name.trim();
  21740.                 }
  21741.                 else {
  21742.                     throw new CoreException("non esistente");
  21743.                 }
  21744.                 this.getProxyReadJMXResourcesReadTimeout = Integer.valueOf(name);
  21745.             } catch(java.lang.Exception e) {
  21746.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.readConnection.timeout': "+e.getMessage(),e);
  21747.             }    
  21748.         }
  21749.         return this.getProxyReadJMXResourcesReadTimeout;
  21750.     }
  21751.     
  21752.     

  21754.     
  21755.     /* -------------Datasource Wrapped  ---------------------*/
  21756.     
  21757.     private Boolean isDSOp2UtilsEnabled = null;
  21758.     public boolean isDSOp2UtilsEnabled() {  
  21759.         if(this.isDSOp2UtilsEnabled==null){
  21760.             try{ 
  21761.                 String name = null;
  21762.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.datasource.useDSUtils");
  21763.                 if(name==null){
  21764.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.datasource.useDSUtils' non impostata, viene utilizzato il default=false");
  21765.                     name="false";
  21766.                 }
  21767.                 name = name.trim();
  21768.                 this.isDSOp2UtilsEnabled = Boolean.parseBoolean(name);
  21769.             } catch(java.lang.Exception e) {
  21770.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.datasource.useDSUtils': "+e.getMessage(),e);
  21771.                 this.isDSOp2UtilsEnabled = false;
  21772.             }    
  21773.         }

  21775.         return this.isDSOp2UtilsEnabled;
  21776.     }
  21777.     
  21778.     
  21779.     
  21780.     /* ------------- Datasource check in getConnection event  ---------------------*/
  21781.     
  21782.     private Boolean isDataSourceGetConnectionCheckAutoCommitDisabled = null;
  21783.     public boolean isDataSourceGetConnectionCheckAutoCommitDisabled() { 
  21784.         String pName = "org.openspcoop2.pdd.datasource.getConnection.checkAutoCommitDisabled";
  21785.         if(this.isDataSourceGetConnectionCheckAutoCommitDisabled==null){
  21786.             try{ 
  21787.                 String name = null;
  21788.                 name = this.reader.getValueConvertEnvProperties(pName);
  21789.                 if(name==null){
  21790.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  21791.                     name="true";
  21792.                 }
  21793.                 name = name.trim();
  21794.                 this.isDataSourceGetConnectionCheckAutoCommitDisabled = Boolean.parseBoolean(name);
  21795.             } catch(java.lang.Exception e) {
  21796.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21797.                 this.isDataSourceGetConnectionCheckAutoCommitDisabled = true;
  21798.             }    
  21799.         }

  21801.         return this.isDataSourceGetConnectionCheckAutoCommitDisabled;
  21802.     }
  21803.     
  21804.     private Boolean isDataSourceGetConnectionCheckTransactionIsolationLevel = null;
  21805.     public boolean isDataSourceGetConnectionCheckTransactionIsolationLevel() {  
  21806.         String pName = "org.openspcoop2.pdd.datasource.getConnection.checkTransactionIsolationLevel";
  21807.         if(this.isDataSourceGetConnectionCheckTransactionIsolationLevel==null){
  21808.             try{ 
  21809.                 String name = null;
  21810.                 name = this.reader.getValueConvertEnvProperties(pName);
  21811.                 if(name==null){
  21812.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  21813.                     name="true";
  21814.                 }
  21815.                 name = name.trim();
  21816.                 this.isDataSourceGetConnectionCheckTransactionIsolationLevel = Boolean.parseBoolean(name);
  21817.             } catch(java.lang.Exception e) {
  21818.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21819.                 this.isDataSourceGetConnectionCheckTransactionIsolationLevel = true;
  21820.             }    
  21821.         }

  21823.         return this.isDataSourceGetConnectionCheckTransactionIsolationLevel;
  21824.     }
  21825.     
  21826.     private Integer getDataSourceGetConnectionCheckTransactionIsolationLevelExpected = null;
  21827.     public int getDataSourceGetConnectionCheckTransactionIsolationLevelExpected() { 
  21828.         String pName = "org.openspcoop2.pdd.datasource.getConnection.checkTransactionIsolationLevel.expected";
  21829.         if(this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected==null){
  21830.             try{ 
  21831.                 String name = null;
  21832.                 name = this.reader.getValueConvertEnvProperties(pName);
  21833.                 if(name==null){
  21834.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,Connection.TRANSACTION_READ_COMMITTED));
  21835.                     name=Connection.TRANSACTION_READ_COMMITTED+"";
  21836.                 }
  21837.                 name = name.trim();
  21838.                 this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected = Integer.valueOf(name);
  21839.             } catch(java.lang.Exception e) {
  21840.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21841.                 this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected = Connection.TRANSACTION_READ_COMMITTED;
  21842.             }    
  21843.         }

  21845.         return this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected;
  21846.     }
  21847.     

  21849.     
  21850.     
  21851.     /* ------------- NotifierInputStream  ---------------------*/
  21852.     
  21853.     private Boolean isNotifierInputStreamEnabled = null;
  21854.     public boolean isNotifierInputStreamEnabled(){

  21856.         if(this.isNotifierInputStreamEnabled==null){
  21857.             try{  
  21858.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.notifierInputStream.enabled"); 

  21860.                 if (value != null){
  21861.                     value = value.trim();
  21862.                     this.isNotifierInputStreamEnabled = Boolean.parseBoolean(value);
  21863.                 }else{
  21864.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.notifierInputStream.enabled' non impostata, viene utilizzato il default=false");
  21865.                     this.isNotifierInputStreamEnabled = false;
  21866.                 }

  21868.             }catch(java.lang.Exception e) {
  21869.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.notifierInputStream.enabled' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  21870.                 this.isNotifierInputStreamEnabled = false;
  21871.             }
  21872.         }

  21874.         return this.isNotifierInputStreamEnabled;
  21875.     }
  21876.     
  21877.     private String notifierInputStreamCallback = null;      
  21878.     private Boolean notifierInputStreamCallbackRead = null;     
  21879.     public String getNotifierInputStreamCallback() throws CoreException{
  21880.         if(this.notifierInputStreamCallbackRead==null){
  21881.             try{ 
  21882.                 this.notifierInputStreamCallback = this.reader.getValue("org.openspcoop2.pdd.notifierInputStream.tipo");
  21883.                 if(this.notifierInputStreamCallback!=null){
  21884.                     this.notifierInputStreamCallback = this.notifierInputStreamCallback.trim();
  21885.                 }
  21886.                 this.notifierInputStreamCallbackRead = true;
  21887.             } catch(java.lang.Exception e) {
  21888.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.notifierInputStream.tipo' non impostata correttamente,  errore:"+e.getMessage(),e);
  21889.                 throw new CoreException("Proprieta' di openspcoop 'org.openspcoop2.pdd.notifierInputStream.tipo' non impostata correttamente,  errore:"+e.getMessage(),e);
  21890.             } 
  21891.         }
  21892.         return this.notifierInputStreamCallback;
  21893.     }
  21894.     
  21895.     
  21896.     /* ------------- PipeUnblockedVersion  ---------------------*/
  21897.     
  21898.     private String pipedUnblockedStreamClassName = null;        
  21899.     private Boolean pipedUnblockedStreamClassNameRead = null;       
  21900.     public String getPipedUnblockedStreamClassName() throws CoreException{
  21901.         if(this.pipedUnblockedStreamClassNameRead==null){
  21902.             String pName = "org.openspcoop2.pdd.pipedUnblockedStream.className";
  21903.             try{ 
  21904.                 this.pipedUnblockedStreamClassName = this.reader.getValue(pName);
  21905.                 if(this.pipedUnblockedStreamClassName!=null){
  21906.                     this.pipedUnblockedStreamClassName = this.pipedUnblockedStreamClassName.trim();
  21907.                 }
  21908.                 this.pipedUnblockedStreamClassNameRead = true;
  21909.             } catch(java.lang.Exception e) {
  21910.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  21911.                 throw new CoreException("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  21912.             } 
  21913.         }
  21914.         return this.pipedUnblockedStreamClassName;
  21915.     }
  21916.     
  21917.     
  21918.     
  21919.     
  21920.     /* ------------- FORMURLEncoder  ---------------------*/
  21921.     
  21922.     private Boolean isFormUrlEncodedFilterEnabled = null;
  21923.     public boolean isFormUrlEncodedFilterEnabled(){

  21925.         if(this.isFormUrlEncodedFilterEnabled==null){
  21926.             try{  
  21927.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.formUrlEncodedFilter.enabled"); 

  21929.                 if (value != null){
  21930.                     value = value.trim();
  21931.                     this.isFormUrlEncodedFilterEnabled = Boolean.parseBoolean(value);
  21932.                 }else{
  21933.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.formUrlEncodedFilter.enabled' non impostata, viene utilizzato il default=false");
  21934.                     this.isFormUrlEncodedFilterEnabled = false;
  21935.                 }

  21937.             }catch(java.lang.Exception e) {
  21938.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.formUrlEncodedFilter.enabled' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  21939.                 this.isFormUrlEncodedFilterEnabled = false;
  21940.             }
  21941.         }

  21943.         return this.isFormUrlEncodedFilterEnabled;
  21944.     }
  21945.     
  21946.     
  21947.     
  21948.     /* ------------- FORMURLEncoder  ---------------------*/
  21949.     
  21950.     private Boolean isWildflyUndertowClientCertificateFilterEnabled = null;
  21951.     public boolean isWildflyUndertowClientCertificateFilterEnabled(){

  21953.         String pName = "org.openspcoop2.pdd.wildflyUndertowClientCertificateFilter.enabled";
  21954.         if(this.isWildflyUndertowClientCertificateFilterEnabled==null){
  21955.             try{  
  21956.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  21958.                 if (value != null){
  21959.                     value = value.trim();
  21960.                     this.isWildflyUndertowClientCertificateFilterEnabled = Boolean.parseBoolean(value);
  21961.                 }else{
  21962.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  21963.                     this.isWildflyUndertowClientCertificateFilterEnabled = false;
  21964.                 }

  21966.             }catch(java.lang.Exception e) {
  21967.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  21968.                 this.isWildflyUndertowClientCertificateFilterEnabled = false;
  21969.             }
  21970.         }

  21972.         return this.isWildflyUndertowClientCertificateFilterEnabled;
  21973.     }
  21974.     
  21975.     
  21976.     
  21977.     
  21978.     /* ------------- SEMAPHORE  ---------------------*/
  21979.     
  21980.     private Long getSemaphoreTimeoutMS = null;
  21981.     public long getSemaphoreTimeoutMS(){

  21983.         String pName = "org.openspcoop2.pdd.semaphore.timeoutMS";
  21984.         if(this.getSemaphoreTimeoutMS==null){
  21985.             try{  
  21986.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  21988.                 if (value != null){
  21989.                     value = value.trim();
  21990.                     this.getSemaphoreTimeoutMS = Long.parseLong(value);
  21991.                 }else{
  21992.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+Semaphore.DEFAULT_LOCK_ACQUISITION_TIMEOUT_MS);
  21993.                     this.getSemaphoreTimeoutMS = Semaphore.DEFAULT_LOCK_ACQUISITION_TIMEOUT_MS;
  21994.                 }

  21996.             }catch(java.lang.Exception e) {
  21997.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+Semaphore.DEFAULT_LOCK_ACQUISITION_TIMEOUT_MS+", errore:"+e.getMessage(),e);
  21998.                 this.getSemaphoreTimeoutMS = Semaphore.DEFAULT_LOCK_ACQUISITION_TIMEOUT_MS;
  21999.             }
  22000.         }

  22002.         return this.getSemaphoreTimeoutMS;
  22003.     }
  22004.     
  22005.     private Long getSemaphoreHoldTimeoutMS = null;
  22006.     public long getSemaphoreHoldTimeoutMS(){

  22008.         String pName = "org.openspcoop2.pdd.semaphore.hold.timeoutMS";
  22009.         if(this.getSemaphoreHoldTimeoutMS==null){
  22010.             try{  
  22011.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22013.                 if (value != null){
  22014.                     value = value.trim();
  22015.                     this.getSemaphoreHoldTimeoutMS = Long.parseLong(value);
  22016.                 }else{
  22017.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+Semaphore.DEFAULT_LOCK_HOLD_TIMEOUT_MS);
  22018.                     this.getSemaphoreHoldTimeoutMS = Semaphore.DEFAULT_LOCK_HOLD_TIMEOUT_MS;
  22019.                 }

  22021.             }catch(java.lang.Exception e) {
  22022.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+Semaphore.DEFAULT_LOCK_HOLD_TIMEOUT_MS+", errore:"+e.getMessage(),e);
  22023.                 this.getSemaphoreHoldTimeoutMS = Semaphore.DEFAULT_LOCK_HOLD_TIMEOUT_MS;
  22024.             }
  22025.         }

  22027.         return this.getSemaphoreHoldTimeoutMS;
  22028.     }
  22029.     
  22030.     private Boolean isSemaphoreDebug = null;
  22031.     public boolean isSemaphoreDebug(){

  22033.         String pName = "org.openspcoop2.pdd.semaphore.debug";
  22034.         if(this.isSemaphoreDebug==null){
  22035.             try{  
  22036.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22038.                 if (value != null){
  22039.                     value = value.trim();
  22040.                     this.isSemaphoreDebug = Boolean.parseBoolean(value);
  22041.                 }else{
  22042.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  22043.                     this.isSemaphoreDebug = false;
  22044.                 }

  22046.             }catch(java.lang.Exception e) {
  22047.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  22048.                 this.isSemaphoreDebug = false;
  22049.             }
  22050.         }

  22052.         return this.isSemaphoreDebug;
  22053.     }
  22054.     
  22055.     private SemaphoreType getSemaphoreType = null;
  22056.     public SemaphoreType getSemaphoreType(){

  22058.         String pName = "org.openspcoop2.pdd.semaphore.type";
  22059.         if(this.getSemaphoreType==null){
  22060.             
  22061.             SemaphoreType defaultV = SemaphoreType.Semaphore;
  22062.             
  22063.             try{  
  22064.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22066.                 if (value != null){
  22067.                     value = value.trim();
  22068.                     this.getSemaphoreType = SemaphoreType.valueOf(value);
  22069.                 }else{
  22070.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultV.toString()));
  22071.                     this.getSemaphoreType = defaultV;
  22072.                 }

  22074.             }catch(java.lang.Exception e) {
  22075.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,defaultV.toString()),e);
  22076.                 this.getSemaphoreType = defaultV;
  22077.             }
  22078.         }

  22080.         return this.getSemaphoreType;
  22081.     }
  22082.     
  22083.     private Boolean isSemaphoreFair = null;
  22084.     public boolean isSemaphoreFair(){

  22086.         String pName = "org.openspcoop2.pdd.semaphore.fair";
  22087.         if(this.isSemaphoreFair==null){
  22088.             try{  
  22089.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22091.                 if (value != null){
  22092.                     value = value.trim();
  22093.                     this.isSemaphoreFair = Boolean.parseBoolean(value);
  22094.                 }else{
  22095.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  22096.                     this.isSemaphoreFair = true;
  22097.                 }

  22099.             }catch(java.lang.Exception e) {
  22100.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  22101.                 this.isSemaphoreFair = true;
  22102.             }
  22103.         }

  22105.         return this.isSemaphoreFair;
  22106.     }
  22107.     
  22108.     
  22109.         
  22110.     /* ------------- JMINIX Console  ---------------------*/
  22111.     
  22112.     private Integer portJminixConsole = null;
  22113.     private Boolean portJminixConsoleReaded = null;
  22114.     public Integer getPortJminixConsole() { 
  22115.         if(this.portJminixConsoleReaded==null){
  22116.             try{ 
  22117.                 String p = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.jminix.port");
  22118.                 if(p!=null){
  22119.                     p = p.trim();
  22120.                     this.portJminixConsole = Integer.parseInt(p);
  22121.                 }
  22122.                 this.portJminixConsoleReaded = true;
  22123.             } catch(java.lang.Exception e) {
  22124.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.jminix.port': "+e.getMessage(),e);
  22125.                 this.portJminixConsoleReaded = true;
  22126.             }    
  22127.         }

  22129.         return this.portJminixConsole;
  22130.     }
  22131.     
  22132.     
  22133.     
  22134.     

  22136.     /* ------------- Custom Function ---------------------*/
  22137.     
  22138.     private Boolean isEnabledFunctionPD = null;
  22139.     public boolean isEnabledFunctionPD() {  
  22140.         if(this.isEnabledFunctionPD==null){
  22141.             try{ 
  22142.                 String name = null;
  22143.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.function.pd.enabled");
  22144.                 if(name==null){
  22145.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.function.pd.enabled' non impostata, viene utilizzato il default=false");
  22146.                     name="true";
  22147.                 }
  22148.                 name = name.trim();
  22149.                 this.isEnabledFunctionPD = Boolean.parseBoolean(name);
  22150.             } catch(java.lang.Exception e) {
  22151.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.function.pd.enabled': "+e.getMessage(),e);
  22152.                 this.isEnabledFunctionPD = false;
  22153.             }    
  22154.         }

  22156.         return this.isEnabledFunctionPD;
  22157.     }
  22158.     
  22159.     private Boolean isEnabledFunctionPDtoSOAP = null;
  22160.     public boolean isEnabledFunctionPDtoSOAP() {    
  22161.         if(this.isEnabledFunctionPDtoSOAP==null){
  22162.             try{ 
  22163.                 String name = null;
  22164.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.function.pdToSoap.enabled");
  22165.                 if(name==null){
  22166.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.function.pdToSoap.enabled' non impostata, viene utilizzato il default=false");
  22167.                     name="true";
  22168.                 }
  22169.                 name = name.trim();
  22170.                 this.isEnabledFunctionPDtoSOAP = Boolean.parseBoolean(name);
  22171.             } catch(java.lang.Exception e) {
  22172.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.function.pdToSoap.enabled': "+e.getMessage(),e);
  22173.                 this.isEnabledFunctionPDtoSOAP = false;
  22174.             }    
  22175.         }

  22177.         return this.isEnabledFunctionPDtoSOAP;
  22178.     }
  22179.     
  22180.     private Boolean isEnabledFunctionPA = null;
  22181.     public boolean isEnabledFunctionPA() {  
  22182.         if(this.isEnabledFunctionPA==null){
  22183.             try{ 
  22184.                 String name = null;
  22185.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.function.pa.enabled");
  22186.                 if(name==null){
  22187.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.function.pa.enabled' non impostata, viene utilizzato il default=false");
  22188.                     name="true";
  22189.                 }
  22190.                 name = name.trim();
  22191.                 this.isEnabledFunctionPA = Boolean.parseBoolean(name);
  22192.             } catch(java.lang.Exception e) {
  22193.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.function.pa.enabled': "+e.getMessage(),e);
  22194.                 this.isEnabledFunctionPA = false;
  22195.             }    
  22196.         }

  22198.         return this.isEnabledFunctionPA;
  22199.     }
  22200.     
  22201.     
  22202.     private FunctionContextsCustom customContexts = null;
  22203.     public FunctionContextsCustom getCustomContexts() throws UtilsException {   
  22204.         if(this.customContexts==null){
  22205.             try{ 
  22206.                 Properties p = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.function.custom.");
  22207.                 if(p!=null && p.size()>0) {
  22208.                     Enumeration<Object> en = p.keys();
  22209.                     while (en.hasMoreElements()) {
  22210.                         Object object = (Object) en.nextElement();
  22211.                         if(object instanceof String) {
  22212.                             String s = (String) object;
  22213.                             if(s.endsWith(".context")) {
  22214.                                 String alias = s.substring(0,s.indexOf(".context"));
  22215.                                 
  22216.                                 String context = p.getProperty(s);
  22217.                                 if(context==null || "".equals(context.trim())) {
  22218.                                     throw new CoreException("Context not defined for alias '"+alias+"'");
  22219.                                 }
  22220.                                 context = context.trim();
  22221.                                 
  22222.                                 String service = p.getProperty(alias+".service");
  22223.                                 boolean serviceFound = false;
  22224.                                 FunctionContextCustom customWithoutSubContext = null;
  22225.                                 IDService idServiceCustomWithoutSubContext = null;
  22226.                                 if(service!=null && !"".equals(service.trim())) {
  22227.                                     idServiceCustomWithoutSubContext = IDService.toEnumConstant(service);
  22228.                                     if(idServiceCustomWithoutSubContext==null) {
  22229.                                         throw new CoreException("Value '"+service+"' unsupported for service in alias '"+alias+"'");
  22230.                                     }
  22231.                                     customWithoutSubContext = new FunctionContextCustom(context, idServiceCustomWithoutSubContext);
  22232.                                     serviceFound = true;
  22233.                                     // lo registro dopo gli eventuali subcontext
  22234.                                 }

  22236.                                 Properties pSubContext = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.function.custom."+alias+".subcontext.");
  22237.                                 if(pSubContext==null || pSubContext.size()<=0) {
  22238.                                     if(!serviceFound) {
  22239.                                         throw new CoreException("Service and SubContext undefined for alias '"+alias+"'");
  22240.                                     }
  22241.                                 }
  22242.                                 else {
  22243.                                     HashMap<String,IDService> subcontextMap = new HashMap<String,IDService>();
  22244.                                     Enumeration<Object> enSubContext = pSubContext.keys();
  22245.                                     while (enSubContext.hasMoreElements()) {
  22246.                                         Object objectSubContext = (Object) enSubContext.nextElement();
  22247.                                         if(objectSubContext instanceof String) {
  22248.                                             String subContextKey = (String) objectSubContext;
  22249.                                             if(subContextKey.endsWith(".url")) {
  22250.                                                 String aliasSubContext = subContextKey.substring(0,subContextKey.indexOf(".url"));
  22251.                                                 
  22252.                                                 String subContext = pSubContext.getProperty(subContextKey);
  22253.                                                 if(subContext==null || "".equals(subContext.trim())) {
  22254.                                                     throw new CoreException("Url not defined for alias '"+alias+"', subcontext '"+aliasSubContext+"'");
  22255.                                                 }
  22256.                                                 subContext = subContext.trim();
  22257.                                                 
  22258.                                                 String serviceSubContext = pSubContext.getProperty(aliasSubContext+".service");
  22259.                                                 if(serviceSubContext!=null && !"".equals(serviceSubContext.trim())) {
  22260.                                                     IDService idService = IDService.toEnumConstant(serviceSubContext);
  22261.                                                     if(idService==null) {
  22262.                                                         throw new CoreException("Value '"+serviceSubContext+"' unsupported for service in alias '"+alias+"', subcontext '"+aliasSubContext+"'");
  22263.                                                     }
  22264.                                                     subcontextMap.put(subContext, idService);   
  22265.                                                 }
  22266.                                                 else {
  22267.                                                     throw new CoreException("Service not defined for alias '"+alias+"', subcontext '"+aliasSubContext+"'");
  22268.                                                 }
  22269.                                             }
  22270.                                         }
  22271.                                     }
  22272.                                     if(subcontextMap.size()<=0) {
  22273.                                         if(!serviceFound) {
  22274.                                             throw new CoreException("SubContext undefined (wrong configuration) for alias '"+alias+"'");
  22275.                                         }
  22276.                                     }
  22277.                                     else {
  22278.                                         FunctionContextCustom custom = new FunctionContextCustom(context, subcontextMap);
  22279.                                         if(this.customContexts==null) {
  22280.                                             this.customContexts = new FunctionContextsCustom();
  22281.                                         }
  22282.                                         this.customContexts.getContexts().add(custom);
  22283.                                         Iterator<String> itS = subcontextMap.keySet().iterator();
  22284.                                         while (itS.hasNext()) {
  22285.                                             String subContext = (String) itS.next();
  22286.                                             this.logInfo("Registrato context '"+context+"', subcontext '"+subContext+"',  per service '"+subcontextMap.get(subContext)+"'");        
  22287.                                         }
  22288.                                     }
  22289.                                 }
  22290.                                 
  22291.                                 if(customWithoutSubContext!=null) {
  22292.                                     if(this.customContexts==null) {
  22293.                                         this.customContexts = new FunctionContextsCustom();
  22294.                                     }
  22295.                                     this.customContexts.getContexts().add(customWithoutSubContext);
  22296.                                     this.logInfo("Registrato context '"+context+"' per service '"+idServiceCustomWithoutSubContext+"'");
  22297.                                 }
  22298.                             }
  22299.                         }
  22300.                     }
  22301.                 }
  22302.                 
  22303.             } catch(java.lang.Exception e) {
  22304.                 this.logError("Riscontrato errore durante la lettura dei custom contexts: "+e.getMessage(),e);
  22305.                 throw new UtilsException("Riscontrato errore durante la lettura dei custom contexts: "+e.getMessage(),e);
  22306.             }    
  22307.         }

  22309.         return this.customContexts;
  22310.     }
  22311.     
  22312.     
  22313.     
  22314.     
  22315.     /* ------------- Custom Container ---------------------*/
  22316.     
  22317.     private Boolean realContainerCustomRead = null;
  22318.     private String realContainerCustom = null;
  22319.     public String getRealContainerCustom() {    
  22320.         if(this.realContainerCustomRead==null){
  22321.             try{ 
  22322.                 String v = null;
  22323.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.realmContainer.custom");
  22324.                 if(v!=null){
  22325.                     v = v.trim();
  22326.                     this.realContainerCustom = v;
  22327.                 } 
  22328.             } catch(java.lang.Exception e) {
  22329.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.realmContainer.custom' non impostata correttamente,  errore:"+e.getMessage(),e);
  22330.             } 
  22331.         }
  22332.         this.realContainerCustomRead = true;
  22333.         return this.realContainerCustom;
  22334.     }
  22335.     
  22336.     
  22337.     /* ------------- govway_configurazioneSistema ---------------------*/
  22338.     
  22339.     private Boolean isConfigurazioneSistema_javaProperties_showPassword = null;
  22340.     public boolean isConfigurazioneSistema_javaProperties_showPassword(){

  22342.         String pName = "org.openspcoop2.pdd.configurazioneSistema.javaProperties.showPassword";
  22343.         if(this.isConfigurazioneSistema_javaProperties_showPassword==null){
  22344.             try{  
  22345.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22347.                 if (value != null){
  22348.                     value = value.trim();
  22349.                     this.isConfigurazioneSistema_javaProperties_showPassword = Boolean.parseBoolean(value);
  22350.                 }else{
  22351.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  22352.                     this.isConfigurazioneSistema_javaProperties_showPassword = false;
  22353.                 }

  22355.             }catch(java.lang.Exception e) {
  22356.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  22357.                 this.isConfigurazioneSistema_javaProperties_showPassword = false;
  22358.             }
  22359.         }

  22361.         return this.isConfigurazioneSistema_javaProperties_showPassword;
  22362.     }
  22363.     
  22364.     
  22365.     /* ------------- govway startup ---------------------*/
  22366.     
  22367.     private Integer getStartupRichiesteIngressoTimeout = null;
  22368.     public int getStartupRichiesteIngressoTimeoutSecondi() {    
  22369.         if(this.getStartupRichiesteIngressoTimeout==null){
  22370.             String pName = "org.openspcoop2.pdd.startup.richiesteIngresso.timeout";
  22371.             try{ 
  22372.                 String name = null;
  22373.                 name = this.reader.getValueConvertEnvProperties(pName);

  22375.                 if(name!=null){
  22376.                     name = name.trim();
  22377.                     this.getStartupRichiesteIngressoTimeout = java.lang.Integer.parseInt(name);
  22378.                 }else{
  22379.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS));
  22380.                     this.getStartupRichiesteIngressoTimeout = CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS;
  22381.                 }
  22382.             }catch(java.lang.Exception e) {
  22383.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS),e);
  22384.                 this.getStartupRichiesteIngressoTimeout = CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS;
  22385.             }
  22386.         }

  22388.         return this.getStartupRichiesteIngressoTimeout;
  22389.     }
  22390.     private Integer getStartupRichiesteIngressoCheck = null;
  22391.     public int getStartupRichiesteIngressoCheckMs() {   
  22392.         if(this.getStartupRichiesteIngressoCheck==null){
  22393.             String pName = "org.openspcoop2.pdd.startup.richiesteIngresso.check";
  22394.             try{ 
  22395.                 String name = null;
  22396.                 name = this.reader.getValueConvertEnvProperties(pName);

  22398.                 if(name!=null){
  22399.                     name = name.trim();
  22400.                     this.getStartupRichiesteIngressoCheck = java.lang.Integer.parseInt(name);
  22401.                 }else{
  22402.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS));
  22403.                     this.getStartupRichiesteIngressoCheck = CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS;
  22404.                 }
  22405.             }catch(java.lang.Exception e) {
  22406.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS),e);
  22407.                 this.getStartupRichiesteIngressoCheck = CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS;
  22408.             }
  22409.         }

  22411.         return this.getStartupRichiesteIngressoCheck;
  22412.     }
  22413.     
  22414.     private Integer getStartupLockMaxLife = null;
  22415.     public int getStartupLockMaxLife() {    
  22416.         if(this.getStartupLockMaxLife==null){
  22417.             try{ 
  22418.                 String name = null;
  22419.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.startup.lock.maxLife");

  22421.                 if(name!=null){
  22422.                     name = name.trim();
  22423.                     this.getStartupLockMaxLife = java.lang.Integer.parseInt(name);
  22424.                 }else{
  22425.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
  22426.                     this.getStartupLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  22427.                 }
  22428.             }catch(java.lang.Exception e) {
  22429.                 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);
  22430.                 this.getStartupLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  22431.             }
  22432.             if(this.getStartupLockMaxLife!=null && this.getStartupLockMaxLife>0) {
  22433.                 // trasformo in millisecondi l'informazione fornita in secondi
  22434.                 this.getStartupLockMaxLife = this.getStartupLockMaxLife *1000;
  22435.             }
  22436.         }

  22438.         if(this.getStartupLockMaxLife!=null) {
  22439.             return this.getStartupLockMaxLife.intValue();
  22440.         }
  22441.         return -1;
  22442.     }
  22443.     
  22444.     private Integer getStartupLockIdleTime = null;
  22445.     public int getStartupLockIdleTime() {   
  22446.         if(this.getStartupLockIdleTime==null){
  22447.             try{ 
  22448.                 String name = null;
  22449.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.startup.lock.idleTime");

  22451.                 if(name!=null){
  22452.                     name = name.trim();
  22453.                     this.getStartupLockIdleTime = java.lang.Integer.parseInt(name);
  22454.                 }else{
  22455.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  22456.                     this.getStartupLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  22457.                 }
  22458.             }catch(java.lang.Exception e) {
  22459.                 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);
  22460.                 this.getStartupLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  22461.             }
  22462.             if(this.getStartupLockIdleTime!=null && this.getStartupLockIdleTime>0) {
  22463.                 // trasformo in millisecondi l'informazione fornita in secondi
  22464.                 this.getStartupLockIdleTime = this.getStartupLockIdleTime *1000;
  22465.             }
  22466.         }

  22468.         if(this.getStartupLockIdleTime!=null) {
  22469.             return this.getStartupLockIdleTime.intValue();
  22470.         }
  22471.         return -1;
  22472.     }
  22473.     
  22474.     private Long getStartupGetLockAttesaAttiva = null;
  22475.     public long getStartupGetLockAttesaAttiva() {   
  22476.         if(this.getStartupGetLockAttesaAttiva==null){
  22477.             String pName = "org.openspcoop2.pdd.startup.lock.attesaAttiva";
  22478.             try{ 
  22479.                 String name = null;
  22480.                 name = this.reader.getValueConvertEnvProperties(pName);

  22482.                 if(name!=null){
  22483.                     name = name.trim();
  22484.                     long time = java.lang.Long.parseLong(name);
  22485.                     this.getStartupGetLockAttesaAttiva = time*1000;
  22486.                 }else{
  22487.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
  22488.                     this.getStartupGetLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
  22489.                 }

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

  22497.         return this.getStartupGetLockAttesaAttiva;
  22498.     }

  22500.     private Integer getStartupGetLockCheckInterval = null;
  22501.     public int getStartupGetLockCheckInterval() {   
  22502.         if(this.getStartupGetLockCheckInterval==null){
  22503.             String pName = "org.openspcoop2.pdd.startup.lock.check";
  22504.             try{ 
  22505.                 String name = null;
  22506.                 name = this.reader.getValueConvertEnvProperties(pName);

  22508.                 if(name!=null){
  22509.                     name = name.trim();
  22510.                     int time = java.lang.Integer.parseInt(name);
  22511.                     this.getStartupGetLockCheckInterval = time;
  22512.                 }else{
  22513.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  22514.                     this.getStartupGetLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  22515.                 }
  22516.             }catch(java.lang.Exception e) {
  22517.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  22518.                 this.getStartupGetLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  22519.             }  
  22520.         }

  22522.         return this.getStartupGetLockCheckInterval;
  22523.     }
  22524.     
  22525.     
  22526.     /* ------------- ExtendedInfo ---------------------*/
  22527.     
  22528.     private String extendedInfoConfigurazione = null;       
  22529.     private Boolean extendedInfoConfigurazioneRead = null;      
  22530.     public String getExtendedInfoConfigurazione() throws CoreException{
  22531.         if(this.extendedInfoConfigurazioneRead==null){
  22532.             String pName = "org.openspcoop2.pdd.config.extendedInfo.configurazione";
  22533.             try{ 
  22534.                 this.extendedInfoConfigurazione = this.reader.getValue(pName);
  22535.                 if(this.extendedInfoConfigurazione!=null){
  22536.                     this.extendedInfoConfigurazione = this.extendedInfoConfigurazione.trim();
  22537.                     this.extendedInfoConfigurazioneRead = true;
  22538.                 }
  22539.             } catch(java.lang.Exception e) {
  22540.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  22541.                 throw new CoreException("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  22542.             } 
  22543.         }
  22544.         return this.extendedInfoConfigurazione;
  22545.     }
  22546.     
  22547.     private String extendedInfoPortaDelegata = null;        
  22548.     private Boolean extendedInfoPortaDelegataRead = null;       
  22549.     public String getExtendedInfoPortaDelegata() throws CoreException{
  22550.         if(this.extendedInfoPortaDelegataRead==null){
  22551.             String pName = "org.openspcoop2.pdd.config.extendedInfo.portaDelegata";
  22552.             try{ 
  22553.                 this.extendedInfoPortaDelegata = this.reader.getValue(pName);
  22554.                 if(this.extendedInfoPortaDelegata!=null){
  22555.                     this.extendedInfoPortaDelegata = this.extendedInfoPortaDelegata.trim();
  22556.                     this.extendedInfoPortaDelegataRead = true;
  22557.                 }
  22558.             } catch(java.lang.Exception e) {
  22559.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  22560.                 throw new CoreException("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  22561.             } 
  22562.         }
  22563.         return this.extendedInfoPortaDelegata;
  22564.     }
  22565.     
  22566.     private String extendedInfoPortaApplicativa = null;     
  22567.     private Boolean extendedInfoPortaApplicativaRead = null;        
  22568.     public String getExtendedInfoPortaApplicativa() throws CoreException{
  22569.         if(this.extendedInfoPortaApplicativaRead==null){
  22570.             String pName = "org.openspcoop2.pdd.config.extendedInfo.portaApplicativa";
  22571.             try{ 
  22572.                 this.extendedInfoPortaApplicativa = this.reader.getValue(pName);
  22573.                 if(this.extendedInfoPortaApplicativa!=null){
  22574.                     this.extendedInfoPortaApplicativa = this.extendedInfoPortaApplicativa.trim();
  22575.                     this.extendedInfoPortaApplicativaRead = true;
  22576.                 }
  22577.             } catch(java.lang.Exception e) {
  22578.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  22579.                 throw new CoreException("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  22580.             } 
  22581.         }
  22582.         return this.extendedInfoPortaApplicativa;
  22583.     }
  22584.     
  22585.     
  22586.     
  22587.     
  22588.     
  22589.     
  22590.     
  22591.     /* ------------- Validazione Contenuti Applicativi ---------------------*/
  22592.     
  22593.     private Boolean isValidazioneContenutiApplicativiDebug = null;
  22594.     public boolean isValidazioneContenutiApplicativiDebug(){

  22596.         if(this.isValidazioneContenutiApplicativiDebug==null){
  22597.             try{  
  22598.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.debug"); 

  22600.                 if (value != null){
  22601.                     value = value.trim();
  22602.                     this.isValidazioneContenutiApplicativiDebug = Boolean.parseBoolean(value);
  22603.                 }else{
  22604.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.debug' non impostata, viene utilizzato il default=false");
  22605.                     this.isValidazioneContenutiApplicativiDebug = false;
  22606.                 }

  22608.             }catch(java.lang.Exception e) {
  22609.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.debug' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  22610.                 this.isValidazioneContenutiApplicativiDebug = false;
  22611.             }
  22612.         }

  22614.         return this.isValidazioneContenutiApplicativiDebug;
  22615.     }
  22616.     
  22617.     private Boolean isValidazioneContenutiApplicativiBufferContentRead = null;
  22618.     public boolean isValidazioneContenutiApplicativiBufferContentRead(){

  22620.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.buffer";
  22621.         if(this.isValidazioneContenutiApplicativiBufferContentRead==null){
  22622.             try{  
  22623.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22625.                 if (value != null){
  22626.                     value = value.trim();
  22627.                     this.isValidazioneContenutiApplicativiBufferContentRead = Boolean.parseBoolean(value);
  22628.                 }else{
  22629.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  22630.                     this.isValidazioneContenutiApplicativiBufferContentRead = true;
  22631.                 }

  22633.             }catch(java.lang.Exception e) {
  22634.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  22635.                 this.isValidazioneContenutiApplicativiBufferContentRead = true;
  22636.             }
  22637.         }

  22639.         return this.isValidazioneContenutiApplicativiBufferContentRead;
  22640.     }
  22641.     
  22642.     private Boolean isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection = null;
  22643.     public boolean isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection(){

  22645.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.xsd.buildSchemaSuccess.serializeXSDCollection";
  22646.         if(this.isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection==null){
  22647.             try{  
  22648.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22650.                 if (value != null){
  22651.                     value = value.trim();
  22652.                     this.isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection = Boolean.parseBoolean(value);
  22653.                 }else{
  22654.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  22655.                     this.isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection = false;
  22656.                 }

  22658.             }catch(java.lang.Exception e) {
  22659.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  22660.                 this.isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection = false;
  22661.             }
  22662.         }

  22664.         return this.isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection;
  22665.     }
  22666.     
  22667.     private Boolean isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection = null;
  22668.     public boolean isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection(){

  22670.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.xsd.buildSchemaError.serializeXSDCollection";
  22671.         if(this.isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection==null){
  22672.             try{  
  22673.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22675.                 if (value != null){
  22676.                     value = value.trim();
  22677.                     this.isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection = Boolean.parseBoolean(value);
  22678.                 }else{
  22679.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  22680.                     this.isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection = true;
  22681.                 }

  22683.             }catch(java.lang.Exception e) {
  22684.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  22685.                 this.isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection = true;
  22686.             }
  22687.         }

  22689.         return this.isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection;
  22690.     }
  22691.     
  22692.     private File getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir = null;
  22693.     private Boolean getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDirRead = null;
  22694.     public File getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir() throws CoreException{

  22696.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.xsd.buildSchema.serializeXSDCollection.dir";
  22697.         if(this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDirRead==null){
  22698.             try{  
  22699.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22701.                 if (value != null){
  22702.                     value = value.trim();
  22703.                     value = LoggerWrapperFactory.applyClusterIdStrategy(value, "xsdCollection");
  22704.                     this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir = new File(value);
  22705.                     checkValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir();
  22706.                 }

  22708.             }catch(java.lang.Exception e) {
  22709.                 this.logError("Riscontrato errore per la directory che deve collezionare gli xsd schema ("+pName+"): "+e.getMessage(),e);
  22710.                 throw new CoreException(e.getMessage(),e);
  22711.             }
  22712.             
  22713.             this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDirRead = true;
  22714.         }

  22716.         return this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir;
  22717.     }
  22718.     private void checkValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir() throws CoreException, UtilsException {   
  22719.         if(this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir.exists()) {
  22720.             if(!this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir.isDirectory()) {
  22721.                 throw newCoreExceptionNotDir(this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir,true);
  22722.             }
  22723.             if(!this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir.canRead()) {
  22724.                 throw newCoreExceptionCannotRead(this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir, true);
  22725.             }
  22726.             if(!this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir.canWrite()) {
  22727.                 throw newCoreExceptionCannotWrite(this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir, true);
  22728.             }
  22729.         }
  22730.         else {
  22731.             FileSystemMkdirConfig configMkdir = new FileSystemMkdirConfig();
  22732.             configMkdir.setCheckCanWrite(true);
  22733.             configMkdir.setCheckCanRead(true);
  22734.             configMkdir.setCheckCanExecute(false);
  22735.             configMkdir.setCrateParentIfNotExists(true);
  22736.             FileSystemUtilities.mkdir(this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir, configMkdir);
  22737.         }
  22738.     }
  22739.     
  22740.     
  22741.     
  22742.     
  22743.         
  22744.     private Boolean isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione = null;
  22745.     public boolean isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione(){

  22747.         if(this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione==null){
  22748.             try{  
  22749.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.gestione"); 

  22751.                 if (value != null){
  22752.                     value = value.trim();
  22753.                     this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione = Boolean.parseBoolean(value);
  22754.                 }else{
  22755.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.gestione' non impostata, viene utilizzato il default=true");
  22756.                     this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione = true;
  22757.                 }

  22759.             }catch(java.lang.Exception e) {
  22760.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.gestione' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  22761.                 this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione = true;
  22762.             }
  22763.         }

  22765.         return this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione;
  22766.     }
  22767.     
  22768.     private Boolean isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione = null;
  22769.     public boolean isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione(){

  22771.         if(this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione==null){
  22772.             try{  
  22773.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.ripulituraDopoValidazione"); 

  22775.                 if (value != null){
  22776.                     value = value.trim();
  22777.                     this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione = Boolean.parseBoolean(value);
  22778.                 }else{
  22779.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.ripulituraDopoValidazione' non impostata, viene utilizzato il default=true");
  22780.                     this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione = true;
  22781.                 }

  22783.             }catch(java.lang.Exception e) {
  22784.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.ripulituraDopoValidazione' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  22785.                 this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione = true;
  22786.             }
  22787.         }

  22789.         return this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione;
  22790.     }
  22791.     
  22792.     private Boolean isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists = null;
  22793.     public boolean isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists(){

  22795.         if(this.isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists==null){
  22796.             String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.rpc.addNamespaceXSITypeIfNotExists";
  22797.             try{  
  22798.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22800.                 if (value != null){
  22801.                     value = value.trim();
  22802.                     this.isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists = Boolean.parseBoolean(value);
  22803.                 }else{
  22804.                     this.logWarn(this.getMessaggioProprietaNonImpostata(pName, true));
  22805.                     this.isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists = true;
  22806.                 }

  22808.             }catch(java.lang.Exception e) {
  22809.                 this.logWarn(this.getMessaggioProprietaNonImpostata(pName, e, true),e);
  22810.                 this.isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists = true;
  22811.             }
  22812.         }

  22814.         return this.isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists;
  22815.     }
  22816.     
  22817.     private Boolean isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists = null;
  22818.     public boolean isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists(){

  22820.         if(this.isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists==null){
  22821.             String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.document.addNamespaceXSITypeIfNotExists";
  22822.             try{  
  22823.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22825.                 if (value != null){
  22826.                     value = value.trim();
  22827.                     this.isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists = Boolean.parseBoolean(value);
  22828.                 }else{
  22829.                     this.logWarn(this.getMessaggioProprietaNonImpostata(pName, false));
  22830.                     this.isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists = true;
  22831.                 }

  22833.             }catch(java.lang.Exception e) {
  22834.                 this.logWarn(this.getMessaggioProprietaNonImpostata(pName, e, false),e);
  22835.                 this.isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists = true;
  22836.             }
  22837.         }

  22839.         return this.isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists;
  22840.     }
  22841.     
  22842.     private Boolean isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists = null;
  22843.     public boolean isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists(){

  22845.         if(this.isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists==null){
  22846.             String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.xsd.addNamespaceXSITypeIfNotExists";
  22847.             try{  
  22848.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22850.                 if (value != null){
  22851.                     value = value.trim();
  22852.                     this.isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists = Boolean.parseBoolean(value);
  22853.                 }else{
  22854.                     this.logWarn(this.getMessaggioProprietaNonImpostata(pName, false));
  22855.                     this.isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists = true;
  22856.                 }

  22858.             }catch(java.lang.Exception e) {
  22859.                 this.logWarn(this.getMessaggioProprietaNonImpostata(pName, e, false),e);
  22860.                 this.isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists = true;
  22861.             }
  22862.         }

  22864.         return this.isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists;
  22865.     }
  22866.     
  22867.     private Boolean isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified = null;
  22868.     public boolean isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified(){

  22870.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.rpc.rootElement.unqualified.accept";
  22871.         if(this.isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified==null){
  22872.             try{  
  22873.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22875.                 if (value != null){
  22876.                     value = value.trim();
  22877.                     this.isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified = Boolean.parseBoolean(value);
  22878.                 }else{
  22879.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  22880.                     this.isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified = true;
  22881.                 }

  22883.             }catch(java.lang.Exception e) {
  22884.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  22885.                 this.isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified = true;
  22886.             }
  22887.         }

  22889.         return this.isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified;
  22890.     }
  22891.     
  22892.     private Boolean isValidazioneContenutiApplicativiCheckSoapAction = null;
  22893.     public boolean isValidazioneContenutiApplicativiCheckSoapAction(){

  22895.         if(this.isValidazioneContenutiApplicativiCheckSoapAction==null){
  22896.             try{  
  22897.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.soapAction.check"); 

  22899.                 if (value != null){
  22900.                     value = value.trim();
  22901.                     this.isValidazioneContenutiApplicativiCheckSoapAction = Boolean.parseBoolean(value);
  22902.                 }else{
  22903.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.soapAction.check' non impostata, viene utilizzato il default=true");
  22904.                     this.isValidazioneContenutiApplicativiCheckSoapAction = true;
  22905.                 }

  22907.             }catch(java.lang.Exception e) {
  22908.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.soapAction.check' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  22909.                 this.isValidazioneContenutiApplicativiCheckSoapAction = true;
  22910.             }
  22911.         }

  22913.         return this.isValidazioneContenutiApplicativiCheckSoapAction;
  22914.     }
  22915.     
  22916.     private ADDITIONAL getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties = null;
  22917.     public ADDITIONAL getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties(){

  22919.         if(this.getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties==null){
  22920.             try{  
  22921.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.json.additionalProperties"); 

  22923.                 if (value != null){
  22924.                     value = value.trim();
  22925.                     this.getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties = ADDITIONAL.valueOf(value);
  22926.                 }else{
  22927.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.json.additionalProperties' non impostata, viene utilizzato il default");
  22928.                     this.getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties = ADDITIONAL.DEFAULT;
  22929.                 }

  22931.             }catch(java.lang.Exception e) {
  22932.                 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);
  22933.                 this.getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties = ADDITIONAL.DEFAULT;
  22934.             }
  22935.         }

  22937.         return this.getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties;
  22938.     }
  22939.     
  22940.     
  22941.     private ApiName getValidazioneContenutiApplicativiOpenApiJsonValidator = null;
  22942.     public ApiName getValidazioneContenutiApplicativiOpenApiJsonValidator(){

  22944.         if(this.getValidazioneContenutiApplicativiOpenApiJsonValidator==null){
  22945.             try{  
  22946.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.json.validator"); 

  22948.                 if (value != null){
  22949.                     value = value.trim();
  22950.                     this.getValidazioneContenutiApplicativiOpenApiJsonValidator = ApiName.valueOf(value);
  22951.                 }else{
  22952.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.json.validator' non impostata, viene utilizzato il default "+ApiName.NETWORK_NT);
  22953.                     this.getValidazioneContenutiApplicativiOpenApiJsonValidator = ApiName.NETWORK_NT;
  22954.                 }

  22956.             }catch(java.lang.Exception e) {
  22957.                 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);
  22958.                 this.getValidazioneContenutiApplicativiOpenApiJsonValidator = ApiName.NETWORK_NT;
  22959.             }
  22960.         }

  22962.         return this.getValidazioneContenutiApplicativiOpenApiJsonValidator;
  22963.     }
  22964.     
  22965.     private OpenAPILibrary getValidazioneContenutiApplicativiOpenApiLibrary = null;
  22966.     public OpenAPILibrary getValidazioneContenutiApplicativiOpenApiLibrary(){

  22968.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.library";
  22969.         OpenAPILibrary defaultValue = OpenAPILibrary.openapi4j;
  22970.         
  22971.         if(this.getValidazioneContenutiApplicativiOpenApiLibrary==null){
  22972.             try{  
  22973.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22975.                 if (value != null){
  22976.                     value = value.trim();
  22977.                     this.getValidazioneContenutiApplicativiOpenApiLibrary = OpenAPILibrary.valueOf(value);
  22978.                 }else{
  22979.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue.toString()));
  22980.                     this.getValidazioneContenutiApplicativiOpenApiLibrary = defaultValue;
  22981.                 }

  22983.             }catch(java.lang.Exception e) {
  22984.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, defaultValue.toString()),e);
  22985.                 this.getValidazioneContenutiApplicativiOpenApiLibrary = defaultValue;
  22986.             }
  22987.         }

  22989.         return this.getValidazioneContenutiApplicativiOpenApiLibrary;
  22990.     }

  22992.     private Boolean isValidazioneContenutiApplicativiOpenApiMergeAPISpec = null;
  22993.     public boolean isValidazioneContenutiApplicativiOpenApiMergeAPISpec(){

  22995.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.mergeAPISpec";
  22996.         
  22997.         if(this.isValidazioneContenutiApplicativiOpenApiMergeAPISpec==null){
  22998.             try{  
  22999.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23001.                 if (value != null){
  23002.                     value = value.trim();
  23003.                     this.isValidazioneContenutiApplicativiOpenApiMergeAPISpec = Boolean.parseBoolean(value);
  23004.                 }else{
  23005.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23006.                     this.isValidazioneContenutiApplicativiOpenApiMergeAPISpec = false;
  23007.                 }

  23009.             }catch(java.lang.Exception e) {
  23010.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23011.                 this.isValidazioneContenutiApplicativiOpenApiMergeAPISpec = false;
  23012.             }
  23013.         }

  23015.         return this.isValidazioneContenutiApplicativiOpenApiMergeAPISpec;
  23016.     }
  23017.     
  23018.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateAPISpec = null;
  23019.     public boolean isValidazioneContenutiApplicativiOpenApiValidateAPISpec(){

  23021.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateAPISpec";
  23022.         
  23023.         if(this.isValidazioneContenutiApplicativiOpenApiValidateAPISpec==null){
  23024.             try{  
  23025.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23027.                 if (value != null){
  23028.                     value = value.trim();
  23029.                     this.isValidazioneContenutiApplicativiOpenApiValidateAPISpec = Boolean.parseBoolean(value);
  23030.                 }else{
  23031.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23032.                     this.isValidazioneContenutiApplicativiOpenApiValidateAPISpec = true;
  23033.                 }

  23035.             }catch(java.lang.Exception e) {
  23036.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23037.                 this.isValidazioneContenutiApplicativiOpenApiValidateAPISpec = true;
  23038.             }
  23039.         }

  23041.         return this.isValidazioneContenutiApplicativiOpenApiValidateAPISpec;
  23042.     }
  23043.     
  23044.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateRequestPath = null;
  23045.     public boolean isValidazioneContenutiApplicativiOpenApiValidateRequestPath(){

  23047.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestPath";
  23048.         
  23049.         if(this.isValidazioneContenutiApplicativiOpenApiValidateRequestPath==null){
  23050.             try{  
  23051.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23053.                 if (value != null){
  23054.                     value = value.trim();
  23055.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestPath = Boolean.parseBoolean(value);
  23056.                 }else{
  23057.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23058.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestPath = true;
  23059.                 }

  23061.             }catch(java.lang.Exception e) {
  23062.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23063.                 this.isValidazioneContenutiApplicativiOpenApiValidateRequestPath = true;
  23064.             }
  23065.         }

  23067.         return this.isValidazioneContenutiApplicativiOpenApiValidateRequestPath;
  23068.     }
  23069.     
  23070.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateRequestQuery = null;
  23071.     public boolean isValidazioneContenutiApplicativiOpenApiValidateRequestQuery(){

  23073.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestQuery";
  23074.         
  23075.         if(this.isValidazioneContenutiApplicativiOpenApiValidateRequestQuery==null){
  23076.             try{  
  23077.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23079.                 if (value != null){
  23080.                     value = value.trim();
  23081.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestQuery = Boolean.parseBoolean(value);
  23082.                 }else{
  23083.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23084.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestQuery = true;
  23085.                 }

  23087.             }catch(java.lang.Exception e) {
  23088.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23089.                 this.isValidazioneContenutiApplicativiOpenApiValidateRequestQuery = true;
  23090.             }
  23091.         }

  23093.         return this.isValidazioneContenutiApplicativiOpenApiValidateRequestQuery;
  23094.     }
  23095.     
  23096.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam = null;
  23097.     public boolean isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam(){

  23099.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestUnexpectedQueryParam";
  23100.         
  23101.         if(this.isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam==null){
  23102.             try{  
  23103.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23105.                 if (value != null){
  23106.                     value = value.trim();
  23107.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam = Boolean.parseBoolean(value);
  23108.                 }else{
  23109.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23110.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam = false;
  23111.                 }

  23113.             }catch(java.lang.Exception e) {
  23114.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23115.                 this.isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam = false;
  23116.             }
  23117.         }

  23119.         return this.isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam;
  23120.     }
  23121.     
  23122.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders = null;
  23123.     public boolean isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders(){

  23125.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestHeaders";
  23126.         
  23127.         if(this.isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders==null){
  23128.             try{  
  23129.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23131.                 if (value != null){
  23132.                     value = value.trim();
  23133.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders = Boolean.parseBoolean(value);
  23134.                 }else{
  23135.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23136.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders = true;
  23137.                 }

  23139.             }catch(java.lang.Exception e) {
  23140.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23141.                 this.isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders = true;
  23142.             }
  23143.         }

  23145.         return this.isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders;
  23146.     }
  23147.     
  23148.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateRequestCookie = null;
  23149.     public boolean isValidazioneContenutiApplicativiOpenApiValidateRequestCookie(){

  23151.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestCookie";
  23152.         
  23153.         if(this.isValidazioneContenutiApplicativiOpenApiValidateRequestCookie==null){
  23154.             try{  
  23155.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23157.                 if (value != null){
  23158.                     value = value.trim();
  23159.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestCookie = Boolean.parseBoolean(value);
  23160.                 }else{
  23161.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23162.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestCookie = true;
  23163.                 }

  23165.             }catch(java.lang.Exception e) {
  23166.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23167.                 this.isValidazioneContenutiApplicativiOpenApiValidateRequestCookie = true;
  23168.             }
  23169.         }

  23171.         return this.isValidazioneContenutiApplicativiOpenApiValidateRequestCookie;
  23172.     }
  23173.     
  23174.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateRequestBody = null;
  23175.     public boolean isValidazioneContenutiApplicativiOpenApiValidateRequestBody(){

  23177.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestBody";
  23178.         
  23179.         if(this.isValidazioneContenutiApplicativiOpenApiValidateRequestBody==null){
  23180.             try{  
  23181.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23183.                 if (value != null){
  23184.                     value = value.trim();
  23185.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestBody = Boolean.parseBoolean(value);
  23186.                 }else{
  23187.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23188.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestBody = true;
  23189.                 }

  23191.             }catch(java.lang.Exception e) {
  23192.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23193.                 this.isValidazioneContenutiApplicativiOpenApiValidateRequestBody = true;
  23194.             }
  23195.         }

  23197.         return this.isValidazioneContenutiApplicativiOpenApiValidateRequestBody;
  23198.     }
  23199.     
  23200.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders = null;
  23201.     public boolean isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders(){

  23203.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateResponseHeaders";
  23204.         
  23205.         if(this.isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders==null){
  23206.             try{  
  23207.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23209.                 if (value != null){
  23210.                     value = value.trim();
  23211.                     this.isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders = Boolean.parseBoolean(value);
  23212.                 }else{
  23213.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23214.                     this.isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders = true;
  23215.                 }

  23217.             }catch(java.lang.Exception e) {
  23218.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23219.                 this.isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders = true;
  23220.             }
  23221.         }

  23223.         return this.isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders;
  23224.     }
  23225.     
  23226.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateResponseBody = null;
  23227.     public boolean isValidazioneContenutiApplicativiOpenApiValidateResponseBody(){

  23229.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateResponseBody";
  23230.         
  23231.         if(this.isValidazioneContenutiApplicativiOpenApiValidateResponseBody==null){
  23232.             try{  
  23233.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23235.                 if (value != null){
  23236.                     value = value.trim();
  23237.                     this.isValidazioneContenutiApplicativiOpenApiValidateResponseBody = Boolean.parseBoolean(value);
  23238.                 }else{
  23239.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23240.                     this.isValidazioneContenutiApplicativiOpenApiValidateResponseBody = true;
  23241.                 }

  23243.             }catch(java.lang.Exception e) {
  23244.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23245.                 this.isValidazioneContenutiApplicativiOpenApiValidateResponseBody = true;
  23246.             }
  23247.         }

  23249.         return this.isValidazioneContenutiApplicativiOpenApiValidateResponseBody;
  23250.     }
  23251.     
  23252.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson = null;
  23253.     public boolean isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson(){

  23255.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateWildcardSubtypeAsJson";
  23256.         
  23257.         if(this.isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson==null){
  23258.             try{  
  23259.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23261.                 if (value != null){
  23262.                     value = value.trim();
  23263.                     this.isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson = Boolean.parseBoolean(value);
  23264.                 }else{
  23265.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23266.                     this.isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson = true;
  23267.                 }

  23269.             }catch(java.lang.Exception e) {
  23270.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23271.                 this.isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson = true;
  23272.             }
  23273.         }

  23275.         return this.isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson;
  23276.     }
  23277.     
  23278.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization = null;
  23279.     public boolean isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization(){

  23281.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateMultipartOptimization";
  23282.         
  23283.         if(this.isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization==null){
  23284.             try{  
  23285.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23287.                 if (value != null){
  23288.                     value = value.trim();
  23289.                     this.isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization = Boolean.parseBoolean(value);
  23290.                 }else{
  23291.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23292.                     this.isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization = false;
  23293.                 }

  23295.             }catch(java.lang.Exception e) {
  23296.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23297.                 this.isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization = false;
  23298.             }
  23299.         }

  23301.         return this.isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization;
  23302.     }
  23303.     
  23304.     private Boolean isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse = null;
  23305.     public boolean isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse(){

  23307.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.swaggerRequestValidator.injectingAdditionalPropertiesFalse";
  23308.         
  23309.         if(this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse==null){
  23310.             try{  
  23311.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23313.                 if (value != null){
  23314.                     value = value.trim();
  23315.                     this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse = Boolean.parseBoolean(value);
  23316.                 }else{
  23317.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23318.                     this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse = false;
  23319.                 }

  23321.             }catch(java.lang.Exception e) {
  23322.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23323.                 this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse = false;
  23324.             }
  23325.         }

  23327.         return this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse;
  23328.     }
  23329.     
  23330.     private Boolean isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec = null;
  23331.     public boolean isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec(){

  23333.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.swaggerRequestValidator.resolveFullyApiSpec";
  23334.         
  23335.         if(this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec==null){
  23336.             try{  
  23337.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23339.                 if (value != null){
  23340.                     value = value.trim();
  23341.                     this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec = Boolean.parseBoolean(value);
  23342.                 }else{
  23343.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23344.                     this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec = false;
  23345.                 }

  23347.             }catch(java.lang.Exception e) {
  23348.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23349.                 this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec = false;
  23350.             }
  23351.         }

  23353.         return this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec;
  23354.     }
  23355.     
  23356.     private Boolean isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values = null;
  23357.     public boolean isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values(){

  23359.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.openapi4j.validateBase64Values";
  23360.         
  23361.         if(this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values==null){
  23362.             try{  
  23363.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23365.                 if (value != null){
  23366.                     value = value.trim();
  23367.                     this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values = Boolean.parseBoolean(value);
  23368.                 }else{
  23369.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23370.                     this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values = false;
  23371.                 }

  23373.             }catch(java.lang.Exception e) {
  23374.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23375.                 this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values = false;
  23376.             }
  23377.         }

  23379.         return this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values;
  23380.     }
  23381.     
  23382.     private Boolean isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl = null;
  23383.     public boolean isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl(){

  23385.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.openapi4j.validateUriReferenceAsUrl";
  23386.         
  23387.         if(this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl==null){
  23388.             try{  
  23389.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23391.                 if (value != null){
  23392.                     value = value.trim();
  23393.                     this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl = Boolean.parseBoolean(value);
  23394.                 }else{
  23395.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23396.                     this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl = false;
  23397.                 }

  23399.             }catch(java.lang.Exception e) {
  23400.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23401.                 this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl = false;
  23402.             }
  23403.         }

  23405.         return this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl;
  23406.     }
  23407.     
  23408.     private Boolean isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ = null;
  23409.     public boolean isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ(){

  23411.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.dateTimeAllowLowerCaseTZ";
  23412.         
  23413.         if(this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ==null){
  23414.             try{  
  23415.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23417.                 if (value != null){
  23418.                     value = value.trim();
  23419.                     this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ = Boolean.parseBoolean(value);
  23420.                 }else{
  23421.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23422.                     this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ = false;
  23423.                 }

  23425.             }catch(java.lang.Exception e) {
  23426.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23427.                 this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ = false;
  23428.             }
  23429.         }

  23431.         return this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ;
  23432.     }
  23433.     
  23434.     private Boolean isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator = null;
  23435.     public boolean isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator(){

  23437.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.dateTimeAllowSpaceSeparator";
  23438.         
  23439.         if(this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator==null){
  23440.             try{  
  23441.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23443.                 if (value != null){
  23444.                     value = value.trim();
  23445.                     this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator = Boolean.parseBoolean(value);
  23446.                 }else{
  23447.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23448.                     this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator = false;
  23449.                 }

  23451.             }catch(java.lang.Exception e) {
  23452.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23453.                 this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator = false;
  23454.             }
  23455.         }

  23457.         return this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator;
  23458.     }
  23459.     
  23460.     
  23461.     
  23462.     /* ------------- XML ---------------------*/
  23463.     
  23464.     private Boolean isXmlFactoryDTDsEnabled = null;
  23465.     public boolean isXmlFactoryDTDsEnabled(){

  23467.         String pName = "org.openspcoop2.pdd.xmlFactory.DTDs.enabled";
  23468.         
  23469.         if(this.isXmlFactoryDTDsEnabled==null){
  23470.             try{  
  23471.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23473.                 if (value != null){
  23474.                     value = value.trim();
  23475.                     this.isXmlFactoryDTDsEnabled = Boolean.parseBoolean(value);
  23476.                 }else{
  23477.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23478.                     this.isXmlFactoryDTDsEnabled = false;
  23479.                 }

  23481.             }catch(java.lang.Exception e) {
  23482.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23483.                 this.isXmlFactoryDTDsEnabled = false;
  23484.             }
  23485.         }

  23487.         return this.isXmlFactoryDTDsEnabled;
  23488.     }
  23489.     
  23490.     private Boolean isXsltProcessAsDOMSource = null;
  23491.     public boolean isXsltProcessAsDOMSource(){

  23493.         String pName = "org.openspcoop2.pdd.xslt.processAsDOMSource";
  23494.         
  23495.         if(this.isXsltProcessAsDOMSource==null){
  23496.             try{  
  23497.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23499.                 if (value != null){
  23500.                     value = value.trim();
  23501.                     this.isXsltProcessAsDOMSource = Boolean.parseBoolean(value);
  23502.                 }else{
  23503.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23504.                     this.isXsltProcessAsDOMSource = true;
  23505.                 }

  23507.             }catch(java.lang.Exception e) {
  23508.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23509.                 this.isXsltProcessAsDOMSource = true;
  23510.             }
  23511.         }

  23513.         return this.isXsltProcessAsDOMSource;
  23514.     }
  23515.     
  23516.     
  23517.     /* ------------- YAML ---------------------*/
  23518.     
  23519.     private Properties yamlSnakeLimits = null;
  23520.     private Boolean yamlSnakeLimits_read = null;
  23521.     public Properties getYamlSnakeLimits(){

  23523.         String pName = "org.openspcoop2.pdd.yaml.snakeLimits";
  23524.         
  23525.         if(this.yamlSnakeLimits_read==null){
  23526.             try{  
  23527.                 String file = this.reader.getValueConvertEnvProperties(pName); 
  23528.                 if(file!=null && StringUtils.isNotEmpty(file)) {
  23529.                     File f = new File(file);
  23530.                     if(f.exists()) {
  23531.                         if(!f.isFile()) {
  23532.                             throw new CoreException("Il file indicato '"+f.getAbsolutePath()+"' non è un file");
  23533.                         }
  23534.                         if(!f.canRead()) {
  23535.                             throw new CoreException("Il file indicato '"+f.getAbsolutePath()+"' non è accessibile in lettura");
  23536.                         }
  23537.                         try(InputStream is = new FileInputStream(f)){
  23538.                             Properties p = new Properties();
  23539.                             p.load(is);
  23540.                             if (p != null && !p.isEmpty()){
  23541.                                 this.yamlSnakeLimits = p;
  23542.                             }
  23543.                         }
  23544.                     }
  23545.                 }
  23546.                 
  23547.             }catch(java.lang.Exception e) {
  23548.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostate, errore:"+e.getMessage(),e);
  23549.             }
  23550.             this.yamlSnakeLimits_read=true;
  23551.         }

  23553.         return this.yamlSnakeLimits;
  23554.     }
  23555.     
  23556.     
  23557.     /* ------------- XPath e JSON Path ---------------------*/
  23558.     
  23559.     private Boolean isJsonPathCacheEnabled = null;
  23560.     public boolean isJsonPathCacheEnabled(){

  23562.         String pName = "org.openspcoop2.pdd.jsonPath.cache.enabled";
  23563.         
  23564.         if(this.isJsonPathCacheEnabled==null){
  23565.             try{  
  23566.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23568.                 if (value != null){
  23569.                     value = value.trim();
  23570.                     this.isJsonPathCacheEnabled = Boolean.parseBoolean(value);
  23571.                 }else{
  23572.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23573.                     this.isJsonPathCacheEnabled = false;
  23574.                 }

  23576.             }catch(java.lang.Exception e) {
  23577.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23578.                 this.isJsonPathCacheEnabled = false;
  23579.             }
  23580.         }

  23582.         return this.isJsonPathCacheEnabled;
  23583.     }
  23584.     
  23585.     private Boolean isReadByPathBufferEnabled = null;
  23586.     public boolean isReadByPathBufferEnabled(){

  23588.         String pName = "org.openspcoop2.pdd.readByPath.buffer";
  23589.         
  23590.         if(this.isReadByPathBufferEnabled==null){
  23591.             try{  
  23592.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23594.                 if (value != null){
  23595.                     value = value.trim();
  23596.                     this.isReadByPathBufferEnabled = Boolean.parseBoolean(value);
  23597.                 }else{
  23598.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23599.                     this.isReadByPathBufferEnabled = true;
  23600.                 }

  23602.             }catch(java.lang.Exception e) {
  23603.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23604.                 this.isReadByPathBufferEnabled = true;
  23605.             }
  23606.         }

  23608.         return this.isReadByPathBufferEnabled;
  23609.     }
  23610.     
  23611.     
  23612.     
  23613.     /* ------------- Caching Response ---------------------*/
  23614.     
  23615.     private String getCachingResponseDigestAlgorithm = null;
  23616.     public String getCachingResponseDigestAlgorithm(){

  23618.         if(this.getCachingResponseDigestAlgorithm==null){
  23619.             try{  
  23620.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cachingResponse.digestAlgorithm"); 

  23622.                 if (value != null){
  23623.                     value = value.trim();
  23624.                     MessageDigest.getInstance(value); // valida
  23625.                     this.getCachingResponseDigestAlgorithm = value;
  23626.                 }else{
  23627.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.cachingResponse.digestAlgorithm' non impostata, viene utilizzato il default="+CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST_DEFAULT_ALGORITHM);
  23628.                     this.getCachingResponseDigestAlgorithm = CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST_DEFAULT_ALGORITHM;
  23629.                 }

  23631.             }catch(java.lang.Exception e) {
  23632.                 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);
  23633.                 this.getCachingResponseDigestAlgorithm = CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST_DEFAULT_ALGORITHM;
  23634.             }
  23635.         }

  23637.         return this.getCachingResponseDigestAlgorithm;
  23638.     }
  23639.     
  23640.     private Boolean getCachingResponseHeaderCacheKey_read = null;
  23641.     private String getCachingResponseHeaderCacheKey = null;
  23642.     public String getCachingResponseHeaderCacheKey(){

  23644.         if(this.getCachingResponseHeaderCacheKey_read==null){
  23645.             try{  
  23646.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cachingResponse.header.cacheKey"); 

  23648.                 if (value != null){
  23649.                     value = value.trim();
  23650.                     this.getCachingResponseHeaderCacheKey = value;
  23651.                 }

  23653.                 this.getCachingResponseHeaderCacheKey_read = true;
  23654.                 
  23655.             }catch(java.lang.Exception e) {
  23656.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.cachingResponse.header.cacheKey', errore:"+e.getMessage(),e);
  23657.                 
  23658.             }
  23659.         }

  23661.         return this.getCachingResponseHeaderCacheKey;
  23662.     }
  23663.     
  23664.     
  23665.     
  23666.     /* ------------- Gestione Token ---------------------*/
  23667.     
  23668.     private Boolean isGestioneTokenDynamicDiscoveryDebug = null;
  23669.     public boolean isGestioneTokenDynamicDiscoveryDebug(){

  23671.         String pName = "org.openspcoop2.pdd.gestioneToken.dynamicDiscovery.debug";
  23672.         if(this.isGestioneTokenDynamicDiscoveryDebug==null){
  23673.             try{  
  23674.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23676.                 if (value != null){
  23677.                     value = value.trim();
  23678.                     this.isGestioneTokenDynamicDiscoveryDebug = Boolean.parseBoolean(value);
  23679.                 }else{
  23680.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23681.                     this.isGestioneTokenDynamicDiscoveryDebug = false;
  23682.                 }

  23684.             }catch(java.lang.Exception e) {
  23685.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23686.                 this.isGestioneTokenDynamicDiscoveryDebug = false;
  23687.             }
  23688.         }

  23690.         return this.isGestioneTokenDynamicDiscoveryDebug;
  23691.     }
  23692.     
  23693.     private Boolean isGestioneTokenIntrospectionDebug = null;
  23694.     public boolean isGestioneTokenIntrospectionDebug(){

  23696.         String pName = "org.openspcoop2.pdd.gestioneToken.introspection.debug";
  23697.         if(this.isGestioneTokenIntrospectionDebug==null){
  23698.             try{  
  23699.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23701.                 if (value != null){
  23702.                     value = value.trim();
  23703.                     this.isGestioneTokenIntrospectionDebug = Boolean.parseBoolean(value);
  23704.                 }else{
  23705.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23706.                     this.isGestioneTokenIntrospectionDebug = false;
  23707.                 }

  23709.             }catch(java.lang.Exception e) {
  23710.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23711.                 this.isGestioneTokenIntrospectionDebug = false;
  23712.             }
  23713.         }

  23715.         return this.isGestioneTokenIntrospectionDebug;
  23716.     }
  23717.     
  23718.     private Boolean isGestioneTokenUserInfoDebug = null;
  23719.     public boolean isGestioneTokenUserInfoDebug(){

  23721.         String pName = "org.openspcoop2.pdd.gestioneToken.userInfo.debug";
  23722.         if(this.isGestioneTokenUserInfoDebug==null){
  23723.             try{  
  23724.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23726.                 if (value != null){
  23727.                     value = value.trim();
  23728.                     this.isGestioneTokenUserInfoDebug = Boolean.parseBoolean(value);
  23729.                 }else{
  23730.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23731.                     this.isGestioneTokenUserInfoDebug = false;
  23732.                 }

  23734.             }catch(java.lang.Exception e) {
  23735.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23736.                 this.isGestioneTokenUserInfoDebug = false;
  23737.             }
  23738.         }

  23740.         return this.isGestioneTokenUserInfoDebug;
  23741.     }
  23742.     
  23743.     private Boolean getGestioneTokenDynamicDiscoveryLockPermitsRead = null;
  23744.     private Integer getGestioneTokenDynamicDiscoveryLockPermits = null;
  23745.     public Integer getGestioneTokenDynamicDiscoveryLockPermits() {

  23747.         String pName = "org.openspcoop2.pdd.gestioneToken.dynamicDiscovery.lock.permits";
  23748.         if(this.getGestioneTokenDynamicDiscoveryLockPermitsRead==null){
  23749.             try{  
  23750.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23752.                 if (value != null){
  23753.                     value = value.trim();
  23754.                     int permits = Integer.parseInt(value); 
  23755.                     if(permits>1) {
  23756.                         // altrimenti è un normale semaphore binario
  23757.                         this.getGestioneTokenDynamicDiscoveryLockPermits = permits;
  23758.                     }
  23759.                 }
  23760.                 
  23761.                 
  23762.             }catch(java.lang.Exception e) {
  23763.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  23764.             }
  23765.             
  23766.             this.getGestioneTokenDynamicDiscoveryLockPermitsRead = true;
  23767.         }

  23769.         return this.getGestioneTokenDynamicDiscoveryLockPermits;
  23770.     }
  23771.     
  23772.     private Boolean getGestioneTokenValidazioneJWTLockPermitsRead = null;
  23773.     private Integer getGestioneTokenValidazioneJWTLockPermits = null;
  23774.     public Integer getGestioneTokenValidazioneJWTLockPermits() {

  23776.         String pName = "org.openspcoop2.pdd.gestioneToken.validazioneJWT.lock.permits";
  23777.         if(this.getGestioneTokenValidazioneJWTLockPermitsRead==null){
  23778.             try{  
  23779.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23781.                 if (value != null){
  23782.                     value = value.trim();
  23783.                     int permits = Integer.parseInt(value); 
  23784.                     if(permits>1) {
  23785.                         // altrimenti è un normale semaphore binario
  23786.                         this.getGestioneTokenValidazioneJWTLockPermits = permits;
  23787.                     }
  23788.                 }
  23789.                 
  23790.                 
  23791.             }catch(java.lang.Exception e) {
  23792.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  23793.             }
  23794.             
  23795.             this.getGestioneTokenValidazioneJWTLockPermitsRead = true;
  23796.         }

  23798.         return this.getGestioneTokenValidazioneJWTLockPermits;
  23799.     }
  23800.     
  23801.     private Boolean getGestioneTokenIntrospectionLockPermitsRead = null;
  23802.     private Integer getGestioneTokenIntrospectionLockPermits = null;
  23803.     public Integer getGestioneTokenIntrospectionLockPermits() {

  23805.         String pName = "org.openspcoop2.pdd.gestioneToken.introspection.lock.permits";
  23806.         if(this.getGestioneTokenIntrospectionLockPermitsRead==null){
  23807.             try{  
  23808.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23810.                 if (value != null){
  23811.                     value = value.trim();
  23812.                     int permits = Integer.parseInt(value); 
  23813.                     if(permits>1) {
  23814.                         // altrimenti è un normale semaphore binario
  23815.                         this.getGestioneTokenIntrospectionLockPermits = permits;
  23816.                     }
  23817.                 }
  23818.                 
  23819.                 
  23820.             }catch(java.lang.Exception e) {
  23821.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  23822.             }
  23823.             
  23824.             this.getGestioneTokenIntrospectionLockPermitsRead = true;
  23825.         }

  23827.         return this.getGestioneTokenIntrospectionLockPermits;
  23828.     }
  23829.     
  23830.     private Boolean getGestioneTokenUserInfoLockPermitsRead = null;
  23831.     private Integer getGestioneTokenUserInfoLockPermits = null;
  23832.     public Integer getGestioneTokenUserInfoLockPermits() {

  23834.         String pName = "org.openspcoop2.pdd.gestioneToken.userInfo.lock.permits";
  23835.         if(this.getGestioneTokenUserInfoLockPermitsRead==null){
  23836.             try{  
  23837.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23839.                 if (value != null){
  23840.                     value = value.trim();
  23841.                     int permits = Integer.parseInt(value); 
  23842.                     if(permits>1) {
  23843.                         // altrimenti è un normale semaphore binario
  23844.                         this.getGestioneTokenUserInfoLockPermits = permits;
  23845.                     }
  23846.                 }
  23847.                 
  23848.                 
  23849.             }catch(java.lang.Exception e) {
  23850.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  23851.             }
  23852.             
  23853.             this.getGestioneTokenUserInfoLockPermitsRead = true;
  23854.         }

  23856.         return this.getGestioneTokenUserInfoLockPermits;
  23857.     }
  23858.     
  23859.     private Boolean isGestioneTokenDynamicDiscoveryKeyCacheUseToken = null;
  23860.     public boolean isGestioneTokenDynamicDiscoveryKeyCacheUseToken(){

  23862.         String pName = "org.openspcoop2.pdd.gestioneToken.dynamicDiscovery.keyCache.useToken";
  23863.         if(this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken==null){
  23864.             try{  
  23865.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23867.                 if (value != null){
  23868.                     value = value.trim();
  23869.                     this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken = Boolean.parseBoolean(value);
  23870.                 }else{
  23871.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23872.                     this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken = false;
  23873.                 }

  23875.             }catch(java.lang.Exception e) {
  23876.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23877.                 this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken = false;
  23878.             }
  23879.         }

  23881.         return this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken;
  23882.     }
  23883.     
  23884.     private Boolean isGestioneTokenDynamicDiscoveryUseCacheConfig = null;
  23885.     public boolean isGestioneTokenDynamicDiscoveryUseCacheConfig(){

  23887.         String pName = "org.openspcoop2.pdd.gestioneToken.dynamicDiscovery.useCacheConfig";
  23888.         if(this.isGestioneTokenDynamicDiscoveryUseCacheConfig==null){
  23889.             try{  
  23890.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23892.                 if (value != null){
  23893.                     value = value.trim();
  23894.                     this.isGestioneTokenDynamicDiscoveryUseCacheConfig = Boolean.parseBoolean(value);
  23895.                 }else{
  23896.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23897.                     this.isGestioneTokenDynamicDiscoveryUseCacheConfig = true;
  23898.                 }

  23900.             }catch(java.lang.Exception e) {
  23901.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23902.                 this.isGestioneTokenDynamicDiscoveryUseCacheConfig = true;
  23903.             }
  23904.         }

  23906.         return this.isGestioneTokenDynamicDiscoveryUseCacheConfig;
  23907.     }
  23908.         
  23909.     private Boolean isGestioneTokenIatRequired = null;
  23910.     public boolean isGestioneTokenIatRequired() {

  23912.         String pName = "org.openspcoop2.pdd.gestioneToken.iat.required";
  23913.         if(this.isGestioneTokenIatRequired==null){
  23914.             try{  
  23915.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23917.                 if (value != null){
  23918.                     value = value.trim();
  23919.                     this.isGestioneTokenIatRequired = Boolean.parseBoolean(value);
  23920.                 }else{
  23921.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23922.                     this.isGestioneTokenIatRequired = false;
  23923.                 }
  23924.             }catch(java.lang.Exception e) {
  23925.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23926.                 this.isGestioneTokenIatRequired = false;
  23927.             }
  23928.         }
  23929.         
  23930.         return this.isGestioneTokenIatRequired;
  23931.     }
  23932.     
  23933.     private static final String GESTIONE_TOKEN_FRUIZIONI = "fruizioni";
  23934.     private static final String GESTIONE_TOKEN_EROGAZIONI = "erogazioni";
  23935.     private static final String GESTIONE_TOKEN_SUFFIX_REQUIRED = ".required";
  23936.     
  23937.     private Map<String,BooleanNullable> isGestioneTokenIatRequirePddRuolodMap = new HashMap<>();
  23938.     public BooleanNullable isGestioneTokenIatRequired(boolean portaDelegata) {

  23940.         String keyRuolo =  portaDelegata ? GESTIONE_TOKEN_FRUIZIONI : GESTIONE_TOKEN_EROGAZIONI;
  23941.         String pName = "org.openspcoop2.pdd.gestioneToken.iat."+keyRuolo+GESTIONE_TOKEN_SUFFIX_REQUIRED;
  23942.         if(!this.isGestioneTokenIatRequirePddRuolodMap.containsKey(keyRuolo)){
  23943.             try{  
  23944.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23946.                 if (value != null){
  23947.                     value = value.trim();
  23948.                     boolean v = Boolean.parseBoolean(value);
  23949.                     this.isGestioneTokenIatRequirePddRuolodMap.put(keyRuolo, v ? BooleanNullable.TRUE() : BooleanNullable.FALSE());
  23950.                 }else{
  23951.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23952.                     this.isGestioneTokenIatRequirePddRuolodMap.put(keyRuolo, BooleanNullable.NULL());
  23953.                 }
  23954.             }catch(java.lang.Exception e) {
  23955.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23956.                 this.isGestioneTokenIatRequirePddRuolodMap.put(keyRuolo, BooleanNullable.NULL());
  23957.             }
  23958.         }
  23959.         
  23960.         return this.isGestioneTokenIatRequirePddRuolodMap.get(keyRuolo);
  23961.     }
  23962.     
  23963.     private Map<String,BooleanNullable> isGestioneTokenIatRequirePddRuoloProtocolloMap = new HashMap<>();
  23964.     public BooleanNullable isGestioneTokenIatRequired(boolean portaDelegata, String protocollo) {

  23966.         String keyRuolo =  portaDelegata ? GESTIONE_TOKEN_FRUIZIONI : GESTIONE_TOKEN_EROGAZIONI;
  23967.         keyRuolo+="."+protocollo;
  23968.         String pName = "org.openspcoop2.pdd.gestioneToken.iat."+keyRuolo+GESTIONE_TOKEN_SUFFIX_REQUIRED;
  23969.         if(!this.isGestioneTokenIatRequirePddRuoloProtocolloMap.containsKey(keyRuolo)){
  23970.             try{  
  23971.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23973.                 if (value != null){
  23974.                     value = value.trim();
  23975.                     boolean v = Boolean.parseBoolean(value);
  23976.                     this.isGestioneTokenIatRequirePddRuoloProtocolloMap.put(keyRuolo, v ? BooleanNullable.TRUE() : BooleanNullable.FALSE());
  23977.                 }else{
  23978.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23979.                     this.isGestioneTokenIatRequirePddRuoloProtocolloMap.put(keyRuolo, BooleanNullable.NULL());
  23980.                 }
  23981.             }catch(java.lang.Exception e) {
  23982.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23983.                 this.isGestioneTokenIatRequirePddRuoloProtocolloMap.put(keyRuolo, BooleanNullable.NULL());
  23984.             }
  23985.         }
  23986.         
  23987.         return this.isGestioneTokenIatRequirePddRuoloProtocolloMap.get(keyRuolo);
  23988.     }
  23989.     public BooleanNullable isGestioneTokenIatPdndRequired() {
  23990.         return isGestioneTokenIatRequired(false, "pdnd");
  23991.     }
  23992.     
  23993.     private Boolean getGestioneTokenIatTimeCheckMillisecondsRead = null;
  23994.     private Long getGestioneTokenIatTimeCheckMilliseconds = null;
  23995.     public Long getGestioneTokenIatTimeCheckMilliseconds() throws CoreException{

  23997.         String pName = "org.openspcoop2.pdd.gestioneToken.iat";
  23998.         if(this.getGestioneTokenIatTimeCheckMillisecondsRead==null){
  23999.             try{  
  24000.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24002.                 if (value != null){
  24003.                     value = value.trim();
  24004.                     long minuti = Long.parseLong(value); // minuti
  24005.                     this.getGestioneTokenIatTimeCheckMilliseconds = minuti * 60l * 1000l;
  24006.                 }
  24007.             }catch(java.lang.Exception e) {
  24008.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  24009.                 throw new CoreException(e.getMessage(),e);
  24010.             }
  24011.             
  24012.             this.getGestioneTokenIatTimeCheckMillisecondsRead = true;
  24013.         }

  24015.         return this.getGestioneTokenIatTimeCheckMilliseconds;
  24016.     }
  24017.     
  24018.     private Boolean getGestioneTokenIatTimeCheckFutureToleranceMillisecondsRead = null;
  24019.     private Long getGestioneTokenIatTimeCheckFutureToleranceMilliseconds = null;
  24020.     public Long getGestioneTokenIatTimeCheckFutureToleranceMilliseconds() throws CoreException{

  24022.         String pName = "org.openspcoop2.pdd.gestioneToken.iat.future.toleranceMilliseconds";
  24023.         if(this.getGestioneTokenIatTimeCheckFutureToleranceMillisecondsRead==null){
  24024.             try{  
  24025.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24027.                 if (value != null){
  24028.                     value = value.trim();
  24029.                     this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds = Long.parseLong(value); // gia' millisecondi
  24030.                     if(this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds<=0) {
  24031.                         // disabilito il controllo
  24032.                         this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds=null;
  24033.                     }
  24034.                 }
  24035.             }catch(java.lang.Exception e) {
  24036.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  24037.                 throw new CoreException(e.getMessage(),e);
  24038.             }
  24039.             
  24040.             this.getGestioneTokenIatTimeCheckFutureToleranceMillisecondsRead = true;
  24041.         }

  24043.         return this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds;
  24044.     }
  24045.     
  24046.     private Boolean isGestioneTokenExpRequired = null;
  24047.     public boolean isGestioneTokenExpRequired() {

  24049.         String pName = "org.openspcoop2.pdd.gestioneToken.exp.required";
  24050.         if(this.isGestioneTokenExpRequired==null){
  24051.             try{  
  24052.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24054.                 if (value != null){
  24055.                     value = value.trim();
  24056.                     this.isGestioneTokenExpRequired = Boolean.parseBoolean(value);
  24057.                 }else{
  24058.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24059.                     this.isGestioneTokenExpRequired = false;
  24060.                 }
  24061.             }catch(java.lang.Exception e) {
  24062.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24063.                 this.isGestioneTokenExpRequired = false;
  24064.             }
  24065.         }
  24066.         
  24067.         return this.isGestioneTokenExpRequired;
  24068.     }
  24069.     
  24070.     private Map<String,BooleanNullable> isGestioneTokenExpRequirePddRuolodMap = new HashMap<>();
  24071.     public BooleanNullable isGestioneTokenExpRequired(boolean portaDelegata) {

  24073.         String keyRuolo =  portaDelegata ? GESTIONE_TOKEN_FRUIZIONI : GESTIONE_TOKEN_EROGAZIONI;
  24074.         String pName = "org.openspcoop2.pdd.gestioneToken.exp."+keyRuolo+GESTIONE_TOKEN_SUFFIX_REQUIRED;
  24075.         if(!this.isGestioneTokenExpRequirePddRuolodMap.containsKey(keyRuolo)){
  24076.             try{  
  24077.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24079.                 if (value != null){
  24080.                     value = value.trim();
  24081.                     boolean v = Boolean.parseBoolean(value);
  24082.                     this.isGestioneTokenExpRequirePddRuolodMap.put(keyRuolo, v ? BooleanNullable.TRUE() : BooleanNullable.FALSE());
  24083.                 }else{
  24084.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24085.                     this.isGestioneTokenExpRequirePddRuolodMap.put(keyRuolo, BooleanNullable.NULL());
  24086.                 }
  24087.             }catch(java.lang.Exception e) {
  24088.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24089.                 this.isGestioneTokenExpRequirePddRuolodMap.put(keyRuolo, BooleanNullable.NULL());
  24090.             }
  24091.         }
  24092.         
  24093.         return this.isGestioneTokenExpRequirePddRuolodMap.get(keyRuolo);
  24094.     }
  24095.     
  24096.     private Map<String,BooleanNullable> isGestioneTokenExpRequirePddRuoloProtocolloMap = new HashMap<>();
  24097.     public BooleanNullable isGestioneTokenExpRequired(boolean portaDelegata, String protocollo) {

  24099.         String keyRuolo =  portaDelegata ? GESTIONE_TOKEN_FRUIZIONI : GESTIONE_TOKEN_EROGAZIONI;
  24100.         keyRuolo+="."+protocollo;
  24101.         String pName = "org.openspcoop2.pdd.gestioneToken.exp."+keyRuolo+GESTIONE_TOKEN_SUFFIX_REQUIRED;
  24102.         if(!this.isGestioneTokenExpRequirePddRuoloProtocolloMap.containsKey(keyRuolo)){
  24103.             try{  
  24104.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24106.                 if (value != null){
  24107.                     value = value.trim();
  24108.                     boolean v = Boolean.parseBoolean(value);
  24109.                     this.isGestioneTokenExpRequirePddRuoloProtocolloMap.put(keyRuolo, v ? BooleanNullable.TRUE() : BooleanNullable.FALSE());
  24110.                 }else{
  24111.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24112.                     this.isGestioneTokenExpRequirePddRuoloProtocolloMap.put(keyRuolo, BooleanNullable.NULL());
  24113.                 }
  24114.             }catch(java.lang.Exception e) {
  24115.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24116.                 this.isGestioneTokenExpRequirePddRuoloProtocolloMap.put(keyRuolo, BooleanNullable.NULL());
  24117.             }
  24118.         }
  24119.         
  24120.         return this.isGestioneTokenExpRequirePddRuoloProtocolloMap.get(keyRuolo);
  24121.     }
  24122.     public BooleanNullable isGestioneTokenExpPdndRequired() {
  24123.         return isGestioneTokenExpRequired(false, "pdnd");
  24124.     }
  24125.     
  24126.     private Boolean isGestioneTokenExpTimeCheck = null;
  24127.     public boolean isGestioneTokenExpTimeCheck(){

  24129.         if(this.isGestioneTokenExpTimeCheck==null){
  24130.             String pName = "org.openspcoop2.pdd.gestioneToken.exp.checkEnabled";
  24131.             try{  
  24132.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24134.                 if (value != null){
  24135.                     value = value.trim();
  24136.                     this.isGestioneTokenExpTimeCheck = Boolean.parseBoolean(value);
  24137.                 }else{
  24138.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  24139.                     this.isGestioneTokenExpTimeCheck = true;
  24140.                 }

  24142.             }catch(java.lang.Exception e) {
  24143.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  24144.                 this.isGestioneTokenExpTimeCheck = true;
  24145.             }
  24146.         }

  24148.         return this.isGestioneTokenExpTimeCheck;
  24149.     }
  24150.     
  24151.     private Boolean getGestioneTokenExpTimeCheckToleranceMillisecondsRead = null;
  24152.     private Long getGestioneTokenExpTimeCheckToleranceMilliseconds = null;
  24153.     public Long getGestioneTokenExpTimeCheckToleranceMilliseconds() throws CoreException{

  24155.         String pName = "org.openspcoop2.pdd.gestioneToken.exp.toleranceMilliseconds";
  24156.         if(this.getGestioneTokenExpTimeCheckToleranceMillisecondsRead==null){
  24157.             try{  
  24158.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24160.                 if (value != null){
  24161.                     value = value.trim();
  24162.                     this.getGestioneTokenExpTimeCheckToleranceMilliseconds = Long.parseLong(value); // gia' millisecondi
  24163.                     if(this.getGestioneTokenExpTimeCheckToleranceMilliseconds<=0) {
  24164.                         // disabilito il controllo
  24165.                         this.getGestioneTokenExpTimeCheckToleranceMilliseconds=null;
  24166.                     }
  24167.                 }
  24168.             }catch(java.lang.Exception e) {
  24169.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  24170.                 throw new CoreException(e.getMessage(),e);
  24171.             }
  24172.             
  24173.             this.getGestioneTokenExpTimeCheckToleranceMillisecondsRead = true;
  24174.         }

  24176.         return this.getGestioneTokenExpTimeCheckToleranceMilliseconds;
  24177.     }
  24178.     
  24179.     private Boolean isGestioneTokenNbfRequired = null;
  24180.     public boolean isGestioneTokenNbfRequired() {

  24182.         String pName = "org.openspcoop2.pdd.gestioneToken.nbf.required";
  24183.         if(this.isGestioneTokenNbfRequired==null){
  24184.             try{  
  24185.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24187.                 if (value != null){
  24188.                     value = value.trim();
  24189.                     this.isGestioneTokenNbfRequired = Boolean.parseBoolean(value);
  24190.                 }else{
  24191.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24192.                     this.isGestioneTokenNbfRequired = false;
  24193.                 }
  24194.             }catch(java.lang.Exception e) {
  24195.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24196.                 this.isGestioneTokenNbfRequired = false;
  24197.             }
  24198.         }
  24199.         
  24200.         return this.isGestioneTokenNbfRequired;
  24201.     }
  24202.     
  24203.     private Map<String,BooleanNullable> isGestioneTokenNbfRequirePddRuolodMap = new HashMap<>();
  24204.     public BooleanNullable isGestioneTokenNbfRequired(boolean portaDelegata) {

  24206.         String keyRuolo =  portaDelegata ? GESTIONE_TOKEN_FRUIZIONI : GESTIONE_TOKEN_EROGAZIONI;
  24207.         String pName = "org.openspcoop2.pdd.gestioneToken.nbf."+keyRuolo+GESTIONE_TOKEN_SUFFIX_REQUIRED;
  24208.         if(!this.isGestioneTokenNbfRequirePddRuolodMap.containsKey(keyRuolo)){
  24209.             try{  
  24210.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24212.                 if (value != null){
  24213.                     value = value.trim();
  24214.                     boolean v = Boolean.parseBoolean(value);
  24215.                     this.isGestioneTokenNbfRequirePddRuolodMap.put(keyRuolo, v ? BooleanNullable.TRUE() : BooleanNullable.FALSE());
  24216.                 }else{
  24217.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24218.                     this.isGestioneTokenNbfRequirePddRuolodMap.put(keyRuolo, BooleanNullable.NULL());
  24219.                 }
  24220.             }catch(java.lang.Exception e) {
  24221.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24222.                 this.isGestioneTokenNbfRequirePddRuolodMap.put(keyRuolo, BooleanNullable.NULL());
  24223.             }
  24224.         }
  24225.         
  24226.         return this.isGestioneTokenNbfRequirePddRuolodMap.get(keyRuolo);
  24227.     }
  24228.     
  24229.     private Map<String,BooleanNullable> isGestioneTokenNbfRequirePddRuoloProtocolloMap = new HashMap<>();
  24230.     public BooleanNullable isGestioneTokenNbfRequired(boolean portaDelegata, String protocollo) {

  24232.         String keyRuolo =  portaDelegata ? GESTIONE_TOKEN_FRUIZIONI : GESTIONE_TOKEN_EROGAZIONI;
  24233.         keyRuolo+="."+protocollo;
  24234.         String pName = "org.openspcoop2.pdd.gestioneToken.nbf."+keyRuolo+GESTIONE_TOKEN_SUFFIX_REQUIRED;
  24235.         if(!this.isGestioneTokenNbfRequirePddRuoloProtocolloMap.containsKey(keyRuolo)){
  24236.             try{  
  24237.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24239.                 if (value != null){
  24240.                     value = value.trim();
  24241.                     boolean v = Boolean.parseBoolean(value);
  24242.                     this.isGestioneTokenNbfRequirePddRuoloProtocolloMap.put(keyRuolo, v ? BooleanNullable.TRUE() : BooleanNullable.FALSE());
  24243.                 }else{
  24244.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24245.                     this.isGestioneTokenNbfRequirePddRuoloProtocolloMap.put(keyRuolo, BooleanNullable.NULL());
  24246.                 }
  24247.             }catch(java.lang.Exception e) {
  24248.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24249.                 this.isGestioneTokenNbfRequirePddRuoloProtocolloMap.put(keyRuolo, BooleanNullable.NULL());
  24250.             }
  24251.         }
  24252.         
  24253.         return this.isGestioneTokenNbfRequirePddRuoloProtocolloMap.get(keyRuolo);
  24254.     }
  24255.     public BooleanNullable isGestioneTokenNbfPdndRequired() {
  24256.         return isGestioneTokenNbfRequired(false, "pdnd");
  24257.     }
  24258.     
  24259.     private Boolean getGestioneTokenNbfTimeCheckToleranceMillisecondsRead = null;
  24260.     private Long getGestioneTokenNbfTimeCheckToleranceMilliseconds = null;
  24261.     public Long getGestioneTokenNbfTimeCheckToleranceMilliseconds() throws CoreException{

  24263.         String pName = "org.openspcoop2.pdd.gestioneToken.nbf.toleranceMilliseconds";
  24264.         if(this.getGestioneTokenNbfTimeCheckToleranceMillisecondsRead==null){
  24265.             try{  
  24266.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24268.                 if (value != null){
  24269.                     value = value.trim();
  24270.                     this.getGestioneTokenNbfTimeCheckToleranceMilliseconds = Long.parseLong(value); // gia' millisecondi
  24271.                     if(this.getGestioneTokenNbfTimeCheckToleranceMilliseconds<=0) {
  24272.                         // disabilito il controllo
  24273.                         this.getGestioneTokenNbfTimeCheckToleranceMilliseconds=null;
  24274.                     }
  24275.                 }
  24276.             }catch(java.lang.Exception e) {
  24277.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  24278.                 throw new CoreException(e.getMessage(),e);
  24279.             }
  24280.             
  24281.             this.getGestioneTokenNbfTimeCheckToleranceMillisecondsRead = true;
  24282.         }

  24284.         return this.getGestioneTokenNbfTimeCheckToleranceMilliseconds;
  24285.     }
  24286.     
  24287.     private CertificateValidityCheck getGestioneTokenValidityCheck = null;
  24288.     public CertificateValidityCheck getGestioneTokenValidityCheck(){

  24290.         String pName = "org.openspcoop2.pdd.gestioneToken.validityCheck";
  24291.         if(this.getGestioneTokenValidityCheck==null){
  24292.             try{  
  24293.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24295.                 if (value != null){
  24296.                     value = value.trim();
  24297.                     this.getGestioneTokenValidityCheck = CertificateValidityCheck.parseCertificateValidityCheck(value);
  24298.                     if(this.getGestioneTokenValidityCheck==null) {
  24299.                         throw new CoreException("Opzione '"+value+"' sconosciuta");
  24300.                     }
  24301.                 }else{
  24302.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  24303.                     this.getGestioneTokenValidityCheck = CertificateValidityCheck.ENABLED;
  24304.                 }

  24306.             }catch(java.lang.Exception e) {
  24307.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  24308.                 this.getGestioneTokenValidityCheck = CertificateValidityCheck.ENABLED;
  24309.             }
  24310.         }

  24312.         return this.getGestioneTokenValidityCheck;
  24313.     }
  24314.     
  24315.     private Boolean isGestioneTokenSaveSourceTokenInfo = null;
  24316.     public boolean isGestioneTokenSaveSourceTokenInfo(){

  24318.         if(this.isGestioneTokenSaveSourceTokenInfo==null){
  24319.             try{  
  24320.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.saveSourceTokenInfo"); 

  24322.                 if (value != null){
  24323.                     value = value.trim();
  24324.                     this.isGestioneTokenSaveSourceTokenInfo = Boolean.parseBoolean(value);
  24325.                 }else{
  24326.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.saveSourceTokenInfo' non impostata, viene utilizzato il default=false");
  24327.                     this.isGestioneTokenSaveSourceTokenInfo = false;
  24328.                 }

  24330.             }catch(java.lang.Exception e) {
  24331.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.saveSourceTokenInfo' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  24332.                 this.isGestioneTokenSaveSourceTokenInfo = false;
  24333.             }
  24334.         }

  24336.         return this.isGestioneTokenSaveSourceTokenInfo;
  24337.     }
  24338.     
  24339.     private Boolean isGestioneTokenSaveTokenInfoValidationFailed = null;
  24340.     public boolean isGestioneTokenSaveTokenInfoValidationFailed(){

  24342.         if(this.isGestioneTokenSaveTokenInfoValidationFailed==null){
  24343.             String pName = "org.openspcoop2.pdd.gestioneToken.saveTokenInfo.validationFailed";
  24344.             try{  
  24345.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24347.                 if (value != null){
  24348.                     value = value.trim();
  24349.                     this.isGestioneTokenSaveTokenInfoValidationFailed = Boolean.parseBoolean(value);
  24350.                 }else{
  24351.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24352.                     this.isGestioneTokenSaveTokenInfoValidationFailed = false;
  24353.                 }

  24355.             }catch(java.lang.Exception e) {
  24356.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24357.                 this.isGestioneTokenSaveTokenInfoValidationFailed = false;
  24358.             }
  24359.         }

  24361.         return this.isGestioneTokenSaveTokenInfoValidationFailed;
  24362.     }
  24363.     
  24364.     private Boolean isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature = null;
  24365.     public boolean isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature(){

  24367.         if(this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature==null){
  24368.             String pName = "org.openspcoop2.pdd.gestioneToken.saveTokenInfo.validationFailed.excludeJwtSignature";
  24369.             try{  
  24370.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24372.                 if (value != null){
  24373.                     value = value.trim();
  24374.                     this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature = Boolean.parseBoolean(value);
  24375.                 }else{
  24376.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  24377.                     this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature = true;
  24378.                 }

  24380.             }catch(java.lang.Exception e) {
  24381.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  24382.                 this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature = true;
  24383.             }
  24384.         }

  24386.         return this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature;
  24387.     }
  24388.     
  24389.     private Boolean isGestioneTokenSaveTokenAuthenticationInfoValidationFailed = null;
  24390.     public boolean isGestioneTokenSaveTokenAuthenticationInfoValidationFailed(){

  24392.         if(this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed==null){
  24393.             String pName = "org.openspcoop2.pdd.gestioneToken.saveTokenAuthenticationInfo.validationFailed";
  24394.             try{  
  24395.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24397.                 if (value != null){
  24398.                     value = value.trim();
  24399.                     this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed = Boolean.parseBoolean(value);
  24400.                 }else{
  24401.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  24402.                     this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed = true;
  24403.                 }

  24405.             }catch(java.lang.Exception e) {
  24406.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  24407.                 this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed = true;
  24408.             }
  24409.         }

  24411.         return this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed;
  24412.     }
  24413.     
  24414.     private Boolean isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed = null;
  24415.     public boolean isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed(){

  24417.         if(this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed==null){
  24418.             String pName = "org.openspcoop2.pdd.gestioneToken.saveTokenAuthenticationInfo.authenticationFailed";
  24419.             try{  
  24420.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24422.                 if (value != null){
  24423.                     value = value.trim();
  24424.                     this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed = Boolean.parseBoolean(value);
  24425.                 }else{
  24426.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  24427.                     this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed = true;
  24428.                 }

  24430.             }catch(java.lang.Exception e) {
  24431.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  24432.                 this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed = true;
  24433.             }
  24434.         }

  24436.         return this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed;
  24437.     }
  24438.     
  24439.     private Boolean getGestioneTokenFormatDateRead = null;
  24440.     private String getGestioneTokenFormatDate = null;
  24441.     public String getGestioneTokenFormatDate() throws CoreException{

  24443.         if(this.getGestioneTokenFormatDateRead==null){
  24444.             try{  
  24445.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.date.format"); 

  24447.                 if (value != null){
  24448.                     value = value.trim();
  24449.                     this.getGestioneTokenFormatDate = value;
  24450.                 }

  24452.             }catch(java.lang.Exception e) {
  24453.                 String msg = "Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.date.format' non impostata, errore:"+e.getMessage();
  24454.                 this.logError(msg,e);
  24455.                 throw new CoreException(msg);
  24456.             }
  24457.             
  24458.             this.getGestioneTokenFormatDateRead = true;
  24459.         }

  24461.         return this.getGestioneTokenFormatDate;
  24462.     }
  24463.     
  24464.     private String getGestioneTokenHeaderTrasportoJSON = null;
  24465.     public String getGestioneTokenHeaderTrasportoJSON() throws CoreException{

  24467.         if(this.getGestioneTokenHeaderTrasportoJSON==null){
  24468.             try{  
  24469.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.jsonHeader"); 

  24471.                 if (value != null){
  24472.                     value = value.trim();
  24473.                     this.getGestioneTokenHeaderTrasportoJSON = value;
  24474.                 }else{
  24475.                     throw new CoreException("Non impostata");
  24476.                 }

  24478.             }catch(java.lang.Exception e) {
  24479.                 String msg = "Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.jsonHeader' non impostata, errore:"+e.getMessage();
  24480.                 this.logError(msg,e);
  24481.                 throw new CoreException(msg);
  24482.             }
  24483.         }

  24485.         return this.getGestioneTokenHeaderTrasportoJSON;
  24486.     }
  24487.     
  24488.     private String getGestioneTokenHeaderTrasportoJWT = null;
  24489.     public String getGestioneTokenHeaderTrasportoJWT() throws CoreException{

  24491.         if(this.getGestioneTokenHeaderTrasportoJWT==null){
  24492.             try{  
  24493.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.jwsHeader"); 

  24495.                 if (value != null){
  24496.                     value = value.trim();
  24497.                     this.getGestioneTokenHeaderTrasportoJWT = value;
  24498.                 }else{
  24499.                     throw new CoreException("Non impostata");
  24500.                 }

  24502.             }catch(java.lang.Exception e) {
  24503.                 String msg = "Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.jwsHeader' non impostata, errore:"+e.getMessage();
  24504.                 this.logError(msg,e);
  24505.                 throw new CoreException(msg);
  24506.             }
  24507.         }

  24509.         return this.getGestioneTokenHeaderTrasportoJWT;
  24510.     }

  24512.     /**
  24513.      * Restituisce le proprieta' che identificano gli header di integrazione in caso di 'trasporto' 
  24514.      *
  24515.      * @return Restituisce le proprieta' che identificano gli header di integrazione in caso di 'trasporto'
  24516.      *  
  24517.      */
  24518.     private Map<String, String> keyValueGestioneTokenHeaderIntegrazioneTrasporto = null;
  24519.     public Map<String, String> getKeyValueGestioneTokenHeaderIntegrazioneTrasporto() {  
  24520.         if(this.keyValueGestioneTokenHeaderIntegrazioneTrasporto==null){

  24522.             try{ 

  24524.                 this.keyValueGestioneTokenHeaderIntegrazioneTrasporto = this.reader.readPropertiesAsHashMapConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.keyword.");
  24525.                 
  24526.             }catch(java.lang.Exception e) {
  24527.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.keyword.*': "+e.getMessage(),e);
  24528.                 this.keyValueGestioneTokenHeaderIntegrazioneTrasporto = null;
  24529.             }    
  24530.         }

  24532.         return this.keyValueGestioneTokenHeaderIntegrazioneTrasporto;
  24533.     }
  24534.     
  24535.     private Map<String, Boolean> keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD = null;
  24536.     public Map<String, Boolean> getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto() throws CoreException { 
  24537.         if(this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD==null){

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

  24542.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled.");
  24543.                 this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD = new HashMap<>();
  24544.                 Iterator<?> it = prop.keySet().iterator();
  24545.                 while (it.hasNext()) {
  24546.                     Object object = it.next();
  24547.                     if(object instanceof String) {
  24548.                         String key = (String) object;
  24549.                         String value = prop.getProperty(key);
  24550.                         processKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(key, value);
  24551.                     }
  24552.                 }
  24553.                 
  24554.             }catch(java.lang.Exception e) {
  24555.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled.*': "+e.getMessage(),e);
  24556.                 throw new CoreException(e.getMessage(),e);
  24557.             }    
  24558.         }

  24560.         return this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD;
  24561.     }
  24562.     private void processKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String key, String value) throws CoreException {
  24563.         try {
  24564.             boolean b = Boolean.parseBoolean(value);
  24565.             this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD.put(key, b);
  24566.         }catch(Exception e) {
  24567.             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);
  24568.         }
  24569.     }

  24571.     
  24572.     private Map<String, Boolean> keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA = null;
  24573.     public Map<String, Boolean> getKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto() throws CoreException { 
  24574.         if(this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA==null){

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

  24579.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled.");
  24580.                 this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA = new HashMap<>();
  24581.                 Iterator<?> it = prop.keySet().iterator();
  24582.                 while (it.hasNext()) {
  24583.                     Object object = it.next();
  24584.                     if(object instanceof String) {
  24585.                         String key = (String) object;
  24586.                         String value = prop.getProperty(key);
  24587.                         processKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(key, value);
  24588.                     }
  24589.                 }
  24590.                 
  24591.             }catch(java.lang.Exception e) {
  24592.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled.*': "+e.getMessage(),e);
  24593.                 throw new CoreException(e.getMessage(),e);
  24594.             }    
  24595.         }

  24597.         return this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA;
  24598.     }
  24599.     private void processKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String key, String value) throws CoreException {
  24600.         try {
  24601.             boolean b = Boolean.parseBoolean(value);
  24602.             this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA.put(key, b);
  24603.         }catch(Exception e) {
  24604.             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);
  24605.         }
  24606.     }
  24607.     
  24608.     private Map<String, Boolean> keyValueGestioneTokenHeaderIntegrazioneJsonSetPD = null;
  24609.     public Map<String, Boolean> getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson() throws CoreException {  
  24610.         if(this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPD==null){

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

  24615.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled.");
  24616.                 this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPD = new HashMap<>();
  24617.                 Iterator<?> it = prop.keySet().iterator();
  24618.                 while (it.hasNext()) {
  24619.                     Object object = it.next();
  24620.                     if(object instanceof String) {
  24621.                         String key = (String) object;
  24622.                         String value = prop.getProperty(key);
  24623.                         processKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(key, value);
  24624.                     }
  24625.                 }
  24626.                 
  24627.             }catch(java.lang.Exception e) {
  24628.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled.*': "+e.getMessage(),e);
  24629.                 throw new CoreException(e.getMessage(),e);
  24630.             }    
  24631.         }

  24633.         return this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPD;
  24634.     }
  24635.     private void processKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(String key, String value) throws CoreException {
  24636.         try {
  24637.             boolean b = Boolean.parseBoolean(value);
  24638.             this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPD.put(key, b);
  24639.         }catch(Exception e) {
  24640.             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);
  24641.         }
  24642.     }

  24644.     
  24645.     private Map<String, Boolean> keyValueGestioneTokenHeaderIntegrazioneJsonSetPA = null;
  24646.     public Map<String, Boolean> getKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson() throws CoreException {  
  24647.         if(this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPA==null){

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

  24652.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled.");
  24653.                 this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPA = new HashMap<>();
  24654.                 Iterator<?> it = prop.keySet().iterator();
  24655.                 while (it.hasNext()) {
  24656.                     Object object = it.next();
  24657.                     if(object instanceof String) {
  24658.                         String key = (String) object;
  24659.                         String value = prop.getProperty(key);
  24660.                         processKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(key, value);
  24661.                     }
  24662.                 }
  24663.                 
  24664.             }catch(java.lang.Exception e) {
  24665.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled.*': "+e.getMessage(),e);
  24666.                 throw new CoreException(e.getMessage(),e);
  24667.             }    
  24668.         }

  24670.         return this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPA;
  24671.     }
  24672.     private void processKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(String key, String value) throws CoreException {
  24673.         try {
  24674.             boolean b = Boolean.parseBoolean(value);
  24675.             this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPA.put(key, b);
  24676.         }catch(Exception e) {
  24677.             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);
  24678.         }
  24679.     }
  24680.     
  24681.     private static final String PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX = "org.openspcoop2.pdd.gestioneToken.forward.custom.";
  24682.     
  24683.     private List<String> getCustomClaimsKeysGestioneTokenForward = null;
  24684.     public List<String> getCustomClaimsKeysGestioneTokenForward() throws CoreException {    
  24685.         if(this.getCustomClaimsKeysGestioneTokenForward==null){

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

  24690.                 this.getCustomClaimsKeysGestioneTokenForward= new ArrayList<>();
  24691.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  24692.                 if(prop!=null && !prop.isEmpty()) {
  24693.                     Enumeration<?> en = prop.keys();
  24694.                     while (en.hasMoreElements()) {
  24695.                         String key = (String) en.nextElement();
  24696.                         processCustomClaimsKeysGestioneTokenForward(key);
  24697.                     }
  24698.                 }
  24699.                 
  24700.             }catch(java.lang.Exception e) {
  24701.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.custom.CLAIM_NAME.name': "+e.getMessage(),e);
  24702.                 throw new CoreException(e.getMessage(),e);
  24703.             }    
  24704.         }

  24706.         return this.getCustomClaimsKeysGestioneTokenForward;
  24707.     }
  24708.     private void processCustomClaimsKeysGestioneTokenForward(String key) {
  24709.         if(key.contains(".")) {
  24710.             String keySub = key.substring(key.indexOf(".")+1); 
  24711.             if("name".equals(keySub)) {
  24712.                 String tmp = key.substring(0, key.indexOf("."));
  24713.                 if(tmp!=null) {
  24714.                     this.getCustomClaimsKeysGestioneTokenForward.add(tmp.trim());
  24715.                 }
  24716.             }
  24717.         }
  24718.     }
  24719.     
  24720.     private Character gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator = null;
  24721.     public Character getGestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator(){

  24723.         if(this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator==null){
  24724.             try{  
  24725.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.audience.separator"); 

  24727.                 if (value != null){
  24728.                     value = value.trim();
  24729.                     if(value.length()<1 || value.length()>1) {
  24730.                         throw new CoreException(ATTESO_UN_CARATTERE_TROVATI+value.length());
  24731.                     }
  24732.                     this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator = value.charAt(0);
  24733.                 }else{
  24734.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.audience.separator' non impostata, viene utilizzato il default=,");
  24735.                     this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator = ',';
  24736.                 }

  24738.             }catch(java.lang.Exception e) {
  24739.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.audience.separator' non impostata, viene utilizzato il default=, ; errore:"+e.getMessage(),e);
  24740.                 this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator = ',';
  24741.             }
  24742.         }

  24744.         return this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator;
  24745.     }
  24746.     
  24747.     private Character gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator = null;
  24748.     public Character getGestioneTokenHeaderIntegrazioneTrasportoScopeSeparator(){

  24750.         if(this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator==null){
  24751.             try{  
  24752.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.scopes.separator"); 

  24754.                 if (value != null){
  24755.                     value = value.trim();
  24756.                     if(value.length()<1 || value.length()>1) {
  24757.                         throw new CoreException(ATTESO_UN_CARATTERE_TROVATI+value.length());
  24758.                     }
  24759.                     this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator = value.charAt(0);
  24760.                 }else{
  24761.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.scopes.separator' non impostata, viene utilizzato il default=,");
  24762.                     this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator = ',';
  24763.                 }

  24765.             }catch(java.lang.Exception e) {
  24766.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.scopes.separator' non impostata, viene utilizzato il default=, ; errore:"+e.getMessage(),e);
  24767.                 this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator = ',';
  24768.             }
  24769.         }

  24771.         return this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator;
  24772.     }
  24773.     
  24774.     private Character gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator = null;
  24775.     public Character getGestioneTokenHeaderIntegrazioneTrasportoRoleSeparator(){

  24777.         if(this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator==null){
  24778.             try{  
  24779.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.roles.separator"); 

  24781.                 if (value != null){
  24782.                     value = value.trim();
  24783.                     if(value.length()<1 || value.length()>1) {
  24784.                         throw new CoreException(ATTESO_UN_CARATTERE_TROVATI+value.length());
  24785.                     }
  24786.                     this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator = value.charAt(0);
  24787.                 }else{
  24788.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.roles.separator' non impostata, viene utilizzato il default=,");
  24789.                     this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator = ',';
  24790.                 }

  24792.             }catch(java.lang.Exception e) {
  24793.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.roles.separator' non impostata, viene utilizzato il default=, ; errore:"+e.getMessage(),e);
  24794.                 this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator = ',';
  24795.             }
  24796.         }

  24798.         return this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator;
  24799.     }
  24800.     
  24801.     private Map<String, String> getCustomClaimsNameGestioneTokenHeaderIntegrazione = null;
  24802.     public String getCustomClaimsNameGestioneTokenHeaderIntegrazione(String claimName) throws CoreException {   
  24803.         if(this.getCustomClaimsNameGestioneTokenHeaderIntegrazione==null){

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

  24808.                 this.getCustomClaimsNameGestioneTokenHeaderIntegrazione = new HashMap<>();
  24809.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  24810.                 if(prop!=null && !prop.isEmpty()) {
  24811.                     Enumeration<?> en = prop.keys();
  24812.                     while (en.hasMoreElements()) {
  24813.                         String key = (String) en.nextElement();
  24814.                         processCustomClaimsNameGestioneTokenHeaderIntegrazioneEngine(key, prop);
  24815.                     }
  24816.                 }
  24817.                 
  24818.             }catch(java.lang.Exception e) {
  24819.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".trasporto.name': "+e.getMessage(),e);
  24820.                 throw new CoreException(e.getMessage(),e);
  24821.             }    
  24822.         }

  24824.         return this.getCustomClaimsNameGestioneTokenHeaderIntegrazione.get(claimName);
  24825.     }
  24826.     private void processCustomClaimsNameGestioneTokenHeaderIntegrazioneEngine(String key, java.util.Properties prop) throws CoreException { 
  24827.         if(key.contains(".")) {
  24828.             String keySub = key.substring(key.indexOf(".")+1); 
  24829.             if("name".equals(keySub)) {
  24830.                 String tmp = prop.getProperty(key);
  24831.                 if(tmp!=null) {
  24832.                     String claimNameTmp = key.substring(0, key.indexOf("."));
  24833.                     this.getCustomClaimsNameGestioneTokenHeaderIntegrazione.put(claimNameTmp, tmp.trim());
  24834.                 }
  24835.                 else {
  24836.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  24837.                 }
  24838.             }
  24839.         }
  24840.     }
  24841.     
  24842.     private Map<String, String> getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto = null;
  24843.     public String getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto(String claimName) throws CoreException {    
  24844.         if(this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto==null){

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

  24849.                 this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto = new HashMap<>();
  24850.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  24851.                 if(prop!=null && !prop.isEmpty()) {
  24852.                     Enumeration<?> en = prop.keys();
  24853.                     while (en.hasMoreElements()) {
  24854.                         String key = (String) en.nextElement();
  24855.                         processCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto(key, prop);
  24856.                     }
  24857.                 }
  24858.                 
  24859.             }catch(java.lang.Exception e) {
  24860.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".trasporto.name': "+e.getMessage(),e);
  24861.                 throw new CoreException(e.getMessage(),e);
  24862.             }    
  24863.         }

  24865.         return this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto.get(claimName);
  24866.     }
  24867.     private void processCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto(String key, java.util.Properties prop) throws CoreException {    
  24868.         if(key.contains(".")) {
  24869.             String keySub = key.substring(key.indexOf(".")+1); 
  24870.             if("trasporto.name".equals(keySub)) {
  24871.                 String tmp = prop.getProperty(key);
  24872.                 if(tmp!=null) {
  24873.                     String claimNameTmp = key.substring(0, key.indexOf("."));
  24874.                     this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto.put(claimNameTmp, tmp.trim());
  24875.                 }
  24876.                 else {
  24877.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  24878.                 }
  24879.             }
  24880.         }
  24881.     }
  24882.     
  24883.     private Map<String, Boolean> getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD = null;
  24884.     public Boolean getCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String claimName) throws CoreException {  
  24885.         if(this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD==null){

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

  24890.                 this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD = new HashMap<>();
  24891.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  24892.                 if(prop!=null && !prop.isEmpty()) {
  24893.                     Enumeration<?> en = prop.keys();
  24894.                     while (en.hasMoreElements()) {
  24895.                         String key = (String) en.nextElement();
  24896.                         processCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(key, prop);
  24897.                     }
  24898.                 }
  24899.                 
  24900.             }catch(java.lang.Exception e) {
  24901.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".trasporto.pd.set.enabled': "+e.getMessage(),e);
  24902.                 throw new CoreException(e.getMessage(),e);
  24903.             }    
  24904.         }

  24906.         return this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD.get(claimName);
  24907.     }
  24908.     private void processCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String key, java.util.Properties prop) throws CoreException {   
  24909.         if(key.contains(".")) {
  24910.             String keySub = key.substring(key.indexOf(".")+1); 
  24911.             if("trasporto.pd.set.enabled".equals(keySub)) {
  24912.                 String tmp = prop.getProperty(key);
  24913.                 if(tmp!=null) {
  24914.                     try {
  24915.                         boolean b = Boolean.parseBoolean(tmp.trim());
  24916.                         String claimNameTmp = key.substring(0, key.indexOf("."));
  24917.                         this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD.put(claimNameTmp, b);
  24918.                     }catch(Exception e) {
  24919.                         throw new CoreException("Rilevato errore durante il parsing della property '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+key+"' (atteso: true/false): "+e.getMessage(),e);
  24920.                     }
  24921.                 }
  24922.                 else {
  24923.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  24924.                 }
  24925.             }
  24926.         }
  24927.     }

  24929.     
  24930.     private Map<String, Boolean> getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA = null;
  24931.     public Boolean getCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String claimName) throws CoreException {  
  24932.         if(this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA==null){

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

  24937.                 this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA = new HashMap<>();
  24938.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  24939.                 if(prop!=null && !prop.isEmpty()) {
  24940.                     Enumeration<?> en = prop.keys();
  24941.                     while (en.hasMoreElements()) {
  24942.                         String key = (String) en.nextElement();
  24943.                         processCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(key, prop);
  24944.                     }
  24945.                 }
  24946.                 
  24947.             }catch(java.lang.Exception e) {
  24948.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".trasporto.pa.set.enabled': "+e.getMessage(),e);
  24949.                 throw new CoreException(e.getMessage(),e);
  24950.             }    
  24951.         }

  24953.         return this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA.get(claimName);
  24954.     }
  24955.     private void processCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String key, java.util.Properties prop) throws CoreException {   
  24956.         if(key.contains(".")) {
  24957.             String keySub = key.substring(key.indexOf(".")+1); 
  24958.             if("trasporto.pa.set.enabled".equals(keySub)) {
  24959.                 String tmp = prop.getProperty(key);
  24960.                 if(tmp!=null) {
  24961.                     try {
  24962.                         boolean b = Boolean.parseBoolean(tmp.trim());
  24963.                         String claimNameTmp = key.substring(0, key.indexOf("."));
  24964.                         this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA.put(claimNameTmp, b);
  24965.                     }catch(Exception e) {
  24966.                         throw new CoreException("Rilevato errore durante il parsing della property '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+key+"' (atteso: true/false): "+e.getMessage(),e);
  24967.                     }
  24968.                 }
  24969.                 else {
  24970.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  24971.                 }
  24972.             }
  24973.         }
  24974.     }
  24975.     
  24976.     private Map<String, String> getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson = null;
  24977.     public String getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson(String claimName) throws CoreException {   
  24978.         if(this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson==null){

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

  24983.                 this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson = new HashMap<>();
  24984.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  24985.                 if(prop!=null && !prop.isEmpty()) {
  24986.                     Enumeration<?> en = prop.keys();
  24987.                     while (en.hasMoreElements()) {
  24988.                         String key = (String) en.nextElement();
  24989.                         processCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson(key, prop);
  24990.                     }
  24991.                 }
  24992.                 
  24993.             }catch(java.lang.Exception e) {
  24994.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".json.name': "+e.getMessage(),e);
  24995.                 throw new CoreException(e.getMessage(),e);
  24996.             }    
  24997.         }

  24999.         return this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson.get(claimName);
  25000.     }
  25001.     private void processCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson(String key, java.util.Properties prop) throws CoreException {   
  25002.         if(key.contains(".")) {
  25003.             String keySub = key.substring(key.indexOf(".")+1); 
  25004.             if("json.name".equals(keySub)) {
  25005.                 String tmp = prop.getProperty(key);
  25006.                 if(tmp!=null) {
  25007.                     String claimNameTmp = key.substring(0, key.indexOf("."));
  25008.                     this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson.put(claimNameTmp, tmp.trim());
  25009.                 }
  25010.                 else {
  25011.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  25012.                 }
  25013.             }
  25014.         }
  25015.     }
  25016.     
  25017.     private Map<String, Boolean> getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD = null;
  25018.     public Boolean getCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(String claimName) throws CoreException {   
  25019.         if(this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD==null){

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

  25024.                 this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD = new HashMap<>();
  25025.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  25026.                 if(prop!=null && !prop.isEmpty()) {
  25027.                     Enumeration<?> en = prop.keys();
  25028.                     while (en.hasMoreElements()) {
  25029.                         String key = (String) en.nextElement();
  25030.                         processCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(key, prop);
  25031.                     }
  25032.                 }
  25033.                 
  25034.             }catch(java.lang.Exception e) {
  25035.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".json.pd.set.enabled': "+e.getMessage(),e);
  25036.                 throw new CoreException(e.getMessage(),e);
  25037.             }    
  25038.         }

  25040.         return this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD.get(claimName);
  25041.     }
  25042.     private void processCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(String key, java.util.Properties prop) throws CoreException {    
  25043.         if(key.contains(".")) {
  25044.             String keySub = key.substring(key.indexOf(".")+1); 
  25045.             if("json.pd.set.enabled".equals(keySub)) {
  25046.                 String tmp = prop.getProperty(key);
  25047.                 if(tmp!=null) {
  25048.                     try {
  25049.                         boolean b = Boolean.parseBoolean(tmp.trim());
  25050.                         String claimNameTmp = key.substring(0, key.indexOf("."));
  25051.                         this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD.put(claimNameTmp, b);
  25052.                     }catch(Exception e) {
  25053.                         throw new CoreException("Rilevato errore durante il parsing della property '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+key+"' (atteso: true/false): "+e.getMessage(),e);
  25054.                     }
  25055.                 }
  25056.                 else {
  25057.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  25058.                 }
  25059.             }
  25060.         }
  25061.     }

  25063.     
  25064.     private Map<String, Boolean> getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA = null;
  25065.     public Boolean getCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(String claimName) throws CoreException {   
  25066.         if(this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA==null){

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

  25071.                 this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA = new HashMap<>();
  25072.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  25073.                 if(prop!=null && !prop.isEmpty()) {
  25074.                     Enumeration<?> en = prop.keys();
  25075.                     while (en.hasMoreElements()) {
  25076.                         String key = (String) en.nextElement();
  25077.                         processCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(key, prop);
  25078.                     }
  25079.                 }
  25080.                 
  25081.             }catch(java.lang.Exception e) {
  25082.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".json.pa.set.enabled': "+e.getMessage(),e);
  25083.                 throw new CoreException(e.getMessage(),e);
  25084.             }    
  25085.         }

  25087.         return this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA.get(claimName);
  25088.     }
  25089.     private void processCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(String key, java.util.Properties prop) throws CoreException {    
  25090.         if(key.contains(".")) {
  25091.             String keySub = key.substring(key.indexOf(".")+1); 
  25092.             if("json.pa.set.enabled".equals(keySub)) {
  25093.                 String tmp = prop.getProperty(key);
  25094.                 if(tmp!=null) {
  25095.                     try {
  25096.                         boolean b = Boolean.parseBoolean(tmp.trim());
  25097.                         String claimNameTmp = key.substring(0, key.indexOf("."));
  25098.                         this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA.put(claimNameTmp, b);
  25099.                     }catch(Exception e) {
  25100.                         throw new CoreException("Rilevato errore durante il parsing della property '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+key+"' (atteso: true/false): "+e.getMessage(),e);
  25101.                     }
  25102.                 }
  25103.                 else {
  25104.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  25105.                 }
  25106.             }
  25107.         }
  25108.     }
  25109.     
  25110.     
  25111.     
  25112.     /* ------------- Gestione Retrieve Token ---------------------*/
  25113.     
  25114.     private Boolean isGestioneRetrieveTokenDebug = null;
  25115.     private Boolean isGestioneRetrieveTokenDebugRead = null;
  25116.     public Boolean getGestioneRetrieveTokenDebug(){

  25118.         String pName = "org.openspcoop2.pdd.retrieveToken.debug";
  25119.         if(this.isGestioneRetrieveTokenDebugRead==null){
  25120.             try{  
  25121.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25123.                 if (value != null){
  25124.                     value = value.trim();
  25125.                     this.isGestioneRetrieveTokenDebug = Boolean.parseBoolean(value);
  25126.                 }
  25127.                 
  25128.                 this.isGestioneRetrieveTokenDebugRead=true;

  25130.             }catch(java.lang.Exception e) {
  25131.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default='Utilizzo dell'impostazione del connettore', errore:"+e.getMessage(),e);
  25132.                 this.isGestioneRetrieveTokenDebug = false;
  25133.             }
  25134.         }

  25136.         return this.isGestioneRetrieveTokenDebug;
  25137.     }
  25138.     
  25139.     private Boolean getGestioneRetrieveTokenLockPermitsRead = null;
  25140.     private Integer getGestioneRetrieveTokenLockPermits = null;
  25141.     public Integer getGestioneRetrieveTokenLockPermits() {

  25143.         String pName = "org.openspcoop2.pdd.retrieveToken.lock.permits";
  25144.         if(this.getGestioneRetrieveTokenLockPermitsRead==null){
  25145.             try{  
  25146.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25148.                 if (value != null){
  25149.                     value = value.trim();
  25150.                     int permits = Integer.parseInt(value); 
  25151.                     if(permits>1) {
  25152.                         // altrimenti è un normale semaphore binario
  25153.                         this.getGestioneRetrieveTokenLockPermits = permits;
  25154.                     }
  25155.                 }
  25156.                 
  25157.                 
  25158.             }catch(java.lang.Exception e) {
  25159.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  25160.             }
  25161.             
  25162.             this.getGestioneRetrieveTokenLockPermitsRead = true;
  25163.         }

  25165.         return this.getGestioneRetrieveTokenLockPermits;
  25166.     }
  25167.     
  25168.     private Integer isGestioneRetrieveTokenRefreshTokenBeforeExpirePercent = null;
  25169.     private Boolean isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentRead = null;
  25170.     private String isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentPName = "org.openspcoop2.pdd.retrieveToken.refreshTokenBeforeExpire.percent";
  25171.     public Integer getGestioneRetrieveTokenRefreshTokenBeforeExpirePercent(){

  25173.         if(this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentRead==null){
  25174.             try{  
  25175.                 String value = this.reader.getValueConvertEnvProperties(this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentPName); 

  25177.                 if (value != null){
  25178.                     value = value.trim();
  25179.                     this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercent = Integer.parseInt(value);
  25180.                 }
  25181.                 
  25182.                 this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentRead=true;

  25184.             }catch(java.lang.Exception e) {
  25185.                 this.logError("Proprieta' di openspcoop '"+this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentPName+"' non impostata, errore:"+e.getMessage(),e);
  25186.                 this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercent = null;
  25187.             }
  25188.         }

  25190.         return this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercent;
  25191.     }
  25192.     
  25193.     private Integer isGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds = null;
  25194.     private Boolean isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsRead = null;
  25195.     private String isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsPName = "org.openspcoop2.pdd.retrieveToken.refreshTokenBeforeExpire.seconds";
  25196.     public Integer getGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds(){

  25198.         if(this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsRead==null){
  25199.             try{  
  25200.                 String value = this.reader.getValueConvertEnvProperties(this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsPName); 

  25202.                 if (value != null){
  25203.                     value = value.trim();
  25204.                     this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds = Integer.parseInt(value);
  25205.                 }
  25206.                 
  25207.                 this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsRead=true;

  25209.             }catch(java.lang.Exception e) {
  25210.                 this.logError("Proprieta' di openspcoop '"+this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsPName+"' non impostata, errore:"+e.getMessage(),e);
  25211.                 this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds = null;
  25212.             }
  25213.         }

  25215.         return this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds;
  25216.     }
  25217.     
  25218.     private boolean validateGestioneRetrieveTokenRefreshTokenBeforeExpire() {
  25219.         Integer percent = getGestioneRetrieveTokenRefreshTokenBeforeExpirePercent();
  25220.         Integer seconds = getGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds();
  25221.         boolean percentDefined = percent !=null && percent>0;
  25222.         boolean secondsDefined = seconds!=null && seconds>0;
  25223.         /**
  25224.          *Fix: lascio la possibilità di usare il token fino alla scadenza prossima se non vengono definite nessuna delle due proprietà
  25225.         if(!percentDefined && !secondsDefined) {
  25226.             this.logError("Almeno una proprietà tra le seguenti deve essere definita: '"+isGestioneRetrieveToken_refreshTokenBeforeExpire_percent_pName+"' o '"+isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds_pName+"'");
  25227.             return false;
  25228.         }*/
  25229.         if(percentDefined && secondsDefined) {
  25230.             this.logError("Non è possibile definire contemporaneamente entrambe le seguenti proprietà: '"+this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentPName+"' o '"+this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsPName+"'");
  25231.             return false;
  25232.         }
  25233.         return true;
  25234.     }
  25235.     
  25236.     private Boolean isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials = null;
  25237.     public boolean isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials(){

  25239.         String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.clientCredentials";
  25240.         if(this.isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials==null){
  25241.             try{  
  25242.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25244.                 if (value != null){
  25245.                     value = value.trim();
  25246.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials = Boolean.parseBoolean(value);
  25247.                 }else{
  25248.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25249.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials = false;
  25250.                 }

  25252.             }catch(java.lang.Exception e) {
  25253.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25254.                 this.isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials = false;
  25255.             }
  25256.         }

  25258.         return this.isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials;
  25259.     }
  25260.     
  25261.     private Boolean isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword = null;
  25262.     public boolean isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword(){

  25264.         String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.usernamePassword";
  25265.         if(this.isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword==null){
  25266.             try{  
  25267.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25269.                 if (value != null){
  25270.                     value = value.trim();
  25271.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword = Boolean.parseBoolean(value);
  25272.                 }else{
  25273.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25274.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword = false;
  25275.                 }

  25277.             }catch(java.lang.Exception e) {
  25278.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25279.                 this.isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword = false;
  25280.             }
  25281.         }

  25283.         return this.isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword;
  25284.     }
  25285.     
  25286.     private Boolean isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509 = null;
  25287.     public boolean isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509(){

  25289.         String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.rfc7523_x509";
  25290.         if(this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509==null){
  25291.             try{  
  25292.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25294.                 if (value != null){
  25295.                     value = value.trim();
  25296.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509 = Boolean.parseBoolean(value);
  25297.                 }else{
  25298.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25299.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509 = false;
  25300.                 }

  25302.             }catch(java.lang.Exception e) {
  25303.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25304.                 this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509 = false;
  25305.             }
  25306.         }

  25308.         return this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509;
  25309.     }
  25310.     
  25311.     private Boolean isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret = null;
  25312.     public boolean isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret(){

  25314.         String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.rfc7523_clientSecret";
  25315.         if(this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret==null){
  25316.             try{  
  25317.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25319.                 if (value != null){
  25320.                     value = value.trim();
  25321.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret = Boolean.parseBoolean(value);
  25322.                 }else{
  25323.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25324.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret = false;
  25325.                 }

  25327.             }catch(java.lang.Exception e) {
  25328.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25329.                 this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret = false;
  25330.             }
  25331.         }

  25333.         return this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret;
  25334.     }
  25335.     
  25336.     private Boolean isGestioneRetrieveTokenRefreshTokenGrantTypeCustom = null;
  25337.     public boolean isGestioneRetrieveTokenRefreshTokenGrantTypeCustom(){

  25339.         String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.custom";
  25340.         if(this.isGestioneRetrieveTokenRefreshTokenGrantTypeCustom==null){
  25341.             try{  
  25342.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25344.                 if (value != null){
  25345.                     value = value.trim();
  25346.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeCustom = Boolean.parseBoolean(value);
  25347.                 }else{
  25348.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25349.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeCustom = false;
  25350.                 }

  25352.             }catch(java.lang.Exception e) {
  25353.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25354.                 this.isGestioneRetrieveTokenRefreshTokenGrantTypeCustom = false;
  25355.             }
  25356.         }

  25358.         return this.isGestioneRetrieveTokenRefreshTokenGrantTypeCustom;
  25359.     }
  25360.     
  25361.     private Boolean isGestioneRetrieveTokenSaveAsTokenInfo = null;
  25362.     public boolean isGestioneRetrieveTokenSaveAsTokenInfo(){

  25364.         String pName = "org.openspcoop2.pdd.retrieveToken.saveAsTokenInfo";
  25365.         if(this.isGestioneRetrieveTokenSaveAsTokenInfo==null){
  25366.             try{  
  25367.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25369.                 if (value != null){
  25370.                     value = value.trim();
  25371.                     this.isGestioneRetrieveTokenSaveAsTokenInfo = Boolean.parseBoolean(value);
  25372.                 }else{
  25373.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25374.                     this.isGestioneRetrieveTokenSaveAsTokenInfo = true;
  25375.                 }

  25377.             }catch(java.lang.Exception e) {
  25378.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25379.                 this.isGestioneRetrieveTokenSaveAsTokenInfo = true;
  25380.             }
  25381.         }

  25383.         return this.isGestioneRetrieveTokenSaveAsTokenInfo;
  25384.     }
  25385.     
  25386.     private Boolean isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature = null;
  25387.     public boolean isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature(){

  25389.         String pName = "org.openspcoop2.pdd.retrieveToken.saveAsTokenInfo.excludeJwtSignature";
  25390.         if(this.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature==null){
  25391.             try{  
  25392.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25394.                 if (value != null){
  25395.                     value = value.trim();
  25396.                     this.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature = Boolean.parseBoolean(value);
  25397.                 }else{
  25398.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25399.                     this.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature = true;
  25400.                 }

  25402.             }catch(java.lang.Exception e) {
  25403.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25404.                 this.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature = true;
  25405.             }
  25406.         }

  25408.         return this.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature;
  25409.     }
  25410.     
  25411.     private Boolean isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest = null;
  25412.     public boolean isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest(){

  25414.         String pName = "org.openspcoop2.pdd.retrieveToken.saveAsTokenInfo.saveSourceRequest";
  25415.         if(this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest==null){
  25416.             try{  
  25417.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25419.                 if (value != null){
  25420.                     value = value.trim();
  25421.                     this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest = Boolean.parseBoolean(value);
  25422.                 }else{
  25423.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25424.                     this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest = true;
  25425.                 }

  25427.             }catch(java.lang.Exception e) {
  25428.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25429.                 this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest = true;
  25430.             }
  25431.         }

  25433.         return this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest;
  25434.     }
  25435.     
  25436.     private Boolean isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate = null;
  25437.     public boolean isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate(){

  25439.         String pName = "org.openspcoop2.pdd.retrieveToken.saveAsTokenInfo.saveSourceRequest.date";
  25440.         if(this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate==null){
  25441.             try{  
  25442.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25444.                 if (value != null){
  25445.                     value = value.trim();
  25446.                     this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate = Boolean.parseBoolean(value);
  25447.                 }else{
  25448.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25449.                     this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate = true;
  25450.                 }

  25452.             }catch(java.lang.Exception e) {
  25453.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25454.                 this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate = true;
  25455.             }
  25456.         }

  25458.         return this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate;
  25459.     }
  25460.     
  25461.     private Boolean isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate = null;
  25462.     public boolean isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate(){

  25464.         String pName = "org.openspcoop2.pdd.retrieveToken.grantType_rfc7523.saveClientAssertionJWTInfo.transazioniRegistrazioneInformazioniNormalizzate";
  25465.         if(this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate==null){
  25466.             try{  
  25467.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25469.                 if (value != null){
  25470.                     value = value.trim();
  25471.                     this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate = Boolean.parseBoolean(value);
  25472.                 }else{
  25473.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25474.                     this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate = false;
  25475.                 }

  25477.             }catch(java.lang.Exception e) {
  25478.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25479.                 this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate = false;
  25480.             }
  25481.         }

  25483.         return this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate;
  25484.     }
  25485.     
  25486.     private Boolean isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature = null;
  25487.     public boolean isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature(){

  25489.         String pName = "org.openspcoop2.pdd.retrieveToken.grantType_rfc7523.saveClientAssertionJWTInfo.excludeJwtSignature";
  25490.         if(this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature==null){
  25491.             try{  
  25492.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25494.                 if (value != null){
  25495.                     value = value.trim();
  25496.                     this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature = Boolean.parseBoolean(value);
  25497.                 }else{
  25498.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25499.                     this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature = true;
  25500.                 }

  25502.             }catch(java.lang.Exception e) {
  25503.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25504.                 this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature = true;
  25505.             }
  25506.         }

  25508.         return this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature;
  25509.     }
  25510.     
  25511.     private Boolean isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed = null;
  25512.     public boolean isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed(){

  25514.         String pName = "org.openspcoop2.pdd.retrieveToken.saveTokenInfo.retrieveFailed";
  25515.         if(this.isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed==null){
  25516.             try{  
  25517.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25519.                 if (value != null){
  25520.                     value = value.trim();
  25521.                     this.isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed = Boolean.parseBoolean(value);
  25522.                 }else{
  25523.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25524.                     this.isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed = false;
  25525.                 }

  25527.             }catch(java.lang.Exception e) {
  25528.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25529.                 this.isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed = false;
  25530.             }
  25531.         }

  25533.         return this.isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed;
  25534.     }

  25536.     private Map<String, Boolean> gestioneRetrieveTokenCacheKey = null;
  25537.     private void initGestioneRetrieveTokenCacheKey() throws CoreException {
  25538.         Properties p = null;
  25539.         try {
  25540.             p = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.retrieveToken.cacheKey.");
  25541.         }catch(Exception e) {
  25542.             throw new CoreException(e.getMessage(),e);
  25543.         }
  25544.         if(p!=null) {
  25545.             this.gestioneRetrieveTokenCacheKey = new HashMap<>();
  25546.             for (Object oKey : p.keySet()) {
  25547.                 if(oKey instanceof String) {
  25548.                     String key = (String) oKey;
  25549.                     String v = p.getProperty(key);
  25550.                     if(v!=null) {
  25551.                         boolean b = Boolean.parseBoolean(v.trim());
  25552.                         this.gestioneRetrieveTokenCacheKey.put(key,b);
  25553.                     }
  25554.                 }
  25555.             }
  25556.         }
  25557.     }
  25558.     public boolean isGestioneRetrieveTokenCacheKey(String tipo) {
  25559.         if(this.gestioneRetrieveTokenCacheKey!=null && !this.gestioneRetrieveTokenCacheKey.isEmpty() && this.gestioneRetrieveTokenCacheKey.containsKey(tipo)) {
  25560.             return this.gestioneRetrieveTokenCacheKey.get(tipo);
  25561.         }
  25562.         
  25563.         // logica di default
  25564.         return !(
  25565.                 CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_IDENTIFIER.equals(tipo)
  25566.                 || 
  25567.                 CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SESSION_INFO.equals(tipo)
  25568.                 );
  25569.     }
  25570.     
  25571.     private static final String PDND_PATTERN_MATCH_DEFAULT = "^https://auth.*\\.interop\\.pagopa\\.it/token\\.oauth2$";
  25572.     private static final String PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY = "org.openspcoop2.pdd.retrieveToken.";
  25573.     private Map<String,String> getGestioneRetrieveTokenPdndUrlPatternMatch = new HashMap<>();
  25574.     public String getGestioneRetrieveTokenPdndUrlPatternMatch(String protocollo){

  25576.         if(protocollo==null) {
  25577.             protocollo = Costanti.MODIPA_PROTOCOL_NAME; // default
  25578.         }
  25579.         
  25580.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+".pdnd.url.pattern";
  25581.         if(!this.getGestioneRetrieveTokenPdndUrlPatternMatch.containsKey(protocollo)){
  25582.             try{  
  25583.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25585.                 if (value != null){
  25586.                     value = value.trim();
  25587.                     this.getGestioneRetrieveTokenPdndUrlPatternMatch.put(protocollo, value);
  25588.                 }else{
  25589.                     // dovrebbe venire chiamato solo per ModI
  25590.                     if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo)) {
  25591.                         this.logWarn(getMessaggioProprietaNonImpostata(pName, PDND_PATTERN_MATCH_DEFAULT));
  25592.                     }
  25593.                     this.getGestioneRetrieveTokenPdndUrlPatternMatch.put(protocollo, PDND_PATTERN_MATCH_DEFAULT);
  25594.                 }

  25596.             }catch(java.lang.Exception e) {
  25597.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, PDND_PATTERN_MATCH_DEFAULT),e);
  25598.                 this.getGestioneRetrieveTokenPdndUrlPatternMatch.put(protocollo, PDND_PATTERN_MATCH_DEFAULT);
  25599.             }
  25600.         }

  25602.         return this.getGestioneRetrieveTokenPdndUrlPatternMatch.get(protocollo);
  25603.     }
  25604.     
  25605.     private Map<String,Boolean> isGestioneRetrieveTokenPdndPayloadClientId = new HashMap<>();
  25606.     private boolean isGestioneRetrieveTokenPdndPayloadClientId(String protocollo){

  25608.         if(protocollo==null) {
  25609.             protocollo = Costanti.MODIPA_PROTOCOL_NAME; // default
  25610.         }
  25611.         
  25612.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+".pdnd.payload.clientId";
  25613.         if(!this.isGestioneRetrieveTokenPdndPayloadClientId.containsKey(protocollo)){
  25614.             try{  
  25615.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25617.                 if (value != null){
  25618.                     value = value.trim();
  25619.                     this.isGestioneRetrieveTokenPdndPayloadClientId.put(protocollo, Boolean.parseBoolean(value));
  25620.                 }else{
  25621.                     // dovrebbe venire chiamato solo per ModI
  25622.                     if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo)) {
  25623.                         this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25624.                     }
  25625.                     this.isGestioneRetrieveTokenPdndPayloadClientId.put(protocollo, false);
  25626.                 }

  25628.             }catch(java.lang.Exception e) {
  25629.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25630.                 this.isGestioneRetrieveTokenPdndPayloadClientId.put(protocollo, false);
  25631.             }
  25632.         }

  25634.         return this.isGestioneRetrieveTokenPdndPayloadClientId.get(protocollo);
  25635.     }
  25636.     
  25637.     private Map<String,Boolean> isGestioneRetrieveTokenPdndPayloadClientIdMapSoggetto = new HashMap<>();
  25638.     public boolean isGestioneRetrieveTokenPdndPayloadClientId(String protocollo, String soggettoFruitore){

  25640.         if(soggettoFruitore==null) {
  25641.             return isGestioneRetrieveTokenPdndPayloadClientId(protocollo);
  25642.         }
  25643.         
  25644.         String key = protocollo+"_"+soggettoFruitore;
  25645.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+"."+soggettoFruitore+".pdnd.payload.clientId";
  25646.         if(!this.isGestioneRetrieveTokenPdndPayloadClientIdMapSoggetto.containsKey(key)){
  25647.             try{  
  25648.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25650.                 if (value != null){
  25651.                     value = value.trim();
  25652.                     this.isGestioneRetrieveTokenPdndPayloadClientIdMapSoggetto.put(key, Boolean.parseBoolean(value));
  25653.                 }else{
  25654.                     return isGestioneRetrieveTokenPdndPayloadClientId(protocollo);
  25655.                 }

  25657.             }catch(java.lang.Exception e) {
  25658.                 this.logError("isGestioneRetrieveTokenPdndPayloadClientId failed: "+e.getMessage(), e);
  25659.                 return isGestioneRetrieveTokenPdndPayloadClientId(protocollo);
  25660.             }
  25661.         }

  25663.         return this.isGestioneRetrieveTokenPdndPayloadClientIdMapSoggetto.get(key);
  25664.     }
  25665.     
  25666.     private Map<String,Boolean> isGestioneRetrieveTokenPdndPayloadNbf = new HashMap<>();
  25667.     private boolean isGestioneRetrieveTokenPdndPayloadNbf(String protocollo){

  25669.         if(protocollo==null) {
  25670.             protocollo = Costanti.MODIPA_PROTOCOL_NAME; // default
  25671.         }
  25672.         
  25673.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+".pdnd.payload.nbf";
  25674.         if(!this.isGestioneRetrieveTokenPdndPayloadNbf.containsKey(protocollo)){
  25675.             try{  
  25676.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25678.                 if (value != null){
  25679.                     value = value.trim();
  25680.                     this.isGestioneRetrieveTokenPdndPayloadNbf.put(protocollo, Boolean.parseBoolean(value));
  25681.                 }else{
  25682.                     // dovrebbe venire chiamato solo per ModI
  25683.                     if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo)) {
  25684.                         this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25685.                     }
  25686.                     this.isGestioneRetrieveTokenPdndPayloadNbf.put(protocollo, false);
  25687.                 }

  25689.             }catch(java.lang.Exception e) {
  25690.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25691.                 this.isGestioneRetrieveTokenPdndPayloadNbf.put(protocollo, false);
  25692.             }
  25693.         }

  25695.         return this.isGestioneRetrieveTokenPdndPayloadNbf.get(protocollo);
  25696.     }
  25697.     
  25698.     private Map<String,Boolean> isGestioneRetrieveTokenPdndPayloadNbfMapSoggetto = new HashMap<>();
  25699.     public boolean isGestioneRetrieveTokenPdndPayloadNbf(String protocollo, String soggettoFruitore){

  25701.         if(soggettoFruitore==null) {
  25702.             return isGestioneRetrieveTokenPdndPayloadNbf(protocollo);
  25703.         }
  25704.         
  25705.         String key = protocollo+"_"+soggettoFruitore;
  25706.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+"."+soggettoFruitore+".pdnd.payload.nbf";
  25707.         if(!this.isGestioneRetrieveTokenPdndPayloadNbfMapSoggetto.containsKey(key)){
  25708.             try{  
  25709.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25711.                 if (value != null){
  25712.                     value = value.trim();
  25713.                     this.isGestioneRetrieveTokenPdndPayloadNbfMapSoggetto.put(key, Boolean.parseBoolean(value));
  25714.                 }else{
  25715.                     return isGestioneRetrieveTokenPdndPayloadNbf(protocollo);
  25716.                 }

  25718.             }catch(java.lang.Exception e) {
  25719.                 this.logError("isGestioneRetrieveTokenPdndPayloadNbf failed: "+e.getMessage(), e);
  25720.                 return isGestioneRetrieveTokenPdndPayloadNbf(protocollo);
  25721.             }
  25722.         }

  25724.         return this.isGestioneRetrieveTokenPdndPayloadNbfMapSoggetto.get(key);
  25725.     }
  25726.     
  25727.     
  25728.     private Map<String,Boolean> isGestioneRetrieveTokenPdndDatiRichiestaForceClientId = new HashMap<>();
  25729.     private boolean isGestioneRetrieveTokenPdndDatiRichiestaForceClientId(String protocollo){

  25731.         if(protocollo==null) {
  25732.             protocollo = Costanti.MODIPA_PROTOCOL_NAME; // default
  25733.         }
  25734.         
  25735.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+".pdnd.datiRichiesta.forceClientId";
  25736.         if(!this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientId.containsKey(protocollo)){
  25737.             try{  
  25738.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25740.                 if (value != null){
  25741.                     value = value.trim();
  25742.                     this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientId.put(protocollo, Boolean.parseBoolean(value));
  25743.                 }else{
  25744.                     // dovrebbe venire chiamato solo per ModI
  25745.                     if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo)) {
  25746.                         this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25747.                     }
  25748.                     this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientId.put(protocollo, true);
  25749.                 }

  25751.             }catch(java.lang.Exception e) {
  25752.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25753.                 this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientId.put(protocollo, true);
  25754.             }
  25755.         }

  25757.         return this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientId.get(protocollo);
  25758.     }
  25759.     
  25760.     private Map<String,Boolean> isGestioneRetrieveTokenPdndDatiRichiestaForceClientIdMapSoggetto = new HashMap<>();
  25761.     public boolean isGestioneRetrieveTokenPdndDatiRichiestaForceClientId(String protocollo, String soggettoFruitore){

  25763.         if(soggettoFruitore==null) {
  25764.             return isGestioneRetrieveTokenPdndDatiRichiestaForceClientId(protocollo);
  25765.         }
  25766.         
  25767.         String key = protocollo+"_"+soggettoFruitore;
  25768.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+"."+soggettoFruitore+".pdnd.datiRichiesta.forceClientId";
  25769.         if(!this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientIdMapSoggetto.containsKey(key)){
  25770.             try{  
  25771.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25773.                 if (value != null){
  25774.                     value = value.trim();
  25775.                     this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientIdMapSoggetto.put(key, Boolean.parseBoolean(value));
  25776.                 }else{
  25777.                     return isGestioneRetrieveTokenPdndDatiRichiestaForceClientId(protocollo);
  25778.                 }

  25780.             }catch(java.lang.Exception e) {
  25781.                 this.logError("isGestioneRetrieveTokenPdndDatiRichiestaForceClientId failed: "+e.getMessage(), e);
  25782.                 return isGestioneRetrieveTokenPdndDatiRichiestaForceClientId(protocollo);
  25783.             }
  25784.         }

  25786.         return this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientIdMapSoggetto.get(key);
  25787.     }
  25788.     
  25789.     
  25790.     
  25791.     
  25792.     /* ------------- Gestione Attribute Authority ---------------------*/
  25793.     
  25794.     private Boolean isGestioneAttributeAuthorityDebug = null;
  25795.     public boolean isGestioneAttributeAuthorityDebug(){

  25797.         String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.debug";
  25798.         if(this.isGestioneAttributeAuthorityDebug==null){
  25799.             try{  
  25800.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25802.                 if (value != null){
  25803.                     value = value.trim();
  25804.                     this.isGestioneAttributeAuthorityDebug = Boolean.parseBoolean(value);
  25805.                 }else{
  25806.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25807.                     this.isGestioneAttributeAuthorityDebug = false;
  25808.                 }

  25810.             }catch(java.lang.Exception e) {
  25811.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25812.                 this.isGestioneAttributeAuthorityDebug = false;
  25813.             }
  25814.         }

  25816.         return this.isGestioneAttributeAuthorityDebug;
  25817.     }
  25818.     
  25819.     private Boolean getGestioneAttributeAuthorityLockPermitsRead = null;
  25820.     private Integer getGestioneAttributeAuthorityLockPermits = null;
  25821.     public Integer getGestioneAttributeAuthorityLockPermits() {

  25823.         String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.lock.permits";
  25824.         if(this.getGestioneAttributeAuthorityLockPermitsRead==null){
  25825.             try{  
  25826.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25828.                 if (value != null){
  25829.                     value = value.trim();
  25830.                     int permits = Integer.parseInt(value); 
  25831.                     if(permits>1) {
  25832.                         // altrimenti è un normale semaphore binario
  25833.                         this.getGestioneAttributeAuthorityLockPermits = permits;
  25834.                     }
  25835.                 }
  25836.                 
  25837.                 
  25838.             }catch(java.lang.Exception e) {
  25839.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  25840.             }
  25841.             
  25842.             this.getGestioneAttributeAuthorityLockPermitsRead = true;
  25843.         }

  25845.         return this.getGestioneAttributeAuthorityLockPermits;
  25846.     }
  25847.     
  25848.     private Boolean isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo = null;
  25849.     public boolean isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo(){

  25851.         String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.saveSourceAttributeResponseInfo";
  25852.         if(this.isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo==null){
  25853.             try{  
  25854.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25856.                 if (value != null){
  25857.                     value = value.trim();
  25858.                     this.isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo = Boolean.parseBoolean(value);
  25859.                 }else{
  25860.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25861.                     this.isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo = false;
  25862.                 }

  25864.             }catch(java.lang.Exception e) {
  25865.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25866.                 this.isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo = false;
  25867.             }
  25868.         }

  25870.         return this.isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo;
  25871.     }
  25872.     
  25873.     private Boolean isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate = null;
  25874.     public boolean isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate(){

  25876.         String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.transazioniRegistrazioneAttributiInformazioniNormalizzate";
  25877.         if(this.isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate==null){
  25878.             try{  
  25879.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25881.                 if (value != null){
  25882.                     value = value.trim();
  25883.                     this.isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate = Boolean.parseBoolean(value);
  25884.                 }else{
  25885.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25886.                     this.isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate = false;
  25887.                 }

  25889.             }catch(java.lang.Exception e) {
  25890.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25891.                 this.isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate = false;
  25892.             }
  25893.         }

  25895.         return this.isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate;
  25896.     }
  25897.     
  25898.     private CertificateValidityCheck getGestioneAttributeAuthorityValidityCheck = null;
  25899.     public CertificateValidityCheck getGestioneAttributeAuthorityValidityCheck(){

  25901.         String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.validityCheck";
  25902.         if(this.getGestioneAttributeAuthorityValidityCheck==null){
  25903.             try{  
  25904.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25906.                 if (value != null){
  25907.                     value = value.trim();
  25908.                     this.getGestioneAttributeAuthorityValidityCheck = CertificateValidityCheck.parseCertificateValidityCheck(value);
  25909.                     if(this.getGestioneAttributeAuthorityValidityCheck==null) {
  25910.                         throw new CoreException("Opzione '"+value+"' sconosciuta");
  25911.                     }
  25912.                 }else{
  25913.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25914.                     this.getGestioneAttributeAuthorityValidityCheck = CertificateValidityCheck.ENABLED;
  25915.                 }

  25917.             }catch(java.lang.Exception e) {
  25918.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25919.                 this.getGestioneAttributeAuthorityValidityCheck = CertificateValidityCheck.ENABLED;
  25920.             }
  25921.         }

  25923.         return this.getGestioneAttributeAuthorityValidityCheck;
  25924.     }
  25925.     
  25926.     
  25927.     
  25928.     
  25929.     
  25930.     
  25931.     /* ------------- JMX Statistiche ---------------------*/
  25932.     
  25933.     private Boolean isStatisticheViaJmx = null;
  25934.     public boolean isStatisticheViaJmx(){

  25936.         if(this.isStatisticheViaJmx==null){
  25937.             try{  
  25938.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.jmx.statistiche"); 

  25940.                 if (value != null){
  25941.                     value = value.trim();
  25942.                     this.isStatisticheViaJmx = Boolean.parseBoolean(value);
  25943.                 }else{
  25944.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jmx.statistiche' non impostata, viene utilizzato il default=false");
  25945.                     this.isStatisticheViaJmx = false;
  25946.                 }

  25948.             }catch(java.lang.Exception e) {
  25949.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jmx.statistiche' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  25950.                 this.isStatisticheViaJmx = false;
  25951.             }
  25952.         }

  25954.         return this.isStatisticheViaJmx;
  25955.     }
  25956.     
  25957.     
  25958.     
  25959.     /* ------------- REST / SOAP Trasporto Utils ---------------------*/
  25960.     
  25961.     private void _list_add(List<MapKey<String>> tmp, List<MapKey<String>> addList) {
  25962.         if(tmp!=null && tmp.size()>0) {
  25963.             for (MapKey<String> hdr : tmp) {
  25964.                 if(addList.contains(hdr)==false) {
  25965.                     addList.add(hdr);
  25966.                 }
  25967.             }
  25968.         }
  25969.     }
  25970.     
  25971.     /* ------------- Forward Proxy ---------------------*/
  25972.     
  25973.     private Boolean isForwardProxyEnable = null;
  25974.     public boolean isForwardProxyEnable(){

  25976.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.enable";
  25977.         if(this.isForwardProxyEnable==null){
  25978.             try{  
  25979.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25981.                 if (value != null){
  25982.                     value = value.trim();
  25983.                     this.isForwardProxyEnable = Boolean.parseBoolean(value);
  25984.                 }else{
  25985.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25986.                     this.isForwardProxyEnable = false;
  25987.                 }

  25989.             }catch(java.lang.Exception e) {
  25990.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25991.                 this.isForwardProxyEnable = false;
  25992.             }
  25993.         }

  25995.         return this.isForwardProxyEnable;
  25996.     }
  25997.     
  25998.     
  25999.     private Boolean isForwardProxyHeaderEnable = null;
  26000.     private boolean isForwardProxyHeaderEnable(){

  26002.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.header.enable";
  26003.         if(this.isForwardProxyHeaderEnable==null){
  26004.             try{  
  26005.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26007.                 if (value != null){
  26008.                     value = value.trim();
  26009.                     this.isForwardProxyHeaderEnable = Boolean.parseBoolean(value);
  26010.                 }else{
  26011.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  26012.                     this.isForwardProxyHeaderEnable = false;
  26013.                 }

  26015.             }catch(java.lang.Exception e) {
  26016.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  26017.                 this.isForwardProxyHeaderEnable = false;
  26018.             }
  26019.         }

  26021.         return this.isForwardProxyHeaderEnable;
  26022.     }
  26023.     
  26024.     private String getForwardProxyHeaderName = null;
  26025.     private String getForwardProxyHeaderName(){

  26027.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.header.nome";
  26028.         if(this.getForwardProxyHeaderName==null){
  26029.             try{  
  26030.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26032.                 if (value != null){
  26033.                     value = value.trim();
  26034.                     this.getForwardProxyHeaderName = value;
  26035.                 }else{
  26036.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER));
  26037.                     this.getForwardProxyHeaderName = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER;
  26038.                 }

  26040.             }catch(java.lang.Exception e) {
  26041.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER),e);
  26042.                 this.getForwardProxyHeaderName = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER;
  26043.             }
  26044.         }

  26046.         return this.getForwardProxyHeaderName;
  26047.     }
  26048.     
  26049.     private Boolean isForwardProxyHeaderBase64 = null;
  26050.     private boolean isForwardProxyHeaderBase64(){

  26052.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.header.base64";
  26053.         if(this.isForwardProxyHeaderBase64==null){
  26054.             try{  
  26055.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26057.                 if (value != null){
  26058.                     value = value.trim();
  26059.                     this.isForwardProxyHeaderBase64 = Boolean.parseBoolean(value);
  26060.                 }else{
  26061.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64));
  26062.                     this.isForwardProxyHeaderBase64 = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64;
  26063.                 }

  26065.             }catch(java.lang.Exception e) {
  26066.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64),e);
  26067.                 this.isForwardProxyHeaderBase64 = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64;
  26068.             }
  26069.         }

  26071.         return this.isForwardProxyHeaderBase64;
  26072.     }
  26073.     
  26074.     
  26075.     private Boolean isForwardProxyQueryParameterEnable = null;
  26076.     private boolean isForwardProxyQueryParameterEnable(){

  26078.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.urlParameter.enable";
  26079.         if(this.isForwardProxyQueryParameterEnable==null){
  26080.             try{  
  26081.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26083.                 if (value != null){
  26084.                     value = value.trim();
  26085.                     this.isForwardProxyQueryParameterEnable = Boolean.parseBoolean(value);
  26086.                 }else{
  26087.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  26088.                     this.isForwardProxyQueryParameterEnable = false;
  26089.                 }

  26091.             }catch(java.lang.Exception e) {
  26092.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  26093.                 this.isForwardProxyQueryParameterEnable = false;
  26094.             }
  26095.         }

  26097.         return this.isForwardProxyQueryParameterEnable;
  26098.     }
  26099.     
  26100.     private String getForwardProxyQueryParameterName = null;
  26101.     private String getForwardProxyQueryParameterName(){

  26103.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.urlParameter.nome";
  26104.         if(this.getForwardProxyQueryParameterName==null){
  26105.             try{  
  26106.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26108.                 if (value != null){
  26109.                     value = value.trim();
  26110.                     this.getForwardProxyQueryParameterName = value;
  26111.                 }else{
  26112.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER));
  26113.                     this.getForwardProxyQueryParameterName = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER;
  26114.                 }

  26116.             }catch(java.lang.Exception e) {
  26117.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER),e);
  26118.                 this.getForwardProxyQueryParameterName = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER;
  26119.             }
  26120.         }

  26122.         return this.getForwardProxyQueryParameterName;
  26123.     }
  26124.     
  26125.     private Boolean isForwardProxyQueryParameterBase64 = null;
  26126.     private boolean isForwardProxyQueryParameterBase64(){

  26128.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.urlParameter.base64";
  26129.         if(this.isForwardProxyQueryParameterBase64==null){
  26130.             try{  
  26131.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26133.                 if (value != null){
  26134.                     value = value.trim();
  26135.                     this.isForwardProxyQueryParameterBase64 = Boolean.parseBoolean(value);
  26136.                 }else{
  26137.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64));
  26138.                     this.isForwardProxyQueryParameterBase64 = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64;
  26139.                 }

  26141.             }catch(java.lang.Exception e) {
  26142.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64),e);
  26143.                 this.isForwardProxyQueryParameterBase64 = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64;
  26144.             }
  26145.         }

  26147.         return this.isForwardProxyQueryParameterBase64;
  26148.     }
  26149.     
  26150.     private Boolean isForwardProxyTokenDynamicDiscoveryEnabled = null;
  26151.     private boolean isForwardProxyTokenDynamicDiscoveryEnabled(){

  26153.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenDynamicDiscovery.enable";
  26154.         if(this.isForwardProxyTokenDynamicDiscoveryEnabled==null){
  26155.             try{  
  26156.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26158.                 if (value != null){
  26159.                     value = value.trim();
  26160.                     this.isForwardProxyTokenDynamicDiscoveryEnabled = Boolean.parseBoolean(value);
  26161.                 }else{
  26162.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_DYNAMIC_DISCOVERY));
  26163.                     this.isForwardProxyTokenDynamicDiscoveryEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_DYNAMIC_DISCOVERY;
  26164.                 }

  26166.             }catch(java.lang.Exception e) {
  26167.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_DYNAMIC_DISCOVERY),e);
  26168.                 this.isForwardProxyTokenDynamicDiscoveryEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_DYNAMIC_DISCOVERY;
  26169.             }
  26170.         }

  26172.         return this.isForwardProxyTokenDynamicDiscoveryEnabled;
  26173.     }
  26174.     
  26175.     private Boolean isForwardProxyTokenValidazioneJwtEnabled = null;
  26176.     private boolean isForwardProxyTokenValidazioneJwtEnabled(){

  26178.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenJwtValidation.enable";
  26179.         if(this.isForwardProxyTokenValidazioneJwtEnabled==null){
  26180.             try{  
  26181.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26183.                 if (value != null){
  26184.                     value = value.trim();
  26185.                     this.isForwardProxyTokenValidazioneJwtEnabled = Boolean.parseBoolean(value);
  26186.                 }else{
  26187.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_VALIDAZIONE_JWT));
  26188.                     this.isForwardProxyTokenValidazioneJwtEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_VALIDAZIONE_JWT;
  26189.                 }

  26191.             }catch(java.lang.Exception e) {
  26192.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_VALIDAZIONE_JWT),e);
  26193.                 this.isForwardProxyTokenValidazioneJwtEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_VALIDAZIONE_JWT;
  26194.             }
  26195.         }

  26197.         return this.isForwardProxyTokenValidazioneJwtEnabled;
  26198.     }
  26199.     
  26200.     private Boolean isForwardProxyTokenIntrospectionEnabled = null;
  26201.     private boolean isForwardProxyTokenIntrospectionEnabled(){

  26203.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenIntrospection.enable";
  26204.         if(this.isForwardProxyTokenIntrospectionEnabled==null){
  26205.             try{  
  26206.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26208.                 if (value != null){
  26209.                     value = value.trim();
  26210.                     this.isForwardProxyTokenIntrospectionEnabled = Boolean.parseBoolean(value);
  26211.                 }else{
  26212.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_INTROSPECTION));
  26213.                     this.isForwardProxyTokenIntrospectionEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_INTROSPECTION;
  26214.                 }

  26216.             }catch(java.lang.Exception e) {
  26217.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_INTROSPECTION),e);
  26218.                 this.isForwardProxyTokenIntrospectionEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_INTROSPECTION;
  26219.             }
  26220.         }

  26222.         return this.isForwardProxyTokenIntrospectionEnabled;
  26223.     }
  26224.     
  26225.     private Boolean isForwardProxyTokenUserInfoEnabled = null;
  26226.     private boolean isForwardProxyTokenUserInfoEnabled(){

  26228.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenUserInfo.enable";
  26229.         if(this.isForwardProxyTokenUserInfoEnabled==null){
  26230.             try{  
  26231.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26233.                 if (value != null){
  26234.                     value = value.trim();
  26235.                     this.isForwardProxyTokenUserInfoEnabled = Boolean.parseBoolean(value);
  26236.                 }else{
  26237.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_USERINFO));
  26238.                     this.isForwardProxyTokenUserInfoEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_USERINFO;
  26239.                 }

  26241.             }catch(java.lang.Exception e) {
  26242.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_USERINFO),e);
  26243.                 this.isForwardProxyTokenUserInfoEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_USERINFO;
  26244.             }
  26245.         }

  26247.         return this.isForwardProxyTokenUserInfoEnabled;
  26248.     }
  26249.     
  26250.     private Boolean isForwardProxyTokenRetrieveEnabled = null;
  26251.     private boolean isForwardProxyTokenRetrieveEnabled(){

  26253.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenRetrieve.enable";
  26254.         if(this.isForwardProxyTokenRetrieveEnabled==null){
  26255.             try{  
  26256.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26258.                 if (value != null){
  26259.                     value = value.trim();
  26260.                     this.isForwardProxyTokenRetrieveEnabled = Boolean.parseBoolean(value);
  26261.                 }else{
  26262.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_RETRIEVE));
  26263.                     this.isForwardProxyTokenRetrieveEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_RETRIEVE;
  26264.                 }

  26266.             }catch(java.lang.Exception e) {
  26267.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_RETRIEVE),e);
  26268.                 this.isForwardProxyTokenRetrieveEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_RETRIEVE;
  26269.             }
  26270.         }

  26272.         return this.isForwardProxyTokenRetrieveEnabled;
  26273.     }
  26274.     
  26275.     private Boolean isForwardProxyAttributeAuthorityEnabled = null;
  26276.     private boolean isForwardProxyAttributeAuthorityEnabled(){

  26278.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.attributeAuthority.enable";
  26279.         if(this.isForwardProxyAttributeAuthorityEnabled==null){
  26280.             try{  
  26281.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26283.                 if (value != null){
  26284.                     value = value.trim();
  26285.                     this.isForwardProxyAttributeAuthorityEnabled = Boolean.parseBoolean(value);
  26286.                 }else{
  26287.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY));
  26288.                     this.isForwardProxyAttributeAuthorityEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY;
  26289.                 }

  26291.             }catch(java.lang.Exception e) {
  26292.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY),e);
  26293.                 this.isForwardProxyAttributeAuthorityEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY;
  26294.             }
  26295.         }

  26297.         return this.isForwardProxyAttributeAuthorityEnabled;
  26298.     }
  26299.     
  26300.     private Boolean isForwardProxyAttributeAuthorityResponseJwtValidationEnabled = null;
  26301.     private boolean isForwardProxyAttributeAuthorityResponseJwtValidationEnabled(){

  26303.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.attributeAuthority.responseJwtValidation.enable";
  26304.         if(this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled==null){
  26305.             try{  
  26306.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26308.                 if (value != null){
  26309.                     value = value.trim();
  26310.                     this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled = Boolean.parseBoolean(value);
  26311.                 }else{
  26312.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY_RESPONSE_JWT_VALIDATION));
  26313.                     this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY_RESPONSE_JWT_VALIDATION;
  26314.                 }

  26316.             }catch(java.lang.Exception e) {
  26317.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY_RESPONSE_JWT_VALIDATION),e);
  26318.                 this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY_RESPONSE_JWT_VALIDATION;
  26319.             }
  26320.         }

  26322.         return this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled;
  26323.     }
  26324.     
  26325.     public ForwardProxyConfigurazione getForwardProxyConfigurazioneDefault() {
  26326.         ForwardProxyConfigurazione config = new ForwardProxyConfigurazione();
  26327.         if(this.isForwardProxyHeaderEnable()) {
  26328.             config.setHeader(this.getForwardProxyHeaderName());
  26329.             config.setHeaderBase64(this.isForwardProxyHeaderBase64());
  26330.         }
  26331.         if(this.isForwardProxyQueryParameterEnable()) {
  26332.             config.setQuery(this.getForwardProxyQueryParameterName());
  26333.             config.setQueryBase64(this.isForwardProxyQueryParameterBase64());
  26334.         }
  26335.         return config;
  26336.     }
  26337.     
  26338.     public ForwardProxyConfigurazioneToken getForwardProxyConfigurazioneTokenDefault() {
  26339.         ForwardProxyConfigurazioneToken config = new ForwardProxyConfigurazioneToken();
  26340.         config.setTokenDynamicDiscoveryEnabled(this.isForwardProxyTokenDynamicDiscoveryEnabled());
  26341.         config.setTokenJwtValidationEnabled(this.isForwardProxyTokenValidazioneJwtEnabled());
  26342.         config.setTokenIntrospectionEnabled(this.isForwardProxyTokenIntrospectionEnabled());
  26343.         config.setTokenUserInfoEnabled(this.isForwardProxyTokenUserInfoEnabled());
  26344.         config.setTokenRetrieveEnabled(this.isForwardProxyTokenRetrieveEnabled());
  26345.         config.setAttributeAuthorityEnabled(this.isForwardProxyAttributeAuthorityEnabled());
  26346.         config.setAttributeAuthorityResponseJwtValidationEnabled(this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled());
  26347.         return config;
  26348.     }

  26350.     
  26351.     
  26352.     
  26353.     
  26354.     
  26355.     
  26356.     /* ------------- Trasformazioni ---------------------*/
  26357.     
  26358.     private Boolean isTrasformazioni_readCharsetFromContentType = null;
  26359.     public boolean isTrasformazioni_readCharsetFromContentType(){

  26361.         String pName = "org.openspcoop2.pdd.trasformazioni.readCharsetFromContentType.enable";
  26362.         if(this.isTrasformazioni_readCharsetFromContentType==null){
  26363.             try{  
  26364.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26366.                 if (value != null){
  26367.                     value = value.trim();
  26368.                     this.isTrasformazioni_readCharsetFromContentType = Boolean.parseBoolean(value);
  26369.                 }else{
  26370.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  26371.                     this.isTrasformazioni_readCharsetFromContentType = false;
  26372.                 }

  26374.             }catch(java.lang.Exception e) {
  26375.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  26376.                 this.isTrasformazioni_readCharsetFromContentType = false;
  26377.             }
  26378.         }

  26380.         return this.isTrasformazioni_readCharsetFromContentType;
  26381.     }
  26382.     
  26383.     private Map<String, String> getTrasformazioni_backwardCompatibility = null;
  26384.     private Boolean getTrasformazioni_backwardCompatibility_read = null;
  26385.     public Map<String, String> getTrasformazioni_backwardCompatibility(){

  26387.         String pName = "org.openspcoop2.pdd.trasformazioni.backwardCompatibility.";
  26388.         if(this.getTrasformazioni_backwardCompatibility_read==null){
  26389.             try{  
  26390.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);

  26392.                 if (p != null && !p.isEmpty()){
  26393.                     Enumeration<?> keys = p.keys();
  26394.                     if(keys!=null) {
  26395.                         while (keys.hasMoreElements()) {
  26396.                             Object object = (Object) keys.nextElement();
  26397.                             if(object!=null && object instanceof String) {
  26398.                                 String key = (String) object;
  26399.                                 String value = p.getProperty(key);
  26400.                                 if(value!=null) {
  26401.                                     key = key.trim();
  26402.                                     value = value.trim();
  26403.                                     if(StringUtils.isNotEmpty(key) && StringUtils.isNotEmpty(value)) {
  26404.                                         if(this.getTrasformazioni_backwardCompatibility==null) {
  26405.                                             this.getTrasformazioni_backwardCompatibility=new HashMap<>();
  26406.                                         }
  26407.                                         this.getTrasformazioni_backwardCompatibility.put(key, value); // old, new
  26408.                                     }
  26409.                                 }
  26410.                             }
  26411.                         }
  26412.                     }
  26413.                 }

  26415.             }catch(java.lang.Exception e) {
  26416.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  26417.                 this.isTrasformazioni_readCharsetFromContentType = false;
  26418.             }
  26419.             
  26420.             this.getTrasformazioni_backwardCompatibility_read = true;
  26421.         }

  26423.         return this.getTrasformazioni_backwardCompatibility;
  26424.     }
  26425.     
  26426.     
  26427.     
  26428.     
  26429.     
  26430.     
  26431.     /* ------------- SOAP (Trasporto - URLParameters) ---------------------*/
  26432.     
  26433.     private Boolean isSOAPServicesUrlParametersForward = null;
  26434.     private boolean isSOAPServicesUrlParametersForward(){

  26436.         if(this.isSOAPServicesUrlParametersForward==null){
  26437.             try{  
  26438.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.urlParameters.forward.enable"); 

  26440.                 if (value != null){
  26441.                     value = value.trim();
  26442.                     this.isSOAPServicesUrlParametersForward = Boolean.parseBoolean(value);
  26443.                 }else{
  26444.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.forward.enable' non impostata, viene utilizzato il default=true");
  26445.                     this.isSOAPServicesUrlParametersForward = true;
  26446.                 }

  26448.             }catch(java.lang.Exception e) {
  26449.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.forward.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  26450.                 this.isSOAPServicesUrlParametersForward = true;
  26451.             }
  26452.         }

  26454.         return this.isSOAPServicesUrlParametersForward;
  26455.     }
  26456.     
  26457.     private Boolean getSOAPServicesBlackListInternalUrlParametersRead = null;
  26458.     private List<MapKey<String>> getSOAPServicesBlackListInternalUrlParametersList = null;
  26459.     private List<MapKey<String>> getSOAPServicesBlackListInternalUrlParameters() {  
  26460.         if(this.getSOAPServicesBlackListInternalUrlParametersRead==null){
  26461.             try{ 
  26462.                 this.getSOAPServicesBlackListInternalUrlParametersList = new ArrayList<>();
  26463.                 String name = null;
  26464.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.urlParameters.blackList.internal");
  26465.                 if(name!=null){
  26466.                     name = name.trim();
  26467.                     String [] split = name.split(",");
  26468.                     if(split!=null){
  26469.                         for (int i = 0; i < split.length; i++) {
  26470.                             this.getSOAPServicesBlackListInternalUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26471.                         }
  26472.                     }
  26473.                 }
  26474.                 this.getSOAPServicesBlackListInternalUrlParametersRead = true;
  26475.             } catch(java.lang.Exception e) {
  26476.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.blackList.internal': "+e.getMessage(),e);
  26477.             }    
  26478.         }
  26479.         
  26480.         return this.getSOAPServicesBlackListInternalUrlParametersList;
  26481.     }
  26482.     
  26483.     private Boolean getSOAPServicesBlackListUrlParametersRead = null;
  26484.     private List<MapKey<String>> getSOAPServicesBlackListUrlParametersList = null;
  26485.     private List<MapKey<String>> getSOAPServicesBlackListUrlParameters() {  
  26486.         if(this.getSOAPServicesBlackListUrlParametersRead==null){
  26487.             try{ 
  26488.                 this.getSOAPServicesBlackListUrlParametersList = new ArrayList<>();
  26489.                 String name = null;
  26490.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.urlParameters.blackList");
  26491.                 if(name!=null){
  26492.                     name = name.trim();
  26493.                     String [] split = name.split(",");
  26494.                     if(split!=null){
  26495.                         for (int i = 0; i < split.length; i++) {
  26496.                             this.getSOAPServicesBlackListUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26497.                         }
  26498.                     }
  26499.                 }
  26500.                 this.getSOAPServicesBlackListUrlParametersRead = true;
  26501.             } catch(java.lang.Exception e) {
  26502.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.blackList': "+e.getMessage(),e);
  26503.             }    
  26504.         }
  26505.         
  26506.         return this.getSOAPServicesBlackListUrlParametersList;
  26507.     }
  26508.     
  26509.     private Boolean getSOAPServicesWhiteListUrlParametersRead = null;
  26510.     private List<MapKey<String>> getSOAPServicesWhiteListUrlParametersList = null;
  26511.     private List<MapKey<String>> getSOAPServicesWhiteListUrlParameters() {  
  26512.         if(this.getSOAPServicesWhiteListUrlParametersRead==null){
  26513.             try{ 
  26514.                 this.getSOAPServicesWhiteListUrlParametersList = new ArrayList<>();
  26515.                 String name = null;
  26516.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.urlParameters.whiteList");
  26517.                 if(name!=null){
  26518.                     name = name.trim();
  26519.                     String [] split = name.split(",");
  26520.                     if(split!=null){
  26521.                         for (int i = 0; i < split.length; i++) {
  26522.                             this.getSOAPServicesWhiteListUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26523.                         }
  26524.                     }
  26525.                 }
  26526.                 this.getSOAPServicesWhiteListUrlParametersRead = true;
  26527.             } catch(java.lang.Exception e) {
  26528.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.whiteList': "+e.getMessage(),e);
  26529.             }    
  26530.         }
  26531.         
  26532.         return this.getSOAPServicesWhiteListUrlParametersList;
  26533.     }
  26534.     
  26535.     private List<String> _getSOAPServicesBlackListUrlParameters() { 
  26536.         
  26537.         List<MapKey<String>> blackList = new ArrayList<>();
  26538.         List<MapKey<String>> tmp = this.getSOAPServicesBlackListInternalUrlParameters();
  26539.         this._list_add(tmp, blackList);
  26540.         tmp = this.getSOAPServicesBlackListUrlParameters();
  26541.         this._list_add(tmp, blackList);
  26542.         
  26543.         List<String> l = new ArrayList<>();
  26544.         if(!blackList.isEmpty()) {
  26545.             for (MapKey<String> key : blackList) {
  26546.                 l.add(key.getValue());
  26547.             }
  26548.         }
  26549.         return l;
  26550.     }
  26551.     private List<String> _getSOAPServicesWhiteListUrlParameters() { 
  26552.         
  26553.         List<MapKey<String>> whiteList = new ArrayList<>();
  26554.         List<MapKey<String>> tmp = this.getSOAPServicesWhiteListUrlParameters();
  26555.         this._list_add(tmp, whiteList);
  26556.         
  26557.         List<String> l = new ArrayList<>();
  26558.         if(!whiteList.isEmpty()) {
  26559.             for (MapKey<String> key : whiteList) {
  26560.                 l.add(key.getValue());
  26561.             }
  26562.         }
  26563.         return l;
  26564.     }
  26565.     public ForwardConfig getSOAPServicesUrlParametersForwardConfig() {
  26566.         ForwardConfig f = new ForwardConfig();
  26567.         f.setForwardEnable(this.isSOAPServicesUrlParametersForward());
  26568.         f.setBlackList(_getSOAPServicesBlackListUrlParameters());
  26569.         f.setWhiteList(_getSOAPServicesWhiteListUrlParameters());
  26570.         return f;
  26571.     }
  26572.     
  26573.     
  26574.     
  26575.     
  26576.     /* ------------- SOAP (Trasporto - Headers) ---------------------*/
  26577.     
  26578.     private Boolean isSOAPServicesHeadersForward = null;
  26579.     private boolean isSOAPServicesHeadersForward(){

  26581.         if(this.isSOAPServicesHeadersForward==null){
  26582.             try{  
  26583.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.forward.enable"); 

  26585.                 if (value != null){
  26586.                     value = value.trim();
  26587.                     this.isSOAPServicesHeadersForward = Boolean.parseBoolean(value);
  26588.                 }else{
  26589.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.forward.enable' non impostata, viene utilizzato il default=true");
  26590.                     this.isSOAPServicesHeadersForward = true;
  26591.                 }

  26593.             }catch(java.lang.Exception e) {
  26594.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.forward.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  26595.                 this.isSOAPServicesHeadersForward = true;
  26596.             }
  26597.         }

  26599.         return this.isSOAPServicesHeadersForward;
  26600.     }
  26601.     
  26602.     private Boolean getSOAPServicesBlackListBothInternalHeadersRead = null;
  26603.     private List<MapKey<String>> getSOAPServicesBlackListBothInternalHeadersList = null;
  26604.     private List<MapKey<String>> getSOAPServicesBlackListBothInternalHeaders() {    
  26605.         if(this.getSOAPServicesBlackListBothInternalHeadersRead==null){
  26606.             try{ 
  26607.                 this.getSOAPServicesBlackListBothInternalHeadersList = new ArrayList<>();
  26608.                 String name = null;
  26609.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.internal.both");
  26610.                 if(name!=null){
  26611.                     name = name.trim();
  26612.                     String [] split = name.split(",");
  26613.                     if(split!=null){
  26614.                         for (int i = 0; i < split.length; i++) {
  26615.                             this.getSOAPServicesBlackListBothInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26616.                         }
  26617.                     }
  26618.                 }
  26619.                 this.getSOAPServicesBlackListBothInternalHeadersRead = true;
  26620.             } catch(java.lang.Exception e) {
  26621.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.internal.both': "+e.getMessage(),e);
  26622.             }    
  26623.         }
  26624.         
  26625.         return this.getSOAPServicesBlackListBothInternalHeadersList;
  26626.     }
  26627.     
  26628.     private Boolean getSOAPServicesBlackListRequestInternalHeadersRead = null;
  26629.     private List<MapKey<String>> getSOAPServicesBlackListRequestInternalHeadersList = null;
  26630.     private List<MapKey<String>> getSOAPServicesBlackListRequestInternalHeaders() { 
  26631.         if(this.getSOAPServicesBlackListRequestInternalHeadersRead==null){
  26632.             try{ 
  26633.                 this.getSOAPServicesBlackListRequestInternalHeadersList = new ArrayList<>();
  26634.                 String name = null;
  26635.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.internal.request");
  26636.                 if(name!=null){
  26637.                     name = name.trim();
  26638.                     String [] split = name.split(",");
  26639.                     if(split!=null){
  26640.                         for (int i = 0; i < split.length; i++) {
  26641.                             this.getSOAPServicesBlackListRequestInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26642.                         }
  26643.                     }
  26644.                 }
  26645.                 this.getSOAPServicesBlackListRequestInternalHeadersRead = true;
  26646.             } catch(java.lang.Exception e) {
  26647.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.internal.request': "+e.getMessage(),e);
  26648.             }    
  26649.         }
  26650.         
  26651.         return this.getSOAPServicesBlackListRequestInternalHeadersList;
  26652.     }
  26653.     
  26654.     private Boolean getSOAPServicesBlackListResponseInternalHeadersRead = null;
  26655.     private List<MapKey<String>> getSOAPServicesBlackListResponseInternalHeadersList = null;
  26656.     private List<MapKey<String>> getSOAPServicesBlackListResponseInternalHeaders() {    
  26657.         if(this.getSOAPServicesBlackListResponseInternalHeadersRead==null){
  26658.             try{ 
  26659.                 this.getSOAPServicesBlackListResponseInternalHeadersList = new ArrayList<>();
  26660.                 String name = null;
  26661.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.internal.response");
  26662.                 if(name!=null){
  26663.                     name = name.trim();
  26664.                     String [] split = name.split(",");
  26665.                     if(split!=null){
  26666.                         for (int i = 0; i < split.length; i++) {
  26667.                             this.getSOAPServicesBlackListResponseInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26668.                         }
  26669.                     }
  26670.                 }
  26671.                 this.getSOAPServicesBlackListResponseInternalHeadersRead = true;
  26672.             } catch(java.lang.Exception e) {
  26673.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.internal.response': "+e.getMessage(),e);
  26674.             }    
  26675.         }
  26676.         
  26677.         return this.getSOAPServicesBlackListResponseInternalHeadersList;
  26678.     }
  26679.     
  26680.     private Boolean getSOAPServicesBlackListBothHeadersRead = null;
  26681.     private List<MapKey<String>> getSOAPServicesBlackListBothHeadersList = null;
  26682.     private List<MapKey<String>> getSOAPServicesBlackListBothHeaders() {    
  26683.         if(this.getSOAPServicesBlackListBothHeadersRead==null){
  26684.             try{ 
  26685.                 this.getSOAPServicesBlackListBothHeadersList = new ArrayList<>();
  26686.                 String name = null;
  26687.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.both");
  26688.                 if(name!=null){
  26689.                     name = name.trim();
  26690.                     String [] split = name.split(",");
  26691.                     if(split!=null){
  26692.                         for (int i = 0; i < split.length; i++) {
  26693.                             this.getSOAPServicesBlackListBothHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26694.                         }
  26695.                     }
  26696.                 }
  26697.                 this.getSOAPServicesBlackListBothHeadersRead = true;
  26698.             } catch(java.lang.Exception e) {
  26699.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.both': "+e.getMessage(),e);
  26700.             }    
  26701.         }
  26702.         
  26703.         return this.getSOAPServicesBlackListBothHeadersList;
  26704.     }
  26705.     
  26706.     private Boolean getSOAPServicesBlackListRequestHeadersRead = null;
  26707.     private List<MapKey<String>> getSOAPServicesBlackListRequestHeadersList = null;
  26708.     private List<MapKey<String>> getSOAPServicesBlackListRequestHeaders() { 
  26709.         if(this.getSOAPServicesBlackListRequestHeadersRead==null){
  26710.             try{ 
  26711.                 this.getSOAPServicesBlackListRequestHeadersList = new ArrayList<>();
  26712.                 String name = null;
  26713.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.request");
  26714.                 if(name!=null){
  26715.                     name = name.trim();
  26716.                     String [] split = name.split(",");
  26717.                     if(split!=null){
  26718.                         for (int i = 0; i < split.length; i++) {
  26719.                             this.getSOAPServicesBlackListRequestHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26720.                         }
  26721.                     }
  26722.                 }
  26723.                 this.getSOAPServicesBlackListRequestHeadersRead = true;
  26724.             } catch(java.lang.Exception e) {
  26725.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.request': "+e.getMessage(),e);
  26726.             }    
  26727.         }
  26728.         
  26729.         return this.getSOAPServicesBlackListRequestHeadersList;
  26730.     }
  26731.     
  26732.     private Boolean getSOAPServicesBlackListResponseHeadersRead = null;
  26733.     private List<MapKey<String>> getSOAPServicesBlackListResponseHeadersList = null;
  26734.     private List<MapKey<String>> getSOAPServicesBlackListResponseHeaders() {    
  26735.         if(this.getSOAPServicesBlackListResponseHeadersRead==null){
  26736.             try{ 
  26737.                 this.getSOAPServicesBlackListResponseHeadersList = new ArrayList<>();
  26738.                 String name = null;
  26739.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.response");
  26740.                 if(name!=null){
  26741.                     name = name.trim();
  26742.                     String [] split = name.split(",");
  26743.                     if(split!=null){
  26744.                         for (int i = 0; i < split.length; i++) {
  26745.                             this.getSOAPServicesBlackListResponseHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26746.                         }
  26747.                     }
  26748.                 }
  26749.                 this.getSOAPServicesBlackListResponseHeadersRead = true;
  26750.             } catch(java.lang.Exception e) {
  26751.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.response': "+e.getMessage(),e);
  26752.             }    
  26753.         }
  26754.         
  26755.         return this.getSOAPServicesBlackListResponseHeadersList;
  26756.     }
  26757.     
  26758.     private Boolean getSOAPServicesWhiteListBothHeadersRead = null;
  26759.     private List<MapKey<String>> getSOAPServicesWhiteListBothHeadersList = null;
  26760.     private List<MapKey<String>> getSOAPServicesWhiteListBothHeaders() {    
  26761.         if(this.getSOAPServicesWhiteListBothHeadersRead==null){
  26762.             try{ 
  26763.                 this.getSOAPServicesWhiteListBothHeadersList = new ArrayList<>();
  26764.                 String name = null;
  26765.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.whiteList.both");
  26766.                 if(name!=null){
  26767.                     name = name.trim();
  26768.                     String [] split = name.split(",");
  26769.                     if(split!=null){
  26770.                         for (int i = 0; i < split.length; i++) {
  26771.                             this.getSOAPServicesWhiteListBothHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26772.                         }
  26773.                     }
  26774.                 }
  26775.                 this.getSOAPServicesWhiteListBothHeadersRead = true;
  26776.             } catch(java.lang.Exception e) {
  26777.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.whiteList.both': "+e.getMessage(),e);
  26778.             }    
  26779.         }
  26780.         
  26781.         return this.getSOAPServicesWhiteListBothHeadersList;
  26782.     }
  26783.     
  26784.     private Boolean getSOAPServicesWhiteListRequestHeadersRead = null;
  26785.     private List<MapKey<String>> getSOAPServicesWhiteListRequestHeadersList = null;
  26786.     private List<MapKey<String>> getSOAPServicesWhiteListRequestHeaders() { 
  26787.         if(this.getSOAPServicesWhiteListRequestHeadersRead==null){
  26788.             try{ 
  26789.                 this.getSOAPServicesWhiteListRequestHeadersList = new ArrayList<>();
  26790.                 String name = null;
  26791.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.whiteList.request");
  26792.                 if(name!=null){
  26793.                     name = name.trim();
  26794.                     String [] split = name.split(",");
  26795.                     if(split!=null){
  26796.                         for (int i = 0; i < split.length; i++) {
  26797.                             this.getSOAPServicesWhiteListRequestHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26798.                         }
  26799.                     }
  26800.                 }
  26801.                 this.getSOAPServicesWhiteListRequestHeadersRead = true;
  26802.             } catch(java.lang.Exception e) {
  26803.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.whiteList.request': "+e.getMessage(),e);
  26804.             }    
  26805.         }
  26806.         
  26807.         return this.getSOAPServicesWhiteListRequestHeadersList;
  26808.     }
  26809.     
  26810.     private Boolean getSOAPServicesWhiteListResponseHeadersRead = null;
  26811.     private List<MapKey<String>> getSOAPServicesWhiteListResponseHeadersList = null;
  26812.     private List<MapKey<String>> getSOAPServicesWhiteListResponseHeaders() {    
  26813.         if(this.getSOAPServicesWhiteListResponseHeadersRead==null){
  26814.             try{ 
  26815.                 this.getSOAPServicesWhiteListResponseHeadersList = new ArrayList<>();
  26816.                 String name = null;
  26817.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.whiteList.response");
  26818.                 if(name!=null){
  26819.                     name = name.trim();
  26820.                     String [] split = name.split(",");
  26821.                     if(split!=null){
  26822.                         for (int i = 0; i < split.length; i++) {
  26823.                             this.getSOAPServicesWhiteListResponseHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26824.                         }
  26825.                     }
  26826.                 }
  26827.                 this.getSOAPServicesWhiteListResponseHeadersRead = true;
  26828.             } catch(java.lang.Exception e) {
  26829.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.whiteList.response': "+e.getMessage(),e);
  26830.             }    
  26831.         }
  26832.         
  26833.         return this.getSOAPServicesWhiteListResponseHeadersList;
  26834.     }
  26835.     
  26836.     private List<String> getSOAPServicesBlackListHeaders(boolean request) { 
  26837.         
  26838.         List<MapKey<String>> blackList = new ArrayList<>();
  26839.         List<MapKey<String>> tmp = this.getSOAPServicesBlackListBothInternalHeaders();
  26840.         this._list_add(tmp, blackList);
  26841.         tmp = this.getSOAPServicesBlackListBothHeaders();
  26842.         this._list_add(tmp, blackList);
  26843.         
  26844.         if(request) {
  26845.             tmp = this.getSOAPServicesBlackListRequestInternalHeaders();
  26846.             this._list_add(tmp, blackList);
  26847.             tmp = this.getSOAPServicesBlackListRequestHeaders();
  26848.             this._list_add(tmp, blackList);
  26849.         }
  26850.         else {
  26851.             tmp = this.getSOAPServicesBlackListResponseInternalHeaders();
  26852.             this._list_add(tmp, blackList);
  26853.             tmp = this.getSOAPServicesBlackListResponseHeaders();
  26854.             this._list_add(tmp, blackList);
  26855.         }
  26856.         
  26857.         List<String> l = new ArrayList<>();
  26858.         if(!blackList.isEmpty()) {
  26859.             for (MapKey<String> key : blackList) {
  26860.                 l.add(key.getValue());
  26861.             }
  26862.         }
  26863.         return l;
  26864.     }
  26865.     private List<String> getSOAPServicesWhiteListHeaders(boolean request) { 
  26866.         
  26867.         List<MapKey<String>> whiteList = new ArrayList<>();
  26868.         List<MapKey<String>> tmp = this.getSOAPServicesWhiteListBothHeaders();
  26869.         this._list_add(tmp, whiteList);
  26870.         if(request) {
  26871.             tmp = this.getSOAPServicesWhiteListRequestHeaders();
  26872.             this._list_add(tmp, whiteList);
  26873.         }
  26874.         else {
  26875.             tmp = this.getSOAPServicesWhiteListResponseHeaders();
  26876.             this._list_add(tmp, whiteList);
  26877.         }
  26878.         
  26879.         List<String> l = new ArrayList<>();
  26880.         if(!whiteList.isEmpty()) {
  26881.             for (MapKey<String> key : whiteList) {
  26882.                 l.add(key.getValue());
  26883.             }
  26884.         }
  26885.         return l;
  26886.     }
  26887.     public ForwardConfig getSOAPServicesHeadersForwardConfig(boolean request) {
  26888.         ForwardConfig f = new ForwardConfig();
  26889.         f.setForwardEnable(this.isSOAPServicesHeadersForward());
  26890.         f.setBlackList(getSOAPServicesBlackListHeaders(request));
  26891.         f.setWhiteList(getSOAPServicesWhiteListHeaders(request));
  26892.         return f;
  26893.     }

  26895.     
  26896.     /* ------------- SOAP (Trasporto - Headers - Proxy Pass Reverse) ---------------------*/
  26897.     
  26898.     // Location
  26899.     
  26900.     private Boolean isSOAPServices_inoltroBuste_proxyPassReverse = null;
  26901.     public boolean isSOAPServices_inoltroBuste_proxyPassReverse() { 
  26902.         if(this.isSOAPServices_inoltroBuste_proxyPassReverse==null){
  26903.             try{ 
  26904.                 String name = null;
  26905.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse");
  26906.                 if(name==null){
  26907.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse' non impostata, viene utilizzato il default=false");
  26908.                     name="false";
  26909.                 }
  26910.                 name = name.trim();
  26911.                 this.isSOAPServices_inoltroBuste_proxyPassReverse = Boolean.parseBoolean(name);
  26912.             } catch(java.lang.Exception e) {
  26913.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse': "+e.getMessage(),e);
  26914.                 this.isSOAPServices_inoltroBuste_proxyPassReverse = false;
  26915.             }    
  26916.         }

  26918.         return this.isSOAPServices_inoltroBuste_proxyPassReverse;
  26919.     }
  26920.     
  26921.     private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse = null;
  26922.     public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse() { 
  26923.         if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse==null){
  26924.             try{ 
  26925.                 String name = null;
  26926.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse");
  26927.                 if(name==null){
  26928.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse' non impostata, viene utilizzato il default=false");
  26929.                     name="false";
  26930.                 }
  26931.                 name = name.trim();
  26932.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse = Boolean.parseBoolean(name);
  26933.             } catch(java.lang.Exception e) {
  26934.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse': "+e.getMessage(),e);
  26935.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse = false;
  26936.             }    
  26937.         }

  26939.         return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse;
  26940.     }
  26941.     
  26942.     private List<String> getSOAPServices_inoltroBuste_proxyPassReverse_headers = null;
  26943.     public List<String> getSOAPServices_inoltroBuste_proxyPassReverse_headers() throws CoreException {  
  26944.         if(this.getSOAPServices_inoltroBuste_proxyPassReverse_headers==null){
  26945.             try{ 
  26946.                 this.getSOAPServices_inoltroBuste_proxyPassReverse_headers = new ArrayList<>();
  26947.                 
  26948.                 String name = null;
  26949.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.headers");
  26950.                 if(name!=null){
  26951.                     name = name.trim();
  26952.                 }
  26953.                 if(name!=null && !"".equals(name)) {
  26954.                     if(name.contains(",")) {
  26955.                         String [] tmp = name.split(",");
  26956.                         for (int i = 0; i < tmp.length; i++) {
  26957.                             this.getSOAPServices_inoltroBuste_proxyPassReverse_headers.add(tmp[i].trim());
  26958.                         }
  26959.                     }
  26960.                     else {
  26961.                         this.getSOAPServices_inoltroBuste_proxyPassReverse_headers.add(name);
  26962.                     }
  26963.                 }
  26964.             } catch(java.lang.Exception e) {
  26965.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.headers': "+e.getMessage();
  26966.                 this.logError(error,e);
  26967.                 throw new CoreException(error);
  26968.             }    
  26969.         }

  26971.         return this.getSOAPServices_inoltroBuste_proxyPassReverse_headers;
  26972.     }
  26973.     
  26974.     private List<String> getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers = null;
  26975.     public List<String> getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers() throws CoreException {  
  26976.         if(this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers==null){
  26977.             try{ 
  26978.                 this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers = new ArrayList<>();
  26979.                 
  26980.                 String name = null;
  26981.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.headers");
  26982.                 if(name!=null){
  26983.                     name = name.trim();
  26984.                 }
  26985.                 if(name!=null && !"".equals(name)) {
  26986.                     if(name.contains(",")) {
  26987.                         String [] tmp = name.split(",");
  26988.                         for (int i = 0; i < tmp.length; i++) {
  26989.                             this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers.add(tmp[i].trim());
  26990.                         }
  26991.                     }
  26992.                     else {
  26993.                         this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers.add(name);
  26994.                     }
  26995.                 }
  26996.             } catch(java.lang.Exception e) {
  26997.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.headers': "+e.getMessage();
  26998.                 this.logError(error,e);
  26999.                 throw new CoreException(error);
  27000.             }    
  27001.         }

  27003.         return this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers;
  27004.     }
  27005.     
  27006.     // Set-Cookie
  27007.     
  27008.     private Boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie = null;
  27009.     public boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie() {   
  27010.         if(this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie==null){
  27011.             String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie";
  27012.             try{ 
  27013.                 String name = null;
  27014.                 name = this.reader.getValueConvertEnvProperties(pName);
  27015.                 if(name==null){
  27016.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  27017.                     name="false";
  27018.                 }
  27019.                 name = name.trim();
  27020.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie = Boolean.parseBoolean(name);
  27021.             } catch(java.lang.Exception e) {
  27022.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27023.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie = false;
  27024.             }    
  27025.         }

  27027.         return this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie;
  27028.     }
  27029.     
  27030.     private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = null;
  27031.     public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie() {   
  27032.         if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie==null){
  27033.             String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie";
  27034.             try{ 
  27035.                 String name = null;
  27036.                 name = this.reader.getValueConvertEnvProperties(pName);
  27037.                 if(name==null){
  27038.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  27039.                     name="false";
  27040.                 }
  27041.                 name = name.trim();
  27042.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = Boolean.parseBoolean(name);
  27043.             } catch(java.lang.Exception e) {
  27044.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27045.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = false;
  27046.             }    
  27047.         }

  27049.         return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie;
  27050.     }
  27051.     
  27052.     private Boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path = null;
  27053.     public boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path() {  
  27054.         if(this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path==null){
  27055.             String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie.path";
  27056.             try{ 
  27057.                 String name = null;
  27058.                 name = this.reader.getValueConvertEnvProperties(pName);
  27059.                 if(name==null){
  27060.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isSOAPServices_inoltroBuste_proxyPassReverse_setCookie()));
  27061.                     name=""+isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
  27062.                 }
  27063.                 name = name.trim();
  27064.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path = Boolean.parseBoolean(name);
  27065.             } catch(java.lang.Exception e) {
  27066.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27067.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path = isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
  27068.             }    
  27069.         }

  27071.         return this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path;
  27072.     }
  27073.     
  27074.     private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = null;
  27075.     public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path() {  
  27076.         if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path==null){
  27077.             String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.path";
  27078.             try{ 
  27079.                 String name = null;
  27080.                 name = this.reader.getValueConvertEnvProperties(pName);
  27081.                 if(name==null){
  27082.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie()));
  27083.                     name=""+isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  27084.                 }
  27085.                 name = name.trim();
  27086.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = Boolean.parseBoolean(name);
  27087.             } catch(java.lang.Exception e) {
  27088.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27089.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  27090.             }    
  27091.         }

  27093.         return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path;
  27094.     }
  27095.     
  27096.     private Boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain = null;
  27097.     public boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain() {    
  27098.         if(this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain==null){
  27099.             String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie.domain";
  27100.             try{ 
  27101.                 String name = null;
  27102.                 name = this.reader.getValueConvertEnvProperties(pName);
  27103.                 if(name==null){
  27104.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isSOAPServices_inoltroBuste_proxyPassReverse_setCookie()));
  27105.                     name=""+isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
  27106.                 }
  27107.                 name = name.trim();
  27108.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain = Boolean.parseBoolean(name);
  27109.             } catch(java.lang.Exception e) {
  27110.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27111.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain = isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
  27112.             }    
  27113.         }

  27115.         return this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain;
  27116.     }
  27117.     
  27118.     private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = null;
  27119.     public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain() {    
  27120.         if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain==null){
  27121.             String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.domain";
  27122.             try{ 
  27123.                 String name = null;
  27124.                 name = this.reader.getValueConvertEnvProperties(pName);
  27125.                 if(name==null){
  27126.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie()));
  27127.                     name=""+isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  27128.                 }
  27129.                 name = name.trim();
  27130.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = Boolean.parseBoolean(name);
  27131.             } catch(java.lang.Exception e) {
  27132.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27133.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  27134.             }    
  27135.         }

  27137.         return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain;
  27138.     }
  27139.     
  27140.     private List<String> getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers = null;
  27141.     public List<String> getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers() throws CoreException {    
  27142.         if(this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers==null){
  27143.             try{ 
  27144.                 this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers = new ArrayList<>();
  27145.                 
  27146.                 String name = null;
  27147.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie.headers");
  27148.                 if(name!=null){
  27149.                     name = name.trim();
  27150.                 }
  27151.                 if(name!=null && !"".equals(name)) {
  27152.                     if(name.contains(",")) {
  27153.                         String [] tmp = name.split(",");
  27154.                         for (int i = 0; i < tmp.length; i++) {
  27155.                             this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers.add(tmp[i].trim());
  27156.                         }
  27157.                     }
  27158.                     else {
  27159.                         this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers.add(name);
  27160.                     }
  27161.                 }
  27162.             } catch(java.lang.Exception e) {
  27163.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie.headers': "+e.getMessage();
  27164.                 this.logError(error,e);
  27165.                 throw new CoreException(error);
  27166.             }    
  27167.         }

  27169.         return this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers;
  27170.     }
  27171.     
  27172.     private List<String> getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers = null;
  27173.     public List<String> getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers() throws CoreException {    
  27174.         if(this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers==null){
  27175.             try{ 
  27176.                 this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers = new ArrayList<>();
  27177.                 
  27178.                 String name = null;
  27179.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.headers");
  27180.                 if(name!=null){
  27181.                     name = name.trim();
  27182.                 }
  27183.                 if(name!=null && !"".equals(name)) {
  27184.                     if(name.contains(",")) {
  27185.                         String [] tmp = name.split(",");
  27186.                         for (int i = 0; i < tmp.length; i++) {
  27187.                             this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers.add(tmp[i].trim());
  27188.                         }
  27189.                     }
  27190.                     else {
  27191.                         this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers.add(name);
  27192.                     }
  27193.                 }
  27194.             } catch(java.lang.Exception e) {
  27195.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.headers': "+e.getMessage();
  27196.                 this.logError(error,e);
  27197.                 throw new CoreException(error);
  27198.             }    
  27199.         }

  27201.         return this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers;
  27202.     }
  27203.     
  27204.     // useProtocolPrefix
  27205.     
  27206.     private Boolean isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = null;
  27207.     public boolean isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix() {   
  27208.         if(this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix==null){
  27209.             try{ 
  27210.                 String name = null;
  27211.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix");
  27212.                 if(name==null){
  27213.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix' non impostata, viene utilizzato il default=false");
  27214.                     name="false";
  27215.                 }
  27216.                 name = name.trim();
  27217.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = Boolean.parseBoolean(name);
  27218.             } catch(java.lang.Exception e) {
  27219.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix': "+e.getMessage(),e);
  27220.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = false;
  27221.             }    
  27222.         }

  27224.         return this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix;
  27225.     }
  27226.     
  27227.     private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = null;
  27228.     public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix() {   
  27229.         if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix==null){
  27230.             try{ 
  27231.                 String name = null;
  27232.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix");
  27233.                 if(name==null){
  27234.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix' non impostata, viene utilizzato il default=false");
  27235.                     name="false";
  27236.                 }
  27237.                 name = name.trim();
  27238.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = Boolean.parseBoolean(name);
  27239.             } catch(java.lang.Exception e) {
  27240.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix': "+e.getMessage(),e);
  27241.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = false;
  27242.             }    
  27243.         }

  27245.         return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix;
  27246.     }
  27247.     
  27248.     private Boolean isSOAPServices_inoltroBuste_response_securityHeaders = null;
  27249.     public boolean isSOAPServices_inoltroBuste_response_securityHeaders() { 
  27250.         if(this.isSOAPServices_inoltroBuste_response_securityHeaders==null){
  27251.             String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.response.securityHeaders";
  27252.             try{ 
  27253.                 String name = null;
  27254.                 name = this.reader.getValueConvertEnvProperties(pName);
  27255.                 if(name==null){
  27256.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  27257.                     name="true";
  27258.                 }
  27259.                 name = name.trim();
  27260.                 this.isSOAPServices_inoltroBuste_response_securityHeaders = Boolean.parseBoolean(name);
  27261.             } catch(java.lang.Exception e) {
  27262.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27263.                 this.isSOAPServices_inoltroBuste_response_securityHeaders = true;
  27264.             }    
  27265.         }

  27267.         return this.isSOAPServices_inoltroBuste_response_securityHeaders;
  27268.     }
  27269.     
  27270.     private Properties getSOAPServices_inoltroBuste_response_securityHeaders = null;
  27271.     public Properties getSOAPServices_inoltroBuste_response_securityHeaders() throws CoreException {    
  27272.         if(this.getSOAPServices_inoltroBuste_response_securityHeaders==null){
  27273.             String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.response.securityHeaders.";
  27274.             try{ 
  27275.                 this.getSOAPServices_inoltroBuste_response_securityHeaders = this.reader.readPropertiesConvertEnvProperties(pName);
  27276.             } catch(java.lang.Exception e) {
  27277.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  27278.                 throw new CoreException(e.getMessage(),e);
  27279.             }    
  27280.         }

  27282.         return this.getSOAPServices_inoltroBuste_response_securityHeaders;
  27283.     }
  27284.     
  27285.     private Boolean isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = null;
  27286.     public boolean isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders() { 
  27287.         if(this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders==null){
  27288.             String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.response.securityHeaders";
  27289.             try{ 
  27290.                 String name = null;
  27291.                 name = this.reader.getValueConvertEnvProperties(pName);
  27292.                 if(name==null){
  27293.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  27294.                     name="true";
  27295.                 }
  27296.                 name = name.trim();
  27297.                 this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = Boolean.parseBoolean(name);
  27298.             } catch(java.lang.Exception e) {
  27299.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27300.                 this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = true;
  27301.             }    
  27302.         }

  27304.         return this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders;
  27305.     }
  27306.     
  27307.     private Properties getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = null;
  27308.     public Properties getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders() throws CoreException {    
  27309.         if(this.getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders==null){
  27310.             String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.response.securityHeaders.";
  27311.             try{ 
  27312.                 this.getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = this.reader.readPropertiesConvertEnvProperties(pName);
  27313.             } catch(java.lang.Exception e) {
  27314.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  27315.                 throw new CoreException(e.getMessage(),e);
  27316.             }    
  27317.         }

  27319.         return this.getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders;
  27320.     }
  27321.     
  27322.     
  27323.     
  27324.     /* ------------- REST (Trasporto - URLParameters) ---------------------*/
  27325.     
  27326.     private Boolean isRESTServicesUrlParametersForward = null;
  27327.     private boolean isRESTServicesUrlParametersForward(){

  27329.         if(this.isRESTServicesUrlParametersForward==null){
  27330.             try{  
  27331.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.urlParameters.forward.enable"); 

  27333.                 if (value != null){
  27334.                     value = value.trim();
  27335.                     this.isRESTServicesUrlParametersForward = Boolean.parseBoolean(value);
  27336.                 }else{
  27337.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.forward.enable' non impostata, viene utilizzato il default=true");
  27338.                     this.isRESTServicesUrlParametersForward = true;
  27339.                 }

  27341.             }catch(java.lang.Exception e) {
  27342.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.forward.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  27343.                 this.isRESTServicesUrlParametersForward = true;
  27344.             }
  27345.         }

  27347.         return this.isRESTServicesUrlParametersForward;
  27348.     }
  27349.     
  27350.     private Boolean getRESTServicesBlackListInternalUrlParametersRead = null;
  27351.     private List<MapKey<String>> getRESTServicesBlackListInternalUrlParametersList = null;
  27352.     private List<MapKey<String>> getRESTServicesBlackListInternalUrlParameters() {  
  27353.         if(this.getRESTServicesBlackListInternalUrlParametersRead==null){
  27354.             try{ 
  27355.                 this.getRESTServicesBlackListInternalUrlParametersList = new ArrayList<>();
  27356.                 String name = null;
  27357.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.urlParameters.blackList.internal");
  27358.                 if(name!=null){
  27359.                     name = name.trim();
  27360.                     String [] split = name.split(",");
  27361.                     if(split!=null){
  27362.                         for (int i = 0; i < split.length; i++) {
  27363.                             this.getRESTServicesBlackListInternalUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27364.                         }
  27365.                     }
  27366.                 }
  27367.                 this.getRESTServicesBlackListInternalUrlParametersRead = true;
  27368.             } catch(java.lang.Exception e) {
  27369.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.blackList.internal': "+e.getMessage(),e);
  27370.             }    
  27371.         }
  27372.         
  27373.         return this.getRESTServicesBlackListInternalUrlParametersList;
  27374.     }
  27375.     
  27376.     private Boolean getRESTServicesBlackListUrlParametersRead = null;
  27377.     private List<MapKey<String>> getRESTServicesBlackListUrlParametersList = null;
  27378.     private List<MapKey<String>> getRESTServicesBlackListUrlParameters() {  
  27379.         if(this.getRESTServicesBlackListUrlParametersRead==null){
  27380.             try{ 
  27381.                 this.getRESTServicesBlackListUrlParametersList = new ArrayList<>();
  27382.                 String name = null;
  27383.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.urlParameters.blackList");
  27384.                 if(name!=null){
  27385.                     name = name.trim();
  27386.                     String [] split = name.split(",");
  27387.                     if(split!=null){
  27388.                         for (int i = 0; i < split.length; i++) {
  27389.                             this.getRESTServicesBlackListUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27390.                         }
  27391.                     }
  27392.                 }
  27393.                 this.getRESTServicesBlackListUrlParametersRead = true;
  27394.             } catch(java.lang.Exception e) {
  27395.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.blackList': "+e.getMessage(),e);
  27396.             }    
  27397.         }
  27398.         
  27399.         return this.getRESTServicesBlackListUrlParametersList;
  27400.     }
  27401.     
  27402.     private Boolean getRESTServicesWhiteListUrlParametersRead = null;
  27403.     private List<MapKey<String>> getRESTServicesWhiteListUrlParametersList = null;
  27404.     private List<MapKey<String>> getRESTServicesWhiteListUrlParameters() {  
  27405.         if(this.getRESTServicesWhiteListUrlParametersRead==null){
  27406.             try{ 
  27407.                 this.getRESTServicesWhiteListUrlParametersList = new ArrayList<>();
  27408.                 String name = null;
  27409.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.urlParameters.whiteList");
  27410.                 if(name!=null){
  27411.                     name = name.trim();
  27412.                     String [] split = name.split(",");
  27413.                     if(split!=null){
  27414.                         for (int i = 0; i < split.length; i++) {
  27415.                             this.getRESTServicesWhiteListUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27416.                         }
  27417.                     }
  27418.                 }
  27419.                 this.getRESTServicesWhiteListUrlParametersRead = true;
  27420.             } catch(java.lang.Exception e) {
  27421.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.whiteList': "+e.getMessage(),e);
  27422.             }    
  27423.         }
  27424.         
  27425.         return this.getRESTServicesWhiteListUrlParametersList;
  27426.     }
  27427.         
  27428.     private List<String> _getRESTServicesBlackListUrlParameters() { 
  27429.         
  27430.         List<MapKey<String>> blackList = new ArrayList<>();
  27431.         List<MapKey<String>> tmp = this.getRESTServicesBlackListInternalUrlParameters();
  27432.         this._list_add(tmp, blackList);
  27433.         tmp = this.getRESTServicesBlackListUrlParameters();
  27434.         this._list_add(tmp, blackList);
  27435.         
  27436.         List<String> l = new ArrayList<>();
  27437.         if(!blackList.isEmpty()) {
  27438.             for (MapKey<String> key : blackList) {
  27439.                 l.add(key.getValue());
  27440.             }
  27441.         }
  27442.         return l;
  27443.     }
  27444.     private List<String> _getRESTServicesWhiteListUrlParameters() { 
  27445.         
  27446.         List<MapKey<String>> whiteList = new ArrayList<>();
  27447.         List<MapKey<String>> tmp = this.getRESTServicesWhiteListUrlParameters();
  27448.         this._list_add(tmp, whiteList);
  27449.         
  27450.         List<String> l = new ArrayList<>();
  27451.         if(!whiteList.isEmpty()) {
  27452.             for (MapKey<String> key : whiteList) {
  27453.                 l.add(key.getValue());
  27454.             }
  27455.         }
  27456.         return l;
  27457.     }
  27458.     public ForwardConfig getRESTServicesUrlParametersForwardConfig() {
  27459.         ForwardConfig f = new ForwardConfig();
  27460.         f.setForwardEnable(this.isRESTServicesUrlParametersForward());
  27461.         f.setBlackList(_getRESTServicesBlackListUrlParameters());
  27462.         f.setWhiteList(_getRESTServicesWhiteListUrlParameters());
  27463.         return f;
  27464.     }
  27465.     
  27466.     
  27467.     
  27468.     
  27469.     /* ------------- REST (Trasporto - Headers) ---------------------*/
  27470.     
  27471.     private Boolean isRESTServicesHeadersForward = null;
  27472.     private boolean isRESTServicesHeadersForward(){

  27474.         if(this.isRESTServicesHeadersForward==null){
  27475.             try{  
  27476.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.forward.enable"); 

  27478.                 if (value != null){
  27479.                     value = value.trim();
  27480.                     this.isRESTServicesHeadersForward = Boolean.parseBoolean(value);
  27481.                 }else{
  27482.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.forward.enable' non impostata, viene utilizzato il default=true");
  27483.                     this.isRESTServicesHeadersForward = true;
  27484.                 }

  27486.             }catch(java.lang.Exception e) {
  27487.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.forward.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  27488.                 this.isRESTServicesHeadersForward = true;
  27489.             }
  27490.         }

  27492.         return this.isRESTServicesHeadersForward;
  27493.     }
  27494.     
  27495.     private Boolean getRESTServicesBlackListBothInternalHeadersRead = null;
  27496.     private List<MapKey<String>> getRESTServicesBlackListBothInternalHeadersList = null;
  27497.     private List<MapKey<String>> getRESTServicesBlackListBothInternalHeaders() {    
  27498.         if(this.getRESTServicesBlackListBothInternalHeadersRead==null){
  27499.             try{ 
  27500.                 this.getRESTServicesBlackListBothInternalHeadersList = new ArrayList<>();
  27501.                 String name = null;
  27502.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.internal.both");
  27503.                 if(name!=null){
  27504.                     name = name.trim();
  27505.                     String [] split = name.split(",");
  27506.                     if(split!=null){
  27507.                         for (int i = 0; i < split.length; i++) {
  27508.                             this.getRESTServicesBlackListBothInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27509.                         }
  27510.                     }
  27511.                 }
  27512.                 this.getRESTServicesBlackListBothInternalHeadersRead = true;
  27513.             } catch(java.lang.Exception e) {
  27514.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.internal.both': "+e.getMessage(),e);
  27515.             }    
  27516.         }
  27517.         
  27518.         return this.getRESTServicesBlackListBothInternalHeadersList;
  27519.     }
  27520.     
  27521.     private Boolean getRESTServicesBlackListRequestInternalHeadersRead = null;
  27522.     private List<MapKey<String>> getRESTServicesBlackListRequestInternalHeadersList = null;
  27523.     private List<MapKey<String>> getRESTServicesBlackListRequestInternalHeaders() { 
  27524.         if(this.getRESTServicesBlackListRequestInternalHeadersRead==null){
  27525.             try{ 
  27526.                 this.getRESTServicesBlackListRequestInternalHeadersList = new ArrayList<>();
  27527.                 String name = null;
  27528.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.internal.request");
  27529.                 if(name!=null){
  27530.                     name = name.trim();
  27531.                     String [] split = name.split(",");
  27532.                     if(split!=null){
  27533.                         for (int i = 0; i < split.length; i++) {
  27534.                             this.getRESTServicesBlackListRequestInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27535.                         }
  27536.                     }
  27537.                 }
  27538.                 this.getRESTServicesBlackListRequestInternalHeadersRead = true;
  27539.             } catch(java.lang.Exception e) {
  27540.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.internal.request': "+e.getMessage(),e);
  27541.             }    
  27542.         }
  27543.         
  27544.         return this.getRESTServicesBlackListRequestInternalHeadersList;
  27545.     }
  27546.     
  27547.     private Boolean getRESTServicesBlackListResponseInternalHeadersRead = null;
  27548.     private List<MapKey<String>> getRESTServicesBlackListResponseInternalHeadersList = null;
  27549.     private List<MapKey<String>> getRESTServicesBlackListResponseInternalHeaders() {    
  27550.         if(this.getRESTServicesBlackListResponseInternalHeadersRead==null){
  27551.             try{ 
  27552.                 this.getRESTServicesBlackListResponseInternalHeadersList = new ArrayList<>();
  27553.                 String name = null;
  27554.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.internal.response");
  27555.                 if(name!=null){
  27556.                     name = name.trim();
  27557.                     String [] split = name.split(",");
  27558.                     if(split!=null){
  27559.                         for (int i = 0; i < split.length; i++) {
  27560.                             this.getRESTServicesBlackListResponseInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27561.                         }
  27562.                     }
  27563.                 }
  27564.                 this.getRESTServicesBlackListResponseInternalHeadersRead = true;
  27565.             } catch(java.lang.Exception e) {
  27566.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.internal.response': "+e.getMessage(),e);
  27567.             }    
  27568.         }
  27569.         
  27570.         return this.getRESTServicesBlackListResponseInternalHeadersList;
  27571.     }
  27572.     
  27573.     private Boolean getRESTServicesBlackListBothHeadersRead = null;
  27574.     private List<MapKey<String>> getRESTServicesBlackListBothHeadersList = null;
  27575.     private List<MapKey<String>> getRESTServicesBlackListBothHeaders() {    
  27576.         if(this.getRESTServicesBlackListBothHeadersRead==null){
  27577.             try{ 
  27578.                 this.getRESTServicesBlackListBothHeadersList = new ArrayList<>();
  27579.                 String name = null;
  27580.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.both");
  27581.                 if(name!=null){
  27582.                     name = name.trim();
  27583.                     String [] split = name.split(",");
  27584.                     if(split!=null){
  27585.                         for (int i = 0; i < split.length; i++) {
  27586.                             this.getRESTServicesBlackListBothHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27587.                         }
  27588.                     }
  27589.                 }
  27590.                 this.getRESTServicesBlackListBothHeadersRead = true;
  27591.             } catch(java.lang.Exception e) {
  27592.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.both': "+e.getMessage(),e);
  27593.             }    
  27594.         }
  27595.         
  27596.         return this.getRESTServicesBlackListBothHeadersList;
  27597.     }
  27598.     
  27599.     private Boolean getRESTServicesBlackListRequestHeadersRead = null;
  27600.     private List<MapKey<String>> getRESTServicesBlackListRequestHeadersList = null;
  27601.     private List<MapKey<String>> getRESTServicesBlackListRequestHeaders() { 
  27602.         if(this.getRESTServicesBlackListRequestHeadersRead==null){
  27603.             try{ 
  27604.                 this.getRESTServicesBlackListRequestHeadersList = new ArrayList<>();
  27605.                 String name = null;
  27606.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.request");
  27607.                 if(name!=null){
  27608.                     name = name.trim();
  27609.                     String [] split = name.split(",");
  27610.                     if(split!=null){
  27611.                         for (int i = 0; i < split.length; i++) {
  27612.                             this.getRESTServicesBlackListRequestHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27613.                         }
  27614.                     }
  27615.                 }
  27616.                 this.getRESTServicesBlackListRequestHeadersRead = true;
  27617.             } catch(java.lang.Exception e) {
  27618.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.request': "+e.getMessage(),e);
  27619.             }    
  27620.         }
  27621.         
  27622.         return this.getRESTServicesBlackListRequestHeadersList;
  27623.     }
  27624.     
  27625.     private Boolean getRESTServicesBlackListResponseHeadersRead = null;
  27626.     private List<MapKey<String>> getRESTServicesBlackListResponseHeadersList = null;
  27627.     private List<MapKey<String>> getRESTServicesBlackListResponseHeaders() {    
  27628.         if(this.getRESTServicesBlackListResponseHeadersRead==null){
  27629.             try{ 
  27630.                 this.getRESTServicesBlackListResponseHeadersList = new ArrayList<>();
  27631.                 String name = null;
  27632.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.response");
  27633.                 if(name!=null){
  27634.                     name = name.trim();
  27635.                     String [] split = name.split(",");
  27636.                     if(split!=null){
  27637.                         for (int i = 0; i < split.length; i++) {
  27638.                             this.getRESTServicesBlackListResponseHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27639.                         }
  27640.                     }
  27641.                 }
  27642.                 this.getRESTServicesBlackListResponseHeadersRead = true;
  27643.             } catch(java.lang.Exception e) {
  27644.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.response': "+e.getMessage(),e);
  27645.             }    
  27646.         }
  27647.         
  27648.         return this.getRESTServicesBlackListResponseHeadersList;
  27649.     }
  27650.     
  27651.     private Boolean getRESTServicesWhiteListBothHeadersRead = null;
  27652.     private List<MapKey<String>> getRESTServicesWhiteListBothHeadersList = null;
  27653.     private List<MapKey<String>> getRESTServicesWhiteListBothHeaders() {    
  27654.         if(this.getRESTServicesWhiteListBothHeadersRead==null){
  27655.             try{ 
  27656.                 this.getRESTServicesWhiteListBothHeadersList = new ArrayList<>();
  27657.                 String name = null;
  27658.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.whiteList.both");
  27659.                 if(name!=null){
  27660.                     name = name.trim();
  27661.                     String [] split = name.split(",");
  27662.                     if(split!=null){
  27663.                         for (int i = 0; i < split.length; i++) {
  27664.                             this.getRESTServicesWhiteListBothHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27665.                         }
  27666.                     }
  27667.                 }
  27668.                 this.getRESTServicesWhiteListBothHeadersRead = true;
  27669.             } catch(java.lang.Exception e) {
  27670.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.whiteList.both': "+e.getMessage(),e);
  27671.             }    
  27672.         }
  27673.         
  27674.         return this.getRESTServicesWhiteListBothHeadersList;
  27675.     }
  27676.     
  27677.     private Boolean getRESTServicesWhiteListRequestHeadersRead = null;
  27678.     private List<MapKey<String>> getRESTServicesWhiteListRequestHeadersList = null;
  27679.     private List<MapKey<String>> getRESTServicesWhiteListRequestHeaders() { 
  27680.         if(this.getRESTServicesWhiteListRequestHeadersRead==null){
  27681.             try{ 
  27682.                 this.getRESTServicesWhiteListRequestHeadersList = new ArrayList<>();
  27683.                 String name = null;
  27684.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.whiteList.request");
  27685.                 if(name!=null){
  27686.                     name = name.trim();
  27687.                     String [] split = name.split(",");
  27688.                     if(split!=null){
  27689.                         for (int i = 0; i < split.length; i++) {
  27690.                             this.getRESTServicesWhiteListRequestHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27691.                         }
  27692.                     }
  27693.                 }
  27694.                 this.getRESTServicesWhiteListRequestHeadersRead = true;
  27695.             } catch(java.lang.Exception e) {
  27696.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.whiteList.request': "+e.getMessage(),e);
  27697.             }    
  27698.         }
  27699.         
  27700.         return this.getRESTServicesWhiteListRequestHeadersList;
  27701.     }
  27702.     
  27703.     private Boolean getRESTServicesWhiteListResponseHeadersRead = null;
  27704.     private List<MapKey<String>> getRESTServicesWhiteListResponseHeadersList = null;
  27705.     private List<MapKey<String>> getRESTServicesWhiteListResponseHeaders() {    
  27706.         if(this.getRESTServicesWhiteListResponseHeadersRead==null){
  27707.             try{ 
  27708.                 this.getRESTServicesWhiteListResponseHeadersList = new ArrayList<>();
  27709.                 String name = null;
  27710.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.whiteList.response");
  27711.                 if(name!=null){
  27712.                     name = name.trim();
  27713.                     String [] split = name.split(",");
  27714.                     if(split!=null){
  27715.                         for (int i = 0; i < split.length; i++) {
  27716.                             this.getRESTServicesWhiteListResponseHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27717.                         }
  27718.                     }
  27719.                 }
  27720.                 this.getRESTServicesWhiteListResponseHeadersRead = true;
  27721.             } catch(java.lang.Exception e) {
  27722.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.whiteList.response': "+e.getMessage(),e);
  27723.             }    
  27724.         }
  27725.         
  27726.         return this.getRESTServicesWhiteListResponseHeadersList;
  27727.     }
  27728.     
  27729.     private List<String> getRESTServicesBlackListHeaders(boolean request) { 
  27730.         
  27731.         List<MapKey<String>> blackList = new ArrayList<>();
  27732.         List<MapKey<String>> tmp = this.getRESTServicesBlackListBothInternalHeaders();
  27733.         this._list_add(tmp, blackList);
  27734.         tmp = this.getRESTServicesBlackListBothHeaders();
  27735.         this._list_add(tmp, blackList);
  27736.         
  27737.         if(request) {
  27738.             tmp = this.getRESTServicesBlackListRequestInternalHeaders();
  27739.             this._list_add(tmp, blackList);
  27740.             tmp = this.getRESTServicesBlackListRequestHeaders();
  27741.             this._list_add(tmp, blackList);
  27742.         }
  27743.         else {
  27744.             tmp = this.getRESTServicesBlackListResponseInternalHeaders();
  27745.             this._list_add(tmp, blackList);
  27746.             tmp = this.getRESTServicesBlackListResponseHeaders();
  27747.             this._list_add(tmp, blackList);
  27748.         }
  27749.         
  27750.         List<String> l = new ArrayList<>();
  27751.         if(!blackList.isEmpty()) {
  27752.             for (MapKey<String> key : blackList) {
  27753.                 l.add(key.getValue());
  27754.             }
  27755.         }
  27756.         return l;
  27757.     }
  27758.     private List<String> getRESTServicesWhiteListHeaders(boolean request) { 
  27759.         
  27760.         List<MapKey<String>> whiteList = new ArrayList<>();
  27761.         List<MapKey<String>> tmp = this.getRESTServicesWhiteListBothHeaders();
  27762.         this._list_add(tmp, whiteList);
  27763.         if(request) {
  27764.             tmp = this.getRESTServicesWhiteListRequestHeaders();
  27765.             this._list_add(tmp, whiteList);
  27766.         }
  27767.         else {
  27768.             tmp = this.getRESTServicesWhiteListResponseHeaders();
  27769.             this._list_add(tmp, whiteList);
  27770.         }
  27771.         
  27772.         List<String> l = new ArrayList<>();
  27773.         if(!whiteList.isEmpty()) {
  27774.             for (MapKey<String> key : whiteList) {
  27775.                 l.add(key.getValue());
  27776.             }
  27777.         }
  27778.         return l;
  27779.     }
  27780.     public ForwardConfig getRESTServicesHeadersForwardConfig(boolean request) {
  27781.         ForwardConfig f = new ForwardConfig();
  27782.         f.setForwardEnable(this.isRESTServicesHeadersForward());
  27783.         f.setBlackList(getRESTServicesBlackListHeaders(request));
  27784.         f.setWhiteList(getRESTServicesWhiteListHeaders(request));
  27785.         return f;
  27786.     }


  27789.     /* ------------- REST (Trasporto - Headers - Proxy Pass Reverse) ---------------------*/
  27790.     
  27791.     // Location
  27792.     
  27793.     private Boolean isRESTServices_inoltroBuste_proxyPassReverse = null;
  27794.     public boolean isRESTServices_inoltroBuste_proxyPassReverse() { 
  27795.         if(this.isRESTServices_inoltroBuste_proxyPassReverse==null){
  27796.             try{ 
  27797.                 String name = null;
  27798.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse");
  27799.                 if(name==null){
  27800.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse' non impostata, viene utilizzato il default=false");
  27801.                     name="false";
  27802.                 }
  27803.                 name = name.trim();
  27804.                 this.isRESTServices_inoltroBuste_proxyPassReverse = Boolean.parseBoolean(name);
  27805.             } catch(java.lang.Exception e) {
  27806.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse': "+e.getMessage(),e);
  27807.                 this.isRESTServices_inoltroBuste_proxyPassReverse = false;
  27808.             }    
  27809.         }

  27811.         return this.isRESTServices_inoltroBuste_proxyPassReverse;
  27812.     }
  27813.     
  27814.     private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse = null;
  27815.     public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse() { 
  27816.         if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse==null){
  27817.             try{ 
  27818.                 String name = null;
  27819.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse");
  27820.                 if(name==null){
  27821.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse' non impostata, viene utilizzato il default=false");
  27822.                     name="false";
  27823.                 }
  27824.                 name = name.trim();
  27825.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse = Boolean.parseBoolean(name);
  27826.             } catch(java.lang.Exception e) {
  27827.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse': "+e.getMessage(),e);
  27828.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse = false;
  27829.             }    
  27830.         }

  27832.         return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse;
  27833.     }
  27834.         
  27835.     private List<String> getRESTServices_inoltroBuste_proxyPassReverse_headers = null;
  27836.     public List<String> getRESTServices_inoltroBuste_proxyPassReverse_headers() throws CoreException {  
  27837.         if(this.getRESTServices_inoltroBuste_proxyPassReverse_headers==null){
  27838.             try{ 
  27839.                 this.getRESTServices_inoltroBuste_proxyPassReverse_headers = new ArrayList<>();
  27840.                 
  27841.                 String name = null;
  27842.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.headers");
  27843.                 if(name!=null){
  27844.                     name = name.trim();
  27845.                 }
  27846.                 if(name!=null && !"".equals(name)) {
  27847.                     if(name.contains(",")) {
  27848.                         String [] tmp = name.split(",");
  27849.                         for (int i = 0; i < tmp.length; i++) {
  27850.                             this.getRESTServices_inoltroBuste_proxyPassReverse_headers.add(tmp[i].trim());
  27851.                         }
  27852.                     }
  27853.                     else {
  27854.                         this.getRESTServices_inoltroBuste_proxyPassReverse_headers.add(name);
  27855.                     }
  27856.                 }
  27857.             } catch(java.lang.Exception e) {
  27858.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.headers': "+e.getMessage();
  27859.                 this.logError(error,e);
  27860.                 throw new CoreException(error);
  27861.             }    
  27862.         }

  27864.         return this.getRESTServices_inoltroBuste_proxyPassReverse_headers;
  27865.     }
  27866.     
  27867.     private List<String> getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers = null;
  27868.     public List<String> getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers() throws CoreException {  
  27869.         if(this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers==null){
  27870.             try{ 
  27871.                 this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers = new ArrayList<>();
  27872.                 
  27873.                 String name = null;
  27874.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.headers");
  27875.                 if(name!=null){
  27876.                     name = name.trim();
  27877.                 }
  27878.                 if(name!=null && !"".equals(name)) {
  27879.                     if(name.contains(",")) {
  27880.                         String [] tmp = name.split(",");
  27881.                         for (int i = 0; i < tmp.length; i++) {
  27882.                             this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers.add(tmp[i].trim());
  27883.                         }
  27884.                     }
  27885.                     else {
  27886.                         this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers.add(name);
  27887.                     }
  27888.                 }
  27889.             } catch(java.lang.Exception e) {
  27890.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.headers': "+e.getMessage();
  27891.                 this.logError(error,e);
  27892.                 throw new CoreException(error);
  27893.             }    
  27894.         }

  27896.         return this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers;
  27897.     }
  27898.     
  27899.     // Set-Cookie
  27900.     
  27901.     private Boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie = null;
  27902.     public boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie() {   
  27903.         if(this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie==null){
  27904.             String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie";
  27905.             try{ 
  27906.                 String name = null;
  27907.                 name = this.reader.getValueConvertEnvProperties(pName);
  27908.                 if(name==null){
  27909.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  27910.                     name="false";
  27911.                 }
  27912.                 name = name.trim();
  27913.                 this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie = Boolean.parseBoolean(name);
  27914.             } catch(java.lang.Exception e) {
  27915.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27916.                 this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie = false;
  27917.             }    
  27918.         }

  27920.         return this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie;
  27921.     }
  27922.     
  27923.     private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = null;
  27924.     public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie() {   
  27925.         if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie==null){
  27926.             String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie";
  27927.             try{ 
  27928.                 String name = null;
  27929.                 name = this.reader.getValueConvertEnvProperties(pName);
  27930.                 if(name==null){
  27931.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  27932.                     name="false";
  27933.                 }
  27934.                 name = name.trim();
  27935.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = Boolean.parseBoolean(name);
  27936.             } catch(java.lang.Exception e) {
  27937.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27938.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = false;
  27939.             }    
  27940.         }

  27942.         return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie;
  27943.     }
  27944.     
  27945.     private Boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path = null;
  27946.     public boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path() {  
  27947.         if(this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path==null){
  27948.             String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie.path";
  27949.             try{ 
  27950.                 String name = null;
  27951.                 name = this.reader.getValueConvertEnvProperties(pName);
  27952.                 if(name==null){
  27953.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isRESTServices_inoltroBuste_proxyPassReverse_setCookie()));
  27954.                     name=""+isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
  27955.                 }
  27956.                 name = name.trim();
  27957.                 this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path = Boolean.parseBoolean(name);
  27958.             } catch(java.lang.Exception e) {
  27959.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27960.                 this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path = isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
  27961.             }    
  27962.         }

  27964.         return this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path;
  27965.     }
  27966.     
  27967.     private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = null;
  27968.     public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path() {  
  27969.         if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path==null){
  27970.             String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.path";
  27971.             try{ 
  27972.                 String name = null;
  27973.                 name = this.reader.getValueConvertEnvProperties(pName);
  27974.                 if(name==null){
  27975.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie()));
  27976.                     name=""+isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  27977.                 }
  27978.                 name = name.trim();
  27979.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = Boolean.parseBoolean(name);
  27980.             } catch(java.lang.Exception e) {
  27981.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27982.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  27983.             }    
  27984.         }

  27986.         return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path;
  27987.     }
  27988.     
  27989.     private Boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain = null;
  27990.     public boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain() {    
  27991.         if(this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain==null){
  27992.             String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie.domain";
  27993.             try{ 
  27994.                 String name = null;
  27995.                 name = this.reader.getValueConvertEnvProperties(pName);
  27996.                 if(name==null){
  27997.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isRESTServices_inoltroBuste_proxyPassReverse_setCookie()));
  27998.                     name=""+isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
  27999.                 }
  28000.                 name = name.trim();
  28001.                 this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain = Boolean.parseBoolean(name);
  28002.             } catch(java.lang.Exception e) {
  28003.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  28004.                 this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain = isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
  28005.             }    
  28006.         }

  28008.         return this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain;
  28009.     }
  28010.     
  28011.     private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = null;
  28012.     public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain() {    
  28013.         if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain==null){
  28014.             String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.domain";
  28015.             try{ 
  28016.                 String name = null;
  28017.                 name = this.reader.getValueConvertEnvProperties(pName);
  28018.                 if(name==null){
  28019.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie()));
  28020.                     name=""+isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  28021.                 }
  28022.                 name = name.trim();
  28023.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = Boolean.parseBoolean(name);
  28024.             } catch(java.lang.Exception e) {
  28025.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  28026.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  28027.             }    
  28028.         }

  28030.         return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain;
  28031.     }
  28032.     
  28033.     private List<String> getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers = null;
  28034.     public List<String> getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers() throws CoreException {    
  28035.         if(this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers==null){
  28036.             try{ 
  28037.                 this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers = new ArrayList<>();
  28038.                 
  28039.                 String name = null;
  28040.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie.headers");
  28041.                 if(name!=null){
  28042.                     name = name.trim();
  28043.                 }
  28044.                 if(name!=null && !"".equals(name)) {
  28045.                     if(name.contains(",")) {
  28046.                         String [] tmp = name.split(",");
  28047.                         for (int i = 0; i < tmp.length; i++) {
  28048.                             this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers.add(tmp[i].trim());
  28049.                         }
  28050.                     }
  28051.                     else {
  28052.                         this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers.add(name);
  28053.                     }
  28054.                 }
  28055.             } catch(java.lang.Exception e) {
  28056.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie.headers': "+e.getMessage();
  28057.                 this.logError(error,e);
  28058.                 throw new CoreException(error);
  28059.             }    
  28060.         }

  28062.         return this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers;
  28063.     }
  28064.     
  28065.     private List<String> getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers = null;
  28066.     public List<String> getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers() throws CoreException {    
  28067.         if(this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers==null){
  28068.             try{ 
  28069.                 this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers = new ArrayList<>();
  28070.                 
  28071.                 String name = null;
  28072.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.headers");
  28073.                 if(name!=null){
  28074.                     name = name.trim();
  28075.                 }
  28076.                 if(name!=null && !"".equals(name)) {
  28077.                     if(name.contains(",")) {
  28078.                         String [] tmp = name.split(",");
  28079.                         for (int i = 0; i < tmp.length; i++) {
  28080.                             this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers.add(tmp[i].trim());
  28081.                         }
  28082.                     }
  28083.                     else {
  28084.                         this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers.add(name);
  28085.                     }
  28086.                 }
  28087.             } catch(java.lang.Exception e) {
  28088.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.headers': "+e.getMessage();
  28089.                 this.logError(error,e);
  28090.                 throw new CoreException(error);
  28091.             }    
  28092.         }

  28094.         return this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers;
  28095.     }
  28096.     
  28097.     // useProtocolPrefix
  28098.     
  28099.     private Boolean isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = null;
  28100.     public boolean isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix() {   
  28101.         if(this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix==null){
  28102.             try{ 
  28103.                 String name = null;
  28104.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix");
  28105.                 if(name==null){
  28106.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix' non impostata, viene utilizzato il default=false");
  28107.                     name="false";
  28108.                 }
  28109.                 name = name.trim();
  28110.                 this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = Boolean.parseBoolean(name);
  28111.             } catch(java.lang.Exception e) {
  28112.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix': "+e.getMessage(),e);
  28113.                 this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = false;
  28114.             }    
  28115.         }

  28117.         return this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix;
  28118.     }
  28119.     
  28120.     private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = null;
  28121.     public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix() {   
  28122.         if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix==null){
  28123.             try{ 
  28124.                 String name = null;
  28125.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix");
  28126.                 if(name==null){
  28127.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix' non impostata, viene utilizzato il default=false");
  28128.                     name="false";
  28129.                 }
  28130.                 name = name.trim();
  28131.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = Boolean.parseBoolean(name);
  28132.             } catch(java.lang.Exception e) {
  28133.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix': "+e.getMessage(),e);
  28134.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = false;
  28135.             }    
  28136.         }

  28138.         return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix;
  28139.     }
  28140.     

  28142.     private Boolean isRESTServices_inoltroBuste_response_securityHeaders = null;
  28143.     public boolean isRESTServices_inoltroBuste_response_securityHeaders() { 
  28144.         if(this.isRESTServices_inoltroBuste_response_securityHeaders==null){
  28145.             String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.response.securityHeaders";
  28146.             try{ 
  28147.                 String name = null;
  28148.                 name = this.reader.getValueConvertEnvProperties(pName);
  28149.                 if(name==null){
  28150.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28151.                     name="true";
  28152.                 }
  28153.                 name = name.trim();
  28154.                 this.isRESTServices_inoltroBuste_response_securityHeaders = Boolean.parseBoolean(name);
  28155.             } catch(java.lang.Exception e) {
  28156.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  28157.                 this.isRESTServices_inoltroBuste_response_securityHeaders = true;
  28158.             }    
  28159.         }
  28160.     
  28161.         return this.isRESTServices_inoltroBuste_response_securityHeaders;
  28162.     }

  28164.     private Properties getRESTServices_inoltroBuste_response_securityHeaders = null;
  28165.     public Properties getRESTServices_inoltroBuste_response_securityHeaders() throws CoreException {    
  28166.         if(this.getRESTServices_inoltroBuste_response_securityHeaders==null){
  28167.             String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.response.securityHeaders.";
  28168.             try{ 
  28169.                 this.getRESTServices_inoltroBuste_response_securityHeaders = this.reader.readPropertiesConvertEnvProperties(pName);
  28170.             } catch(java.lang.Exception e) {
  28171.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  28172.                 throw new CoreException(e.getMessage(),e);
  28173.             }    
  28174.         }
  28175.     
  28176.         return this.getRESTServices_inoltroBuste_response_securityHeaders;
  28177.     }
  28178.     
  28179.     private Boolean isRESTServices_consegnaContenutiApplicativi_response_securityHeaders = null;
  28180.     public boolean isRESTServices_consegnaContenutiApplicativi_response_securityHeaders() { 
  28181.         if(this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders==null){
  28182.             String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.response.securityHeaders";
  28183.             try{ 
  28184.                 String name = null;
  28185.                 name = this.reader.getValueConvertEnvProperties(pName);
  28186.                 if(name==null){
  28187.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28188.                     name="true";
  28189.                 }
  28190.                 name = name.trim();
  28191.                 this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders = Boolean.parseBoolean(name);
  28192.             } catch(java.lang.Exception e) {
  28193.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  28194.                 this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders = true;
  28195.             }    
  28196.         }
  28197.     
  28198.         return this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders;
  28199.     }
  28200.     
  28201.     private Properties getRESTServices_consegnaContenutiApplicativi_response_securityHeaders = null;
  28202.     public Properties getRESTServices_consegnaContenutiApplicativi_response_securityHeaders() throws CoreException {    
  28203.         if(this.getRESTServices_consegnaContenutiApplicativi_response_securityHeaders==null){
  28204.             String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.response.securityHeaders.";
  28205.             try{ 
  28206.                 this.getRESTServices_consegnaContenutiApplicativi_response_securityHeaders = this.reader.readPropertiesConvertEnvProperties(pName);
  28207.             } catch(java.lang.Exception e) {
  28208.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  28209.                 throw new CoreException(e.getMessage(),e);
  28210.             }    
  28211.         }
  28212.     
  28213.         return this.getRESTServices_consegnaContenutiApplicativi_response_securityHeaders;
  28214.     }

  28216.     
  28217.     
  28218.     /* ------------- Transazioni ---------------------*/
  28219.     
  28220.     private Boolean isTransazioniEnabled = null;
  28221.     public boolean isTransazioniEnabled() { 
  28222.         if(this.isTransazioniEnabled==null){
  28223.             try{ 
  28224.                 String name = null;
  28225.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.enabled");
  28226.                 if(name==null){
  28227.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.enabled' non impostata, viene utilizzato il default=true");
  28228.                     name="true";
  28229.                 }
  28230.                 name = name.trim();
  28231.                 this.isTransazioniEnabled = Boolean.parseBoolean(name);
  28232.             } catch(java.lang.Exception e) {
  28233.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
  28234.                 this.isTransazioniEnabled = true;
  28235.             }    
  28236.         }

  28238.         return this.isTransazioniEnabled;
  28239.     }   
  28240.     
  28241.     private Boolean isTransazioniDebug = null;
  28242.     public boolean isTransazioniDebug() {   
  28243.         if(this.isTransazioniDebug==null){
  28244.             try{ 
  28245.                 String name = null;
  28246.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.debug");
  28247.                 if(name==null){
  28248.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.debug' non impostata, viene utilizzato il default=true");
  28249.                     name="true";
  28250.                 }
  28251.                 name = name.trim();
  28252.                 this.isTransazioniDebug = Boolean.parseBoolean(name);
  28253.             } catch(java.lang.Exception e) {
  28254.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.debug', viene utilizzato il default=true : "+e.getMessage(),e);
  28255.                 this.isTransazioniDebug = true;
  28256.             }    
  28257.         }

  28259.         return this.isTransazioniDebug;
  28260.     }   
  28261.     
  28262.     private Boolean isTransazioniUsePddRuntimeDatasource = null;
  28263.     public boolean isTransazioniUsePddRuntimeDatasource() { 
  28264.         if(this.isTransazioniUsePddRuntimeDatasource==null){
  28265.             try{ 
  28266.                 String name = null;
  28267.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.dataSource.usePddRuntime");
  28268.                 if(name==null){
  28269.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dataSource.usePddRuntime' non impostata, viene utilizzato il default=true");
  28270.                     name="true";
  28271.                 }
  28272.                 name = name.trim();
  28273.                 this.isTransazioniUsePddRuntimeDatasource = Boolean.parseBoolean(name);
  28274.             } catch(java.lang.Exception e) {
  28275.                 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);
  28276.                 this.isTransazioniUsePddRuntimeDatasource = true;
  28277.             }    
  28278.         }

  28280.         return this.isTransazioniUsePddRuntimeDatasource;
  28281.     }
  28282.     
  28283.     private String getTransazioniDatasource = null;
  28284.     public String getTransazioniDatasource() throws CoreException { 
  28285.         if(this.getTransazioniDatasource==null){
  28286.             try{ 
  28287.                 String name = null;
  28288.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.dataSource");
  28289.                 if(name==null){
  28290.                     throw new CoreException("Proprieta' non impostata");
  28291.                 }
  28292.                 name = name.trim();
  28293.                 this.getTransazioniDatasource = name;
  28294.             } catch(java.lang.Exception e) {
  28295.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dataSource': "+e.getMessage(),e);
  28296.                 throw new CoreException(e.getMessage(),e);
  28297.             }    
  28298.         }

  28300.         return this.getTransazioniDatasource;
  28301.     }
  28302.     
  28303.     private Properties getTransazioniDatasourceJndiContext = null;
  28304.     public Properties getTransazioniDatasourceJndiContext() throws CoreException {  
  28305.         if(this.getTransazioniDatasourceJndiContext==null){
  28306.             try{ 
  28307.                 this.getTransazioniDatasourceJndiContext = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.transazioni.dataSource.property.");
  28308.             } catch(java.lang.Exception e) {
  28309.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dataSource.property.*': "+e.getMessage(),e);
  28310.                 throw new CoreException(e.getMessage(),e);
  28311.             }    
  28312.         }

  28314.         return this.getTransazioniDatasourceJndiContext;
  28315.     }
  28316.     
  28317.     private Boolean isTransazioniDatasourceUseDBUtils = null;
  28318.     public boolean isTransazioniDatasourceUseDBUtils() {    
  28319.         if(this.isTransazioniDatasourceUseDBUtils==null){
  28320.             try{ 
  28321.                 String name = null;
  28322.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.datasource.useDSUtils");
  28323.                 if(name==null){
  28324.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.datasource.useDSUtils' non impostata, viene utilizzato il default=true");
  28325.                     name="true";
  28326.                 }
  28327.                 name = name.trim();
  28328.                 this.isTransazioniDatasourceUseDBUtils = Boolean.parseBoolean(name);
  28329.             } catch(java.lang.Exception e) {
  28330.                 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);
  28331.                 this.isTransazioniDatasourceUseDBUtils = true;
  28332.             }    
  28333.         }

  28335.         return this.isTransazioniDatasourceUseDBUtils;
  28336.     }
  28337.     
  28338.     private Boolean isTransazioniSaveTracceInUniqueTransaction = null;
  28339.     public boolean isTransazioniSaveTracceInUniqueTransaction() {   
  28340.         if(this.isTransazioniSaveTracceInUniqueTransaction==null){
  28341.             try{ 
  28342.                 String name = null;
  28343.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.enabled");
  28344.                 if(name==null){
  28345.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.enabled' non impostata, viene utilizzato il default=true");
  28346.                     name="true";
  28347.                 }
  28348.                 name = name.trim();
  28349.                 this.isTransazioniSaveTracceInUniqueTransaction = Boolean.parseBoolean(name);
  28350.             } catch(java.lang.Exception e) {
  28351.                 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);
  28352.                 this.isTransazioniSaveTracceInUniqueTransaction = true;
  28353.             }    
  28354.         }

  28356.         return this.isTransazioniSaveTracceInUniqueTransaction;
  28357.     }
  28358.     
  28359.     private Boolean isTransazioniSaveDiagnosticiInUniqueTransaction = null;
  28360.     public boolean isTransazioniSaveDiagnosticiInUniqueTransaction() {  
  28361.         if(this.isTransazioniSaveDiagnosticiInUniqueTransaction==null){
  28362.             try{ 
  28363.                 String name = null;
  28364.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.diagnostici.enabled");
  28365.                 if(name==null){
  28366.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.diagnostici.enabled' non impostata, viene utilizzato il default=true");
  28367.                     name="true";
  28368.                 }
  28369.                 name = name.trim();
  28370.                 this.isTransazioniSaveDiagnosticiInUniqueTransaction = Boolean.parseBoolean(name);
  28371.             } catch(java.lang.Exception e) {
  28372.                 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);
  28373.                 this.isTransazioniSaveDiagnosticiInUniqueTransaction = true;
  28374.             }    
  28375.         }

  28377.         return this.isTransazioniSaveDiagnosticiInUniqueTransaction;
  28378.     }
  28379.     
  28380.     private Boolean isTransazioniSaveDumpInUniqueTransaction = null;
  28381.     public boolean isTransazioniSaveDumpInUniqueTransaction() { 
  28382.         if(this.isTransazioniSaveDumpInUniqueTransaction==null){
  28383.             try{ 
  28384.                 String name = null;
  28385.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.dump.enabled");
  28386.                 if(name==null){
  28387.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dump.enabled' non impostata, viene utilizzato il default=true");
  28388.                     name="true";
  28389.                 }
  28390.                 name = name.trim();
  28391.                 this.isTransazioniSaveDumpInUniqueTransaction = Boolean.parseBoolean(name);
  28392.             } catch(java.lang.Exception e) {
  28393.                 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);
  28394.                 this.isTransazioniSaveDumpInUniqueTransaction = true;
  28395.             }    
  28396.         }

  28398.         return this.isTransazioniSaveDumpInUniqueTransaction;
  28399.     }
  28400.     
  28401.     private Boolean isTransazioniValorizzaDataIngressoConDataAccettazione = null;
  28402.     public boolean isTransazioniValorizzaDataIngressoConDataAccettazione() {    
  28403.         String pName = "org.openspcoop2.pdd.transazioni.dataIngresso.valorizzaConDataAccettazione";
  28404.         if(this.isTransazioniValorizzaDataIngressoConDataAccettazione==null){
  28405.             try{ 
  28406.                 String name = null;
  28407.                 name = this.reader.getValueConvertEnvProperties(pName);
  28408.                 if(name==null){
  28409.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28410.                     name="true";
  28411.                 }
  28412.                 name = name.trim();
  28413.                 this.isTransazioniValorizzaDataIngressoConDataAccettazione = Boolean.parseBoolean(name);
  28414.             } catch(java.lang.Exception e) {
  28415.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28416.                 this.isTransazioniValorizzaDataIngressoConDataAccettazione = true;
  28417.             }    
  28418.         }

  28420.         return this.isTransazioniValorizzaDataIngressoConDataAccettazione;
  28421.     }
  28422.     
  28423.     private Boolean isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent = null;
  28424.     public boolean isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent() { 
  28425.         String pName = "org.openspcoop2.pdd.transazioni.dataUscitaRisposta.useDateAfterResponseSent";
  28426.         if(this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent==null){
  28427.             try{ 
  28428.                 String name = null;
  28429.                 name = this.reader.getValueConvertEnvProperties(pName);
  28430.                 if(name==null){
  28431.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28432.                     name="true";
  28433.                 }
  28434.                 name = name.trim();
  28435.                 this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent = Boolean.parseBoolean(name);
  28436.             } catch(java.lang.Exception e) {
  28437.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28438.                 this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent = true;
  28439.             }    
  28440.         }

  28442.         return this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent;
  28443.     }
  28444.     
  28445.     private Boolean isTransazioniFaultPrettyPrint = null;
  28446.     public boolean isTransazioniFaultPrettyPrint() {    
  28447.         if(this.isTransazioniFaultPrettyPrint==null){
  28448.             try{ 
  28449.                 String name = null;
  28450.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.fault.prettyPrint");
  28451.                 if(name==null){
  28452.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.fault.prettyPrint' non impostata, viene utilizzato il default=false");
  28453.                     name="false";
  28454.                 }
  28455.                 name = name.trim();
  28456.                 this.isTransazioniFaultPrettyPrint = Boolean.parseBoolean(name);
  28457.             } catch(java.lang.Exception e) {
  28458.                 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);
  28459.                 this.isTransazioniFaultPrettyPrint = false;
  28460.             }    
  28461.         }

  28463.         return this.isTransazioniFaultPrettyPrint;
  28464.     }
  28465.     
  28466.     private Boolean isTransazioniHttpStatusAsEvent_inResponseCode = null;
  28467.     public boolean isTransazioniHttpStatusAsEvent_inResponseCode() {    
  28468.         if(this.isTransazioniHttpStatusAsEvent_inResponseCode==null){
  28469.             String pName = "org.openspcoop2.pdd.transazioni.httpStatusAsEvent.inResponseCode";
  28470.             try{ 
  28471.                 String name = null;
  28472.                 name = this.reader.getValueConvertEnvProperties(pName);
  28473.                 if(name==null){
  28474.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28475.                     name="false";
  28476.                 }
  28477.                 name = name.trim();
  28478.                 this.isTransazioniHttpStatusAsEvent_inResponseCode = Boolean.parseBoolean(name);
  28479.             } catch(java.lang.Exception e) {
  28480.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28481.                 this.isTransazioniHttpStatusAsEvent_inResponseCode = false;
  28482.             }    
  28483.         }

  28485.         return this.isTransazioniHttpStatusAsEvent_inResponseCode;
  28486.     }
  28487.     private Boolean isTransazioniHttpStatusAsEvent_outResponseCode = null;
  28488.     public boolean isTransazioniHttpStatusAsEvent_outResponseCode() {   
  28489.         if(this.isTransazioniHttpStatusAsEvent_outResponseCode==null){
  28490.             String pName = "org.openspcoop2.pdd.transazioni.httpStatusAsEvent.outResponseCode";
  28491.             try{ 
  28492.                 String name = null;
  28493.                 name = this.reader.getValueConvertEnvProperties(pName);
  28494.                 if(name==null){
  28495.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28496.                     name="false";
  28497.                 }
  28498.                 name = name.trim();
  28499.                 this.isTransazioniHttpStatusAsEvent_outResponseCode = Boolean.parseBoolean(name);
  28500.             } catch(java.lang.Exception e) {
  28501.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28502.                 this.isTransazioniHttpStatusAsEvent_outResponseCode = false;
  28503.             }    
  28504.         }

  28506.         return this.isTransazioniHttpStatusAsEvent_outResponseCode;
  28507.     }
  28508.     
  28509.     private Boolean isTransazioniTipoApiAsEvent = null;
  28510.     public boolean isTransazioniTipoApiAsEvent() {  
  28511.         if(this.isTransazioniTipoApiAsEvent==null){
  28512.             String pName = "org.openspcoop2.pdd.transazioni.tipoApiAsEvent";
  28513.             try{ 
  28514.                 String name = null;
  28515.                 name = this.reader.getValueConvertEnvProperties(pName);
  28516.                 if(name==null){
  28517.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28518.                     name="false";
  28519.                 }
  28520.                 name = name.trim();
  28521.                 this.isTransazioniTipoApiAsEvent = Boolean.parseBoolean(name);
  28522.             } catch(java.lang.Exception e) {
  28523.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28524.                 this.isTransazioniTipoApiAsEvent = false;
  28525.             }    
  28526.         }

  28528.         return this.isTransazioniTipoApiAsEvent;
  28529.     }
  28530.     
  28531.     private Boolean isTransazioniConnettoriMultipliAsEvent = null;
  28532.     public boolean isTransazioniConnettoriMultipliAsEvent() {   
  28533.         if(this.isTransazioniConnettoriMultipliAsEvent==null){
  28534.             String pName = "org.openspcoop2.pdd.transazioni.connettoriMultipliAsEvent";
  28535.             try{ 
  28536.                 String name = null;
  28537.                 name = this.reader.getValueConvertEnvProperties(pName);
  28538.                 if(name==null){
  28539.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28540.                     name="false";
  28541.                 }
  28542.                 name = name.trim();
  28543.                 this.isTransazioniConnettoriMultipliAsEvent = Boolean.parseBoolean(name);
  28544.             } catch(java.lang.Exception e) {
  28545.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28546.                 this.isTransazioniConnettoriMultipliAsEvent = false;
  28547.             }    
  28548.         }

  28550.         return this.isTransazioniConnettoriMultipliAsEvent;
  28551.     }
  28552.     
  28553.     private Boolean isTransazioniUpdateUseDayInterval = null;
  28554.     public boolean isTransazioniUpdateUseDayInterval() {    
  28555.         if(this.isTransazioniUpdateUseDayInterval==null){
  28556.             String pName = "org.openspcoop2.pdd.transazioni.update.useDayInterval";
  28557.             try{ 
  28558.                 String name = null;
  28559.                 name = this.reader.getValueConvertEnvProperties(pName);
  28560.                 if(name==null){
  28561.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28562.                     name="true";
  28563.                 }
  28564.                 name = name.trim();
  28565.                 this.isTransazioniUpdateUseDayInterval = Boolean.parseBoolean(name);
  28566.             } catch(java.lang.Exception e) {
  28567.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28568.                 this.isTransazioniUpdateUseDayInterval = true;
  28569.             }    
  28570.         }

  28572.         return this.isTransazioniUpdateUseDayInterval;
  28573.     }
  28574.     
  28575.     private Boolean isTransazioniRegistrazioneSlowLog = null;
  28576.     public boolean isTransazioniRegistrazioneSlowLog() {    
  28577.         if(this.isTransazioniRegistrazioneSlowLog==null){
  28578.             String pName = "org.openspcoop2.pdd.transazioni.slowLog.enabled";
  28579.             try{ 
  28580.                 String name = null;
  28581.                 name = this.reader.getValueConvertEnvProperties(pName);
  28582.                 if(name==null){
  28583.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28584.                     name="false";
  28585.                 }
  28586.                 name = name.trim();
  28587.                 this.isTransazioniRegistrazioneSlowLog = Boolean.parseBoolean(name);
  28588.             } catch(java.lang.Exception e) {
  28589.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28590.                 this.isTransazioniRegistrazioneSlowLog = false;
  28591.             }    
  28592.         }

  28594.         return this.isTransazioniRegistrazioneSlowLog;
  28595.     }
  28596.     
  28597.     private Integer getTransazioniRegistrazioneSlowLogThresholdMs = null;
  28598.     private final int getTransazioniRegistrazioneSlowLogThresholdMs_default = 1000;
  28599.     public int getTransazioniRegistrazioneSlowLogThresholdMs() {    
  28600.         if(this.getTransazioniRegistrazioneSlowLogThresholdMs==null){
  28601.             String pName = "org.openspcoop2.pdd.transazioni.slowLog.thresholdMs";
  28602.             try{ 
  28603.                 String name = null;
  28604.                 name = this.reader.getValueConvertEnvProperties(pName);
  28605.                 if(name==null){
  28606.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,this.getTransazioniRegistrazioneSlowLogThresholdMs_default));
  28607.                     name=""+this.getTransazioniRegistrazioneSlowLogThresholdMs_default;
  28608.                 }
  28609.                 name = name.trim();
  28610.                 this.getTransazioniRegistrazioneSlowLogThresholdMs = Integer.valueOf(name);
  28611.             } catch(java.lang.Exception e) {
  28612.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+this.getTransazioniRegistrazioneSlowLogThresholdMs_default+" : "+e.getMessage(),e);
  28613.                 this.getTransazioniRegistrazioneSlowLogThresholdMs = this.getTransazioniRegistrazioneSlowLogThresholdMs_default;
  28614.             }    
  28615.         }

  28617.         return this.getTransazioniRegistrazioneSlowLogThresholdMs;
  28618.     }
  28619.     
  28620.     private Boolean isTransazioniRegistrazioneSlowLogBuildTransactionDetails = null;
  28621.     public boolean isTransazioniRegistrazioneSlowLogBuildTransactionDetails() { 
  28622.         if(this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails==null){
  28623.             String pName = "org.openspcoop2.pdd.transazioni.slowLog.buildTransactionDetails.enabled";
  28624.             try{ 
  28625.                 String name = null;
  28626.                 name = this.reader.getValueConvertEnvProperties(pName);
  28627.                 if(name==null){
  28628.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28629.                     name="false";
  28630.                 }
  28631.                 name = name.trim();
  28632.                 this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails = Boolean.parseBoolean(name);
  28633.             } catch(java.lang.Exception e) {
  28634.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28635.                 this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails = false;
  28636.             }    
  28637.         }

  28639.         return this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails;
  28640.     }
  28641.     
  28642.     private Boolean isTransazioniRegistrazioneSlowLogRateLimitingDetails = null;
  28643.     public boolean isTransazioniRegistrazioneSlowLogRateLimitingDetails() { 
  28644.         if(this.isTransazioniRegistrazioneSlowLogRateLimitingDetails==null){
  28645.             String pName = "org.openspcoop2.pdd.transazioni.slowLog.rateLimitingDetails.enabled";
  28646.             try{ 
  28647.                 String name = null;
  28648.                 name = this.reader.getValueConvertEnvProperties(pName);
  28649.                 if(name==null){
  28650.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28651.                     name="false";
  28652.                 }
  28653.                 name = name.trim();
  28654.                 this.isTransazioniRegistrazioneSlowLogRateLimitingDetails = Boolean.parseBoolean(name);
  28655.             } catch(java.lang.Exception e) {
  28656.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28657.                 this.isTransazioniRegistrazioneSlowLogRateLimitingDetails = false;
  28658.             }    
  28659.         }

  28661.         return this.isTransazioniRegistrazioneSlowLogRateLimitingDetails;
  28662.     }
  28663.     
  28664.     private Boolean isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails = null;
  28665.     public boolean isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails() {   
  28666.         if(this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails==null){
  28667.             String pName = "org.openspcoop2.pdd.transazioni.slowLog.connettoriMultipli.processTransactionSADetails.enabled";
  28668.             try{ 
  28669.                 String name = null;
  28670.                 name = this.reader.getValueConvertEnvProperties(pName);
  28671.                 if(name==null){
  28672.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28673.                     name="false";
  28674.                 }
  28675.                 name = name.trim();
  28676.                 this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails = Boolean.parseBoolean(name);
  28677.             } catch(java.lang.Exception e) {
  28678.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28679.                 this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails = false;
  28680.             }    
  28681.         }

  28683.         return this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails;
  28684.     }
  28685.     
  28686.     private Boolean isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails = null;
  28687.     public boolean isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails() {  
  28688.         if(this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails==null){
  28689.             String pName = "org.openspcoop2.pdd.transazioni.slowLog.connettoriMultipli.updateTransactionDetails.enabled";
  28690.             try{ 
  28691.                 String name = null;
  28692.                 name = this.reader.getValueConvertEnvProperties(pName);
  28693.                 if(name==null){
  28694.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28695.                     name="false";
  28696.                 }
  28697.                 name = name.trim();
  28698.                 this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails = Boolean.parseBoolean(name);
  28699.             } catch(java.lang.Exception e) {
  28700.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28701.                 this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails = false;
  28702.             }    
  28703.         }

  28705.         return this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails;
  28706.     }
  28707.     
  28708.     
  28709.     // TracciamentoDB

  28711.     private Boolean isTransazioniTracciamentoDBOutRequestThrowRequestException = null;
  28712.     public boolean isTransazioniTracciamentoDBOutRequestThrowRequestException() {   
  28713.         if(this.isTransazioniTracciamentoDBOutRequestThrowRequestException==null){
  28714.             String pName = "org.openspcoop2.pdd.transazioni.tracciamentoDB.outRequest.throwRequestException";
  28715.             try{ 
  28716.                 String name = null;
  28717.                 name = this.reader.getValueConvertEnvProperties(pName);
  28718.                 if(name==null){
  28719.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28720.                     name="true";
  28721.                 }
  28722.                 name = name.trim();
  28723.                 this.isTransazioniTracciamentoDBOutRequestThrowRequestException = Boolean.parseBoolean(name);
  28724.             } catch(java.lang.Exception e) {
  28725.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28726.                 this.isTransazioniTracciamentoDBOutRequestThrowRequestException = true;
  28727.             }    
  28728.         }

  28730.         return this.isTransazioniTracciamentoDBOutRequestThrowRequestException;
  28731.     }
  28732.     
  28733.     private Boolean isTransazioniTracciamentoDBOutResponseThrowRequestException = null;
  28734.     public boolean isTransazioniTracciamentoDBOutResponseThrowRequestException() {  
  28735.         if(this.isTransazioniTracciamentoDBOutResponseThrowRequestException==null){
  28736.             String pName = "org.openspcoop2.pdd.transazioni.tracciamentoDB.outResponse.throwRequestException";
  28737.             try{ 
  28738.                 String name = null;
  28739.                 name = this.reader.getValueConvertEnvProperties(pName);
  28740.                 if(name==null){
  28741.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28742.                     name="true";
  28743.                 }
  28744.                 name = name.trim();
  28745.                 this.isTransazioniTracciamentoDBOutResponseThrowRequestException = Boolean.parseBoolean(name);
  28746.             } catch(java.lang.Exception e) {
  28747.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28748.                 this.isTransazioniTracciamentoDBOutResponseThrowRequestException = true;
  28749.             }    
  28750.         }

  28752.         return this.isTransazioniTracciamentoDBOutResponseThrowRequestException;
  28753.     }
  28754.     
  28755.     private Boolean isTransazioniTracciamentoDBPostOutResponseThrowRequestException = null;
  28756.     public boolean isTransazioniTracciamentoDBPostOutResponseThrowRequestException() {  
  28757.         if(this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException==null){
  28758.             String pName = "org.openspcoop2.pdd.transazioni.tracciamentoDB.postOutResponse.throwRequestException";
  28759.             try{ 
  28760.                 String name = null;
  28761.                 name = this.reader.getValueConvertEnvProperties(pName);
  28762.                 if(name==null){
  28763.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28764.                     name="true";
  28765.                 }
  28766.                 name = name.trim();
  28767.                 this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException = Boolean.parseBoolean(name);
  28768.             } catch(java.lang.Exception e) {
  28769.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28770.                 this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException = true;
  28771.             }    
  28772.         }

  28774.         return this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException;
  28775.     }
  28776.     
  28777.     private Boolean isTransazioniTracciamentoDBPostOutResponseThrowResponseException = null;
  28778.     public boolean isTransazioniTracciamentoDBPostOutResponseThrowResponseException() { 
  28779.         if(this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException==null){
  28780.             String pName = "org.openspcoop2.pdd.transazioni.tracciamentoDB.postOutResponse.throwResponseException";
  28781.             try{ 
  28782.                 String name = null;
  28783.                 name = this.reader.getValueConvertEnvProperties(pName);
  28784.                 if(name==null){
  28785.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28786.                     name="true";
  28787.                 }
  28788.                 name = name.trim();
  28789.                 this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException = Boolean.parseBoolean(name);
  28790.             } catch(java.lang.Exception e) {
  28791.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28792.                 this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException = true;
  28793.             }    
  28794.         }

  28796.         return this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException;
  28797.     }
  28798.     
  28799.     
  28800.     // FiltroDuplicati
  28801.     
  28802.     private Boolean isTransazioniFiltroDuplicatiSaveDateEnabled = null;
  28803.     private boolean _isTransazioniFiltroDuplicatiSaveDateEnabled() throws ProtocolException {   
  28804.         if(this.isTransazioniFiltroDuplicatiSaveDateEnabled==null){
  28805.             try{ 
  28806.                 String name = null;
  28807.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.duplicati.dateIdentificativiProtocolloInCampiSeparati");
  28808.                 if(name==null){
  28809.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.dateIdentificativiProtocolloInCampiSeparati' non impostata, viene utilizzato il default=true");
  28810.                     name="true";
  28811.                 }
  28812.                 name = name.trim();
  28813.                 this.isTransazioniFiltroDuplicatiSaveDateEnabled = Boolean.parseBoolean(name);
  28814.             } catch(java.lang.Exception e) {
  28815.                 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);
  28816.                 this.isTransazioniFiltroDuplicatiSaveDateEnabled = true;
  28817.             }    
  28818.         }

  28820.         return this.isTransazioniFiltroDuplicatiSaveDateEnabled;
  28821.     }
  28822.     public boolean isTransazioniFiltroDuplicatiSaveDateEnabled(IProtocolFactory<?> protocolFactory) throws ProtocolException {  
  28823.         return _isTransazioniFiltroDuplicatiSaveDateEnabled() && protocolFactory.createProtocolConfiguration().isDataPresenteInIdentificativoMessaggio();
  28824.     }
  28825.     
  28826.     private Boolean isTransazioniFiltroDuplicatiTramiteTransazioniEnabled = null;
  28827.     public boolean isTransazioniFiltroDuplicatiTramiteTransazioniEnabled() {    
  28828.         if(this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled==null){
  28829.             try{ 
  28830.                 String name = null;
  28831.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.enabled");
  28832.                 if(name==null){
  28833.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.enabled' non impostata, viene utilizzato il default=true");
  28834.                     name="true";
  28835.                 }
  28836.                 name = name.trim();
  28837.                 this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled = Boolean.parseBoolean(name);
  28838.             } catch(java.lang.Exception e) {
  28839.                 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);
  28840.                 this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled = true;
  28841.             }    
  28842.         }

  28844.         return this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled;
  28845.     }
  28846.     
  28847.     private Boolean isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection = null;
  28848.     public boolean isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection() {   
  28849.         if(this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection==null){
  28850.             try{ 
  28851.                 String name = null;
  28852.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.usePdDConnection");
  28853.                 if(name==null){
  28854.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.usePdDConnection' non impostata, viene utilizzato il default=true");
  28855.                     name="true";
  28856.                 }
  28857.                 name = name.trim();
  28858.                 this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection = Boolean.parseBoolean(name);
  28859.             } catch(java.lang.Exception e) {
  28860.                 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);
  28861.                 this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection = true;
  28862.             }    
  28863.         }

  28865.         return this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection;
  28866.     }
  28867.     
  28868.     private Boolean isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex = null;
  28869.     public boolean isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex() { 
  28870.         if(this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex==null){
  28871.             try{ 
  28872.                 String name = null;
  28873.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.forceIndex");
  28874.                 if(name==null){
  28875.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.forceIndex' non impostata, viene utilizzato il default=false");
  28876.                     name="false";
  28877.                 }
  28878.                 name = name.trim();
  28879.                 this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex = Boolean.parseBoolean(name);
  28880.             } catch(java.lang.Exception e) {
  28881.                 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);
  28882.                 this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex = false;
  28883.             }    
  28884.         }

  28886.         return this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex;
  28887.     }
  28888.     
  28889.     
  28890.     // Stateful
  28891.     
  28892.     private Boolean isTransazioniStatefulEnabled = null;
  28893.     public boolean isTransazioniStatefulEnabled() { 
  28894.         if(this.isTransazioniStatefulEnabled==null){
  28895.             try{ 
  28896.                 String name = null;
  28897.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.stateful.enabled");
  28898.                 if(name==null){
  28899.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.stateful.enabled' non impostata, viene utilizzato il default=true");
  28900.                     name="true";
  28901.                 }
  28902.                 name = name.trim();
  28903.                 this.isTransazioniStatefulEnabled = Boolean.parseBoolean(name);
  28904.             } catch(java.lang.Exception e) {
  28905.                 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);
  28906.                 this.isTransazioniStatefulEnabled = true;
  28907.             }    
  28908.         }

  28910.         return this.isTransazioniStatefulEnabled;
  28911.     }
  28912.     
  28913.     private Boolean isTransazioniStatefulDebug = null;
  28914.     public boolean isTransazioniStatefulDebug() {   
  28915.         if(this.isTransazioniStatefulDebug==null){
  28916.             try{ 
  28917.                 String name = null;
  28918.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.stateful.debug");
  28919.                 if(name==null){
  28920.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.stateful.debug' non impostata, viene utilizzato il default=true");
  28921.                     name="true";
  28922.                 }
  28923.                 name = name.trim();
  28924.                 this.isTransazioniStatefulDebug = Boolean.parseBoolean(name);
  28925.             } catch(java.lang.Exception e) {
  28926.                 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);
  28927.                 this.isTransazioniStatefulDebug = true;
  28928.             }    
  28929.         }

  28931.         return this.isTransazioniStatefulDebug;
  28932.     }
  28933.     
  28934.     private Integer getTransazioniStatefulTimerIntervalSeconds = null;
  28935.     public int getTransazioniStatefulTimerIntervalSeconds() throws CoreException {  
  28936.         if(this.getTransazioniStatefulTimerIntervalSeconds==null){
  28937.             try{ 
  28938.                 String name = null;
  28939.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.stateful.seconds");
  28940.                 if(name==null){
  28941.                     throw new CoreException("Proprieta' non impostata");
  28942.                 }
  28943.                 name = name.trim();
  28944.                 this.getTransazioniStatefulTimerIntervalSeconds = Integer.valueOf(name);
  28945.             } catch(java.lang.Exception e) {
  28946.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.stateful.seconds': "+e.getMessage(),e);
  28947.                 throw new CoreException(e.getMessage(),e);
  28948.             }    
  28949.         }

  28951.         return this.getTransazioniStatefulTimerIntervalSeconds;
  28952.     }
  28953.     
  28954.     
  28955.     // Salvataggio
  28956.     
  28957.     private Integer getTransazioniCredenzialiMittenteMaxLength = null;
  28958.     public int getTransazioniCredenzialiMittenteMaxLength() throws CoreException {  
  28959.         if(this.getTransazioniCredenzialiMittenteMaxLength==null){
  28960.             try{ 
  28961.                 String name = null;
  28962.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.credenzialiMittente.maxLength");
  28963.                 if(name==null){
  28964.                     throw new CoreException("Proprieta' non impostata");
  28965.                 }
  28966.                 name = name.trim();
  28967.                 this.getTransazioniCredenzialiMittenteMaxLength = Integer.valueOf(name);
  28968.             } catch(java.lang.Exception e) {
  28969.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.credenzialiMittente.maxLength': "+e.getMessage(),e);
  28970.                 throw new CoreException(e.getMessage(),e);
  28971.             }    
  28972.         }

  28974.         return this.getTransazioniCredenzialiMittenteMaxLength;
  28975.     }
  28976.     
  28977.     private Boolean getTransazioniCredenzialiMittenteLifeSeconds_read = null;
  28978.     private Integer getTransazioniCredenzialiMittenteLifeSeconds = null;
  28979.     public Integer getTransazioniCredenzialiMittenteLifeSeconds() throws CoreException {    
  28980.         if(this.getTransazioniCredenzialiMittenteLifeSeconds_read==null){
  28981.             try{ 
  28982.                 String name = null;
  28983.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.credenzialiMittente.updateAfterSeconds");
  28984.                 if(name==null){
  28985.                     throw new CoreException("Proprieta' non impostata");
  28986.                 }
  28987.                 name = name.trim();
  28988.                 this.getTransazioniCredenzialiMittenteLifeSeconds = Integer.valueOf(name);
  28989.             } catch(java.lang.Exception e) {
  28990.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.credenzialiMittente.updateAfterSeconds': "+e.getMessage(),e);
  28991.                 throw new CoreException(e.getMessage(),e);
  28992.             }    
  28993.             
  28994.             this.getTransazioniCredenzialiMittenteLifeSeconds_read = true;
  28995.         }

  28997.         return this.getTransazioniCredenzialiMittenteLifeSeconds;
  28998.     }
  28999.     
  29000.     private Boolean isTransazioniRegistrazioneTracceProtocolPropertiesEnabled = null;
  29001.     public boolean isTransazioniRegistrazioneTracceProtocolPropertiesEnabled() {    
  29002.         if(this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled==null){
  29003.             try{ 
  29004.                 String name = null;
  29005.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.protocolProperties.enabled");
  29006.                 if(name==null){
  29007.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.protocolProperties.enabled' non impostata, viene utilizzato il default=false");
  29008.                     name="false";
  29009.                 }
  29010.                 name = name.trim();
  29011.                 this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled = Boolean.parseBoolean(name);
  29012.             } catch(java.lang.Exception e) {
  29013.                 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);
  29014.                 this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled = false;
  29015.             }    
  29016.         }

  29018.         return this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled;
  29019.     }
  29020.     
  29021.     private Boolean isTransazioniRegistrazioneTracceHeaderRawEnabled = null;
  29022.     public boolean isTransazioniRegistrazioneTracceHeaderRawEnabled() { 
  29023.         if(this.isTransazioniRegistrazioneTracceHeaderRawEnabled==null){
  29024.             try{ 
  29025.                 String name = null;
  29026.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.headerRaw.enabled");
  29027.                 if(name==null){
  29028.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.headerRaw.enabled' non impostata, viene utilizzato il default=false");
  29029.                     name="false";
  29030.                 }
  29031.                 name = name.trim();
  29032.                 this.isTransazioniRegistrazioneTracceHeaderRawEnabled = Boolean.parseBoolean(name);
  29033.             } catch(java.lang.Exception e) {
  29034.                 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);
  29035.                 this.isTransazioniRegistrazioneTracceHeaderRawEnabled = false;
  29036.             }    
  29037.         }

  29039.         return this.isTransazioniRegistrazioneTracceHeaderRawEnabled;
  29040.     }
  29041.     
  29042.     private Boolean isTransazioniRegistrazioneTracceDigestEnabled = null;
  29043.     public boolean isTransazioniRegistrazioneTracceDigestEnabled() {    
  29044.         if(this.isTransazioniRegistrazioneTracceDigestEnabled==null){
  29045.             try{ 
  29046.                 String name = null;
  29047.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.digest.enabled");
  29048.                 if(name==null){
  29049.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.digest.enabled' non impostata, viene utilizzato il default=false");
  29050.                     name="false";
  29051.                 }
  29052.                 name = name.trim();
  29053.                 this.isTransazioniRegistrazioneTracceDigestEnabled = Boolean.parseBoolean(name);
  29054.             } catch(java.lang.Exception e) {
  29055.                 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);
  29056.                 this.isTransazioniRegistrazioneTracceDigestEnabled = false;
  29057.             }    
  29058.         }

  29060.         return this.isTransazioniRegistrazioneTracceDigestEnabled;
  29061.     }
  29062.     
  29063.     private ISalvataggioTracceManager getTransazioniRegistrazioneTracceManager = null;
  29064.     private Boolean getTransazioniRegistrazioneTracceManager_read = null;
  29065.     public ISalvataggioTracceManager getTransazioniRegistrazioneTracceManager() throws CoreException {  
  29066.         return this.getTransazioniRegistrazioneTracceManager;
  29067.     }
  29068.     private ISalvataggioTracceManager _getTransazioniRegistrazioneTracceManager(ClassNameProperties className, Loader loader) throws CoreException {    
  29069.         if(this.getTransazioniRegistrazioneTracceManager_read==null){
  29070.             try{ 
  29071.                 String name = null;
  29072.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.salvataggio");
  29073.                 if(name!=null){
  29074.                     name = name.trim();
  29075.                     
  29076.                     String classe = className.getSalvataggioTracceManager(name);
  29077.                     if(classe == null) {
  29078.                         throw new CoreException("Classe non trovata per il salvataggio delle tracce con tipo '"+name+"'");
  29079.                     }
  29080.                     
  29081.                     this.getTransazioniRegistrazioneTracceManager = (ISalvataggioTracceManager) loader.newInstance(classe);
  29082.                 }
  29083.                 
  29084.                 this.getTransazioniRegistrazioneTracceManager_read = true;
  29085.                 
  29086.             } catch(java.lang.Exception e) {
  29087.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.salvataggio': "+e.getMessage(),e);
  29088.                 throw new CoreException(e.getMessage(),e);
  29089.             }    
  29090.         }

  29092.         return this.getTransazioniRegistrazioneTracceManager;
  29093.     }
  29094.     
  29095.     private ISalvataggioDiagnosticiManager getTransazioniRegistrazioneDiagnosticiManager = null;
  29096.     private Boolean getTransazioniRegistrazioneDiagnosticiManager_read = null;
  29097.     public ISalvataggioDiagnosticiManager getTransazioniRegistrazioneDiagnosticiManager() throws CoreException {    
  29098.         return this.getTransazioniRegistrazioneDiagnosticiManager;
  29099.     }
  29100.     private ISalvataggioDiagnosticiManager _getTransazioniRegistrazioneDiagnosticiManager(ClassNameProperties className, Loader loader) throws CoreException {  
  29101.         if(this.getTransazioniRegistrazioneDiagnosticiManager_read==null){
  29102.             try{ 
  29103.                 String name = null;
  29104.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.diagnostici.salvataggio");
  29105.                 if(name!=null){
  29106.                     name = name.trim();
  29107.                     
  29108.                     String classe = className.getSalvataggioDiagnosticiManager(name);
  29109.                     if(classe == null) {
  29110.                         throw new CoreException("Classe non trovata per il salvataggio dei diagnostici con tipo '"+name+"'");
  29111.                     }
  29112.                     
  29113.                     this.getTransazioniRegistrazioneDiagnosticiManager = (ISalvataggioDiagnosticiManager) loader.newInstance(classe);
  29114.                 }
  29115.                 
  29116.                 this.getTransazioniRegistrazioneDiagnosticiManager_read = true;
  29117.                 
  29118.             } catch(java.lang.Exception e) {
  29119.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.diagnostici.salvataggio': "+e.getMessage(),e);
  29120.                 throw new CoreException(e.getMessage(),e);
  29121.             }    
  29122.         }

  29124.         return this.getTransazioniRegistrazioneDiagnosticiManager;
  29125.     }
  29126.     
  29127.     private Boolean isTransazioniRegistrazioneDumpHeadersCompactEnabled = null;
  29128.     public boolean isTransazioniRegistrazioneDumpHeadersCompactEnabled() {  
  29129.         if(this.isTransazioniRegistrazioneDumpHeadersCompactEnabled==null){
  29130.             try{ 
  29131.                 String name = null;
  29132.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.dump.headers.compact.enabled");
  29133.                 if(name==null){
  29134.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dump.headers.compact.enabled' non impostata, viene utilizzato il default=false");
  29135.                     name="false";
  29136.                 }
  29137.                 name = name.trim();
  29138.                 this.isTransazioniRegistrazioneDumpHeadersCompactEnabled = Boolean.parseBoolean(name);
  29139.             } catch(java.lang.Exception e) {
  29140.                 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);
  29141.                 this.isTransazioniRegistrazioneDumpHeadersCompactEnabled = false;
  29142.             }    
  29143.         }

  29145.         return this.isTransazioniRegistrazioneDumpHeadersCompactEnabled;
  29146.     }
  29147.     
  29148.     // Trace su File
  29149.     
  29150.     private Boolean isTransazioniFileTraceEnabled = null;
  29151.     public boolean isTransazioniFileTraceEnabled() {    
  29152.         if(this.isTransazioniFileTraceEnabled==null){
  29153.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.enabled";
  29154.             try{ 
  29155.                 String name = null;
  29156.                 name = this.reader.getValueConvertEnvProperties(pName);
  29157.                 if(name==null){
  29158.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  29159.                     name="false";
  29160.                 }
  29161.                 name = name.trim();
  29162.                 this.isTransazioniFileTraceEnabled = Boolean.parseBoolean(name);
  29163.             } catch(java.lang.Exception e) {
  29164.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  29165.                 this.isTransazioniFileTraceEnabled = false;
  29166.             }    
  29167.         }

  29169.         return this.isTransazioniFileTraceEnabled;
  29170.     }
  29171.     
  29172.     private Boolean isTransazioniFileTraceDumpBinarioPDEnabled = null;
  29173.     public boolean isTransazioniFileTraceDumpBinarioPDEnabled() {   
  29174.         if(this.isTransazioniFileTraceDumpBinarioPDEnabled==null){
  29175.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.enabled";
  29176.             try{ 
  29177.                 String name = null;
  29178.                 name = this.reader.getValueConvertEnvProperties(pName);
  29179.                 if(name==null){
  29180.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  29181.                     name="false";
  29182.                 }
  29183.                 name = name.trim();
  29184.                 this.isTransazioniFileTraceDumpBinarioPDEnabled = Boolean.parseBoolean(name);
  29185.             } catch(java.lang.Exception e) {
  29186.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  29187.                 this.isTransazioniFileTraceDumpBinarioPDEnabled = false;
  29188.             }    
  29189.         }

  29191.         return this.isTransazioniFileTraceDumpBinarioPDEnabled;
  29192.     }
  29193.     private Boolean isTransazioniFileTraceDumpBinarioPDPayloadEnabled = null;
  29194.     public boolean isTransazioniFileTraceDumpBinarioPDPayloadEnabled() {    
  29195.         if(this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled==null){
  29196.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.payload.enabled";
  29197.             try{ 
  29198.                 String name = null;
  29199.                 name = this.reader.getValueConvertEnvProperties(pName);
  29200.                 if(name==null || "".equals(name)){
  29201.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPDEnabled()));
  29202.                     name=""+isTransazioniFileTraceDumpBinarioPDEnabled();
  29203.                 }
  29204.                 name = name.trim();
  29205.                 this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled = Boolean.parseBoolean(name);
  29206.             } catch(java.lang.Exception e) {
  29207.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPDEnabled()+" : "+e.getMessage(),e);
  29208.                 this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled = isTransazioniFileTraceDumpBinarioPDEnabled();
  29209.             }    
  29210.         }

  29212.         return this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled;
  29213.     }
  29214.     private Boolean isTransazioniFileTraceDumpBinarioPDHeadersEnabled = null;
  29215.     public boolean isTransazioniFileTraceDumpBinarioPDHeadersEnabled() {    
  29216.         if(this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled==null){
  29217.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.headers.enabled";
  29218.             try{ 
  29219.                 String name = null;
  29220.                 name = this.reader.getValueConvertEnvProperties(pName);
  29221.                 if(name==null || "".equals(name)){
  29222.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPDEnabled()));
  29223.                     name=""+isTransazioniFileTraceDumpBinarioPDEnabled();
  29224.                 }
  29225.                 name = name.trim();
  29226.                 this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled = Boolean.parseBoolean(name);
  29227.             } catch(java.lang.Exception e) {
  29228.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPDEnabled()+" : "+e.getMessage(),e);
  29229.                 this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled = isTransazioniFileTraceDumpBinarioPDEnabled();
  29230.             }    
  29231.         }

  29233.         return this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled;
  29234.     }
  29235.     
  29236.     private Boolean isTransazioniFileTraceDumpBinarioPDConnettoreEnabled = null;
  29237.     public boolean isTransazioniFileTraceDumpBinarioPDConnettoreEnabled() { 
  29238.         if(this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled==null){
  29239.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.connettore.enabled";
  29240.             try{ 
  29241.                 String name = null;
  29242.                 name = this.reader.getValueConvertEnvProperties(pName);
  29243.                 if(name==null){
  29244.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  29245.                     name="false";
  29246.                 }
  29247.                 name = name.trim();
  29248.                 this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled = Boolean.parseBoolean(name);
  29249.             } catch(java.lang.Exception e) {
  29250.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  29251.                 this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled = false;
  29252.             }    
  29253.         }

  29255.         return this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled;
  29256.     }
  29257.     private Boolean isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled = null;
  29258.     public boolean isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled() {  
  29259.         if(this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled==null){
  29260.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.connettore.payload.enabled";
  29261.             try{ 
  29262.                 String name = null;
  29263.                 name = this.reader.getValueConvertEnvProperties(pName);
  29264.                 if(name==null || "".equals(name)){
  29265.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()));
  29266.                     name=""+isTransazioniFileTraceDumpBinarioPDConnettoreEnabled();
  29267.                 }
  29268.                 name = name.trim();
  29269.                 this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled = Boolean.parseBoolean(name);
  29270.             } catch(java.lang.Exception e) {
  29271.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()+" : "+e.getMessage(),e);
  29272.                 this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled = isTransazioniFileTraceDumpBinarioPDConnettoreEnabled();
  29273.             }    
  29274.         }

  29276.         return this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled;
  29277.     }
  29278.     private Boolean isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled = null;
  29279.     public boolean isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled() {  
  29280.         if(this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled==null){
  29281.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.connettore.headers.enabled";
  29282.             try{ 
  29283.                 String name = null;
  29284.                 name = this.reader.getValueConvertEnvProperties(pName);
  29285.                 if(name==null || "".equals(name)){
  29286.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()));
  29287.                     name=""+isTransazioniFileTraceDumpBinarioPDConnettoreEnabled();
  29288.                 }
  29289.                 name = name.trim();
  29290.                 this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled = Boolean.parseBoolean(name);
  29291.             } catch(java.lang.Exception e) {
  29292.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()+" : "+e.getMessage(),e);
  29293.                 this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled = isTransazioniFileTraceDumpBinarioPDConnettoreEnabled();
  29294.             }    
  29295.         }

  29297.         return this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled;
  29298.     }
  29299.     
  29300.     private Boolean isTransazioniFileTraceDumpBinarioPAEnabled = null;
  29301.     public boolean isTransazioniFileTraceDumpBinarioPAEnabled() {   
  29302.         if(this.isTransazioniFileTraceDumpBinarioPAEnabled==null){
  29303.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.enabled";
  29304.             try{ 
  29305.                 String name = null;
  29306.                 name = this.reader.getValueConvertEnvProperties(pName);
  29307.                 if(name==null){
  29308.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  29309.                     name="false";
  29310.                 }
  29311.                 name = name.trim();
  29312.                 this.isTransazioniFileTraceDumpBinarioPAEnabled = Boolean.parseBoolean(name);
  29313.             } catch(java.lang.Exception e) {
  29314.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  29315.                 this.isTransazioniFileTraceDumpBinarioPAEnabled = false;
  29316.             }    
  29317.         }

  29319.         return this.isTransazioniFileTraceDumpBinarioPAEnabled;
  29320.     }
  29321.     private Boolean isTransazioniFileTraceDumpBinarioPAPayloadEnabled = null;
  29322.     public boolean isTransazioniFileTraceDumpBinarioPAPayloadEnabled() {    
  29323.         if(this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled==null){
  29324.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.payload.enabled";
  29325.             try{ 
  29326.                 String name = null;
  29327.                 name = this.reader.getValueConvertEnvProperties(pName);
  29328.                 if(name==null || "".equals(name)){
  29329.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPAEnabled()));
  29330.                     name=""+isTransazioniFileTraceDumpBinarioPAEnabled();
  29331.                 }
  29332.                 name = name.trim();
  29333.                 this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled = Boolean.parseBoolean(name);
  29334.             } catch(java.lang.Exception e) {
  29335.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPAEnabled()+" : "+e.getMessage(),e);
  29336.                 this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled = isTransazioniFileTraceDumpBinarioPAEnabled();
  29337.             }    
  29338.         }

  29340.         return this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled;
  29341.     }
  29342.     private Boolean isTransazioniFileTraceDumpBinarioPAHeadersEnabled = null;
  29343.     public boolean isTransazioniFileTraceDumpBinarioPAHeadersEnabled() {    
  29344.         if(this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled==null){
  29345.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.headers.enabled";
  29346.             try{ 
  29347.                 String name = null;
  29348.                 name = this.reader.getValueConvertEnvProperties(pName);
  29349.                 if(name==null || "".equals(name)){
  29350.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPAEnabled()));
  29351.                     name=""+isTransazioniFileTraceDumpBinarioPAEnabled();
  29352.                 }
  29353.                 name = name.trim();
  29354.                 this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled = Boolean.parseBoolean(name);
  29355.             } catch(java.lang.Exception e) {
  29356.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPAEnabled()+" : "+e.getMessage(),e);
  29357.                 this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled = isTransazioniFileTraceDumpBinarioPAEnabled();
  29358.             }    
  29359.         }

  29361.         return this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled;
  29362.     }

  29364.     
  29365.     private Boolean isTransazioniFileTraceDumpBinarioPAConnettoreEnabled = null;
  29366.     public boolean isTransazioniFileTraceDumpBinarioPAConnettoreEnabled() { 
  29367.         if(this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled==null){
  29368.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.connettore.enabled";
  29369.             try{ 
  29370.                 String name = null;
  29371.                 name = this.reader.getValueConvertEnvProperties(pName);
  29372.                 if(name==null){
  29373.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  29374.                     name="false";
  29375.                 }
  29376.                 name = name.trim();
  29377.                 this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled = Boolean.parseBoolean(name);
  29378.             } catch(java.lang.Exception e) {
  29379.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  29380.                 this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled = false;
  29381.             }    
  29382.         }

  29384.         return this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled;
  29385.     }
  29386.     private Boolean isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled = null;
  29387.     public boolean isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled() {  
  29388.         if(this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled==null){
  29389.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.connettore.payload.enabled";
  29390.             try{ 
  29391.                 String name = null;
  29392.                 name = this.reader.getValueConvertEnvProperties(pName);
  29393.                 if(name==null || "".equals(name)){
  29394.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()));
  29395.                     name=""+isTransazioniFileTraceDumpBinarioPAConnettoreEnabled();
  29396.                 }
  29397.                 name = name.trim();
  29398.                 this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled = Boolean.parseBoolean(name);
  29399.             } catch(java.lang.Exception e) {
  29400.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()+" : "+e.getMessage(),e);
  29401.                 this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled = isTransazioniFileTraceDumpBinarioPAConnettoreEnabled();
  29402.             }    
  29403.         }

  29405.         return this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled;
  29406.     }
  29407.     private Boolean isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled = null;
  29408.     public boolean isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled() {  
  29409.         if(this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled==null){
  29410.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.connettore.headers.enabled";
  29411.             try{ 
  29412.                 String name = null;
  29413.                 name = this.reader.getValueConvertEnvProperties(pName);
  29414.                 if(name==null || "".equals(name)){
  29415.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()));
  29416.                     name=""+isTransazioniFileTraceDumpBinarioPAConnettoreEnabled();
  29417.                 }
  29418.                 name = name.trim();
  29419.                 this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled = Boolean.parseBoolean(name);
  29420.             } catch(java.lang.Exception e) {
  29421.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()+" : "+e.getMessage(),e);
  29422.                 this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled = isTransazioniFileTraceDumpBinarioPAConnettoreEnabled();
  29423.             }    
  29424.         }

  29426.         return this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled;
  29427.     }
  29428.     
  29429.     private Boolean isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase = null;
  29430.     public boolean isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase() {  
  29431.         if(this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase==null){
  29432.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinario.releaseInLastTrackingPhase";
  29433.             try{ 
  29434.                 String name = null;
  29435.                 name = this.reader.getValueConvertEnvProperties(pName);
  29436.                 if(name==null || "".equals(name)){
  29437.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,true));
  29438.                     name=""+true;
  29439.                 }
  29440.                 name = name.trim();
  29441.                 this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase = Boolean.parseBoolean(name);
  29442.             } catch(java.lang.Exception e) {
  29443.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+true+" : "+e.getMessage(),e);
  29444.                 this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase = true;
  29445.             }    
  29446.         }

  29448.         return this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase;
  29449.     }

  29451.     private File getTransazioniFileTraceConfig = null;
  29452.     public File getTransazioniFileTraceConfig() throws CoreException {  
  29453.         if(this.getTransazioniFileTraceConfig==null){
  29454.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.config";
  29455.             try{ 
  29456.                 String name = null;
  29457.                 name = this.reader.getValueConvertEnvProperties(pName);
  29458.                 if(name==null){
  29459.                     throw new CoreException("Proprieta' non impostata");
  29460.                 }
  29461.                 name = name.trim();
  29462.                 
  29463.                 this.getTransazioniFileTraceConfig = ConfigurazioneTracciamento.toFileTraceConfig(name, this.getRootDirectory(), false);
  29464.                 
  29465.             } catch(java.lang.Exception e) {
  29466.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  29467.                 throw new CoreException(e.getMessage(),e);
  29468.             }    
  29469.         }

  29471.         return this.getTransazioniFileTraceConfig;
  29472.     }
  29473.     
  29474.     public FileTraceGovWayState getFileTraceGovWayState() {
  29475.         FileTraceGovWayState state = new FileTraceGovWayState();
  29476.         state.setEnabled(this.isTransazioniFileTraceEnabled());
  29477.         if(state.isEnabled()) {
  29478.             try {
  29479.                 state.setPath(this.getTransazioniFileTraceConfig().getAbsolutePath());
  29480.             }catch(Exception e) {
  29481.                 state.setPath("ERROR: "+e.getMessage());
  29482.             }
  29483.             state.setEnabledInErogazione(this.isTransazioniFileTraceDumpBinarioPAEnabled());
  29484.             if(this.isTransazioniFileTraceDumpBinarioPAEnabled()) {
  29485.                 state.setEnabledInErogazione_headers(this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled());
  29486.                 state.setEnabledInErogazione_payload(this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled());
  29487.             }
  29488.             
  29489.             state.setEnabledOutErogazione(this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled());
  29490.             if(this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()) {
  29491.                 state.setEnabledOutErogazione_headers(this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled());
  29492.                 state.setEnabledOutErogazione_payload(this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled());
  29493.             }
  29494.             
  29495.             state.setEnabledInFruizione(this.isTransazioniFileTraceDumpBinarioPDEnabled());
  29496.             if(this.isTransazioniFileTraceDumpBinarioPDEnabled()) {
  29497.                 state.setEnabledInFruizione_headers(this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled());
  29498.                 state.setEnabledInFruizione_payload(this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled());
  29499.             }
  29500.             
  29501.             state.setEnabledOutFruizione(this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled());
  29502.             if(this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()) {
  29503.                 state.setEnabledOutFruizione_headers(this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled());
  29504.                 state.setEnabledOutFruizione_payload(this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled());
  29505.             }
  29506.         }
  29507.         return state;
  29508.     }
  29509.     
  29510.     
  29511.     /* ------------- Testsuite ---------------------*/
  29512.     
  29513.     private String getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit = null;
  29514.     private Boolean getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommitRead = null;
  29515.     public String getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit() throws CoreException { 
  29516.         if(this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommitRead==null){
  29517.             String pName = "org.openspcoop2.pdd.transazioni.testsuite.manuallyFaultHeader.db.beforeCommit";
  29518.             try{ 
  29519.                 String name = null;
  29520.                 name = this.reader.getValueConvertEnvProperties(pName);
  29521.                 if(name!=null){
  29522.                     name = name.trim();
  29523.                     this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit = name;
  29524.                 }
  29525.             } catch(java.lang.Exception e) {
  29526.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  29527.                 throw new CoreException(e.getMessage(),e);
  29528.             }    
  29529.             this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommitRead=true;
  29530.         }

  29532.         return this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit;
  29533.     }
  29534.     
  29535.     private String getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog = null;
  29536.     private Boolean getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLogRead = null;
  29537.     public String getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog() throws CoreException { 
  29538.         if(this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLogRead==null){
  29539.             String pName = "org.openspcoop2.pdd.transazioni.testsuite.manuallyFaultHeader.fileTrace.beforeLog";
  29540.             try{ 
  29541.                 String name = null;
  29542.                 name = this.reader.getValueConvertEnvProperties(pName);
  29543.                 if(name!=null){
  29544.                     name = name.trim();
  29545.                     this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog = name;
  29546.                 }
  29547.             } catch(java.lang.Exception e) {
  29548.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  29549.                 throw new CoreException(e.getMessage(),e);
  29550.             }    
  29551.             this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLogRead=true;
  29552.         }

  29554.         return this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog;
  29555.     }
  29556.     
  29557.     /* ------------- Eventi ---------------------*/
  29558.     
  29559.     private Boolean isEventiEnabled = null;
  29560.     public boolean isEventiEnabled() {  
  29561.         if(this.isEventiEnabled==null){
  29562.             try{ 
  29563.                 String name = null;
  29564.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.enabled");
  29565.                 if(name==null){
  29566.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.enabled' non impostata, viene utilizzato il default=true");
  29567.                     name="true";
  29568.                 }
  29569.                 name = name.trim();
  29570.                 this.isEventiEnabled = Boolean.parseBoolean(name);
  29571.             } catch(java.lang.Exception e) {
  29572.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
  29573.                 this.isEventiEnabled = true;
  29574.             }    
  29575.         }

  29577.         return this.isEventiEnabled;
  29578.     }
  29579.     
  29580.     private Boolean isEventiDebug = null;
  29581.     public boolean isEventiDebug() {    
  29582.         if(this.isEventiDebug==null){
  29583.             try{ 
  29584.                 String name = null;
  29585.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.debug");
  29586.                 if(name==null){
  29587.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.debug' non impostata, viene utilizzato il default=true");
  29588.                     name="true";
  29589.                 }
  29590.                 name = name.trim();
  29591.                 this.isEventiDebug = Boolean.parseBoolean(name);
  29592.             } catch(java.lang.Exception e) {
  29593.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.debug', viene utilizzato il default=true : "+e.getMessage(),e);
  29594.                 this.isEventiDebug = true;
  29595.             }    
  29596.         }

  29598.         return this.isEventiDebug;
  29599.     }
  29600.     
  29601.     private Boolean isEventiRegistrazioneStatoPorta = null;
  29602.     public boolean isEventiRegistrazioneStatoPorta() {  
  29603.         if(this.isEventiRegistrazioneStatoPorta==null){
  29604.             try{ 
  29605.                 String name = null;
  29606.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.registraStatoPorta");
  29607.                 if(name==null){
  29608.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.registraStatoPorta' non impostata, viene utilizzato il default=true");
  29609.                     name="true";
  29610.                 }
  29611.                 name = name.trim();
  29612.                 this.isEventiRegistrazioneStatoPorta = Boolean.parseBoolean(name);
  29613.             } catch(java.lang.Exception e) {
  29614.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.registraStatoPorta', viene utilizzato il default=true : "+e.getMessage(),e);
  29615.                 this.isEventiRegistrazioneStatoPorta = true;
  29616.             }    
  29617.         }

  29619.         return this.isEventiRegistrazioneStatoPorta;
  29620.     }
  29621.     
  29622.     private Boolean isEventiTimerEnabled = null;
  29623.     public boolean isEventiTimerEnabled() { 
  29624.         if(this.isEventiTimerEnabled==null){
  29625.             try{ 
  29626.                 String name = null;
  29627.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.timer.enabled");
  29628.                 if(name==null){
  29629.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.timer.enabled' non impostata, viene utilizzato il default=true");
  29630.                     name="true";
  29631.                 }
  29632.                 name = name.trim();
  29633.                 this.isEventiTimerEnabled = Boolean.parseBoolean(name);
  29634.             } catch(java.lang.Exception e) {
  29635.                 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);
  29636.                 this.isEventiTimerEnabled = true;
  29637.             }    
  29638.         }

  29640.         return this.isEventiTimerEnabled;
  29641.     }
  29642.     
  29643.     private Integer getEventiTimerIntervalSeconds = null;
  29644.     public int getEventiTimerIntervalSeconds() throws CoreException {   
  29645.         if(this.getEventiTimerIntervalSeconds==null){
  29646.             try{ 
  29647.                 String name = null;
  29648.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.timer.seconds");
  29649.                 if(name==null){
  29650.                     throw new CoreException("Proprieta' non impostata");
  29651.                 }
  29652.                 name = name.trim();
  29653.                 this.getEventiTimerIntervalSeconds = Integer.valueOf(name);
  29654.             } catch(java.lang.Exception e) {
  29655.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.timer.seconds': "+e.getMessage(),e);
  29656.                 throw new CoreException(e.getMessage(),e);
  29657.             }    
  29658.         }

  29660.         return this.getEventiTimerIntervalSeconds;
  29661.     }
  29662.     
  29663.     private Integer getEventiTimerIntervalConnectionTimeoutEveryXTimes = null;
  29664.     public int getEventiTimerIntervalConnectionTimeoutEveryXTimes() throws CoreException {  
  29665.         if(this.getEventiTimerIntervalConnectionTimeoutEveryXTimes==null){
  29666.             String pName = "org.openspcoop2.pdd.eventi.timer.connectionTimeout.everyXtimes";
  29667.             try{ 
  29668.                 String name = null;
  29669.                 name = this.reader.getValueConvertEnvProperties(pName);
  29670.                 if(name==null){
  29671.                     throw new CoreException("Proprieta' non impostata");
  29672.                 }
  29673.                 name = name.trim();
  29674.                 this.getEventiTimerIntervalConnectionTimeoutEveryXTimes = Integer.valueOf(name);
  29675.                 if(this.getEventiTimerIntervalConnectionTimeoutEveryXTimes<=0) {
  29676.                     this.getEventiTimerIntervalConnectionTimeoutEveryXTimes = 1;
  29677.                 }
  29678.             } catch(java.lang.Exception e) {
  29679.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+5+" : "+e.getMessage(),e);
  29680.                 this.getEventiTimerIntervalConnectionTimeoutEveryXTimes = 5;
  29681.             }    
  29682.         }

  29684.         return this.getEventiTimerIntervalConnectionTimeoutEveryXTimes;
  29685.     }
  29686.     
  29687.     private Integer getEventiTimerIntervalRequestReadTimeoutEveryXTimes = null;
  29688.     public int getEventiTimerIntervalRequestReadTimeoutEveryXTimes() throws CoreException { 
  29689.         if(this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes==null){
  29690.             String pName = "org.openspcoop2.pdd.eventi.timer.requestReadTimeout.everyXtimes";
  29691.             try{ 
  29692.                 String name = null;
  29693.                 name = this.reader.getValueConvertEnvProperties(pName);
  29694.                 if(name==null){
  29695.                     throw new CoreException("Proprieta' non impostata");
  29696.                 }
  29697.                 name = name.trim();
  29698.                 this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes = Integer.valueOf(name);
  29699.                 if(this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes<=0) {
  29700.                     this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes = 1;
  29701.                 }
  29702.             } catch(java.lang.Exception e) {
  29703.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=5 : "+e.getMessage(),e);
  29704.                 this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes = 5;
  29705.             }    
  29706.         }

  29708.         return this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes;
  29709.     }
  29710.     
  29711.     private Integer getEventiTimerIntervalReadTimeoutEveryXTimes = null;
  29712.     public int getEventiTimerIntervalReadTimeoutEveryXTimes() throws CoreException {    
  29713.         if(this.getEventiTimerIntervalReadTimeoutEveryXTimes==null){
  29714.             String pName = "org.openspcoop2.pdd.eventi.timer.readTimeout.everyXtimes";
  29715.             try{ 
  29716.                 String name = null;
  29717.                 name = this.reader.getValueConvertEnvProperties(pName);
  29718.                 if(name==null){
  29719.                     throw new CoreException("Proprieta' non impostata");
  29720.                 }
  29721.                 name = name.trim();
  29722.                 this.getEventiTimerIntervalReadTimeoutEveryXTimes = Integer.valueOf(name);
  29723.                 if(this.getEventiTimerIntervalReadTimeoutEveryXTimes<=0) {
  29724.                     this.getEventiTimerIntervalReadTimeoutEveryXTimes = 1;
  29725.                 }
  29726.             } catch(java.lang.Exception e) {
  29727.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=5 : "+e.getMessage(),e);
  29728.                 this.getEventiTimerIntervalReadTimeoutEveryXTimes = 5;
  29729.             }    
  29730.         }

  29732.         return this.getEventiTimerIntervalReadTimeoutEveryXTimes;
  29733.     }
  29734.     
  29735.     
  29736.     
  29737.     
  29738.     /* ------------- Repository ---------------------*/
  29739.     
  29740.     private File getFileSystemRecoveryRepository = null;
  29741.     public File getFileSystemRecoveryRepository() throws CoreException {    
  29742.         if(this.getFileSystemRecoveryRepository==null){
  29743.             try{ 
  29744.                 String name = null;
  29745.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.repository");
  29746.                 if(name==null){
  29747.                     throw new CoreException("Proprieta' non impostata");
  29748.                 }
  29749.                 name = LoggerWrapperFactory.applyClusterIdStrategy(name.trim(), "resources");
  29750.                 this.getFileSystemRecoveryRepository = new File(name);
  29751.                 checkFileSystemRecoveryRepository();
  29752.             } catch(java.lang.Exception e) {
  29753.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.repository': "+e.getMessage(),e);
  29754.                 throw new CoreException(e.getMessage(),e);
  29755.             }    
  29756.         }

  29758.         return this.getFileSystemRecoveryRepository;
  29759.     }
  29760.     private void checkFileSystemRecoveryRepository() throws CoreException {
  29761.         if(this.getFileSystemRecoveryRepository.exists()) {
  29762.             if(!this.getFileSystemRecoveryRepository.isDirectory()) {
  29763.                 throw newCoreExceptionNotDir(this.getFileSystemRecoveryRepository,true);
  29764.             }
  29765.             if(!this.getFileSystemRecoveryRepository.canRead()) {
  29766.                 throw newCoreExceptionCannotRead(this.getFileSystemRecoveryRepository,true);
  29767.             }
  29768.             if(!this.getFileSystemRecoveryRepository.canWrite()) {
  29769.                 throw newCoreExceptionCannotWrite(this.getFileSystemRecoveryRepository,true);
  29770.             }
  29771.         }
  29772.         else {
  29773.             // viene creata automaticamente
  29774.         }
  29775.     }
  29776.     
  29777.     private Boolean isFileSystemRecoveryDebug = null;
  29778.     public boolean isFileSystemRecoveryDebug() {    
  29779.         if(this.isFileSystemRecoveryDebug==null){
  29780.             try{ 
  29781.                 String name = null;
  29782.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.debug");
  29783.                 if(name==null){
  29784.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.debug' non impostata, viene utilizzato il default=true");
  29785.                     name="true";
  29786.                 }
  29787.                 name = name.trim();
  29788.                 this.isFileSystemRecoveryDebug = Boolean.parseBoolean(name);
  29789.             } catch(java.lang.Exception e) {
  29790.                 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);
  29791.                 this.isFileSystemRecoveryDebug = true;
  29792.             }    
  29793.         }

  29795.         return this.isFileSystemRecoveryDebug;
  29796.     }
  29797.     
  29798.     private Boolean isFileSystemRecoveryTimerEnabled = null;
  29799.     public boolean isFileSystemRecoveryTimerEnabled() { 
  29800.         if(this.isFileSystemRecoveryTimerEnabled==null){
  29801.             try{ 
  29802.                 String name = null;
  29803.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.enabled");
  29804.                 if(name==null){
  29805.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.enabled' non impostata, viene utilizzato il default=true");
  29806.                     name="true";
  29807.                 }
  29808.                 name = name.trim();
  29809.                 this.isFileSystemRecoveryTimerEnabled = Boolean.parseBoolean(name);
  29810.             } catch(java.lang.Exception e) {
  29811.                 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);
  29812.                 this.isFileSystemRecoveryTimerEnabled = true;
  29813.             }    
  29814.         }

  29816.         return this.isFileSystemRecoveryTimerEnabled;
  29817.     }
  29818.     
  29819.     private Integer getFileSystemRecoveryTimerIntervalSeconds = null;
  29820.     public int getFileSystemRecoveryTimerIntervalSeconds() throws CoreException {   
  29821.         if(this.getFileSystemRecoveryTimerIntervalSeconds==null){
  29822.             try{ 
  29823.                 String name = null;
  29824.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.timeout");
  29825.                 if(name==null){
  29826.                     throw new CoreException("Proprieta' non impostata");
  29827.                 }
  29828.                 name = name.trim();
  29829.                 this.getFileSystemRecoveryTimerIntervalSeconds = Integer.valueOf(name);
  29830.             } catch(java.lang.Exception e) {
  29831.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.timeout': "+e.getMessage(),e);
  29832.                 throw new CoreException(e.getMessage(),e);
  29833.             }    
  29834.         }

  29836.         return this.getFileSystemRecoveryTimerIntervalSeconds;
  29837.     }
  29838.         
  29839.     private Integer getFileSystemRecoveryTimerMaxAttempts = null;
  29840.     public int getFileSystemRecoveryMaxAttempts() throws CoreException {    
  29841.         if(this.getFileSystemRecoveryTimerMaxAttempts==null){
  29842.             try{ 
  29843.                 String name = null;
  29844.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.maxAttempts");
  29845.                 if(name==null){
  29846.                     throw new CoreException("Proprieta' non impostata");
  29847.                 }
  29848.                 name = name.trim();
  29849.                 this.getFileSystemRecoveryTimerMaxAttempts = Integer.valueOf(name);
  29850.             } catch(java.lang.Exception e) {
  29851.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.maxAttempts': "+e.getMessage(),e);
  29852.                 throw new CoreException(e.getMessage(),e);
  29853.             }    
  29854.         }

  29856.         return this.getFileSystemRecoveryTimerMaxAttempts;
  29857.     }
  29858.     
  29859.     private Boolean isFileSystemRecoveryTimerEventEnabled = null;
  29860.     public boolean isFileSystemRecoveryTimerEventEnabled() {    
  29861.         if(this.isFileSystemRecoveryTimerEventEnabled==null){
  29862.             try{ 
  29863.                 String name = null;
  29864.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.events.enabled");
  29865.                 if(name==null){
  29866.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.events.enabled' non impostata, viene utilizzato il default=true");
  29867.                     name="true";
  29868.                 }
  29869.                 name = name.trim();
  29870.                 this.isFileSystemRecoveryTimerEventEnabled = Boolean.parseBoolean(name);
  29871.             } catch(java.lang.Exception e) {
  29872.                 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);
  29873.                 this.isFileSystemRecoveryTimerEventEnabled = true;
  29874.             }    
  29875.         }

  29877.         return this.isFileSystemRecoveryTimerEventEnabled;
  29878.     }
  29879.     
  29880.     private Boolean isFileSystemRecoveryTimerTransactionEnabled = null;
  29881.     public boolean isFileSystemRecoveryTimerTransactionEnabled() {  
  29882.         if(this.isFileSystemRecoveryTimerTransactionEnabled==null){
  29883.             try{ 
  29884.                 String name = null;
  29885.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.transaction.enabled");
  29886.                 if(name==null){
  29887.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.transaction.enabled' non impostata, viene utilizzato il default=true");
  29888.                     name="true";
  29889.                 }
  29890.                 name = name.trim();
  29891.                 this.isFileSystemRecoveryTimerTransactionEnabled = Boolean.parseBoolean(name);
  29892.             } catch(java.lang.Exception e) {
  29893.                 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);
  29894.                 this.isFileSystemRecoveryTimerTransactionEnabled = true;
  29895.             }    
  29896.         }

  29898.         return this.isFileSystemRecoveryTimerTransactionEnabled;
  29899.     }
  29900.     
  29901.     private Long getFileSystemRecoveryEventsProcessingFileAfterMs = null;
  29902.     public long getFileSystemRecoveryEventsProcessingFileAfterMs() throws CoreException {   
  29903.         if(this.getFileSystemRecoveryEventsProcessingFileAfterMs==null){
  29904.             String pName = "org.openspcoop2.pdd.resources.fileSystemRecovery.events.processingFileAfterMs";
  29905.             try{ 
  29906.                 String name = null;
  29907.                 name = this.reader.getValueConvertEnvProperties(pName);
  29908.                 if(name==null){
  29909.                     throw new CoreException("Proprieta' non impostata");
  29910.                 }
  29911.                 name = name.trim();
  29912.                 this.getFileSystemRecoveryEventsProcessingFileAfterMs = Long.valueOf(name);
  29913.             } catch(java.lang.Exception e) {
  29914.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  29915.                 throw new CoreException(e.getMessage(),e);
  29916.             }    
  29917.         }

  29919.         return this.getFileSystemRecoveryEventsProcessingFileAfterMs;
  29920.     }
  29921.     
  29922.     private Long getFileSystemRecoveryTransactionProcessingFileAfterMs = null;
  29923.     public long getFileSystemRecoveryTransactionProcessingFileAfterMs() throws CoreException {  
  29924.         if(this.getFileSystemRecoveryTransactionProcessingFileAfterMs==null){
  29925.             String pName = "org.openspcoop2.pdd.resources.fileSystemRecovery.transaction.processingFileAfterMs";
  29926.             try{ 
  29927.                 String name = null;
  29928.                 name = this.reader.getValueConvertEnvProperties(pName);
  29929.                 if(name==null){
  29930.                     throw new CoreException("Proprieta' non impostata");
  29931.                 }
  29932.                 name = name.trim();
  29933.                 this.getFileSystemRecoveryTransactionProcessingFileAfterMs = Long.valueOf(name);
  29934.             } catch(java.lang.Exception e) {
  29935.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  29936.                 throw new CoreException(e.getMessage(),e);
  29937.             }    
  29938.         }

  29940.         return this.getFileSystemRecoveryTransactionProcessingFileAfterMs;
  29941.     }
  29942.     
  29943.     
  29944.     
  29945.     
  29946.     
  29947.     /* ------------- Controllo Traffico ---------------------*/
  29948.     
  29949.     private Boolean isControlloTrafficoEnabled = null;
  29950.     public boolean isControlloTrafficoEnabled() {   
  29951.         if(this.isControlloTrafficoEnabled==null){
  29952.             try{ 
  29953.                 if(CostantiConfigurazione.CONFIGURAZIONE_XML.equalsIgnoreCase(getTipoConfigurazionePDD())){
  29954.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.enabled' ignorata. Il controllo del traffico e' disabilitato sulla configurazione xml");
  29955.                     this.isControlloTrafficoEnabled = false;
  29956.                 }
  29957.                 else {
  29958.                     String name = null;
  29959.                     name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.enabled");
  29960.                     if(name==null){
  29961.                         this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.enabled' non impostata, viene utilizzato il default=true");
  29962.                         name="true";
  29963.                     }
  29964.                     name = name.trim();
  29965.                     this.isControlloTrafficoEnabled = Boolean.parseBoolean(name);
  29966.                 }
  29967.             } catch(java.lang.Exception e) {
  29968.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
  29969.                 this.isControlloTrafficoEnabled = true;
  29970.             }    
  29971.         }

  29973.         return this.isControlloTrafficoEnabled;
  29974.     }
  29975.     
  29976.     private Boolean isControlloTrafficoDebug = null;
  29977.     public boolean isControlloTrafficoDebug() { 
  29978.         if(this.isControlloTrafficoDebug==null){
  29979.             try{ 
  29980.                 String name = null;
  29981.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.debug");
  29982.                 if(name==null){
  29983.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.debug' non impostata, viene utilizzato il default=true");
  29984.                     name="true";
  29985.                 }
  29986.                 name = name.trim();
  29987.                 this.isControlloTrafficoDebug = Boolean.parseBoolean(name);
  29988.             } catch(java.lang.Exception e) {
  29989.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.debug', viene utilizzato il default=true : "+e.getMessage(),e);
  29990.                 this.isControlloTrafficoDebug = true;
  29991.             }    
  29992.         }

  29994.         return this.isControlloTrafficoDebug;
  29995.     }
  29996.     
  29997.     private Boolean isControlloTrafficoViolazioneGenerazioneErroreGenerico = null;
  29998.     private boolean isControlloTrafficoViolazioneGenerazioneErroreGenerico() {  
  29999.         if(this.isControlloTrafficoViolazioneGenerazioneErroreGenerico==null){
  30000.             try{ 
  30001.                 String name = null;
  30002.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.erroreGenerico");
  30003.                 if(name==null){
  30004.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.erroreGenerico' non impostata, viene utilizzato il default=true");
  30005.                     name="true";
  30006.                 }
  30007.                 name = name.trim();
  30008.                 this.isControlloTrafficoViolazioneGenerazioneErroreGenerico = Boolean.parseBoolean(name);
  30009.             } catch(java.lang.Exception e) {
  30010.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.erroreGenerico', viene utilizzato il default=true : "+e.getMessage(),e);
  30011.                 this.isControlloTrafficoViolazioneGenerazioneErroreGenerico = true;
  30012.             }    
  30013.         }

  30015.         return this.isControlloTrafficoViolazioneGenerazioneErroreGenerico;
  30016.     }
  30017.     
  30018.     private Boolean isControlloTrafficoPolicyLetturaDaCacheDinamica = null;
  30019.     private boolean isControlloTrafficoPolicyLetturaDaCacheDinamica() { 
  30020.         if(this.isControlloTrafficoPolicyLetturaDaCacheDinamica==null){
  30021.             try{ 
  30022.                 String name = null;
  30023.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.policy.readWithDynamicCache");
  30024.                 if(name==null){
  30025.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.policy.readWithDynamicCache' non impostata, viene utilizzato il default=true");
  30026.                     name="true";
  30027.                 }
  30028.                 name = name.trim();
  30029.                 this.isControlloTrafficoPolicyLetturaDaCacheDinamica = Boolean.parseBoolean(name);
  30030.             } catch(java.lang.Exception e) {
  30031.                 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);
  30032.                 this.isControlloTrafficoPolicyLetturaDaCacheDinamica = true;
  30033.             }    
  30034.         }

  30036.         return this.isControlloTrafficoPolicyLetturaDaCacheDinamica;
  30037.     }
  30038.     
  30039.     private Map<String, int[]> getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata = new HashMap<>();
  30040.     private int[] getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata(String protocollo) throws CoreException{
  30041.         if(!this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.containsKey(protocollo)){
  30042.             EsitiProperties esitiProperties = null;
  30043.             try{
  30044.                 esitiProperties =EsitiProperties.getInstanceFromProtocolName(this.log,protocollo);
  30045.             }catch(Exception e) {
  30046.                 throw new CoreException(e.getMessage(),e);
  30047.             }
  30048.             try{
  30049.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaDelegata.esitiConsiderati");
  30050.                 if(value!=null){
  30051.                     value = value.trim();
  30052.                     String [] split = value.split(",");
  30053.                     List<Integer> lInt = new ArrayList<>();
  30054.                     for (int i = 0; i < split.length; i++) {
  30055.                         String s = split[i].trim();
  30056.                         int e = -1;
  30057.                         try{
  30058.                             e = Integer.parseInt(s);
  30059.                         }catch(Exception eParse){
  30060.                             throw new CoreException("Valore ["+s+"] non riconosciuto come esito valido: "+eParse.getMessage(),eParse);
  30061.                         }
  30062.                         if(esitiProperties.existsEsitoCode(e)==false){
  30063.                             continue; // non supportato dal protocollo
  30064.                         }
  30065.                         lInt.add(e);
  30066.                     }
  30067.                     if(lInt.isEmpty()) {
  30068.                         throw new CoreException("Nessun valore è utilizzabile per il protocollo '"+protocollo+"'");
  30069.                     }
  30070.                     int [] tmp = new int[lInt.size()];
  30071.                     for (int i = 0; i < lInt.size(); i++) {
  30072.                         tmp[i] = lInt.get(i);
  30073.                     }
  30074.                     this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.put(protocollo, tmp);
  30075.                 }
  30076.                 else{
  30077.                     // default
  30078.                     int defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
  30079.                     this.logWarn("Proprieta' non presente [org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaDelegata.esitiConsiderati] (Uso il default '"+EsitoTransazioneName.OK+"="+defaultEsito+"')");
  30080.                     int [] tmp = new int[1];
  30081.                     tmp[0] = defaultEsito;
  30082.                     this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.put(protocollo, tmp);
  30083.                 }

  30085.             }catch(Exception e){
  30086.                 // default
  30087.                 int defaultEsito = -1;
  30088.                 try{
  30089.                     defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
  30090.                 }catch(Exception eEsito) {
  30091.                     throw new CoreException(eEsito.getMessage(),eEsito);
  30092.                 }
  30093.                 this.logError("Errore durante la lettura della proprieta' [org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaDelegata.esitiConsideratii] (Uso il default '"+EsitoTransazioneName.OK+"="+defaultEsito+"'): "+e.getMessage(),e);
  30094.                 int [] tmp = new int[1];
  30095.                 tmp[0] = defaultEsito;
  30096.                 this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.put(protocollo, tmp);
  30097.             }
  30098.         }
  30099.         return this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.get(protocollo);
  30100.     }
  30101.     
  30102.     private Map<String, int[]> getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa = new HashMap<>();
  30103.     private int[] getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa(String protocollo) throws CoreException{
  30104.         if(!this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.containsKey(protocollo)){
  30105.             EsitiProperties esitiProperties = null;
  30106.             try{
  30107.                 esitiProperties = EsitiProperties.getInstanceFromProtocolName(this.log,protocollo);
  30108.             }catch(Exception e) {
  30109.                 throw new CoreException(e.getMessage(),e);
  30110.             }
  30111.             try{
  30112.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaApplicativa.esitiConsiderati");
  30113.                 if(value!=null){
  30114.                     value = value.trim();
  30115.                     String [] split = value.split(",");
  30116.                     List<Integer> lInt = new ArrayList<>();
  30117.                     for (int i = 0; i < split.length; i++) {
  30118.                         String s = split[i].trim();
  30119.                         int e = -1;
  30120.                         try{
  30121.                             e = Integer.parseInt(s);
  30122.                         }catch(Exception eParse){
  30123.                             throw new CoreException("Valore ["+s+"] non riconosciuto come esito valido: "+eParse.getMessage(),eParse);
  30124.                         }
  30125.                         if(esitiProperties.existsEsitoCode(e)==false){
  30126.                             continue; // non supportato dal protocollo
  30127.                         }
  30128.                         lInt.add(e);
  30129.                     }
  30130.                     if(lInt.isEmpty()) {
  30131.                         throw new CoreException("Nessun valore è utilizzabile per il protocollo '"+protocollo+"'");
  30132.                     }
  30133.                     int [] tmp = new int[lInt.size()];
  30134.                     for (int i = 0; i < lInt.size(); i++) {
  30135.                         tmp[i] = lInt.get(i);
  30136.                     }
  30137.                     this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.put(protocollo, tmp);
  30138.                 }
  30139.                 else{
  30140.                     // default
  30141.                     int defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
  30142.                     this.logWarn("Proprieta' non presente [org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaApplicativa.esitiConsiderati] (Uso il default '"+EsitoTransazioneName.OK+"="+defaultEsito+"')");
  30143.                     int [] tmp = new int[1];
  30144.                     tmp[0] = defaultEsito;
  30145.                     this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.put(protocollo, tmp);
  30146.                 }

  30148.             }catch(Exception e){
  30149.                 // default
  30150.                 int defaultEsito = -1;
  30151.                 try{
  30152.                     defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
  30153.                 }catch(Exception eEsito) {
  30154.                     throw new CoreException(eEsito.getMessage(),eEsito);
  30155.                 }
  30156.                 this.logError("Errore durante la lettura della proprieta' [org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaApplicativa.esitiConsideratii] (Uso il default '"+EsitoTransazioneName.OK+"="+defaultEsito+"'): "+e.getMessage(),e);
  30157.                 int [] tmp = new int[1];
  30158.                 tmp[0] = defaultEsito;
  30159.                 this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.put(protocollo, tmp);
  30160.             }
  30161.         }
  30162.         return this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.get(protocollo);
  30163.     }
  30164.     
  30165.     private Boolean isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo = null;
  30166.     private boolean isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo() {    
  30167.         if(this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo==null){
  30168.             try{ 
  30169.                 String name = null;
  30170.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.statistiche.finestraScorrevole.gestioneUltimoIntervallo");
  30171.                 if(name==null){
  30172.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.statistiche.finestraScorrevole.gestioneUltimoIntervallo' non impostata, viene utilizzato il default=true");
  30173.                     name="true";
  30174.                 }
  30175.                 name = name.trim();
  30176.                 this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo = Boolean.parseBoolean(name);
  30177.             } catch(java.lang.Exception e) {
  30178.                 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);
  30179.                 this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo = true;
  30180.             }    
  30181.         }

  30183.         return this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo;
  30184.     }
  30185.     
  30186.     private Boolean isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere = null;
  30187.     private boolean isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere() { 
  30188.         if(this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere==null){
  30189.             String pName = "org.openspcoop2.pdd.controlloTraffico.statistiche.distribuzioneSettimanale.usaStatisticheGiornaliere";
  30190.             try{ 
  30191.                 String name = null;
  30192.                 name = this.reader.getValueConvertEnvProperties(pName);
  30193.                 if(name==null){
  30194.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  30195.                     name="true";
  30196.                 }
  30197.                 name = name.trim();
  30198.                 this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere = Boolean.parseBoolean(name);
  30199.             } catch(java.lang.Exception e) {
  30200.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  30201.                 this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere = true;
  30202.             }    
  30203.         }

  30205.         return this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere;
  30206.     }
  30207.     
  30208.     private Boolean isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere = null;
  30209.     private boolean isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere() { 
  30210.         if(this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere==null){
  30211.             String pName = "org.openspcoop2.pdd.controlloTraffico.statistiche.distribuzioneMensile.usaStatisticheGiornaliere";
  30212.             try{ 
  30213.                 String name = null;
  30214.                 name = this.reader.getValueConvertEnvProperties(pName);
  30215.                 if(name==null){
  30216.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  30217.                     name="true";
  30218.                 }
  30219.                 name = name.trim();
  30220.                 this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere = Boolean.parseBoolean(name);
  30221.             } catch(java.lang.Exception e) {
  30222.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  30223.                 this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere = true;
  30224.             }    
  30225.         }

  30227.         return this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere;
  30228.     }
  30229.     
  30230.     private Boolean isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata = null;
  30231.     private boolean isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata() {    
  30232.         if(this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata==null){
  30233.             String pName = "org.openspcoop2.pdd.controlloTraffico.statistiche.distribuzioneSettimanaleMensile.usaStatisticheGiornaliere.latenza.mediaPesata";
  30234.             try{ 
  30235.                 String name = null;
  30236.                 name = this.reader.getValueConvertEnvProperties(pName);
  30237.                 if(name==null){
  30238.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  30239.                     name="true";
  30240.                 }
  30241.                 name = name.trim();
  30242.                 this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata = Boolean.parseBoolean(name);
  30243.             } catch(java.lang.Exception e) {
  30244.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  30245.                 this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata = true;
  30246.             }    
  30247.         }

  30249.         return this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata;
  30250.     }
  30251.     
  30252.     private Map<String, int[]> getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy = new HashMap<>();
  30253.     private int[] getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy(String protocollo) throws CoreException{
  30254.         if(!this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.containsKey(protocollo)){
  30255.             EsitiProperties esitiProperties = null;
  30256.             try{
  30257.                 esitiProperties = EsitiProperties.getInstanceFromProtocolName(this.log, protocollo);
  30258.             }catch(Exception e) {
  30259.                 throw new CoreException(e.getMessage(),e);
  30260.             }
  30261.             try{
  30262.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.violazionePolicy.esitiConsiderati");
  30263.                 if(value!=null){
  30264.                     value = value.trim();
  30265.                     String [] split = value.split(",");
  30266.                     int [] tmp = new int[split.length];
  30267.                     for (int i = 0; i < split.length; i++) {
  30268.                         String s = split[i].trim();
  30269.                         int e = -1;
  30270.                         try{
  30271.                             e = Integer.parseInt(s);
  30272.                         }catch(Exception eParse){
  30273.                             throw new CoreException("Valore ["+s+"] non riconosciuto come esito valido: "+eParse.getMessage(),eParse);
  30274.                         }
  30275.                         if(!esitiProperties.existsEsitoCode(e)){
  30276.                             throw new CoreException("Valore ["+s+"] non riconosciuto come esito valido");
  30277.                         }
  30278.                         tmp[i] = e;
  30279.                     }
  30280.                     this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.put(protocollo, tmp);
  30281.                 }
  30282.                 else{
  30283.                     // default
  30284.                     int defaultEsito =  esitiProperties.convertoToCode(EsitoTransazioneName.CONTROLLO_TRAFFICO_POLICY_VIOLATA);
  30285.                     this.logWarn("Proprieta' non presente [org.openspcoop2.pdd.controlloTraffico.violazionePolicy.esitiConsiderati] (Uso il default '"+defaultEsito+"')");
  30286.                     int [] tmp = new int[1];
  30287.                     tmp[0] = defaultEsito;
  30288.                     this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.put(protocollo, tmp);
  30289.                 }

  30291.             }catch(Exception e){
  30292.                 // default
  30293.                 int defaultEsito = -1;
  30294.                 try {
  30295.                     defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.CONTROLLO_TRAFFICO_POLICY_VIOLATA);
  30296.                 }catch(Exception eEsito) {
  30297.                     throw new CoreException(eEsito.getMessage(),eEsito);
  30298.                 }
  30299.                 this.logError("Errore durante la lettura della proprieta' [org.openspcoop2.pdd.controlloTraffico.violazionePolicy.esitiConsiderati] (Uso il default '"+defaultEsito+"'): "+e.getMessage(),e);
  30300.                 int [] tmp = new int[1];
  30301.                 tmp[0] = defaultEsito;
  30302.                 this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.put(protocollo, tmp);
  30303.             }
  30304.         }
  30305.         return this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.get(protocollo);
  30306.     }
  30307.     
  30308.     private EsitoTransazioneName getControlloTrafficoEsitiPolicyElaborazioneInErrore = null;
  30309.     public EsitoTransazioneName getControlloTrafficoEsitiPolicyElaborazioneInErrore(EsitiProperties esitiProperties) {  
  30310.         if(this.getControlloTrafficoEsitiPolicyElaborazioneInErrore==null){
  30311.             String pName = "org.openspcoop2.pdd.controlloTraffico.violazionePolicy.elaborazioneInErrore";
  30312.             try{ 
  30313.                 String name = null;
  30314.                 name = this.reader.getValueConvertEnvProperties(pName);
  30315.                 if(name==null){
  30316.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX);
  30317.                     this.getControlloTrafficoEsitiPolicyElaborazioneInErrore = EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX;
  30318.                 }
  30319.                 else {
  30320.                     name = name.trim();
  30321.                     if(esitiProperties!=null) {
  30322.                         this.getControlloTrafficoEsitiPolicyElaborazioneInErrore = esitiProperties.getEsitoTransazioneName(Integer.parseInt(name));
  30323.                     }
  30324.                     else {
  30325.                         // verrà inizializzato alla prima chiamata
  30326.                     }
  30327.                 }
  30328.             } catch(java.lang.Exception e) {
  30329.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX+" : "+e.getMessage(),e);
  30330.                 this.getControlloTrafficoEsitiPolicyElaborazioneInErrore = EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX;
  30331.             }    
  30332.         }

  30334.         return this.getControlloTrafficoEsitiPolicyElaborazioneInErrore;
  30335.     }
  30336.     
  30337.     private Boolean isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile = null;
  30338.     private boolean isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile() {  
  30339.         if(this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile==null){
  30340.             try{ 
  30341.                 String name = null;
  30342.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.realtime.incrementaSoloPolicyApplicabile");
  30343.                 if(name==null){
  30344.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.realtime.incrementaSoloPolicyApplicabile' non impostata, viene utilizzato il default=false");
  30345.                     name="false";
  30346.                 }
  30347.                 name = name.trim();
  30348.                 this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile = Boolean.parseBoolean(name);
  30349.             } catch(java.lang.Exception e) {
  30350.                 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);
  30351.                 this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile = false;
  30352.             }    
  30353.         }

  30355.         return this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile;
  30356.     }
  30357.     
  30358.     private ConfigurazioneGatewayControlloTraffico controlloTrafficoConfigurazione = null;
  30359.     public void initConfigurazioneControlloTraffico(Loader loaderOpenSPCoop, List<String> protocolli) throws CoreException{
  30360.         if(this.controlloTrafficoConfigurazione==null){
  30361.             
  30362.             this.controlloTrafficoConfigurazione = new ConfigurazioneGatewayControlloTraffico();
  30363.                         
  30364.             AccessoConfigurazionePdD config = null;
  30365.             try {
  30366.                 config = this.getAccessoConfigurazionePdD();
  30367.             }catch(Exception e) {
  30368.                 throw new CoreException(e.getMessage(),e);
  30369.             }
  30370.             this.controlloTrafficoConfigurazione.setTipoDatabaseConfig(config.getTipoDatabase());
  30371.             
  30372.             this.controlloTrafficoConfigurazione.setDebug(this.isControlloTrafficoDebug());
  30373.             
  30374.             this.controlloTrafficoConfigurazione.setErroreGenerico(this.isControlloTrafficoViolazioneGenerazioneErroreGenerico());
  30375.             
  30376.             this.controlloTrafficoConfigurazione.setPolicyReadedWithDynamicCache(this.isControlloTrafficoPolicyLetturaDaCacheDinamica());
  30377.             
  30378.             for (String protocollo : protocolli) {
  30379.                 getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata(protocollo);
  30380.                 getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa(protocollo);
  30381.             }
  30382.             this.controlloTrafficoConfigurazione.setCalcoloLatenzaPortaDelegataEsitiConsiderati(this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata);
  30383.             this.controlloTrafficoConfigurazione.setCalcoloLatenzaPortaApplicativaEsitiConsiderati(this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa);
  30384.             
  30385.             this.controlloTrafficoConfigurazione.setElaborazioneStatistica_finestraScorrevole_gestioneIntervalloCorrente(this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo());
  30386.             
  30387.             this.controlloTrafficoConfigurazione.setElaborazioneStatistica_distribuzioneSettimanale_usaStatisticheGiornaliere(this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere());
  30388.             this.controlloTrafficoConfigurazione.setElaborazioneStatistica_distribuzioneMensile_usaStatisticheGiornaliere(this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere());
  30389.             this.controlloTrafficoConfigurazione.setElaborazioneStatistica_distribuzioneSettimanaleMensile_usaStatisticheGiornaliere_latenza_mediaPesata(this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata());
  30390.                         
  30391.             INotify notifier = this.getControlloTrafficoNotifyImpl(loaderOpenSPCoop);
  30392.             this.controlloTrafficoConfigurazione.setNotifierEnabled(notifier!=null);
  30393.             this.controlloTrafficoConfigurazione.setNotifier(notifier);
  30394.             
  30395.             for (String protocollo : protocolli) {
  30396.                 getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy(protocollo);
  30397.             }
  30398.             this.controlloTrafficoConfigurazione.setEsitiPolicyViolate(this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy);
  30399.             
  30400.             getControlloTrafficoEsitiPolicyElaborazioneInErrore(null);
  30401.             
  30402.             this.controlloTrafficoConfigurazione.setElaborazioneRealtime_incrementaSoloPolicyApplicabile(this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile());
  30403.         }
  30404.     }
  30405.     public ConfigurazioneGatewayControlloTraffico getConfigurazioneControlloTraffico(){
  30406.         return this.controlloTrafficoConfigurazione;
  30407.     }
  30408.     
  30409.     
  30410.     private TipoGestorePolicy isControlloTrafficoGestorePolicyTipo = null;
  30411.     public TipoGestorePolicy getControlloTrafficoGestorePolicyTipo() {  
  30412.         if(this.isControlloTrafficoGestorePolicyTipo==null){
  30413.             try{ 
  30414.                 String name = null;
  30415.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.gestorePolicy.tipo");
  30416.                 if(name==null){
  30417.                     TipoGestorePolicy gestoreDefault = TipoGestorePolicy.IN_MEMORY;
  30418.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.tipo' non impostata, viene utilizzato il default="+gestoreDefault);
  30419.                     this.isControlloTrafficoGestorePolicyTipo = gestoreDefault;
  30420.                 }
  30421.                 else {
  30422.                     name = name.trim();
  30423.                     this.isControlloTrafficoGestorePolicyTipo = TipoGestorePolicy.toEnumConstant(name, true);
  30424.                 }
  30425.             } catch(java.lang.Exception e) {
  30426.                 TipoGestorePolicy gestoreDefault = TipoGestorePolicy.IN_MEMORY;
  30427.                 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);
  30428.                 this.isControlloTrafficoGestorePolicyTipo = gestoreDefault;
  30429.             }    
  30430.         }

  30432.         return this.isControlloTrafficoGestorePolicyTipo;
  30433.     }
  30434.     
  30435.     private PolicyGroupByActiveThreadsType getControlloTrafficoGestorePolicyInMemoryType = null;
  30436.     public PolicyGroupByActiveThreadsType getControlloTrafficoGestorePolicyInMemoryType() throws CoreException {    
  30437.         if(this.getControlloTrafficoGestorePolicyInMemoryType==null){
  30438.             try{ 
  30439.                 String name = null;
  30440.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.tipo");
  30441.                 if(name==null){
  30442.                     this.getControlloTrafficoGestorePolicyInMemoryType = PolicyGroupByActiveThreadsType.LOCAL;
  30443.                     this.logWarn("Proprieta' 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.tipo' non impostata; viene usato il default: "+this.getControlloTrafficoGestorePolicyInMemoryType);
  30444.                 }
  30445.                 else {
  30446.                     name = name.trim();
  30447.                     this.getControlloTrafficoGestorePolicyInMemoryType = PolicyGroupByActiveThreadsType.valueOf(name);
  30448.                 }
  30449.             } catch(java.lang.Exception e) {
  30450.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.tipo': "+e.getMessage(),e);
  30451.                 throw new CoreException(e.getMessage(),e);
  30452.             }    
  30453.         }

  30455.         return this.getControlloTrafficoGestorePolicyInMemoryType;
  30456.     }
  30457.     
  30458.     private Map<PolicyGroupByActiveThreadsType, Boolean> getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization = null;
  30459.     public boolean isControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization(PolicyGroupByActiveThreadsType type) throws CoreException {   
  30460.         if(this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization==null){
  30461.             this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization = new HashMap<PolicyGroupByActiveThreadsType, Boolean>();
  30462.             for (PolicyGroupByActiveThreadsType initType : PolicyGroupByActiveThreadsType.values()) {
  30463.                 String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory."+initType.name()+".lazyInitialization";
  30464.                 try{ 
  30465.                     String name = this.reader.getValueConvertEnvProperties(pName);
  30466.                     if(name==null){
  30467.                         this.logWarn("Proprieta' '"+pName+"' non impostata; viene usato il default: "+true);
  30468.                         this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization.put(initType, true);
  30469.                     }
  30470.                     else {
  30471.                         name = name.trim();
  30472.                         Boolean v = Boolean.valueOf(name);
  30473.                         this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization.put(initType, v);
  30474.                     }
  30475.                 } catch(java.lang.Exception e) {
  30476.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default: "+true+". Errore: "+e.getMessage(),e);
  30477.                     this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization.put(initType, true);
  30478.                 }           
  30479.             }
  30480.         }

  30482.         return this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization.get(type);
  30483.     }
  30484.     
  30485.     private Boolean isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock = null;
  30486.     public boolean isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock(){
  30487.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.counters.useLocalLock";
  30488.         if(this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock==null){
  30489.             try{  
  30490.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30492.                 if(value!=null){
  30493.                     value = value.trim();
  30494.                     this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock = Boolean.parseBoolean(value);
  30495.                 }else{
  30496.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  30497.                     this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock = false;
  30498.                 }

  30500.             }catch(java.lang.Exception e) {
  30501.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  30502.                 this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock = false;
  30503.             }
  30504.         }
  30505.         return this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock;
  30506.     }
  30507.     
  30508.     private Boolean isControlloTrafficoGestioneClusterRemainingZeroValue = null;
  30509.     public boolean isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodesRemainingZeroValue(){
  30510.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.LOCAL_DIVIDED_BY_NODES.remaining.zeroValue";
  30511.         if(this.isControlloTrafficoGestioneClusterRemainingZeroValue==null){
  30512.             try{  
  30513.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30515.                 if(value!=null){
  30516.                     value = value.trim();
  30517.                     this.isControlloTrafficoGestioneClusterRemainingZeroValue = Boolean.parseBoolean(value);
  30518.                 }else{
  30519.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  30520.                     this.isControlloTrafficoGestioneClusterRemainingZeroValue = false;
  30521.                 }

  30523.             }catch(java.lang.Exception e) {
  30524.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  30525.                 this.isControlloTrafficoGestioneClusterRemainingZeroValue = false;
  30526.             }
  30527.         }
  30528.         return this.isControlloTrafficoGestioneClusterRemainingZeroValue;
  30529.     }
  30530.     
  30531.     private Boolean isControlloTrafficoGestioneClusterLimitRoundingDown = null;
  30532.     public boolean isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodesLimitRoundingDown(){
  30533.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.LOCAL_DIVIDED_BY_NODES.limit.roundingDown";
  30534.         if(this.isControlloTrafficoGestioneClusterLimitRoundingDown==null){
  30535.             try{  
  30536.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30538.                 if(value!=null){
  30539.                     value = value.trim();
  30540.                     this.isControlloTrafficoGestioneClusterLimitRoundingDown = Boolean.parseBoolean(value);
  30541.                 }else{
  30542.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  30543.                     this.isControlloTrafficoGestioneClusterLimitRoundingDown = true;
  30544.                 }

  30546.             }catch(java.lang.Exception e) {
  30547.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  30548.                 this.isControlloTrafficoGestioneClusterLimitRoundingDown = true;
  30549.             }
  30550.         }
  30551.         return this.isControlloTrafficoGestioneClusterLimitRoundingDown;
  30552.     }
  30553.     
  30554.     private Boolean isControlloTrafficoGestioneClusterLimitNormalizedQuota = null;
  30555.     public boolean isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodesLimitNormalizedQuota(){
  30556.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.LOCAL_DIVIDED_BY_NODES.limit.normalizedQuota";
  30557.         if(this.isControlloTrafficoGestioneClusterLimitNormalizedQuota==null){
  30558.             try{  
  30559.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30561.                 if(value!=null){
  30562.                     value = value.trim();
  30563.                     this.isControlloTrafficoGestioneClusterLimitNormalizedQuota = Boolean.parseBoolean(value);
  30564.                 }else{
  30565.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  30566.                     this.isControlloTrafficoGestioneClusterLimitNormalizedQuota = false;
  30567.                 }

  30569.             }catch(java.lang.Exception e) {
  30570.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  30571.                 this.isControlloTrafficoGestioneClusterLimitNormalizedQuota = false;
  30572.             }
  30573.         }
  30574.         return this.isControlloTrafficoGestioneClusterLimitNormalizedQuota;
  30575.     }
  30576.     
  30577.     private Boolean getControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction = null;
  30578.     public boolean isControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction() {
  30579.         if(this.getControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction==null){
  30580.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.DATABASE.useTransaction";
  30581.             try{ 
  30582.                 String name = null;
  30583.                 name = this.reader.getValueConvertEnvProperties(pName);
  30584.                 if (name != null) {
  30585.                     name = name.trim();
  30586.                     this.getControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction = Boolean.valueOf(name);
  30587.                 } else {
  30588.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  30589.                     this.getControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction =  true;
  30590.                 }
  30591.             }catch(java.lang.Exception e) {
  30592.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  30593.                 this.getControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction = true;
  30594.             }   
  30595.         }

  30597.         return this.getControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction;
  30598.     }
  30599.     
  30600.     private Long getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva = null;
  30601.     public long getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva() { 
  30602.         if(this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva==null){
  30603.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.DATABASE.serializable.attesaAttiva";
  30604.             try{ 
  30605.                 String name = null;
  30606.                 name = this.reader.getValueConvertEnvProperties(pName);
  30607.                 if (name != null) {
  30608.                     name = name.trim();
  30609.                     long time = java.lang.Long.parseLong(name);
  30610.                     this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva = time*1000;
  30611.                 } else {
  30612.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA));
  30613.                     this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva =  Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA;
  30614.                 }
  30615.             }catch(java.lang.Exception e) {
  30616.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA),e);
  30617.                 this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva = Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA;
  30618.             }   
  30619.         }

  30621.         return this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva;
  30622.     }

  30624.     private Integer getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval = null;
  30625.     public int getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval() { 
  30626.         if(this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval==null){
  30627.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.DATABASE.serializable.check";
  30628.             try{ 
  30629.                 String name = null;
  30630.                 name = this.reader.getValueConvertEnvProperties(pName);
  30631.                 if (name != null){
  30632.                     name = name.trim();
  30633.                     int time = java.lang.Integer.parseInt(name);
  30634.                     this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval = time;
  30635.                 } else{
  30636.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL));
  30637.                     this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval = Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL;
  30638.                 }
  30639.             }catch(java.lang.Exception e) {
  30640.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL),e);
  30641.                 this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval = Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL;
  30642.             }    
  30643.         }

  30645.         return this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval;
  30646.     }

  30648.     private Boolean isHazelcastEngineEnabled = null;
  30649.     public boolean isHazelcastEngineEnabled() { 
  30650.         if(this.isHazelcastEngineEnabled==null){
  30651.             String pName = "org.openspcoop2.pdd.hazelcast.enabled";
  30652.             try{ 
  30653.                 String name = null;
  30654.                 name = this.reader.getValueConvertEnvProperties(pName);
  30655.                 if(name==null){
  30656.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  30657.                     name="true";
  30658.                 }
  30659.                 name = name.trim();
  30660.                 this.isHazelcastEngineEnabled = Boolean.parseBoolean(name);
  30661.             } catch(java.lang.Exception e) {
  30662.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  30663.                 this.isHazelcastEngineEnabled = true;
  30664.             }    
  30665.         }

  30667.         return this.isHazelcastEngineEnabled;
  30668.     }
  30669.     
  30670.     
  30671.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPathRead = null;
  30672.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath = null;
  30673.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath() throws CoreException {
  30674.         
  30675.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPathRead==null){
  30676.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_MAP.config";

  30678.             try{  
  30679.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30681.                 if (value != null){
  30682.                     value = value.trim();
  30683.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath = value;
  30684.                 }
  30685.                 
  30686.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPathRead = true;
  30687.                 
  30688.             }catch(java.lang.Exception e) {
  30689.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30690.                 this.logError(msgError,e);
  30691.                 throw new CoreException(msgError,e);
  30692.             }
  30693.         }

  30695.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath;        
  30696.     }
  30697.     
  30698.     
  30699.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPathRead = null;
  30700.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath = null;
  30701.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath() throws CoreException {
  30702.         
  30703.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPathRead==null){
  30704.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_PNCOUNTER.config";

  30706.             try{  
  30707.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30709.                 if (value != null){
  30710.                     value = value.trim();
  30711.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath = value;
  30712.                 }
  30713.                 
  30714.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPathRead = true;
  30715.                 
  30716.             }catch(java.lang.Exception e) {
  30717.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30718.                 this.logError(msgError,e);
  30719.                 throw new CoreException(msgError,e);
  30720.             }
  30721.         }

  30723.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath;      
  30724.     }
  30725.     
  30726.     
  30727.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPathRead = null;
  30728.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath = null;
  30729.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath() throws CoreException {
  30730.         
  30731.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPathRead==null){
  30732.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_ATOMIC_LONG.config";

  30734.             try{  
  30735.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30737.                 if (value != null){
  30738.                     value = value.trim();
  30739.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath = value;
  30740.                 }
  30741.                 
  30742.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPathRead = true;
  30743.                 
  30744.             }catch(java.lang.Exception e) {
  30745.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30746.                 this.logError(msgError,e);
  30747.                 throw new CoreException(msgError,e);
  30748.             }
  30749.         }

  30751.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath;     
  30752.     }
  30753.     
  30754.     
  30755.     
  30756.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPathRead = null;
  30757.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath = null;
  30758.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath() throws CoreException {
  30759.         
  30760.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPathRead==null){
  30761.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_ATOMIC_LONG_ASYNC.config";

  30763.             try{  
  30764.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30766.                 if (value != null){
  30767.                     value = value.trim();
  30768.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath = value;
  30769.                 }
  30770.                 
  30771.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPathRead = true;
  30772.                 
  30773.             }catch(java.lang.Exception e) {
  30774.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30775.                 this.logError(msgError,e);
  30776.                 throw new CoreException(msgError,e);
  30777.             }
  30778.         }

  30780.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath;        
  30781.     }
  30782.     
  30783.     
  30784.         
  30785.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPathRead = null;
  30786.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath = null;
  30787.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath() throws CoreException {
  30788.         
  30789.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPathRead==null){
  30790.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_NEAR_CACHE.config";

  30792.             try{  
  30793.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30795.                 if (value != null){
  30796.                     value = value.trim();
  30797.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath = value;
  30798.                 }

  30800.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPathRead = true;
  30801.                 
  30802.             }catch(java.lang.Exception e) {
  30803.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30804.                 this.logError(msgError,e);
  30805.                 throw new CoreException(msgError,e);
  30806.             }
  30807.         }

  30809.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath;      
  30810.     }
  30811.     
  30812.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPathRead = null;
  30813.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath = null;
  30814.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath() throws CoreException {
  30815.         
  30816.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPathRead==null){
  30817.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_NEAR_CACHE_UNSAFE_SYNC_MAP.config";

  30819.             try{  
  30820.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30822.                 if (value != null){
  30823.                     value = value.trim();
  30824.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath = value;
  30825.                 }

  30827.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPathRead = true;
  30828.                 
  30829.             }catch(java.lang.Exception e) {
  30830.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30831.                 this.logError(msgError,e);
  30832.                 throw new CoreException(msgError,e);
  30833.             }
  30834.         }

  30836.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath;     
  30837.     }
  30838.     
  30839.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPathRead = null;
  30840.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath = null;
  30841.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath() throws CoreException {
  30842.         
  30843.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPathRead==null){
  30844.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_NEAR_CACHE_UNSAFE_ASYNC_MAP.config";

  30846.             try{  
  30847.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30849.                 if (value != null){
  30850.                     value = value.trim();
  30851.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath = value;
  30852.                 }

  30854.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPathRead = true;
  30855.                 
  30856.             }catch(java.lang.Exception e) {
  30857.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30858.                 this.logError(msgError,e);
  30859.                 throw new CoreException(msgError,e);
  30860.             }
  30861.         }

  30863.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath;        
  30864.     }
  30865.     
  30866.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPathRead = null;
  30867.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath = null;
  30868.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath() throws CoreException {
  30869.         
  30870.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPathRead==null){
  30871.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_REPLICATED_MAP.config";

  30873.             try{  
  30874.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30876.                 if (value != null){
  30877.                     value = value.trim();
  30878.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath = value;
  30879.                 }

  30881.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPathRead = true;
  30882.                 
  30883.             }catch(java.lang.Exception e) {
  30884.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30885.                 this.logError(msgError,e);
  30886.                 throw new CoreException(msgError,e);
  30887.             }
  30888.         }

  30890.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath;      
  30891.     }
  30892.     
  30893.     
  30894.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastLocalConfigPathRead = null;
  30895.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath = null;
  30896.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath() throws CoreException {
  30897.         
  30898.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalConfigPathRead==null){
  30899.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_LOCAL_CACHE.config";

  30901.             try{  
  30902.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30904.                 if (value != null){
  30905.                     value = value.trim();
  30906.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath = value;
  30907.                 }

  30909.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalConfigPathRead = true;
  30910.                 
  30911.             }catch(java.lang.Exception e) {
  30912.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30913.                 this.logError(msgError,e);
  30914.                 throw new CoreException(msgError,e);
  30915.             }
  30916.         }

  30918.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath;     
  30919.     }
  30920.     
  30921.     private Boolean isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy = null;
  30922.     public Boolean isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy() {
  30923.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST.oneMapForeachPolicy";
  30924.         
  30925.         if(this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy==null){
  30926.             try{  
  30927.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30929.                 if(value!=null){
  30930.                     value = value.trim();
  30931.                     this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy = Boolean.parseBoolean(value);
  30932.                 }else{
  30933.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  30934.                     this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy = false;
  30935.                 }

  30937.             }catch(java.lang.Exception e) {
  30938.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  30939.                 this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy = false;
  30940.             }
  30941.         }
  30942.         
  30943.         return this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy;
  30944.     }
  30945.     
  30946.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId = null;
  30947.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId() {
  30948.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST.group_id";
  30949.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId==null){
  30950.             try{ 
  30951.                 String name = null;
  30952.                 name = this.reader.getValueConvertEnvProperties(pName);
  30953.                 if(name==null) {
  30954.                     throw new CoreException(NON_DEFINITA);
  30955.                 }
  30956.                 else {
  30957.                     name = name.trim();
  30958.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId = name;
  30959.                 }
  30960.             }catch(java.lang.Exception e) {
  30961.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  30962.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId = null;
  30963.             }  
  30964.         }

  30966.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId;
  30967.     }
  30968.     
  30969.     private File getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig = null;
  30970.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfigRead = null;
  30971.     public File getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig() throws CoreException {
  30972.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST.sharedConfig";
  30973.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfigRead==null){
  30974.             initControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfigEngine(pName);
  30975.         }

  30977.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig;
  30978.     }
  30979.     private void initControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfigEngine(String pName) throws CoreException {
  30980.         try{ 
  30981.             String name = null;
  30982.             name = this.reader.getValueConvertEnvProperties(pName);
  30983.             if(name!=null) {
  30984.                 name = name.trim();
  30985.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig = new File(name);
  30986.                 if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig.exists()) {
  30987.                     if(!this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig.isFile()) {
  30988.                         throw newCoreExceptionNotFile(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig,false);
  30989.                     }
  30990.                     if(!this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig.canRead()) {
  30991.                         throw newCoreExceptionCannotRead(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig,false);
  30992.                     }
  30993.                 }
  30994.                 else {
  30995.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig=null;
  30996.                 }
  30997.             }
  30998.         }catch(java.lang.Exception e) {
  30999.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  31000.             throw new CoreException(e.getMessage(),e);
  31001.         }
  31002.         this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfigRead = true;
  31003.     }

  31005.     private Integer getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval = null;  
  31006.     public Integer getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheTimerUpdate() {
  31007.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval==null){
  31008.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_LOCAL_CACHE.updateInterval";
  31009.             
  31010.             try{ 
  31011.                 String name = null;
  31012.                 name = this.reader.getValueConvertEnvProperties(pName);
  31013.                 if (name != null) {
  31014.                     name = name.trim();
  31015.                     this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval = Integer.valueOf(name);
  31016.                 } else {
  31017.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,5));
  31018.                     this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval =  5;
  31019.                 }
  31020.             }catch(java.lang.Exception e) {
  31021.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,5),e);
  31022.                 this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval = 5;
  31023.             }   
  31024.         }

  31026.         return this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval;
  31027.     }
  31028.     
  31029.     private Boolean isHazelcastSecurityRecommendationsEnabled = null;
  31030.     public boolean isHazelcastSecurityRecommendationsEnabled() {    
  31031.         if(this.isHazelcastSecurityRecommendationsEnabled==null){
  31032.             String pName = "org.openspcoop2.pdd.hazelcast.security.recommendations";
  31033.             try{ 
  31034.                 String name = null;
  31035.                 name = this.reader.getValueConvertEnvProperties(pName);
  31036.                 if(name==null){
  31037.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  31038.                     name="true";
  31039.                 }
  31040.                 name = name.trim();
  31041.                 this.isHazelcastSecurityRecommendationsEnabled = Boolean.parseBoolean(name);
  31042.             } catch(java.lang.Exception e) {
  31043.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, true));
  31044.                 this.isHazelcastSecurityRecommendationsEnabled = true;
  31045.             }    
  31046.         }

  31048.         return this.isHazelcastSecurityRecommendationsEnabled;
  31049.     }
  31050.     
  31051.     private Boolean isHazelcastDiagnosticsEnabled = null;
  31052.     public boolean isHazelcastDiagnosticsEnabled() {    
  31053.         if(this.isHazelcastDiagnosticsEnabled==null){
  31054.             String pName = "org.openspcoop2.pdd.hazelcast.diagnostics.enabled";
  31055.             try{ 
  31056.                 String name = null;
  31057.                 name = this.reader.getValueConvertEnvProperties(pName);
  31058.                 if(name==null){
  31059.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  31060.                     name="true";
  31061.                 }
  31062.                 name = name.trim();
  31063.                 this.isHazelcastDiagnosticsEnabled = Boolean.parseBoolean(name);
  31064.             } catch(java.lang.Exception e) {
  31065.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, true));
  31066.                 this.isHazelcastDiagnosticsEnabled = true;
  31067.             }    
  31068.         }

  31070.         return this.isHazelcastDiagnosticsEnabled;
  31071.     }
  31072.     
  31073.     private File getHazelcastDiagnosticsDirectory = null;
  31074.     public File getHazelcastDiagnosticsDirectory() throws CoreException {   
  31075.         if(this.getHazelcastDiagnosticsDirectory==null){
  31076.             String pName = "org.openspcoop2.pdd.hazelcast.diagnostics.directory";
  31077.             try{ 
  31078.                 String name = null;
  31079.                 name = this.reader.getValueConvertEnvProperties(pName);
  31080.                 if(name==null){
  31081.                     throw new CoreException("Hazelcast diagnostics dir non impostata");
  31082.                 }
  31083.                 name = LoggerWrapperFactory.applyClusterIdStrategy(name.trim(), "hazelcast");
  31084.                 this.getHazelcastDiagnosticsDirectory = new File(name);
  31085.                 checkHazelcastDiagnosticsDirectory();
  31086.             } catch(java.lang.Exception e) {
  31087.                 this.logError("Riscontrato errore per la directory della diagnostica di hazelcast ("+pName+"): "+e.getMessage(),e);
  31088.                 throw new CoreException(e.getMessage(),e);
  31089.             }    
  31090.         }

  31092.         return this.getHazelcastDiagnosticsDirectory;
  31093.     }
  31094.     private void checkHazelcastDiagnosticsDirectory() throws CoreException {    
  31095.         if(this.getHazelcastDiagnosticsDirectory.exists()) {
  31096.             if(!this.getHazelcastDiagnosticsDirectory.isDirectory()) {
  31097.                 throw newCoreExceptionNotDir(this.getHazelcastDiagnosticsDirectory,true);
  31098.             }
  31099.             if(!this.getHazelcastDiagnosticsDirectory.canRead()) {
  31100.                 throw newCoreExceptionCannotRead(this.getHazelcastDiagnosticsDirectory, true);
  31101.             }
  31102.             if(!this.getHazelcastDiagnosticsDirectory.canWrite()) {
  31103.                 throw newCoreExceptionCannotWrite(this.getHazelcastDiagnosticsDirectory, true);
  31104.             }
  31105.         }
  31106.         else {
  31107.             // viene creata automaticamente
  31108.         }
  31109.     }
  31110.     
  31111.     private Integer getHazelcastDiagnosticsMaxRolledFileCount = null;
  31112.     public int getHazelcastDiagnosticsMaxRolledFileCount() throws CoreException {   
  31113.         if(this.getHazelcastDiagnosticsMaxRolledFileCount==null){
  31114.             String pName = "org.openspcoop2.pdd.hazelcast.diagnostics.max.rolled.file.count";
  31115.             try{ 
  31116.                 String name = null;
  31117.                 name = this.reader.getValueConvertEnvProperties(pName);
  31118.                 if(name==null){
  31119.                     throw new CoreException("Hazelcast diagnostics max.rolled.file.count config not found");
  31120.                 }
  31121.                 name = name.trim();
  31122.                 this.getHazelcastDiagnosticsMaxRolledFileCount = Integer.valueOf(name);
  31123.             } catch(java.lang.Exception e) {
  31124.                 this.logError("Riscontrato errore durante la lettura delle configurazione diagnostica di hazelcast ("+pName+"): "+e.getMessage(),e);
  31125.                 throw new CoreException(e.getMessage(),e);
  31126.             }    
  31127.         }

  31129.         return this.getHazelcastDiagnosticsMaxRolledFileCount;
  31130.     }
  31131.     
  31132.     private Integer getHazelcastDiagnosticsMaxFileSizeMb = null;
  31133.     public int getHazelcastDiagnosticsMaxFileSizeMb() throws CoreException {    
  31134.         if(this.getHazelcastDiagnosticsMaxFileSizeMb==null){
  31135.             String pName = "org.openspcoop2.pdd.hazelcast.diagnostics.max.file.size.mb";
  31136.             try{ 
  31137.                 String name = null;
  31138.                 name = this.reader.getValueConvertEnvProperties(pName);
  31139.                 if(name==null){
  31140.                     throw new CoreException("Hazelcast diagnostics max.rolled.file.count config not found");
  31141.                 }
  31142.                 name = name.trim();
  31143.                 this.getHazelcastDiagnosticsMaxFileSizeMb = Integer.valueOf(name);
  31144.             } catch(java.lang.Exception e) {
  31145.                 this.logError("Riscontrato errore durante la lettura delle configurazione diagnostica di hazelcast ("+pName+"): "+e.getMessage(),e);
  31146.                 throw new CoreException(e.getMessage(),e);
  31147.             }    
  31148.         }

  31150.         return this.getHazelcastDiagnosticsMaxFileSizeMb;
  31151.     }
  31152.     
  31153.     private Integer getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover = null;
  31154.     public int getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover() {   
  31155.         if(this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover==null){
  31156.             String pName = "org.openspcoop2.pdd.hazelcast.CPSubsystem.distributedObjectDestroyedException.failover";
  31157.             try{ 
  31158.                 String name = null;
  31159.                 name = this.reader.getValueConvertEnvProperties(pName);
  31160.                 if(name==null){
  31161.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, -1));
  31162.                     name="-1";
  31163.                 }
  31164.                 name = name.trim();
  31165.                 this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover = Integer.valueOf(name);
  31166.             } catch(java.lang.Exception e) {
  31167.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, -1));
  31168.                 this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover = -1;
  31169.             }    
  31170.         }

  31172.         return this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover;
  31173.     }
  31174.     
  31175.     private Integer getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs = null;
  31176.     public int getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs() {   
  31177.         if(this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs==null){
  31178.             String pName = "org.openspcoop2.pdd.hazelcast.CPSubsystem.distributedObjectDestroyedException.failover.checkEveryMs";
  31179.             try{ 
  31180.                 String name = null;
  31181.                 name = this.reader.getValueConvertEnvProperties(pName);
  31182.                 if(name==null){
  31183.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, 500));
  31184.                     name="500";
  31185.                 }
  31186.                 name = name.trim();
  31187.                 this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs = Integer.valueOf(name);
  31188.             } catch(java.lang.Exception e) {
  31189.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, 500));
  31190.                 this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs = 500;
  31191.             }    
  31192.         }

  31194.         return this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs;
  31195.     }
  31196.     
  31197.     private Boolean isRedisEngineEnabled = null;
  31198.     public boolean isRedisEngineEnabled() { 
  31199.         if(this.isRedisEngineEnabled==null){
  31200.             String pName = "org.openspcoop2.pdd.redis.enabled";
  31201.             try{ 
  31202.                 String name = null;
  31203.                 name = this.reader.getValueConvertEnvProperties(pName);
  31204.                 if(name==null){
  31205.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  31206.                     name="true";
  31207.                 }
  31208.                 name = name.trim();
  31209.                 this.isRedisEngineEnabled = Boolean.parseBoolean(name);
  31210.             } catch(java.lang.Exception e) {
  31211.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  31212.                 this.isRedisEngineEnabled = true;
  31213.             }    
  31214.         }

  31216.         return this.isRedisEngineEnabled;
  31217.     }
  31218.     
  31219.     private List<String> getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl = null;
  31220.     private boolean getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrlRead = false;
  31221.     public List<String> getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl() throws CoreException {    
  31222.         if(!this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrlRead){
  31223.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.REDIS.connectionUrl";
  31224.             try{ 

  31226.                 String name = null;
  31227.                 name = this.reader.getValueConvertEnvProperties(pName);
  31228.                 if(name==null){
  31229.                     throw new CoreException(NON_DEFINITA);
  31230.                 }else{
  31231.                     String [] r = name.trim().split(",");
  31232.                     List<String> l = new ArrayList<>();
  31233.                     for(int i=0; i<r.length; i++){
  31234.                         r[i] = r[i].trim();
  31235.                         l.add(r[i]);
  31236.                     }
  31237.                     
  31238.                     if(!l.isEmpty()) {
  31239.                         this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl = new ArrayList<>();
  31240.                         this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl.addAll(l);
  31241.                     }
  31242.                     else {
  31243.                         throw new CoreException(NON_DEFINITA);
  31244.                     }
  31245.                 }
  31246.             }catch(java.lang.Exception e) {
  31247.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  31248.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  31249.             }  
  31250.             this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrlRead = true;
  31251.         }

  31253.         return this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl;
  31254.     }
  31255.     
  31256.     private Boolean isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy = null;
  31257.     public Boolean isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy() {
  31258.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.REDIS.oneMapForeachPolicy";
  31259.         
  31260.         if(this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy==null){
  31261.             try{  
  31262.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  31264.                 if(value!=null){
  31265.                     value = value.trim();
  31266.                     this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy = Boolean.parseBoolean(value);
  31267.                 }else{
  31268.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  31269.                     this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy = false;
  31270.                 }

  31272.             }catch(java.lang.Exception e) {
  31273.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  31274.                 this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy = false;
  31275.             }
  31276.         }
  31277.         
  31278.         return this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy;
  31279.     }
  31280.     
  31281.     private Boolean isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady = null;
  31282.     public Boolean isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady() {
  31283.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.REDIS.startupGovWay.throwExceptionIfRedisNotReady";
  31284.         
  31285.         if(this.isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady==null){
  31286.             try{  
  31287.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  31289.                 if(value!=null){
  31290.                     value = value.trim();
  31291.                     this.isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady = Boolean.parseBoolean(value);
  31292.                 }else{
  31293.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  31294.                     this.isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady = false;
  31295.                 }

  31297.             }catch(java.lang.Exception e) {
  31298.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  31299.                 this.isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady = false;
  31300.             }
  31301.         }
  31302.         
  31303.         return this.isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady;
  31304.     }
  31305.     
  31306.     
  31307.     private String getControlloTrafficoGestorePolicyWSUrl = null;
  31308.     public String getControlloTrafficoGestorePolicyWSUrl() throws CoreException {   
  31309.         if(this.getControlloTrafficoGestorePolicyWSUrl==null){
  31310.             try{ 
  31311.                 String name = null;
  31312.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.gestorePolicy.ws.url");
  31313.                 if(name==null){
  31314.                     throw new CoreException("Proprieta' non impostata");
  31315.                 }
  31316.                 else {
  31317.                     name = name.trim();
  31318.                     @SuppressWarnings("unused")
  31319.                     String s = (new URL(name)).toString();
  31320.                     this.getControlloTrafficoGestorePolicyWSUrl = name;
  31321.                 }
  31322.             } catch(java.lang.Exception e) {
  31323.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.ws.url': "+e.getMessage(),e);
  31324.                 throw new CoreException(e.getMessage(),e);
  31325.             }    
  31326.         }

  31328.         return this.getControlloTrafficoGestorePolicyWSUrl;
  31329.     }
  31330.         
  31331.     private Boolean getControlloTrafficoNotifyImplRead = null;
  31332.     private INotify getControlloTrafficoNotifyImpl = null;
  31333.     public INotify getControlloTrafficoNotifyImpl(Loader loaderOpenSPCoop) throws CoreException {   
  31334.         if(this.getControlloTrafficoNotifyImplRead==null){
  31335.             try{ 
  31336.                 String name = null;
  31337.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.notifier.implementation");
  31338.                 if(name!=null){
  31339.                     name = name.trim();
  31340.                     this.getControlloTrafficoNotifyImpl = (INotify) loaderOpenSPCoop.newInstance(name);
  31341.                 }
  31342.             } catch(java.lang.Exception e) {
  31343.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.notifier.implementation': "+e.getMessage(),e);
  31344.                 throw new CoreException(e.getMessage(),e);
  31345.             }  
  31346.             this.getControlloTrafficoNotifyImplRead = true;
  31347.         }

  31349.         return this.getControlloTrafficoNotifyImpl;
  31350.     }
  31351.     
  31352.     private File getControlloTrafficoGestorePolicyFileSystemRecoveryRepository = null;
  31353.     public File getControlloTrafficoGestorePolicyFileSystemRecoveryRepository() throws CoreException {  
  31354.         if(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository==null){
  31355.             try{ 
  31356.                 String name = null;
  31357.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.gestorePolicy.fileSystemRecovery.repository");
  31358.                 if(name!=null){
  31359.                     name = LoggerWrapperFactory.applyClusterIdStrategy(name.trim(), "controlloTraffico");
  31360.                     initControlloTrafficoGestorePolicyFileSystemRecoveryRepository(name);
  31361.                 }
  31362.             } catch(java.lang.Exception e) {
  31363.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.fileSystemRecovery.repository': "+e.getMessage(),e);
  31364.                 throw new CoreException(e.getMessage(),e);
  31365.             }    
  31366.         }

  31368.         return this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository;
  31369.     }
  31370.     private void initControlloTrafficoGestorePolicyFileSystemRecoveryRepository(String name) throws CoreException { 
  31371.         this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository = new File(name);
  31372.         if(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository.exists()) {
  31373.             if(!this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository.isDirectory()) {
  31374.                 throw newCoreExceptionNotDir(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository, true);
  31375.             }
  31376.             if(!this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository.canRead()) {
  31377.                 throw newCoreExceptionCannotRead(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository, true);
  31378.             }
  31379.             if(!this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository.canWrite()) {
  31380.                 throw newCoreExceptionCannotWrite(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository, true);
  31381.             }
  31382.         }
  31383.         else {
  31384.             // viene creata automaticamente
  31385.         }
  31386.     }
  31387.     
  31388.     
  31389.     
  31390.     
  31391.     
  31392.     // Limit
  31393.     
  31394.     private String [] getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit = null;
  31395.     private Boolean getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimitRead = null;
  31396.     public String [] getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit() throws CoreException {  
  31397.         if(this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimitRead==null){
  31398.             try{ 
  31399.                 String name = null;
  31400.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteSimultanee.header.limit");
  31401.                 if(name!=null){
  31402.                     name = name.trim();
  31403.                     this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit = name.split(",");
  31404.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit.length; i++) {
  31405.                         this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit[i].trim();
  31406.                     }
  31407.                 }
  31408.                 
  31409.                 this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimitRead = true;
  31410.                 
  31411.             } catch(java.lang.Exception e) {
  31412.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteSimultanee.header.limit': "+e.getMessage(),e);
  31413.                 throw new CoreException(e.getMessage(),e);
  31414.             }    
  31415.         }

  31417.         return this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit;
  31418.     }
  31419.     
  31420.     private String [] getControlloTrafficoNumeroRichiesteHeaderLimit = null;
  31421.     private Boolean getControlloTrafficoNumeroRichiesteHeaderLimitRead = null;
  31422.     public String [] getControlloTrafficoNumeroRichiesteHeaderLimit() throws CoreException {    
  31423.         if(this.getControlloTrafficoNumeroRichiesteHeaderLimitRead==null){
  31424.             try{ 
  31425.                 String name = null;
  31426.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit");
  31427.                 if(name!=null){
  31428.                     name = name.trim();
  31429.                     this.getControlloTrafficoNumeroRichiesteHeaderLimit = name.split(",");
  31430.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteHeaderLimit.length; i++) {
  31431.                         this.getControlloTrafficoNumeroRichiesteHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteHeaderLimit[i].trim();
  31432.                     }
  31433.                 }
  31434.                 
  31435.                 this.getControlloTrafficoNumeroRichiesteHeaderLimitRead = true;
  31436.                 
  31437.             } catch(java.lang.Exception e) {
  31438.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit': "+e.getMessage(),e);
  31439.                 throw new CoreException(e.getMessage(),e);
  31440.             }    
  31441.         }

  31443.         return this.getControlloTrafficoNumeroRichiesteHeaderLimit;
  31444.     }
  31445.     
  31446.     private String [] getControlloTrafficoOccupazioneBandaHeaderLimit = null;
  31447.     private Boolean getControlloTrafficoOccupazioneBandaHeaderLimitRead = null;
  31448.     public String [] getControlloTrafficoOccupazioneBandaHeaderLimit() throws CoreException {   
  31449.         if(this.getControlloTrafficoOccupazioneBandaHeaderLimitRead==null){
  31450.             try{ 
  31451.                 String name = null;
  31452.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.limit");
  31453.                 if(name!=null){
  31454.                     name = name.trim();
  31455.                     this.getControlloTrafficoOccupazioneBandaHeaderLimit = name.split(",");
  31456.                     for (int i = 0; i < this.getControlloTrafficoOccupazioneBandaHeaderLimit.length; i++) {
  31457.                         this.getControlloTrafficoOccupazioneBandaHeaderLimit[i]=this.getControlloTrafficoOccupazioneBandaHeaderLimit[i].trim();
  31458.                     }
  31459.                 }
  31460.                 
  31461.                 this.getControlloTrafficoOccupazioneBandaHeaderLimitRead = true;
  31462.                 
  31463.             } catch(java.lang.Exception e) {
  31464.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.limit': "+e.getMessage(),e);
  31465.                 throw new CoreException(e.getMessage(),e);
  31466.             }    
  31467.         }

  31469.         return this.getControlloTrafficoOccupazioneBandaHeaderLimit;
  31470.     }
  31471.     
  31472.     private String [] getControlloTrafficoTempoComplessivoRispostaHeaderLimit = null;
  31473.     private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderLimitRead = null;
  31474.     public String [] getControlloTrafficoTempoComplessivoRispostaHeaderLimit() throws CoreException {   
  31475.         if(this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitRead==null){
  31476.             try{ 
  31477.                 String name = null;
  31478.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.limit");
  31479.                 if(name!=null){
  31480.                     name = name.trim();
  31481.                     this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit = name.split(",");
  31482.                     for (int i = 0; i < this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit.length; i++) {
  31483.                         this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit[i]=this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit[i].trim();
  31484.                     }
  31485.                 }
  31486.                 
  31487.                 this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitRead = true;
  31488.                 
  31489.             } catch(java.lang.Exception e) {
  31490.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.limit': "+e.getMessage(),e);
  31491.                 throw new CoreException(e.getMessage(),e);
  31492.             }    
  31493.         }

  31495.         return this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit;
  31496.     }
  31497.     
  31498.     private String [] getControlloTrafficoTempoMedioRispostaHeaderLimit = null;
  31499.     private Boolean getControlloTrafficoTempoMedioRispostaHeaderLimitRead = null;
  31500.     public String [] getControlloTrafficoTempoMedioRispostaHeaderLimit() throws CoreException { 
  31501.         if(this.getControlloTrafficoTempoMedioRispostaHeaderLimitRead==null){
  31502.             try{ 
  31503.                 String name = null;
  31504.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.limit");
  31505.                 if(name!=null){
  31506.                     name = name.trim();
  31507.                     this.getControlloTrafficoTempoMedioRispostaHeaderLimit = name.split(",");
  31508.                     for (int i = 0; i < this.getControlloTrafficoTempoMedioRispostaHeaderLimit.length; i++) {
  31509.                         this.getControlloTrafficoTempoMedioRispostaHeaderLimit[i]=this.getControlloTrafficoTempoMedioRispostaHeaderLimit[i].trim();
  31510.                     }
  31511.                 }
  31512.                 
  31513.                 this.getControlloTrafficoTempoMedioRispostaHeaderLimitRead = true;
  31514.                 
  31515.             } catch(java.lang.Exception e) {
  31516.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.limit': "+e.getMessage(),e);
  31517.                 throw new CoreException(e.getMessage(),e);
  31518.             }    
  31519.         }

  31521.         return this.getControlloTrafficoTempoMedioRispostaHeaderLimit;
  31522.     }
  31523.     
  31524.     private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit = null;
  31525.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitRead = null;
  31526.     public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit() throws CoreException {   
  31527.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitRead==null){
  31528.             try{ 
  31529.                 String name = null;
  31530.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.limit");
  31531.                 if(name!=null){
  31532.                     name = name.trim();
  31533.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit = name.split(",");
  31534.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit.length; i++) {
  31535.                         this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit[i].trim();
  31536.                     }
  31537.                 }
  31538.                 
  31539.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitRead = true;
  31540.                 
  31541.             } catch(java.lang.Exception e) {
  31542.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.limit': "+e.getMessage(),e);
  31543.                 throw new CoreException(e.getMessage(),e);
  31544.             }    
  31545.         }

  31547.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit;
  31548.     }
  31549.     
  31550.     private String [] getControlloTrafficoNumeroRichiesteFalliteHeaderLimit = null;
  31551.     private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderLimitRead = null;
  31552.     public String [] getControlloTrafficoNumeroRichiesteFalliteHeaderLimit() throws CoreException { 
  31553.         if(this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitRead==null){
  31554.             try{ 
  31555.                 String name = null;
  31556.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.limit");
  31557.                 if(name!=null){
  31558.                     name = name.trim();
  31559.                     this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit = name.split(",");
  31560.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit.length; i++) {
  31561.                         this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit[i].trim();
  31562.                     }
  31563.                 }
  31564.                 
  31565.                 this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitRead = true;
  31566.                 
  31567.             } catch(java.lang.Exception e) {
  31568.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.limit': "+e.getMessage(),e);
  31569.                 throw new CoreException(e.getMessage(),e);
  31570.             }    
  31571.         }

  31573.         return this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit;
  31574.     }
  31575.     
  31576.     private String [] getControlloTrafficoNumeroFaultApplicativiHeaderLimit = null;
  31577.     private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderLimitRead = null;
  31578.     public String [] getControlloTrafficoNumeroFaultApplicativiHeaderLimit() throws CoreException { 
  31579.         if(this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitRead==null){
  31580.             try{ 
  31581.                 String name = null;
  31582.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.limit");
  31583.                 if(name!=null){
  31584.                     name = name.trim();
  31585.                     this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit = name.split(",");
  31586.                     for (int i = 0; i < this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit.length; i++) {
  31587.                         this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit[i]=this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit[i].trim();
  31588.                     }
  31589.                 }
  31590.                 
  31591.                 this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitRead = true;
  31592.                 
  31593.             } catch(java.lang.Exception e) {
  31594.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.limit': "+e.getMessage(),e);
  31595.                 throw new CoreException(e.getMessage(),e);
  31596.             }    
  31597.         }

  31599.         return this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit;
  31600.     }
  31601.     
  31602.     private String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit = null;
  31603.     private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitRead = null;
  31604.     public String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit() throws CoreException {    
  31605.         if(this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitRead==null){
  31606.             try{ 
  31607.                 String name = null;
  31608.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.limit");
  31609.                 if(name!=null){
  31610.                     name = name.trim();
  31611.                     this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit = name.split(",");
  31612.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit.length; i++) {
  31613.                         this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit[i].trim();
  31614.                     }
  31615.                 }
  31616.                 
  31617.                 this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitRead = true;
  31618.                 
  31619.             } catch(java.lang.Exception e) {
  31620.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.limit': "+e.getMessage(),e);
  31621.                 throw new CoreException(e.getMessage(),e);
  31622.             }    
  31623.         }

  31625.         return this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit;
  31626.     }   
  31627.         
  31628.     private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit = null;
  31629.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitRead = null;
  31630.     public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit() throws CoreException {  
  31631.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitRead==null){
  31632.             try{ 
  31633.                 String name = null;
  31634.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.limit");
  31635.                 if(name!=null){
  31636.                     name = name.trim();
  31637.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit = name.split(",");
  31638.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit.length; i++) {
  31639.                         this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit[i].trim();
  31640.                     }
  31641.                 }
  31642.                 
  31643.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitRead = true;
  31644.                 
  31645.             } catch(java.lang.Exception e) {
  31646.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.limit': "+e.getMessage(),e);
  31647.                 throw new CoreException(e.getMessage(),e);
  31648.             }    
  31649.         }

  31651.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit;
  31652.     }   
  31653.     
  31654.     
  31655.     // Windows
  31656.     
  31657.     private Boolean getControlloTrafficoNumeroRichiesteHeaderLimitWindows = null;
  31658.     private Boolean getControlloTrafficoNumeroRichiesteHeaderLimitWindowsRead = null;
  31659.     public Boolean getControlloTrafficoNumeroRichiesteHeaderLimitWindows() throws CoreException {   
  31660.         if(this.getControlloTrafficoNumeroRichiesteHeaderLimitWindowsRead==null){
  31661.             try{ 
  31662.                 String name = null;
  31663.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit.windows");
  31664.                 if(name!=null){
  31665.                     name = name.trim();
  31666.                     this.getControlloTrafficoNumeroRichiesteHeaderLimitWindows = Boolean.valueOf(name);
  31667.                 }
  31668.                 
  31669.                 this.getControlloTrafficoNumeroRichiesteHeaderLimitWindowsRead = true;
  31670.                 
  31671.             } catch(java.lang.Exception e) {
  31672.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit.windows': "+e.getMessage(),e);
  31673.                 throw new CoreException(e.getMessage(),e);
  31674.             }    
  31675.         }

  31677.         return this.getControlloTrafficoNumeroRichiesteHeaderLimitWindows;
  31678.     }
  31679.     
  31680.     private Boolean getControlloTrafficoOccupazioneBandaHeaderLimitWindows = null;
  31681.     private Boolean getControlloTrafficoOccupazioneBandaHeaderLimitWindowsRead = null;
  31682.     public Boolean getControlloTrafficoOccupazioneBandaHeaderLimitWindows() throws CoreException {  
  31683.         if(this.getControlloTrafficoOccupazioneBandaHeaderLimitWindowsRead==null){
  31684.             try{ 
  31685.                 String name = null;
  31686.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.limit.windows");
  31687.                 if(name!=null){
  31688.                     name = name.trim();
  31689.                     this.getControlloTrafficoOccupazioneBandaHeaderLimitWindows = Boolean.valueOf(name);
  31690.                 }
  31691.                 
  31692.                 this.getControlloTrafficoOccupazioneBandaHeaderLimitWindowsRead = true;
  31693.                 
  31694.             } catch(java.lang.Exception e) {
  31695.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.limit.windows': "+e.getMessage(),e);
  31696.                 throw new CoreException(e.getMessage(),e);
  31697.             }    
  31698.         }

  31700.         return this.getControlloTrafficoOccupazioneBandaHeaderLimitWindows;
  31701.     }
  31702.     
  31703.     private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows = null;
  31704.     private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindowsRead = null;
  31705.     public Boolean getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows() throws CoreException {  
  31706.         if(this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindowsRead==null){
  31707.             try{ 
  31708.                 String name = null;
  31709.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.limit.windows");
  31710.                 if(name!=null){
  31711.                     name = name.trim();
  31712.                     this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows = Boolean.valueOf(name);
  31713.                 }
  31714.                 
  31715.                 this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindowsRead = true;
  31716.                 
  31717.             } catch(java.lang.Exception e) {
  31718.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.limit.windows': "+e.getMessage(),e);
  31719.                 throw new CoreException(e.getMessage(),e);
  31720.             }    
  31721.         }

  31723.         return this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows;
  31724.     }
  31725.     
  31726.     private Boolean getControlloTrafficoTempoMedioRispostaHeaderLimitWindows = null;
  31727.     private Boolean getControlloTrafficoTempoMedioRispostaHeaderLimitWindowsRead = null;
  31728.     public Boolean getControlloTrafficoTempoMedioRispostaHeaderLimitWindows() throws CoreException {    
  31729.         if(this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindowsRead==null){
  31730.             try{ 
  31731.                 String name = null;
  31732.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.limit.windows");
  31733.                 if(name!=null){
  31734.                     name = name.trim();
  31735.                     this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindows = Boolean.valueOf(name);
  31736.                 }
  31737.                 
  31738.                 this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindowsRead = true;
  31739.                 
  31740.             } catch(java.lang.Exception e) {
  31741.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.limit.windows': "+e.getMessage(),e);
  31742.                 throw new CoreException(e.getMessage(),e);
  31743.             }    
  31744.         }

  31746.         return this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindows;
  31747.     }
  31748.     
  31749.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows = null;
  31750.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindowsRead = null;
  31751.     public Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows() throws CoreException {  
  31752.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindowsRead==null){
  31753.             try{ 
  31754.                 String name = null;
  31755.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.limit.windows");
  31756.                 if(name!=null){
  31757.                     name = name.trim();
  31758.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows = Boolean.valueOf(name);
  31759.                 }
  31760.                 
  31761.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindowsRead = true;
  31762.                 
  31763.             } catch(java.lang.Exception e) {
  31764.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.limit.windows': "+e.getMessage(),e);
  31765.                 throw new CoreException(e.getMessage(),e);
  31766.             }    
  31767.         }

  31769.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows;
  31770.     }
  31771.     
  31772.     private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows = null;
  31773.     private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindowsRead = null;
  31774.     public Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows() throws CoreException {    
  31775.         if(this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindowsRead==null){
  31776.             try{ 
  31777.                 String name = null;
  31778.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.limit.windows");
  31779.                 if(name!=null){
  31780.                     name = name.trim();
  31781.                     this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows = Boolean.valueOf(name);
  31782.                 }
  31783.                 
  31784.                 this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindowsRead = true;
  31785.                 
  31786.             } catch(java.lang.Exception e) {
  31787.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.limit.windows': "+e.getMessage(),e);
  31788.                 throw new CoreException(e.getMessage(),e);
  31789.             }    
  31790.         }

  31792.         return this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows;
  31793.     }
  31794.     
  31795.     private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows = null;
  31796.     private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindowsRead = null;
  31797.     public Boolean getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows() throws CoreException {    
  31798.         if(this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindowsRead==null){
  31799.             try{ 
  31800.                 String name = null;
  31801.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.limit.windows");
  31802.                 if(name!=null){
  31803.                     name = name.trim();
  31804.                     this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows = Boolean.valueOf(name);
  31805.                 }
  31806.                 
  31807.                 this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindowsRead = true;
  31808.                 
  31809.             } catch(java.lang.Exception e) {
  31810.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.limit.windows': "+e.getMessage(),e);
  31811.                 throw new CoreException(e.getMessage(),e);
  31812.             }    
  31813.         }

  31815.         return this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows;
  31816.     }
  31817.     
  31818.     private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows = null;
  31819.     private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindowsRead = null;
  31820.     public Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows() throws CoreException {   
  31821.         if(this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindowsRead==null){
  31822.             try{ 
  31823.                 String name = null;
  31824.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.limit.windows");
  31825.                 if(name!=null){
  31826.                     name = name.trim();
  31827.                     this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows = Boolean.valueOf(name);
  31828.                 }
  31829.                 
  31830.                 this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindowsRead = true;
  31831.                 
  31832.             } catch(java.lang.Exception e) {
  31833.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.limit.windows': "+e.getMessage(),e);
  31834.                 throw new CoreException(e.getMessage(),e);
  31835.             }    
  31836.         }

  31838.         return this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows;
  31839.     }   
  31840.     
  31841.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindows = null;
  31842.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindowsRead = null;
  31843.     public Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindows() throws CoreException { 
  31844.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindowsRead==null){
  31845.             try{ 
  31846.                 String name = null;
  31847.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.limit.windows");
  31848.                 if(name!=null){
  31849.                     name = name.trim();
  31850.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindows = Boolean.valueOf(name);
  31851.                 }
  31852.                 
  31853.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindowsRead = true;
  31854.                 
  31855.             } catch(java.lang.Exception e) {
  31856.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.limit.windows': "+e.getMessage(),e);
  31857.                 throw new CoreException(e.getMessage(),e);
  31858.             }    
  31859.         }

  31861.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindows;
  31862.     }   

  31864.     
  31865.     // Remaining
  31866.     
  31867.     private String [] getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining = null;
  31868.     private Boolean getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemainingRead = null;
  31869.     public String [] getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining() throws CoreException {  
  31870.         if(this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemainingRead==null){
  31871.             try{ 
  31872.                 String name = null;
  31873.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteSimultanee.header.remaining");
  31874.                 if(name!=null){
  31875.                     name = name.trim();
  31876.                     this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining = name.split(",");
  31877.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining.length; i++) {
  31878.                         this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining[i].trim();
  31879.                     }
  31880.                 }
  31881.                 
  31882.                 this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemainingRead = true;
  31883.                 
  31884.             } catch(java.lang.Exception e) {
  31885.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteSimultanee.header.remaining': "+e.getMessage(),e);
  31886.                 throw new CoreException(e.getMessage(),e);
  31887.             }    
  31888.         }

  31890.         return this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining;
  31891.     }
  31892.     
  31893.     private String [] getControlloTrafficoNumeroRichiesteHeaderRemaining = null;
  31894.     private Boolean getControlloTrafficoNumeroRichiesteHeaderRemainingRead = null;
  31895.     public String [] getControlloTrafficoNumeroRichiesteHeaderRemaining() throws CoreException {    
  31896.         if(this.getControlloTrafficoNumeroRichiesteHeaderRemainingRead==null){
  31897.             try{ 
  31898.                 String name = null;
  31899.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.remaining");
  31900.                 if(name!=null){
  31901.                     name = name.trim();
  31902.                     this.getControlloTrafficoNumeroRichiesteHeaderRemaining = name.split(",");
  31903.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteHeaderRemaining.length; i++) {
  31904.                         this.getControlloTrafficoNumeroRichiesteHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteHeaderRemaining[i].trim();
  31905.                     }
  31906.                 }
  31907.                 
  31908.                 this.getControlloTrafficoNumeroRichiesteHeaderRemainingRead = true;
  31909.                 
  31910.             } catch(java.lang.Exception e) {
  31911.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.remaining': "+e.getMessage(),e);
  31912.                 throw new CoreException(e.getMessage(),e);
  31913.             }    
  31914.         }

  31916.         return this.getControlloTrafficoNumeroRichiesteHeaderRemaining;
  31917.     }
  31918.     
  31919.     private String [] getControlloTrafficoOccupazioneBandaHeaderRemaining = null;
  31920.     private Boolean getControlloTrafficoOccupazioneBandaHeaderRemainingRead = null;
  31921.     public String [] getControlloTrafficoOccupazioneBandaHeaderRemaining() throws CoreException {   
  31922.         if(this.getControlloTrafficoOccupazioneBandaHeaderRemainingRead==null){
  31923.             try{ 
  31924.                 String name = null;
  31925.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.remaining");
  31926.                 if(name!=null){
  31927.                     name = name.trim();
  31928.                     this.getControlloTrafficoOccupazioneBandaHeaderRemaining = name.split(",");
  31929.                     for (int i = 0; i < this.getControlloTrafficoOccupazioneBandaHeaderRemaining.length; i++) {
  31930.                         this.getControlloTrafficoOccupazioneBandaHeaderRemaining[i]=this.getControlloTrafficoOccupazioneBandaHeaderRemaining[i].trim();
  31931.                     }
  31932.                 }
  31933.                 
  31934.                 this.getControlloTrafficoOccupazioneBandaHeaderRemainingRead = true;
  31935.                 
  31936.             } catch(java.lang.Exception e) {
  31937.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.remaining': "+e.getMessage(),e);
  31938.                 throw new CoreException(e.getMessage(),e);
  31939.             }    
  31940.         }

  31942.         return this.getControlloTrafficoOccupazioneBandaHeaderRemaining;
  31943.     }
  31944.     
  31945.     private String [] getControlloTrafficoTempoComplessivoRispostaHeaderRemaining = null;
  31946.     private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderRemainingRead = null;
  31947.     public String [] getControlloTrafficoTempoComplessivoRispostaHeaderRemaining() throws CoreException {   
  31948.         if(this.getControlloTrafficoTempoComplessivoRispostaHeaderRemainingRead==null){
  31949.             try{ 
  31950.                 String name = null;
  31951.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.remaining");
  31952.                 if(name!=null){
  31953.                     name = name.trim();
  31954.                     this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining = name.split(",");
  31955.                     for (int i = 0; i < this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining.length; i++) {
  31956.                         this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining[i]=this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining[i].trim();
  31957.                     }
  31958.                 }
  31959.                 
  31960.                 this.getControlloTrafficoTempoComplessivoRispostaHeaderRemainingRead = true;
  31961.                 
  31962.             } catch(java.lang.Exception e) {
  31963.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.remaining': "+e.getMessage(),e);
  31964.                 throw new CoreException(e.getMessage(),e);
  31965.             }    
  31966.         }

  31968.         return this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining;
  31969.     }
  31970.         
  31971.     private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining = null;
  31972.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemainingRead = null;
  31973.     public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining() throws CoreException {   
  31974.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemainingRead==null){
  31975.             try{ 
  31976.                 String name = null;
  31977.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.remaining");
  31978.                 if(name!=null){
  31979.                     name = name.trim();
  31980.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining = name.split(",");
  31981.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining.length; i++) {
  31982.                         this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining[i].trim();
  31983.                     }
  31984.                 }
  31985.                 
  31986.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemainingRead = true;
  31987.                 
  31988.             } catch(java.lang.Exception e) {
  31989.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.remaining': "+e.getMessage(),e);
  31990.                 throw new CoreException(e.getMessage(),e);
  31991.             }    
  31992.         }

  31994.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining;
  31995.     }
  31996.     
  31997.     private String [] getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining = null;
  31998.     private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderRemainingRead = null;
  31999.     public String [] getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining() throws CoreException { 
  32000.         if(this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemainingRead==null){
  32001.             try{ 
  32002.                 String name = null;
  32003.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.remaining");
  32004.                 if(name!=null){
  32005.                     name = name.trim();
  32006.                     this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining = name.split(",");
  32007.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining.length; i++) {
  32008.                         this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining[i].trim();
  32009.                     }
  32010.                 }
  32011.                 
  32012.                 this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemainingRead = true;
  32013.                 
  32014.             } catch(java.lang.Exception e) {
  32015.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.remaining': "+e.getMessage(),e);
  32016.                 throw new CoreException(e.getMessage(),e);
  32017.             }    
  32018.         }

  32020.         return this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining;
  32021.     }
  32022.     
  32023.     private String [] getControlloTrafficoNumeroFaultApplicativiHeaderRemaining = null;
  32024.     private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderRemainingRead = null;
  32025.     public String [] getControlloTrafficoNumeroFaultApplicativiHeaderRemaining() throws CoreException { 
  32026.         if(this.getControlloTrafficoNumeroFaultApplicativiHeaderRemainingRead==null){
  32027.             try{ 
  32028.                 String name = null;
  32029.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.remaining");
  32030.                 if(name!=null){
  32031.                     name = name.trim();
  32032.                     this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining = name.split(",");
  32033.                     for (int i = 0; i < this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining.length; i++) {
  32034.                         this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining[i]=this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining[i].trim();
  32035.                     }
  32036.                 }
  32037.                 
  32038.                 this.getControlloTrafficoNumeroFaultApplicativiHeaderRemainingRead = true;
  32039.                 
  32040.             } catch(java.lang.Exception e) {
  32041.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.remaining': "+e.getMessage(),e);
  32042.                 throw new CoreException(e.getMessage(),e);
  32043.             }    
  32044.         }

  32046.         return this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining;
  32047.     }
  32048.     
  32049.     private String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining = null;
  32050.     private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemainingRead = null;
  32051.     public String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining() throws CoreException {    
  32052.         if(this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemainingRead==null){
  32053.             try{ 
  32054.                 String name = null;
  32055.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.remaining");
  32056.                 if(name!=null){
  32057.                     name = name.trim();
  32058.                     this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining = name.split(",");
  32059.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining.length; i++) {
  32060.                         this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining[i].trim();
  32061.                     }
  32062.                 }
  32063.                 
  32064.                 this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemainingRead = true;
  32065.                 
  32066.             } catch(java.lang.Exception e) {
  32067.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteNonCompletateConSuccesso.header.remaining': "+e.getMessage(),e);
  32068.                 throw new CoreException(e.getMessage(),e);
  32069.             }    
  32070.         }

  32072.         return this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining;
  32073.     }
  32074.     
  32075.     private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining = null;
  32076.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemainingRead = null;
  32077.     public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining() throws CoreException {  
  32078.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemainingRead==null){
  32079.             try{ 
  32080.                 String name = null;
  32081.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.remaining");
  32082.                 if(name!=null){
  32083.                     name = name.trim();
  32084.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining = name.split(",");
  32085.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining.length; i++) {
  32086.                         this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining[i].trim();
  32087.                     }
  32088.                 }
  32089.                 
  32090.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemainingRead = true;
  32091.                 
  32092.             } catch(java.lang.Exception e) {
  32093.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.remaining': "+e.getMessage(),e);
  32094.                 throw new CoreException(e.getMessage(),e);
  32095.             }    
  32096.         }

  32098.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining;
  32099.     }
  32100.     

  32102.     
  32103.     
  32104.     
  32105.     // Reset
  32106.     
  32107.     private String [] getControlloTrafficoNumeroRichiesteHeaderReset = null;
  32108.     private Boolean getControlloTrafficoNumeroRichiesteHeaderResetRead = null;
  32109.     public String [] getControlloTrafficoNumeroRichiesteHeaderReset() throws CoreException {    
  32110.         if(this.getControlloTrafficoNumeroRichiesteHeaderResetRead==null){
  32111.             try{ 
  32112.                 String name = null;
  32113.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.reset");
  32114.                 if(name!=null){
  32115.                     name = name.trim();
  32116.                     this.getControlloTrafficoNumeroRichiesteHeaderReset = name.split(",");
  32117.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteHeaderReset.length; i++) {
  32118.                         this.getControlloTrafficoNumeroRichiesteHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteHeaderReset[i].trim();
  32119.                     }
  32120.                 }
  32121.                 
  32122.                 this.getControlloTrafficoNumeroRichiesteHeaderResetRead = true;
  32123.                 
  32124.             } catch(java.lang.Exception e) {
  32125.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.reset': "+e.getMessage(),e);
  32126.                 throw new CoreException(e.getMessage(),e);
  32127.             }    
  32128.         }

  32130.         return this.getControlloTrafficoNumeroRichiesteHeaderReset;
  32131.     }
  32132.     
  32133.     private String [] getControlloTrafficoOccupazioneBandaHeaderReset = null;
  32134.     private Boolean getControlloTrafficoOccupazioneBandaHeaderResetRead = null;
  32135.     public String [] getControlloTrafficoOccupazioneBandaHeaderReset() throws CoreException {   
  32136.         if(this.getControlloTrafficoOccupazioneBandaHeaderResetRead==null){
  32137.             try{ 
  32138.                 String name = null;
  32139.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.reset");
  32140.                 if(name!=null){
  32141.                     name = name.trim();
  32142.                     this.getControlloTrafficoOccupazioneBandaHeaderReset = name.split(",");
  32143.                     for (int i = 0; i < this.getControlloTrafficoOccupazioneBandaHeaderReset.length; i++) {
  32144.                         this.getControlloTrafficoOccupazioneBandaHeaderReset[i]=this.getControlloTrafficoOccupazioneBandaHeaderReset[i].trim();
  32145.                     }
  32146.                 }
  32147.                 
  32148.                 this.getControlloTrafficoOccupazioneBandaHeaderResetRead = true;
  32149.                 
  32150.             } catch(java.lang.Exception e) {
  32151.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.reset': "+e.getMessage(),e);
  32152.                 throw new CoreException(e.getMessage(),e);
  32153.             }    
  32154.         }

  32156.         return this.getControlloTrafficoOccupazioneBandaHeaderReset;
  32157.     }
  32158.     
  32159.     private String [] getControlloTrafficoTempoComplessivoRispostaHeaderReset = null;
  32160.     private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderResetRead = null;
  32161.     public String [] getControlloTrafficoTempoComplessivoRispostaHeaderReset() throws CoreException {   
  32162.         if(this.getControlloTrafficoTempoComplessivoRispostaHeaderResetRead==null){
  32163.             try{ 
  32164.                 String name = null;
  32165.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.reset");
  32166.                 if(name!=null){
  32167.                     name = name.trim();
  32168.                     this.getControlloTrafficoTempoComplessivoRispostaHeaderReset = name.split(",");
  32169.                     for (int i = 0; i < this.getControlloTrafficoTempoComplessivoRispostaHeaderReset.length; i++) {
  32170.                         this.getControlloTrafficoTempoComplessivoRispostaHeaderReset[i]=this.getControlloTrafficoTempoComplessivoRispostaHeaderReset[i].trim();
  32171.                     }
  32172.                 }
  32173.                 
  32174.                 this.getControlloTrafficoTempoComplessivoRispostaHeaderResetRead = true;
  32175.                 
  32176.             } catch(java.lang.Exception e) {
  32177.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.reset': "+e.getMessage(),e);
  32178.                 throw new CoreException(e.getMessage(),e);
  32179.             }    
  32180.         }

  32182.         return this.getControlloTrafficoTempoComplessivoRispostaHeaderReset;
  32183.     }
  32184.     
  32185.     private String [] getControlloTrafficoTempoMedioRispostaHeaderReset = null;
  32186.     private Boolean getControlloTrafficoTempoMedioRispostaHeaderResetRead = null;
  32187.     public String [] getControlloTrafficoTempoMedioRispostaHeaderReset() throws CoreException { 
  32188.         if(this.getControlloTrafficoTempoMedioRispostaHeaderResetRead==null){
  32189.             try{ 
  32190.                 String name = null;
  32191.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.reset");
  32192.                 if(name!=null){
  32193.                     name = name.trim();
  32194.                     this.getControlloTrafficoTempoMedioRispostaHeaderReset = name.split(",");
  32195.                     for (int i = 0; i < this.getControlloTrafficoTempoMedioRispostaHeaderReset.length; i++) {
  32196.                         this.getControlloTrafficoTempoMedioRispostaHeaderReset[i]=this.getControlloTrafficoTempoMedioRispostaHeaderReset[i].trim();
  32197.                     }
  32198.                 }
  32199.                 
  32200.                 this.getControlloTrafficoTempoMedioRispostaHeaderResetRead = true;
  32201.                 
  32202.             } catch(java.lang.Exception e) {
  32203.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.reset': "+e.getMessage(),e);
  32204.                 throw new CoreException(e.getMessage(),e);
  32205.             }    
  32206.         }

  32208.         return this.getControlloTrafficoTempoMedioRispostaHeaderReset;
  32209.     }
  32210.     
  32211.     private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset = null;
  32212.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderResetRead = null;
  32213.     public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset() throws CoreException {   
  32214.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderResetRead==null){
  32215.             try{ 
  32216.                 String name = null;
  32217.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.reset");
  32218.                 if(name!=null){
  32219.                     name = name.trim();
  32220.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset = name.split(",");
  32221.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset.length; i++) {
  32222.                         this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset[i].trim();
  32223.                     }
  32224.                 }
  32225.                 
  32226.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderResetRead = true;
  32227.                 
  32228.             } catch(java.lang.Exception e) {
  32229.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.reset': "+e.getMessage(),e);
  32230.                 throw new CoreException(e.getMessage(),e);
  32231.             }    
  32232.         }

  32234.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset;
  32235.     }
  32236.     
  32237.     private String [] getControlloTrafficoNumeroRichiesteFalliteHeaderReset = null;
  32238.     private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderResetRead = null;
  32239.     public String [] getControlloTrafficoNumeroRichiesteFalliteHeaderReset() throws CoreException { 
  32240.         if(this.getControlloTrafficoNumeroRichiesteFalliteHeaderResetRead==null){
  32241.             try{ 
  32242.                 String name = null;
  32243.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.reset");
  32244.                 if(name!=null){
  32245.                     name = name.trim();
  32246.                     this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset = name.split(",");
  32247.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset.length; i++) {
  32248.                         this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset[i].trim();
  32249.                     }
  32250.                 }
  32251.                 
  32252.                 this.getControlloTrafficoNumeroRichiesteFalliteHeaderResetRead = true;
  32253.                 
  32254.             } catch(java.lang.Exception e) {
  32255.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.reset': "+e.getMessage(),e);
  32256.                 throw new CoreException(e.getMessage(),e);
  32257.             }    
  32258.         }

  32260.         return this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset;
  32261.     }
  32262.     
  32263.     private String [] getControlloTrafficoNumeroFaultApplicativiHeaderReset = null;
  32264.     private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderResetRead = null;
  32265.     public String [] getControlloTrafficoNumeroFaultApplicativiHeaderReset() throws CoreException { 
  32266.         if(this.getControlloTrafficoNumeroFaultApplicativiHeaderResetRead==null){
  32267.             try{ 
  32268.                 String name = null;
  32269.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.reset");
  32270.                 if(name!=null){
  32271.                     name = name.trim();
  32272.                     this.getControlloTrafficoNumeroFaultApplicativiHeaderReset = name.split(",");
  32273.                     for (int i = 0; i < this.getControlloTrafficoNumeroFaultApplicativiHeaderReset.length; i++) {
  32274.                         this.getControlloTrafficoNumeroFaultApplicativiHeaderReset[i]=this.getControlloTrafficoNumeroFaultApplicativiHeaderReset[i].trim();
  32275.                     }
  32276.                 }
  32277.                 
  32278.                 this.getControlloTrafficoNumeroFaultApplicativiHeaderResetRead = true;
  32279.                 
  32280.             } catch(java.lang.Exception e) {
  32281.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.reset': "+e.getMessage(),e);
  32282.                 throw new CoreException(e.getMessage(),e);
  32283.             }    
  32284.         }

  32286.         return this.getControlloTrafficoNumeroFaultApplicativiHeaderReset;
  32287.     }
  32288.     
  32289.     private String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset = null;
  32290.     private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderResetRead = null;
  32291.     public String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset() throws CoreException {    
  32292.         if(this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderResetRead==null){
  32293.             try{ 
  32294.                 String name = null;
  32295.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.reset");
  32296.                 if(name!=null){
  32297.                     name = name.trim();
  32298.                     this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset = name.split(",");
  32299.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset.length; i++) {
  32300.                         this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset[i].trim();
  32301.                     }
  32302.                 }
  32303.                 
  32304.                 this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderResetRead = true;
  32305.                 
  32306.             } catch(java.lang.Exception e) {
  32307.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.reset': "+e.getMessage(),e);
  32308.                 throw new CoreException(e.getMessage(),e);
  32309.             }    
  32310.         }

  32312.         return this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset;
  32313.     }
  32314.     
  32315.     private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset = null;
  32316.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderResetRead = null;
  32317.     public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset() throws CoreException {  
  32318.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderResetRead==null){
  32319.             try{ 
  32320.                 String name = null;
  32321.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.reset");
  32322.                 if(name!=null){
  32323.                     name = name.trim();
  32324.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset = name.split(",");
  32325.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset.length; i++) {
  32326.                         this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset[i].trim();
  32327.                     }
  32328.                 }
  32329.                 
  32330.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderResetRead = true;
  32331.                 
  32332.             } catch(java.lang.Exception e) {
  32333.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.reset': "+e.getMessage(),e);
  32334.                 throw new CoreException(e.getMessage(),e);
  32335.             }    
  32336.         }

  32338.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset;
  32339.     }
  32340.     
  32341.     
  32342.     
  32343.     // Header Retry After
  32344.     
  32345.     private String [] getControlloTrafficoRetryAfterHeader = null;
  32346.     private Boolean getControlloTrafficoRetryAfterHeaderRead = null;
  32347.     public String [] getControlloTrafficoRetryAfterHeader() throws CoreException {  
  32348.         if(this.getControlloTrafficoRetryAfterHeaderRead==null){
  32349.             try{ 
  32350.                 String name = null;
  32351.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.policyViolate.retryAfter");
  32352.                 if(name!=null){
  32353.                     name = name.trim();
  32354.                     this.getControlloTrafficoRetryAfterHeader = name.split(",");
  32355.                     for (int i = 0; i < this.getControlloTrafficoRetryAfterHeader.length; i++) {
  32356.                         this.getControlloTrafficoRetryAfterHeader[i]=this.getControlloTrafficoRetryAfterHeader[i].trim();
  32357.                     }
  32358.                 }
  32359.                 
  32360.                 this.getControlloTrafficoRetryAfterHeaderRead = true;
  32361.                 
  32362.             } catch(java.lang.Exception e) {
  32363.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit': "+e.getMessage(),e);
  32364.                 throw new CoreException(e.getMessage(),e);
  32365.             }    
  32366.         }

  32368.         return this.getControlloTrafficoRetryAfterHeader;
  32369.     }
  32370.         
  32371.     private Integer getControlloTrafficoRetryAfterHeaderRandomBackoff = null;
  32372.     public Integer getControlloTrafficoRetryAfterHeaderRandomBackoff() {    
  32373.         if(this.getControlloTrafficoRetryAfterHeaderRandomBackoff==null){
  32374.             try{ 
  32375.                 String name = null;
  32376.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.policyViolate.retryAfter.randomBackoff.seconds");
  32377.                 if(name!=null){
  32378.                     name = name.trim();
  32379.                     this.getControlloTrafficoRetryAfterHeaderRandomBackoff = Integer.parseInt(name);
  32380.                 }
  32381.                 else {
  32382.                     this.getControlloTrafficoRetryAfterHeaderRandomBackoff = 0;
  32383.                 }
  32384.             } catch(java.lang.Exception e) {
  32385.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.policyViolate.retryAfter.randomBackoff.seconds': "+e.getMessage(),e);
  32386.                 this.getControlloTrafficoRetryAfterHeaderRandomBackoff = 0;
  32387.             }    
  32388.         }

  32390.         return this.getControlloTrafficoRetryAfterHeaderRandomBackoff;
  32391.     }
  32392.     
  32393.     
  32394.     
  32395.     /* ------------- Allarmi ---------------------*/
  32396.     
  32397.     private Boolean isAllarmiEnabled = null;
  32398.     public boolean isAllarmiEnabled() { 
  32399.         if(this.isAllarmiEnabled==null){
  32400.             try{ 
  32401.                 if(CostantiConfigurazione.CONFIGURAZIONE_XML.equalsIgnoreCase(getTipoConfigurazionePDD())){
  32402.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.enabled' ignorata. La segnalazione degli allarmi è disabilitata sulla configurazione xml");
  32403.                     this.isAllarmiEnabled = false;
  32404.                 }
  32405.                 else {
  32406.                     String name = null;
  32407.                     name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.allarmi.enabled");
  32408.                     if(name==null){
  32409.                         this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.enabled' non impostata, viene utilizzato il default=false");
  32410.                         name="false";
  32411.                     }
  32412.                     name = name.trim();
  32413.                     this.isAllarmiEnabled = Boolean.parseBoolean(name);
  32414.                 }
  32415.             } catch(java.lang.Exception e) {
  32416.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.enabled', viene utilizzato il default=false : "+e.getMessage(),e);
  32417.                 this.isAllarmiEnabled = true;
  32418.             }    
  32419.         }

  32421.         return this.isAllarmiEnabled;
  32422.     }
  32423.     
  32424.     private Boolean isAllarmiDebug = null;
  32425.     public boolean isAllarmiDebug() {   
  32426.         if(this.isAllarmiDebug==null){
  32427.             try{ 
  32428.                 String name = null;
  32429.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.allarmi.debug");
  32430.                 if(name==null){
  32431.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.debug' non impostata, viene utilizzato il default=true");
  32432.                     name="true";
  32433.                 }
  32434.                 name = name.trim();
  32435.                 this.isAllarmiDebug = Boolean.parseBoolean(name);
  32436.             } catch(java.lang.Exception e) {
  32437.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.debug', viene utilizzato il default=true : "+e.getMessage(),e);
  32438.                 this.isAllarmiDebug = true;
  32439.             }    
  32440.         }

  32442.         return this.isAllarmiDebug;
  32443.     }
  32444.     
  32445.     
  32446.     
  32447.     
  32448.     /* ------------- Service Unavailable ---------------------*/
  32449.     
  32450.     private Integer getServiceUnavailableRetryAfterSecondsPD = null;
  32451.     public Integer getServiceUnavailableRetryAfterSecondsPD() { 
  32452.         if(this.getServiceUnavailableRetryAfterSecondsPD==null){
  32453.             try{ 
  32454.                 String name = null;
  32455.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.seconds");
  32456.                 if(name!=null){
  32457.                     name = name.trim();
  32458.                     this.getServiceUnavailableRetryAfterSecondsPD = Integer.parseInt(name);
  32459.                 }
  32460.                 else {
  32461.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  32462.                 }
  32463.             } catch(java.lang.Exception e) {
  32464.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.seconds', default:60 : "+e.getMessage(),e);
  32465.                 this.getServiceUnavailableRetryAfterSecondsPD = 60;
  32466.             }    
  32467.         }

  32469.         return this.getServiceUnavailableRetryAfterSecondsPD;
  32470.     }
  32471.     
  32472.     private Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPD = null;
  32473.     public Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPD() {    
  32474.         if(this.getServiceUnavailableRetryAfterSecondsRandomBackoffPD==null){
  32475.             try{ 
  32476.                 String name = null;
  32477.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.randomBackoff.seconds");
  32478.                 if(name!=null){
  32479.                     name = name.trim();
  32480.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPD = Integer.parseInt(name);
  32481.                 }
  32482.                 else {
  32483.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPD = 0;
  32484.                 }
  32485.             } catch(java.lang.Exception e) {
  32486.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.randomBackoff.seconds': "+e.getMessage(),e);
  32487.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPD = 0;
  32488.             }    
  32489.         }

  32491.         return this.getServiceUnavailableRetryAfterSecondsRandomBackoffPD;
  32492.     }
  32493.     
  32494.     private Integer getServiceUnavailableRetryAfterSecondsPA = null;
  32495.     public Integer getServiceUnavailableRetryAfterSecondsPA() { 
  32496.         if(this.getServiceUnavailableRetryAfterSecondsPA==null){
  32497.             try{ 
  32498.                 String name = null;
  32499.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.seconds");
  32500.                 if(name!=null){
  32501.                     name = name.trim();
  32502.                     this.getServiceUnavailableRetryAfterSecondsPA = Integer.parseInt(name);
  32503.                 }
  32504.                 else {
  32505.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  32506.                 }
  32507.             } catch(java.lang.Exception e) {
  32508.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.seconds', default:60 : "+e.getMessage(),e);
  32509.                 this.getServiceUnavailableRetryAfterSecondsPA = 60;
  32510.             }    
  32511.         }

  32513.         return this.getServiceUnavailableRetryAfterSecondsPA;
  32514.     }
  32515.     
  32516.     private Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPA = null;
  32517.     public Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPA() {    
  32518.         if(this.getServiceUnavailableRetryAfterSecondsRandomBackoffPA==null){
  32519.             try{ 
  32520.                 String name = null;
  32521.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.randomBackoff.seconds");
  32522.                 if(name!=null){
  32523.                     name = name.trim();
  32524.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPA = Integer.parseInt(name);
  32525.                 }
  32526.                 else {
  32527.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPA = 0;
  32528.                 }
  32529.             } catch(java.lang.Exception e) {
  32530.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.randomBackoff.seconds': "+e.getMessage(),e);
  32531.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPA = 0;
  32532.             }    
  32533.         }

  32535.         return this.getServiceUnavailableRetryAfterSecondsRandomBackoffPA;
  32536.     }
  32537.     
  32538.     
  32539.     
  32540.     private Boolean isEnabledServiceUnavailableRetryAfterPDSuspend = null;
  32541.     public boolean isEnabledServiceUnavailableRetryAfterPDSuspend() {   
  32542.         if(this.isEnabledServiceUnavailableRetryAfterPDSuspend==null){
  32543.             try{ 
  32544.                 String name = null;
  32545.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.enabled");
  32546.                 if(name==null){
  32547.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.enabled' non impostata, viene utilizzato il default=true");
  32548.                     name="true";
  32549.                 }
  32550.                 name = name.trim();
  32551.                 this.isEnabledServiceUnavailableRetryAfterPDSuspend = Boolean.parseBoolean(name);
  32552.             } catch(java.lang.Exception e) {
  32553.                 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);
  32554.                 this.isEnabledServiceUnavailableRetryAfterPDSuspend = true;
  32555.             }    
  32556.         }

  32558.         return this.isEnabledServiceUnavailableRetryAfterPDSuspend;
  32559.     }
  32560.     
  32561.     private Integer getServiceUnavailableRetryAfterSecondsPDSuspend = null;
  32562.     public Integer getServiceUnavailableRetryAfterSecondsPDSuspend() {  
  32563.         if(this.getServiceUnavailableRetryAfterSecondsPDSuspend==null){
  32564.             try{ 
  32565.                 String name = null;
  32566.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.seconds");
  32567.                 if(name!=null){
  32568.                     name = name.trim();
  32569.                     this.getServiceUnavailableRetryAfterSecondsPDSuspend = Integer.parseInt(name);
  32570.                 }
  32571.                 else {
  32572.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  32573.                 }
  32574.             } catch(java.lang.Exception e) {
  32575.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.seconds', default:60 : "+e.getMessage(),e);
  32576.                 this.getServiceUnavailableRetryAfterSecondsPDSuspend = 60;
  32577.             }    
  32578.         }

  32580.         return this.getServiceUnavailableRetryAfterSecondsPDSuspend;
  32581.     }
  32582.     
  32583.     private Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend = null;
  32584.     public Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend() { 
  32585.         if(this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend==null){
  32586.             try{ 
  32587.                 String name = null;
  32588.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.randomBackoff.seconds");
  32589.                 if(name!=null){
  32590.                     name = name.trim();
  32591.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend = Integer.parseInt(name);
  32592.                 }
  32593.                 else {
  32594.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend = 0;
  32595.                 }
  32596.             } catch(java.lang.Exception e) {
  32597.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.randomBackoff.seconds': "+e.getMessage(),e);
  32598.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend = 0;
  32599.             }    
  32600.         }

  32602.         return this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend;
  32603.     }
  32604.     
  32605.     private Boolean isEnabledServiceUnavailableRetryAfterPASuspend = null;
  32606.     public boolean isEnabledServiceUnavailableRetryAfterPASuspend() {   
  32607.         if(this.isEnabledServiceUnavailableRetryAfterPASuspend==null){
  32608.             try{ 
  32609.                 String name = null;
  32610.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.enabled");
  32611.                 if(name==null){
  32612.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.enabled' non impostata, viene utilizzato il default=true");
  32613.                     name="true";
  32614.                 }
  32615.                 name = name.trim();
  32616.                 this.isEnabledServiceUnavailableRetryAfterPASuspend = Boolean.parseBoolean(name);
  32617.             } catch(java.lang.Exception e) {
  32618.                 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);
  32619.                 this.isEnabledServiceUnavailableRetryAfterPASuspend = true;
  32620.             }    
  32621.         }

  32623.         return this.isEnabledServiceUnavailableRetryAfterPASuspend;
  32624.     }
  32625.     
  32626.     private Integer getServiceUnavailableRetryAfterSecondsPASuspend = null;
  32627.     public Integer getServiceUnavailableRetryAfterSecondsPASuspend() {  
  32628.         if(this.getServiceUnavailableRetryAfterSecondsPASuspend==null){
  32629.             try{ 
  32630.                 String name = null;
  32631.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.seconds");
  32632.                 if(name!=null){
  32633.                     name = name.trim();
  32634.                     this.getServiceUnavailableRetryAfterSecondsPASuspend = Integer.parseInt(name);
  32635.                 }
  32636.                 else {
  32637.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  32638.                 }
  32639.             } catch(java.lang.Exception e) {
  32640.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.seconds', default:60 : "+e.getMessage(),e);
  32641.                 this.getServiceUnavailableRetryAfterSecondsPASuspend = 60;
  32642.             }    
  32643.         }

  32645.         return this.getServiceUnavailableRetryAfterSecondsPASuspend;
  32646.     }
  32647.     
  32648.     private Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend = null;
  32649.     public Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend() { 
  32650.         if(this.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend==null){
  32651.             try{ 
  32652.                 String name = null;
  32653.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.randomBackoff.seconds");
  32654.                 if(name!=null){
  32655.                     name = name.trim();
  32656.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend = Integer.parseInt(name);
  32657.                 }
  32658.                 else {
  32659.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend = 0;
  32660.                 }
  32661.             } catch(java.lang.Exception e) {
  32662.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.randomBackoff.seconds': "+e.getMessage(),e);
  32663.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend = 0;
  32664.             }    
  32665.         }

  32667.         return this.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend;
  32668.     }
  32669.     
  32670.     private Boolean isEnabledServiceUnavailableRetryAfterPDConnectionFailed = null;
  32671.     public boolean isEnabledServiceUnavailableRetryAfterPDConnectionFailed() {  
  32672.         if(this.isEnabledServiceUnavailableRetryAfterPDConnectionFailed==null){
  32673.             try{ 
  32674.                 String name = null;
  32675.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.enabled");
  32676.                 if(name==null){
  32677.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.enabled' non impostata, viene utilizzato il default=true");
  32678.                     name="true";
  32679.                 }
  32680.                 name = name.trim();
  32681.                 this.isEnabledServiceUnavailableRetryAfterPDConnectionFailed = Boolean.parseBoolean(name);
  32682.             } catch(java.lang.Exception e) {
  32683.                 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);
  32684.                 this.isEnabledServiceUnavailableRetryAfterPDConnectionFailed = true;
  32685.             }    
  32686.         }

  32688.         return this.isEnabledServiceUnavailableRetryAfterPDConnectionFailed;
  32689.     }
  32690.     
  32691.     private Integer getServiceUnavailableRetryAfterSecondsPDConnectionFailed = null;
  32692.     public Integer getServiceUnavailableRetryAfterSecondsPDConnectionFailed() { 
  32693.         if(this.getServiceUnavailableRetryAfterSecondsPDConnectionFailed==null){
  32694.             try{ 
  32695.                 String name = null;
  32696.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.seconds");
  32697.                 if(name!=null){
  32698.                     name = name.trim();
  32699.                     this.getServiceUnavailableRetryAfterSecondsPDConnectionFailed = Integer.parseInt(name);
  32700.                 }
  32701.                 else {
  32702.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  32703.                 }
  32704.             } catch(java.lang.Exception e) {
  32705.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.seconds', default:60 : "+e.getMessage(),e);
  32706.                 this.getServiceUnavailableRetryAfterSecondsPDConnectionFailed = 60;
  32707.             }    
  32708.         }

  32710.         return this.getServiceUnavailableRetryAfterSecondsPDConnectionFailed;
  32711.     }
  32712.     
  32713.     private Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed = null;
  32714.     public Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed() {    
  32715.         if(this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed==null){
  32716.             try{ 
  32717.                 String name = null;
  32718.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.randomBackoff.seconds");
  32719.                 if(name!=null){
  32720.                     name = name.trim();
  32721.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed = Integer.parseInt(name);
  32722.                 }
  32723.                 else {
  32724.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed = 0;
  32725.                 }
  32726.             } catch(java.lang.Exception e) {
  32727.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.randomBackoff.seconds': "+e.getMessage(),e);
  32728.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed = 0;
  32729.             }    
  32730.         }

  32732.         return this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed;
  32733.     }
  32734.     
  32735.     private Boolean isEnabledServiceUnavailableRetryAfterPAConnectionFailed = null;
  32736.     public boolean isEnabledServiceUnavailableRetryAfterPAConnectionFailed() {  
  32737.         if(this.isEnabledServiceUnavailableRetryAfterPAConnectionFailed==null){
  32738.             try{ 
  32739.                 String name = null;
  32740.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.enabled");
  32741.                 if(name==null){
  32742.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.enabled' non impostata, viene utilizzato il default=true");
  32743.                     name="true";
  32744.                 }
  32745.                 name = name.trim();
  32746.                 this.isEnabledServiceUnavailableRetryAfterPAConnectionFailed = Boolean.parseBoolean(name);
  32747.             } catch(java.lang.Exception e) {
  32748.                 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);
  32749.                 this.isEnabledServiceUnavailableRetryAfterPAConnectionFailed = true;
  32750.             }    
  32751.         }

  32753.         return this.isEnabledServiceUnavailableRetryAfterPAConnectionFailed;
  32754.     }
  32755.     
  32756.     private Integer getServiceUnavailableRetryAfterSecondsPAConnectionFailed = null;
  32757.     public Integer getServiceUnavailableRetryAfterSecondsPAConnectionFailed() { 
  32758.         if(this.getServiceUnavailableRetryAfterSecondsPAConnectionFailed==null){
  32759.             try{ 
  32760.                 String name = null;
  32761.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.seconds");
  32762.                 if(name!=null){
  32763.                     name = name.trim();
  32764.                     this.getServiceUnavailableRetryAfterSecondsPAConnectionFailed = Integer.parseInt(name);
  32765.                 }
  32766.                 else {
  32767.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  32768.                 }
  32769.             } catch(java.lang.Exception e) {
  32770.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.seconds', default:60 : "+e.getMessage(),e);
  32771.                 this.getServiceUnavailableRetryAfterSecondsPAConnectionFailed = 60;
  32772.             }    
  32773.         }

  32775.         return this.getServiceUnavailableRetryAfterSecondsPAConnectionFailed;
  32776.     }
  32777.     
  32778.     private Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed = null;
  32779.     public Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed() {    
  32780.         if(this.getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed==null){
  32781.             try{ 
  32782.                 String name = null;
  32783.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.randomBackoff.seconds");
  32784.                 if(name!=null){
  32785.                     name = name.trim();
  32786.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed = Integer.parseInt(name);
  32787.                 }
  32788.                 else {
  32789.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed = 0;
  32790.                 }
  32791.             } catch(java.lang.Exception e) {
  32792.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.randomBackoff.seconds': "+e.getMessage(),e);
  32793.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed = 0;
  32794.             }    
  32795.         }

  32797.         return this.getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed;
  32798.     }
  32799.     
  32800.     
  32801.     private List<String> isReadTimedOut = null;
  32802.     public boolean isServiceUnavailableReadTimedOut(String msg) {   
  32803.         if(this.isReadTimedOut==null){
  32804.             initServiceUnavailableReadTimedOut();
  32805.         }

  32807.         if(!this.isReadTimedOut.isEmpty()) {
  32808.             for (String s : this.isReadTimedOut) {
  32809.                 if(msg.contains(s)) {
  32810.                     return true;
  32811.                 }
  32812.             }
  32813.         }
  32814.         
  32815.         return false;
  32816.     }
  32817.     private void initServiceUnavailableReadTimedOut() { 
  32818.         try{ 
  32819.             Properties p = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.readTimedOut.");
  32820.             this.isReadTimedOut = new ArrayList<>();
  32821.             if(p!=null && !p.isEmpty()) {
  32822.                 Iterator<Object> it = p.values().iterator();
  32823.                 while (it.hasNext()) {
  32824.                     Object o = it.next();
  32825.                     if(o instanceof String) {
  32826.                         String s = (String) o;
  32827.                         this.isReadTimedOut.add(s);
  32828.                     }
  32829.                 }
  32830.             }
  32831.         } catch(java.lang.Exception e) {
  32832.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.error.': "+e.getMessage(),e);
  32833.             this.isReadTimedOut = new ArrayList<>();
  32834.         }    
  32835.     }
  32836.     
  32837.     
  32838.     /* ------------- Statistiche ---------------------*/
  32839.     
  32840.     private Boolean isStatisticheGenerazioneEnabled = null;
  32841.     public boolean isStatisticheGenerazioneEnabled() {  
  32842.         if(this.isStatisticheGenerazioneEnabled==null){
  32843.             try{ 
  32844.                 String name = null;
  32845.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.enabled");
  32846.                 if(name==null){
  32847.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.enabled' non impostata, viene utilizzato il default=true");
  32848.                     name="true";
  32849.                 }
  32850.                 name = name.trim();
  32851.                 this.isStatisticheGenerazioneEnabled = Boolean.parseBoolean(name);
  32852.             } catch(java.lang.Exception e) {
  32853.                 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);
  32854.                 this.isStatisticheGenerazioneEnabled = true;
  32855.             }    
  32856.         }

  32858.         return this.isStatisticheGenerazioneEnabled;
  32859.     }
  32860.     
  32861.     
  32862.     private Boolean isStatisticheUsePddRuntimeDatasource = null;
  32863.     public boolean isStatisticheUsePddRuntimeDatasource() { 
  32864.         if(this.isStatisticheUsePddRuntimeDatasource==null){
  32865.             try{ 
  32866.                 String name = null;
  32867.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.dataSource.usePddRuntime");
  32868.                 if(name==null){
  32869.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource.usePddRuntime' non impostata, viene utilizzato il default=true");
  32870.                     name="true";
  32871.                 }
  32872.                 name = name.trim();
  32873.                 this.isStatisticheUsePddRuntimeDatasource = Boolean.parseBoolean(name);
  32874.             } catch(java.lang.Exception e) {
  32875.                 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);
  32876.                 this.isStatisticheUsePddRuntimeDatasource = false;
  32877.             }    
  32878.         }

  32880.         return this.isStatisticheUsePddRuntimeDatasource;
  32881.     }
  32882.     
  32883.     private Boolean isStatisticheUseTransazioniDatasource = null;
  32884.     public boolean isStatisticheUseTransazioniDatasource() {    
  32885.         if(this.isStatisticheUseTransazioniDatasource==null){
  32886.             try{ 
  32887.                 String name = null;
  32888.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.dataSource.useTransazioni");
  32889.                 if(name==null){
  32890.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource.useTransazioni' non impostata, viene utilizzato il default=true");
  32891.                     name="true";
  32892.                 }
  32893.                 name = name.trim();
  32894.                 this.isStatisticheUseTransazioniDatasource = Boolean.parseBoolean(name);
  32895.             } catch(java.lang.Exception e) {
  32896.                 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);
  32897.                 this.isStatisticheUseTransazioniDatasource = true;
  32898.             }    
  32899.         }

  32901.         return this.isStatisticheUseTransazioniDatasource;
  32902.     }
  32903.     
  32904.     private String getStatisticheDatasource = null;
  32905.     public String getStatisticheDatasource() throws CoreException { 
  32906.         if(this.getStatisticheDatasource==null){
  32907.             try{ 
  32908.                 String name = null;
  32909.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.dataSource");
  32910.                 if(name==null){
  32911.                     throw new CoreException("Proprieta' non impostata");
  32912.                 }
  32913.                 name = name.trim();
  32914.                 this.getStatisticheDatasource = name;
  32915.             } catch(java.lang.Exception e) {
  32916.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource': "+e.getMessage(),e);
  32917.                 throw new CoreException(e.getMessage(),e);
  32918.             }    
  32919.         }

  32921.         return this.getStatisticheDatasource;
  32922.     }
  32923.     
  32924.     private Properties getStatisticheDatasourceJndiContext = null;
  32925.     public Properties getStatisticheDatasourceJndiContext() throws CoreException {  
  32926.         if(this.getStatisticheDatasourceJndiContext==null){
  32927.             try{ 
  32928.                 this.getStatisticheDatasourceJndiContext = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.statistiche.dataSource.property.");
  32929.             } catch(java.lang.Exception e) {
  32930.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource.property.*': "+e.getMessage(),e);
  32931.                 throw new CoreException(e.getMessage(),e);
  32932.             }    
  32933.         }

  32935.         return this.getStatisticheDatasourceJndiContext;
  32936.     }
  32937.     
  32938.     private Boolean isStatisticheDatasourceUseDBUtils = null;
  32939.     public boolean isStatisticheDatasourceUseDBUtils() {    
  32940.         if(this.isStatisticheDatasourceUseDBUtils==null){
  32941.             try{ 
  32942.                 String name = null;
  32943.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.datasource.useDSUtils");
  32944.                 if(name==null){
  32945.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.datasource.useDSUtils' non impostata, viene utilizzato il default=true");
  32946.                     name="true";
  32947.                 }
  32948.                 name = name.trim();
  32949.                 this.isStatisticheDatasourceUseDBUtils = Boolean.parseBoolean(name);
  32950.             } catch(java.lang.Exception e) {
  32951.                 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);
  32952.                 this.isStatisticheDatasourceUseDBUtils = true;
  32953.             }    
  32954.         }

  32956.         return this.isStatisticheDatasourceUseDBUtils;
  32957.     }

  32959.     private Boolean isStatisticheGenerazioneUseUnionForLatency = null;
  32960.     public boolean isStatisticheGenerazioneUseUnionForLatency() {   
  32961.         if(this.isStatisticheGenerazioneUseUnionForLatency==null){
  32962.             try{ 
  32963.                 String name = null;
  32964.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.useUnionForLatency");
  32965.                 if(name==null){
  32966.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.useUnionForLatency' non impostata, viene utilizzato il default=true");
  32967.                     name="true";
  32968.                 }
  32969.                 name = name.trim();
  32970.                 this.isStatisticheGenerazioneUseUnionForLatency = Boolean.parseBoolean(name);
  32971.             } catch(java.lang.Exception e) {
  32972.                 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);
  32973.                 this.isStatisticheGenerazioneUseUnionForLatency = true;
  32974.             }    
  32975.         }

  32977.         return this.isStatisticheGenerazioneUseUnionForLatency;
  32978.     }
  32979.     
  32980.     private Boolean isStatisticheGenerazioneCustomEnabled = null;
  32981.     public boolean isStatisticheGenerazioneCustomEnabled() {    
  32982.         if(this.isStatisticheGenerazioneCustomEnabled==null){
  32983.             try{ 
  32984.                 String name = null;
  32985.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.custom.enabled");
  32986.                 if(name==null){
  32987.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.custom.enabled' non impostata, viene utilizzato il default=false");
  32988.                     name="false";
  32989.                 }
  32990.                 name = name.trim();
  32991.                 this.isStatisticheGenerazioneCustomEnabled = Boolean.parseBoolean(name);
  32992.             } catch(java.lang.Exception e) {
  32993.                 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);
  32994.                 this.isStatisticheGenerazioneCustomEnabled = false;
  32995.             }    
  32996.         }

  32998.         return this.isStatisticheGenerazioneCustomEnabled;
  32999.     }
  33000.     
  33001.     private Boolean isStatisticheGenerazioneCustomSdkEnabled = null;
  33002.     public boolean isStatisticheGenerazioneCustomSdkEnabled() { 
  33003.         if(this.isStatisticheGenerazioneCustomSdkEnabled==null){
  33004.             try{ 
  33005.                 String name = null;
  33006.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.custom.transazioniSdk.enabled");
  33007.                 if(name==null){
  33008.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.custom.transazioniSdk.enabled' non impostata, viene utilizzato il default=false");
  33009.                     name="false";
  33010.                 }
  33011.                 name = name.trim();
  33012.                 this.isStatisticheGenerazioneCustomSdkEnabled = Boolean.parseBoolean(name);
  33013.             } catch(java.lang.Exception e) {
  33014.                 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);
  33015.                 this.isStatisticheGenerazioneCustomSdkEnabled = false;
  33016.             }    
  33017.         }

  33019.         return this.isStatisticheGenerazioneCustomSdkEnabled;
  33020.     }
  33021.     
  33022.     private Boolean isStatisticheGenerazioneDebug = null;
  33023.     public boolean isStatisticheGenerazioneDebug() {    
  33024.         if(this.isStatisticheGenerazioneDebug==null){
  33025.             try{ 
  33026.                 String name = null;
  33027.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.debug");
  33028.                 if(name==null){
  33029.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.debug' non impostata, viene utilizzato il default=true");
  33030.                     name="true";
  33031.                 }
  33032.                 name = name.trim();
  33033.                 this.isStatisticheGenerazioneDebug = Boolean.parseBoolean(name);
  33034.             } catch(java.lang.Exception e) {
  33035.                 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);
  33036.                 this.isStatisticheGenerazioneDebug = true;
  33037.             }    
  33038.         }

  33040.         return this.isStatisticheGenerazioneDebug;
  33041.     }
  33042.     
  33043.     private Integer getStatisticheOrarieGenerazioneTimerIntervalSeconds = null;
  33044.     public int getStatisticheOrarieGenerazioneTimerIntervalSeconds() throws CoreException { 
  33045.         if(this.getStatisticheOrarieGenerazioneTimerIntervalSeconds==null){
  33046.             try{ 
  33047.                 String name = null;
  33048.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseOraria.timer.intervalloSecondi");
  33049.                 if(name==null){
  33050.                     throw new CoreException("Proprieta' non impostata");
  33051.                 }
  33052.                 name = name.trim();
  33053.                 this.getStatisticheOrarieGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
  33054.             } catch(java.lang.Exception e) {
  33055.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseOraria.timer.intervalloSecondi': "+e.getMessage(),e);
  33056.                 throw new CoreException(e.getMessage(),e);
  33057.             }    
  33058.         }

  33060.         return this.getStatisticheOrarieGenerazioneTimerIntervalSeconds;
  33061.     }
  33062.     
  33063.     private Integer getStatisticheGiornaliereGenerazioneTimerIntervalSeconds = null;
  33064.     public int getStatisticheGiornaliereGenerazioneTimerIntervalSeconds() throws CoreException {    
  33065.         if(this.getStatisticheGiornaliereGenerazioneTimerIntervalSeconds==null){
  33066.             try{ 
  33067.                 String name = null;
  33068.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.timer.intervalloSecondi");
  33069.                 if(name==null){
  33070.                     throw new CoreException("Proprieta' non impostata");
  33071.                 }
  33072.                 name = name.trim();
  33073.                 this.getStatisticheGiornaliereGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
  33074.             } catch(java.lang.Exception e) {
  33075.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.timer.intervalloSecondi': "+e.getMessage(),e);
  33076.                 throw new CoreException(e.getMessage(),e);
  33077.             }    
  33078.         }

  33080.         return this.getStatisticheGiornaliereGenerazioneTimerIntervalSeconds;
  33081.     }
  33082.     
  33083.     private Integer getStatisticheSettimanaliGenerazioneTimerIntervalSeconds = null;
  33084.     public int getStatisticheSettimanaliGenerazioneTimerIntervalSeconds() throws CoreException {    
  33085.         if(this.getStatisticheSettimanaliGenerazioneTimerIntervalSeconds==null){
  33086.             try{ 
  33087.                 String name = null;
  33088.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.timer.intervalloSecondi");
  33089.                 if(name==null){
  33090.                     throw new CoreException("Proprieta' non impostata");
  33091.                 }
  33092.                 name = name.trim();
  33093.                 this.getStatisticheSettimanaliGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
  33094.             } catch(java.lang.Exception e) {
  33095.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.timer.intervalloSecondi': "+e.getMessage(),e);
  33096.                 throw new CoreException(e.getMessage(),e);
  33097.             }    
  33098.         }

  33100.         return this.getStatisticheSettimanaliGenerazioneTimerIntervalSeconds;
  33101.     }
  33102.     
  33103.     private Integer getStatisticheMensiliGenerazioneTimerIntervalSeconds = null;
  33104.     public int getStatisticheMensiliGenerazioneTimerIntervalSeconds() throws CoreException {    
  33105.         if(this.getStatisticheMensiliGenerazioneTimerIntervalSeconds==null){
  33106.             try{ 
  33107.                 String name = null;
  33108.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseMensile.timer.intervalloSecondi");
  33109.                 if(name==null){
  33110.                     throw new CoreException("Proprieta' non impostata");
  33111.                 }
  33112.                 name = name.trim();
  33113.                 this.getStatisticheMensiliGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
  33114.             } catch(java.lang.Exception e) {
  33115.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseMensile.timer.intervalloSecondi': "+e.getMessage(),e);
  33116.                 throw new CoreException(e.getMessage(),e);
  33117.             }    
  33118.         }

  33120.         return this.getStatisticheMensiliGenerazioneTimerIntervalSeconds;
  33121.     }
  33122.     
  33123.     private Integer getStatisticheGenerazioneTimerLockMaxLife = null;
  33124.     public int getStatisticheGenerazioneTimerLockMaxLife() {    
  33125.         if(this.getStatisticheGenerazioneTimerLockMaxLife==null){
  33126.             try{ 
  33127.                 String name = null;
  33128.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.timer.lock.maxLife");

  33130.                 if(name!=null){
  33131.                     name = name.trim();
  33132.                     this.getStatisticheGenerazioneTimerLockMaxLife = java.lang.Integer.parseInt(name);
  33133.                 }else{
  33134.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.timer.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
  33135.                     this.getStatisticheGenerazioneTimerLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  33136.                 }
  33137.             }catch(java.lang.Exception e) {
  33138.                 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);
  33139.                 this.getStatisticheGenerazioneTimerLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  33140.             }
  33141.             if(this.getStatisticheGenerazioneTimerLockMaxLife!=null && this.getStatisticheGenerazioneTimerLockMaxLife>0) {
  33142.                 // trasformo in millisecondi l'informazione fornita in secondi
  33143.                 this.getStatisticheGenerazioneTimerLockMaxLife = this.getStatisticheGenerazioneTimerLockMaxLife *1000;
  33144.             }
  33145.         }

  33147.         if(this.getStatisticheGenerazioneTimerLockMaxLife!=null) {
  33148.             return this.getStatisticheGenerazioneTimerLockMaxLife.intValue();
  33149.         }
  33150.         return -1;
  33151.     }
  33152.     
  33153.     private Integer getStatisticheGenerazioneTimerLockIdleTime = null;
  33154.     public int getStatisticheGenerazioneTimerLockIdleTime() {   
  33155.         if(this.getStatisticheGenerazioneTimerLockIdleTime==null){
  33156.             try{ 
  33157.                 String name = null;
  33158.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.timer.lock.idleTime");

  33160.                 if(name!=null){
  33161.                     name = name.trim();
  33162.                     this.getStatisticheGenerazioneTimerLockIdleTime = java.lang.Integer.parseInt(name);
  33163.                 }else{
  33164.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.timer.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  33165.                     this.getStatisticheGenerazioneTimerLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  33166.                 }
  33167.             }catch(java.lang.Exception e) {
  33168.                 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);
  33169.                 this.getStatisticheGenerazioneTimerLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  33170.             }
  33171.             if(this.getStatisticheGenerazioneTimerLockIdleTime!=null && this.getStatisticheGenerazioneTimerLockIdleTime>0) {
  33172.                 // trasformo in millisecondi l'informazione fornita in secondi
  33173.                 this.getStatisticheGenerazioneTimerLockIdleTime = this.getStatisticheGenerazioneTimerLockIdleTime *1000;
  33174.             }
  33175.         }

  33177.         if(this.getStatisticheGenerazioneTimerLockIdleTime!=null) {
  33178.             return this.getStatisticheGenerazioneTimerLockIdleTime.intValue();
  33179.         }
  33180.         return -1;
  33181.     }
  33182.     
  33183.     private Long getStatisticheGenerazioneTimerLockAttesaAttiva = null;
  33184.     public long getStatisticheGenerazioneTimerLockAttesaAttiva() {  
  33185.         if(this.getStatisticheGenerazioneTimerLockAttesaAttiva==null){
  33186.             String pName = "org.openspcoop2.pdd.statistiche.generazione.timer.lock.attesaAttiva";
  33187.             try{ 
  33188.                 String name = null;
  33189.                 name = this.reader.getValueConvertEnvProperties(pName);

  33191.                 if(name!=null){
  33192.                     name = name.trim();
  33193.                     long time = java.lang.Long.parseLong(name);
  33194.                     this.getStatisticheGenerazioneTimerLockAttesaAttiva = time*1000;
  33195.                 }else{
  33196.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
  33197.                     this.getStatisticheGenerazioneTimerLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
  33198.                 }

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

  33206.         return this.getStatisticheGenerazioneTimerLockAttesaAttiva;
  33207.     }

  33209.     private Integer getStatisticheGenerazioneTimerLockCheckInterval = null;
  33210.     public int getStatisticheGenerazioneTimerLockCheckInterval() {  
  33211.         if(this.getStatisticheGenerazioneTimerLockCheckInterval==null){
  33212.             String pName = "org.openspcoop2.pdd.statistiche.generazione.timer.lock.check";
  33213.             try{ 
  33214.                 String name = null;
  33215.                 name = this.reader.getValueConvertEnvProperties(pName);

  33217.                 if(name!=null){
  33218.                     name = name.trim();
  33219.                     int time = java.lang.Integer.parseInt(name);
  33220.                     this.getStatisticheGenerazioneTimerLockCheckInterval = time;
  33221.                 }else{
  33222.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  33223.                     this.getStatisticheGenerazioneTimerLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  33224.                 }
  33225.             }catch(java.lang.Exception e) {
  33226.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  33227.                 this.getStatisticheGenerazioneTimerLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  33228.             }  
  33229.         }

  33231.         return this.getStatisticheGenerazioneTimerLockCheckInterval;
  33232.     }
  33233.     
  33234.     private Boolean isStatisticheGenerazioneBaseOrariaEnabled = null;
  33235.     public boolean isStatisticheGenerazioneBaseOrariaEnabled() {    
  33236.         if(this.isStatisticheGenerazioneBaseOrariaEnabled==null){
  33237.             try{ 
  33238.                 String name = null;
  33239.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseOraria.enabled");
  33240.                 if(name==null){
  33241.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseOraria.enabled' non impostata, viene utilizzato il default=true");
  33242.                     name="true";
  33243.                 }
  33244.                 name = name.trim();
  33245.                 this.isStatisticheGenerazioneBaseOrariaEnabled = Boolean.parseBoolean(name);
  33246.             } catch(java.lang.Exception e) {
  33247.                 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);
  33248.                 this.isStatisticheGenerazioneBaseOrariaEnabled = true;
  33249.             }    
  33250.         }

  33252.         return this.isStatisticheGenerazioneBaseOrariaEnabled;
  33253.     }
  33254.     
  33255.     private Boolean isStatisticheGenerazioneBaseGiornalieraEnabled = null;
  33256.     public boolean isStatisticheGenerazioneBaseGiornalieraEnabled() {   
  33257.         if(this.isStatisticheGenerazioneBaseGiornalieraEnabled==null){
  33258.             try{ 
  33259.                 String name = null;
  33260.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.enabled");
  33261.                 if(name==null){
  33262.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.enabled' non impostata, viene utilizzato il default=true");
  33263.                     name="true";
  33264.                 }
  33265.                 name = name.trim();
  33266.                 this.isStatisticheGenerazioneBaseGiornalieraEnabled = Boolean.parseBoolean(name);
  33267.             } catch(java.lang.Exception e) {
  33268.                 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);
  33269.                 this.isStatisticheGenerazioneBaseGiornalieraEnabled = true;
  33270.             }    
  33271.         }

  33273.         return this.isStatisticheGenerazioneBaseGiornalieraEnabled;
  33274.     }
  33275.     
  33276.     private Boolean isStatisticheGenerazioneBaseSettimanaleEnabled = null;
  33277.     public boolean isStatisticheGenerazioneBaseSettimanaleEnabled() {   
  33278.         if(this.isStatisticheGenerazioneBaseSettimanaleEnabled==null){
  33279.             try{ 
  33280.                 String name = null;
  33281.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.enabled");
  33282.                 if(name==null){
  33283.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.enabled' non impostata, viene utilizzato il default=true");
  33284.                     name="true";
  33285.                 }
  33286.                 name = name.trim();
  33287.                 this.isStatisticheGenerazioneBaseSettimanaleEnabled = Boolean.parseBoolean(name);
  33288.             } catch(java.lang.Exception e) {
  33289.                 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);
  33290.                 this.isStatisticheGenerazioneBaseSettimanaleEnabled = true;
  33291.             }    
  33292.         }

  33294.         return this.isStatisticheGenerazioneBaseSettimanaleEnabled;
  33295.     }
  33296.     
  33297.     private Boolean isStatisticheGenerazioneBaseMensileEnabled = null;
  33298.     public boolean isStatisticheGenerazioneBaseMensileEnabled() {   
  33299.         if(this.isStatisticheGenerazioneBaseMensileEnabled==null){
  33300.             try{ 
  33301.                 String name = null;
  33302.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseMensile.enabled");
  33303.                 if(name==null){
  33304.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseMensile.enabled' non impostata, viene utilizzato il default=true");
  33305.                     name="true";
  33306.                 }
  33307.                 name = name.trim();
  33308.                 this.isStatisticheGenerazioneBaseMensileEnabled = Boolean.parseBoolean(name);
  33309.             } catch(java.lang.Exception e) {
  33310.                 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);
  33311.                 this.isStatisticheGenerazioneBaseMensileEnabled = true;
  33312.             }    
  33313.         }

  33315.         return this.isStatisticheGenerazioneBaseMensileEnabled;
  33316.     }
  33317.     
  33318.     
  33319.     private Boolean isStatisticheGenerazioneBaseOrariaEnabledUltimaOra = null;
  33320.     public boolean isStatisticheGenerazioneBaseOrariaEnabledUltimaOra() {   
  33321.         if(this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra==null){
  33322.             try{ 
  33323.                 String name = null;
  33324.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseOraria.gestioneUltimaOra");
  33325.                 if(name==null){
  33326.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseOraria.gestioneUltimaOra' non impostata, viene utilizzato il default=true");
  33327.                     name="true";
  33328.                 }
  33329.                 name = name.trim();
  33330.                 this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra = Boolean.parseBoolean(name);
  33331.             } catch(java.lang.Exception e) {
  33332.                 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);
  33333.                 this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra = true;
  33334.             }    
  33335.         }

  33337.         return this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra;
  33338.     }
  33339.     
  33340.     private Boolean isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno = null;
  33341.     public boolean isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno() {   
  33342.         if(this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno==null){
  33343.             try{ 
  33344.                 String name = null;
  33345.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.gestioneUltimoGiorno");
  33346.                 if(name==null){
  33347.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.gestioneUltimoGiorno' non impostata, viene utilizzato il default=true");
  33348.                     name="true";
  33349.                 }
  33350.                 name = name.trim();
  33351.                 this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno = Boolean.parseBoolean(name);
  33352.             } catch(java.lang.Exception e) {
  33353.                 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);
  33354.                 this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno = true;
  33355.             }    
  33356.         }

  33358.         return this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno;
  33359.     }
  33360.     
  33361.     private Boolean isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana = null;
  33362.     public boolean isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana() {    
  33363.         if(this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana==null){
  33364.             try{ 
  33365.                 String name = null;
  33366.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.gestioneUltimaSettimana");
  33367.                 if(name==null){
  33368.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.gestioneUltimaSettimana' non impostata, viene utilizzato il default=true");
  33369.                     name="true";
  33370.                 }
  33371.                 name = name.trim();
  33372.                 this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana = Boolean.parseBoolean(name);
  33373.             } catch(java.lang.Exception e) {
  33374.                 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);
  33375.                 this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana = true;
  33376.             }    
  33377.         }

  33379.         return this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana;
  33380.     }
  33381.     
  33382.     private Boolean isStatisticheGenerazioneBaseMensileEnabledUltimoMese = null;
  33383.     public boolean isStatisticheGenerazioneBaseMensileEnabledUltimoMese() { 
  33384.         if(this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese==null){
  33385.             try{ 
  33386.                 String name = null;
  33387.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseMensile.gestioneUltimoMese");
  33388.                 if(name==null){
  33389.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseMensile.gestioneUltimoMese' non impostata, viene utilizzato il default=true");
  33390.                     name="true";
  33391.                 }
  33392.                 name = name.trim();
  33393.                 this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese = Boolean.parseBoolean(name);
  33394.             } catch(java.lang.Exception e) {
  33395.                 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);
  33396.                 this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese = true;
  33397.             }    
  33398.         }

  33400.         return this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese;
  33401.     }
  33402.     
  33403.     private Boolean isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie = null;
  33404.     public boolean isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie() {  
  33405.         if(this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie==null){
  33406.             String pName = "org.openspcoop2.pdd.statistiche.generazione.attendiCompletamentoTransazioniInFasiIntermedie";
  33407.             try{ 
  33408.                 String name = null;
  33409.                 name = this.reader.getValueConvertEnvProperties(pName);
  33410.                 if(name==null){
  33411.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=true");
  33412.                     name="true";
  33413.                 }
  33414.                 name = name.trim();
  33415.                 this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie = Boolean.parseBoolean(name);
  33416.             } catch(java.lang.Exception e) {
  33417.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  33418.                 this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie = true;
  33419.             }    
  33420.         }

  33422.         return this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie;
  33423.     }
  33424.     
  33425.     private Long getStatisticheGenerazioneTradeOffMs = null;
  33426.     public long getStatisticheGenerazioneTradeOffMs() { 
  33427.         if(this.getStatisticheGenerazioneTradeOffMs==null){
  33428.             String pName = "org.openspcoop2.pdd.statistiche.generazione.tradeOffSeconds";
  33429.             try{ 
  33430.                 String name = null;
  33431.                 name = this.reader.getValueConvertEnvProperties(pName);
  33432.                 if(name==null){
  33433.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata");
  33434.                     name="-1";
  33435.                 }
  33436.                 name = name.trim();
  33437.                 this.getStatisticheGenerazioneTradeOffMs = Long.parseLong(name);
  33438.                 if(this.getStatisticheGenerazioneTradeOffMs>0) {
  33439.                     this.getStatisticheGenerazioneTradeOffMs = this.getStatisticheGenerazioneTradeOffMs * 1000l; // traduco in ms
  33440.                 }
  33441.             } catch(java.lang.Exception e) {
  33442.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=300 : "+e.getMessage(),e);
  33443.                 this.getStatisticheGenerazioneTradeOffMs = 300l * 1000l;  // traduco in ms
  33444.             }    
  33445.         }

  33447.         return this.getStatisticheGenerazioneTradeOffMs;
  33448.     }

  33450.     // NOTA: DEVE ESSERE RILETTO TUTTE LE VOLTE CHE VIENE CHIAMATO!!!!!!!
  33451.     public StatisticsForceIndexConfig getStatisticheGenerazioneExternalForceIndexRepository() throws CoreException {    
  33452.         try{ 
  33453.             String name = null;
  33454.             name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.forceIndex.repository");
  33455.             if(name!=null){
  33456.                 name = name.trim();
  33457.                 return readStatisticsForceIndexConfig(name);
  33458.             }
  33459.             
  33460.             return null;
  33461.             
  33462.         } catch(java.lang.Exception e) {
  33463.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.forceIndex.repository': "+e.getMessage(),e);
  33464.             throw new CoreException(e.getMessage(),e);
  33465.         }    
  33466.         
  33467.     }
  33468.     private StatisticsForceIndexConfig readStatisticsForceIndexConfig(String name) throws CoreException, IOException {
  33469.         File f = new File(name);
  33470.         if(f.exists()) {
  33471.             if(f.isDirectory()) {
  33472.                 throw newCoreExceptionNotFile(f,false);
  33473.             }
  33474.             if(!f.canRead()) {
  33475.                 throw newCoreExceptionCannotRead(f, false);
  33476.             }
  33477.         }
  33478.         else {
  33479.             // provo a cercarlo nel classpath
  33480.         }
  33481.         try (InputStream is = f.exists() ? new FileInputStream(f) : OpenSPCoop2Properties.class.getResourceAsStream(name);){
  33482.             if(is!=null) {
  33483.                 Properties p = new Properties();
  33484.                 p.load(is);
  33485.                 return new StatisticsForceIndexConfig(p);
  33486.             }
  33487.         }
  33488.         return null;
  33489.     }
  33490.     
  33491.     
  33492.     
  33493.     
  33494.     
  33495.     
  33496.     /* ------------- Gestore Chiavi PDND ---------------------*/
  33497.     
  33498.     private Boolean isGestoreChiaviPDNDEnabled = null;
  33499.     public boolean isGestoreChiaviPDNDEnabled() {   
  33500.         if(this.isGestoreChiaviPDNDEnabled==null){
  33501.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.enabled";
  33502.             try{ 
  33503.                 String name = null;
  33504.                 name = this.reader.getValueConvertEnvProperties(pName);
  33505.                 if(name==null){
  33506.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  33507.                     name="false";
  33508.                 }
  33509.                 name = name.trim();
  33510.                 this.isGestoreChiaviPDNDEnabled = Boolean.parseBoolean(name);
  33511.             } catch(java.lang.Exception e) {
  33512.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  33513.                 this.isGestoreChiaviPDNDEnabled = false;
  33514.             }    
  33515.         }

  33517.         return this.isGestoreChiaviPDNDEnabled;
  33518.     }
  33519.     
  33520.     private Boolean isGestoreChiaviPDNDDebug = null;
  33521.     public boolean isGestoreChiaviPDNDDebug() { 
  33522.         if(this.isGestoreChiaviPDNDDebug==null){
  33523.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.debug";
  33524.             try{ 
  33525.                 String name = null;
  33526.                 name = this.reader.getValueConvertEnvProperties(pName);
  33527.                 if(name==null){
  33528.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  33529.                     name="true";
  33530.                 }
  33531.                 name = name.trim();
  33532.                 this.isGestoreChiaviPDNDDebug = Boolean.parseBoolean(name);
  33533.             } catch(java.lang.Exception e) {
  33534.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  33535.                 this.isGestoreChiaviPDNDDebug = true;
  33536.             }    
  33537.         }

  33539.         return this.isGestoreChiaviPDNDDebug;
  33540.     }
  33541.     
  33542.     private Boolean isGestoreChiaviPDNDEventiAdd = null;
  33543.     public boolean isGestoreChiaviPDNDEventiAdd() { 
  33544.         if(this.isGestoreChiaviPDNDEventiAdd==null){
  33545.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.eventi.add";
  33546.             try{ 
  33547.                 String name = null;
  33548.                 name = this.reader.getValueConvertEnvProperties(pName);
  33549.                 if(name==null){
  33550.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  33551.                     name="true";
  33552.                 }
  33553.                 name = name.trim();
  33554.                 this.isGestoreChiaviPDNDEventiAdd = Boolean.parseBoolean(name);
  33555.             } catch(java.lang.Exception e) {
  33556.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  33557.                 this.isGestoreChiaviPDNDEventiAdd = true;
  33558.             }    
  33559.         }

  33561.         return this.isGestoreChiaviPDNDEventiAdd;
  33562.     }
  33563.     
  33564.     private Boolean isGestoreChiaviPDNDEventiUpdate = null;
  33565.     public boolean isGestoreChiaviPDNDEventiUpdate() {  
  33566.         if(this.isGestoreChiaviPDNDEventiUpdate==null){
  33567.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.eventi.update";
  33568.             try{ 
  33569.                 String name = null;
  33570.                 name = this.reader.getValueConvertEnvProperties(pName);
  33571.                 if(name==null){
  33572.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  33573.                     name="true";
  33574.                 }
  33575.                 name = name.trim();
  33576.                 this.isGestoreChiaviPDNDEventiUpdate = Boolean.parseBoolean(name);
  33577.             } catch(java.lang.Exception e) {
  33578.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  33579.                 this.isGestoreChiaviPDNDEventiUpdate = true;
  33580.             }    
  33581.         }

  33583.         return this.isGestoreChiaviPDNDEventiUpdate;
  33584.     }
  33585.     
  33586.     private Boolean isGestoreChiaviPDNDEventiDelete = null;
  33587.     public boolean isGestoreChiaviPDNDEventiDelete() {  
  33588.         if(this.isGestoreChiaviPDNDEventiDelete==null){
  33589.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.eventi.delete";
  33590.             try{ 
  33591.                 String name = null;
  33592.                 name = this.reader.getValueConvertEnvProperties(pName);
  33593.                 if(name==null){
  33594.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  33595.                     name="true";
  33596.                 }
  33597.                 name = name.trim();
  33598.                 this.isGestoreChiaviPDNDEventiDelete = Boolean.parseBoolean(name);
  33599.             } catch(java.lang.Exception e) {
  33600.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  33601.                 this.isGestoreChiaviPDNDEventiDelete = true;
  33602.             }    
  33603.         }

  33605.         return this.isGestoreChiaviPDNDEventiDelete;
  33606.     }
  33607.     
  33608.     private List<String> getGestoreChiaviPDNDRemoteStoreName = null;
  33609.     public List<String> getGestoreChiaviPDNDRemoteStoreName() throws CoreException {    
  33610.         if(this.getGestoreChiaviPDNDRemoteStoreName==null){
  33611.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.remoteStore.name";
  33612.             try{ 
  33613.                 String name = null;
  33614.                 name = this.reader.getValueConvertEnvProperties(pName);
  33615.                 if(name==null){
  33616.                     throw new CoreException("Proprieta' non impostata");
  33617.                 }
  33618.                 name = name.trim();
  33619.                 this.getGestoreChiaviPDNDRemoteStoreName = new ArrayList<>();
  33620.                 
  33621.                 initSplitValues(this.getGestoreChiaviPDNDRemoteStoreName, name, false);
  33622.                 
  33623.             } catch(java.lang.Exception e) {
  33624.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  33625.                 throw new CoreException(e.getMessage(),e);
  33626.             }    
  33627.         }

  33629.         return this.getGestoreChiaviPDNDRemoteStoreName;
  33630.     }
  33631.     
  33632.     private Boolean isGestoreChiaviPDNDEventiCheckAllStores = null;
  33633.     public boolean isGestoreChiaviPDNDEventiCheckAllStores() {  
  33634.         if(this.isGestoreChiaviPDNDEventiCheckAllStores==null){
  33635.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.remoteStore.checkAllStores";
  33636.             try{ 
  33637.                 String name = null;
  33638.                 name = this.reader.getValueConvertEnvProperties(pName);
  33639.                 if(name==null){
  33640.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  33641.                     name="true";
  33642.                 }
  33643.                 name = name.trim();
  33644.                 this.isGestoreChiaviPDNDEventiCheckAllStores = Boolean.parseBoolean(name);
  33645.             } catch(java.lang.Exception e) {
  33646.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, true));
  33647.                 this.isGestoreChiaviPDNDEventiCheckAllStores = true;
  33648.             }    
  33649.         }

  33651.         return this.isGestoreChiaviPDNDEventiCheckAllStores;
  33652.     }
  33653.     
  33654.     private Integer getGestoreChiaviPDNDkeysMaxLifeMinutes = null;
  33655.     public int getGestoreChiaviPDNDkeysMaxLifeMinutes() {   
  33656.         if(this.getGestoreChiaviPDNDkeysMaxLifeMinutes==null){
  33657.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.keys.maxLifeMinutes";
  33658.             int defaultValue = 43200;
  33659.             try{ 
  33660.                 String name = null;
  33661.                 name = this.reader.getValueConvertEnvProperties(pName);
  33662.                 if(name==null){
  33663.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
  33664.                     name=defaultValue+"";
  33665.                 }
  33666.                 name = name.trim();
  33667.                 this.getGestoreChiaviPDNDkeysMaxLifeMinutes = Integer.valueOf(name);
  33668.                 /**if(this.getGestoreChiaviPDNDkeysMaxLifeMinutes<=0) {
  33669.                     throw new CoreException("Atteso un limite maggiore di zero");
  33670.                 }*/ // Se la proprietà viene valorizzata con un valore <=0 le informazioni hanno vita infinita
  33671.             } catch(java.lang.Exception e) {
  33672.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
  33673.                 this.getGestoreChiaviPDNDkeysMaxLifeMinutes = defaultValue;
  33674.             }    
  33675.         }

  33677.         return this.getGestoreChiaviPDNDkeysMaxLifeMinutes;
  33678.     }
  33679.         
  33680.     private String getGestoreChiaviPDNDkeysPath = null;
  33681.     public String getGestoreChiaviPDNDkeysPath() throws CoreException { 
  33682.         if(this.getGestoreChiaviPDNDkeysPath==null){
  33683.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.keys.path";
  33684.             try{ 
  33685.                 String name = null;
  33686.                 name = this.reader.getValueConvertEnvProperties(pName);
  33687.                 if(name==null){
  33688.                     throw new CoreException("Proprieta' non impostata");
  33689.                 }
  33690.                 name = name.trim();
  33691.                 this.getGestoreChiaviPDNDkeysPath = name;
  33692.             } catch(java.lang.Exception e) {
  33693.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  33694.                 throw new CoreException(e.getMessage(),e);
  33695.             }    
  33696.         }

  33698.         return this.getGestoreChiaviPDNDkeysPath;
  33699.     }
  33700.     
  33701.     private String getGestoreChiaviPDNDeventsKeysPath = null;
  33702.     public String getGestoreChiaviPDNDeventsKeysPath() throws CoreException {   
  33703.         if(this.getGestoreChiaviPDNDeventsKeysPath==null){
  33704.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.path";
  33705.             try{ 
  33706.                 String name = null;
  33707.                 name = this.reader.getValueConvertEnvProperties(pName);
  33708.                 if(name==null){
  33709.                     throw new CoreException("Proprieta' non impostata");
  33710.                 }
  33711.                 name = name.trim();
  33712.                 this.getGestoreChiaviPDNDeventsKeysPath = name;
  33713.             } catch(java.lang.Exception e) {
  33714.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  33715.                 throw new CoreException(e.getMessage(),e);
  33716.             }    
  33717.         }

  33719.         return this.getGestoreChiaviPDNDeventsKeysPath;
  33720.     }
  33721.     
  33722.     private String getGestoreChiaviPDNDeventsKeysParameterLastEventId = null;
  33723.     public String getGestoreChiaviPDNDeventsKeysParameterLastEventId() throws CoreException {   
  33724.         if(this.getGestoreChiaviPDNDeventsKeysParameterLastEventId==null){
  33725.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.parameter.lastEventId";
  33726.             try{ 
  33727.                 String name = null;
  33728.                 name = this.reader.getValueConvertEnvProperties(pName);
  33729.                 if(name==null){
  33730.                     throw new CoreException("Proprieta' non impostata");
  33731.                 }
  33732.                 name = name.trim();
  33733.                 this.getGestoreChiaviPDNDeventsKeysParameterLastEventId = name;
  33734.             } catch(java.lang.Exception e) {
  33735.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  33736.                 throw new CoreException(e.getMessage(),e);
  33737.             }    
  33738.         }

  33740.         return this.getGestoreChiaviPDNDeventsKeysParameterLastEventId;
  33741.     }
  33742.     
  33743.     private String getGestoreChiaviPDNDeventsKeysParameterLimit = null;
  33744.     public String getGestoreChiaviPDNDeventsKeysParameterLimit() throws CoreException { 
  33745.         if(this.getGestoreChiaviPDNDeventsKeysParameterLimit==null){
  33746.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.parameter.limit";
  33747.             try{ 
  33748.                 String name = null;
  33749.                 name = this.reader.getValueConvertEnvProperties(pName);
  33750.                 if(name==null){
  33751.                     throw new CoreException("Proprieta' non impostata");
  33752.                 }
  33753.                 name = name.trim();
  33754.                 this.getGestoreChiaviPDNDeventsKeysParameterLimit = name;
  33755.             } catch(java.lang.Exception e) {
  33756.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  33757.                 throw new CoreException(e.getMessage(),e);
  33758.             }    
  33759.         }

  33761.         return this.getGestoreChiaviPDNDeventsKeysParameterLimit;
  33762.     }

  33764.     private Integer getGestoreChiaviPDNDeventsKeysLimit = null;
  33765.     public int getGestoreChiaviPDNDeventsKeysLimit() {  
  33766.         if(this.getGestoreChiaviPDNDeventsKeysLimit==null){
  33767.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.limit";
  33768.             int defaultValue = 100;
  33769.             try{ 
  33770.                 String name = null;
  33771.                 name = this.reader.getValueConvertEnvProperties(pName);
  33772.                 if(name==null){
  33773.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
  33774.                     name=defaultValue+"";
  33775.                 }
  33776.                 name = name.trim();
  33777.                 this.getGestoreChiaviPDNDeventsKeysLimit = Integer.valueOf(name);
  33778.                 if(this.getGestoreChiaviPDNDeventsKeysLimit<=0) {
  33779.                     throw new CoreException("Atteso un limite maggiore di zero");
  33780.                 }
  33781.             } catch(java.lang.Exception e) {
  33782.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
  33783.                 this.getGestoreChiaviPDNDeventsKeysLimit = defaultValue;
  33784.             }    
  33785.         }

  33787.         return this.getGestoreChiaviPDNDeventsKeysLimit;
  33788.     }

  33790.     private Long getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi = null;
  33791.     public long getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi() {    
  33792.         if(this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi==null){
  33793.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.intervalloSecondi";
  33794.             long defaultValue = 3600;
  33795.             try{ 
  33796.                 String name = null;
  33797.                 name = this.reader.getValueConvertEnvProperties(pName);
  33798.                 if(name==null){
  33799.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
  33800.                     name=defaultValue+"";
  33801.                 }
  33802.                 name = name.trim();
  33803.                 this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi = Long.valueOf(name);
  33804.                 if(this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi<=0) {
  33805.                     throw new CoreException("Atteso un intervallo maggiore di zero");
  33806.                 }
  33807.             } catch(java.lang.Exception e) {
  33808.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
  33809.                 this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi = defaultValue;
  33810.             }    
  33811.         }

  33813.         return this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi;
  33814.     }
  33815.     
  33816.     private Long getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi = null;
  33817.     public long getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi() { 
  33818.         if(this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi==null){
  33819.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.cache.keys.timer.intervalloSecondi";
  33820.             long defaultValue = 300;
  33821.             try{ 
  33822.                 String name = null;
  33823.                 name = this.reader.getValueConvertEnvProperties(pName);
  33824.                 if(name==null){
  33825.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
  33826.                     name=defaultValue+"";
  33827.                 }
  33828.                 name = name.trim();
  33829.                 this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi = Long.valueOf(name);
  33830.                 if(this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi<=0) {
  33831.                     throw new CoreException("Atteso un intervallo maggiore di zero");
  33832.                 }
  33833.             } catch(java.lang.Exception e) {
  33834.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
  33835.                 this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi = defaultValue;
  33836.             }    
  33837.         }

  33839.         return this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi;
  33840.     }
  33841.     
  33842.     private Integer getGestoreChiaviPDNDTimerLockMaxLife = null;
  33843.     public int getGestoreChiaviPDNDTimerLockMaxLife() { 
  33844.         if(this.getGestoreChiaviPDNDTimerLockMaxLife==null){
  33845.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.lock.maxLife";
  33846.             try{ 
  33847.                 String name = null;
  33848.                 name = this.reader.getValueConvertEnvProperties(pName);

  33850.                 if(name!=null){
  33851.                     name = name.trim();
  33852.                     this.getGestoreChiaviPDNDTimerLockMaxLife = java.lang.Integer.parseInt(name);
  33853.                 }else{
  33854.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.TIMER_LOCK_MAX_LIFE));
  33855.                     this.getGestoreChiaviPDNDTimerLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  33856.                 }
  33857.             }catch(java.lang.Exception e) {
  33858.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.TIMER_LOCK_MAX_LIFE),e);
  33859.                 this.getGestoreChiaviPDNDTimerLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  33860.             }
  33861.             if(this.getGestoreChiaviPDNDTimerLockMaxLife!=null && this.getGestoreChiaviPDNDTimerLockMaxLife>0) {
  33862.                 // trasformo in millisecondi l'informazione fornita in secondi
  33863.                 this.getGestoreChiaviPDNDTimerLockMaxLife = this.getGestoreChiaviPDNDTimerLockMaxLife *1000;
  33864.             }
  33865.         }

  33867.         if(this.getGestoreChiaviPDNDTimerLockMaxLife!=null) {
  33868.             return this.getGestoreChiaviPDNDTimerLockMaxLife.intValue();
  33869.         }
  33870.         return -1;
  33871.     }
  33872.     
  33873.     private Integer getGestoreChiaviPDNDTimerLockIdleTime = null;
  33874.     public int getGestoreChiaviPDNDTimerLockIdleTime() {    
  33875.         if(this.getGestoreChiaviPDNDTimerLockIdleTime==null){
  33876.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.lock.idleTime";
  33877.             try{ 
  33878.                 String name = null;
  33879.                 name = this.reader.getValueConvertEnvProperties(pName);

  33881.                 if(name!=null){
  33882.                     name = name.trim();
  33883.                     this.getGestoreChiaviPDNDTimerLockIdleTime = java.lang.Integer.parseInt(name);
  33884.                 }else{
  33885.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.TIMER_LOCK_IDLE_TIME));
  33886.                     this.getGestoreChiaviPDNDTimerLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  33887.                 }
  33888.             }catch(java.lang.Exception e) {
  33889.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.TIMER_LOCK_IDLE_TIME),e);
  33890.                 this.getGestoreChiaviPDNDTimerLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  33891.             }
  33892.             if(this.getGestoreChiaviPDNDTimerLockIdleTime!=null && this.getGestoreChiaviPDNDTimerLockIdleTime>0) {
  33893.                 // trasformo in millisecondi l'informazione fornita in secondi
  33894.                 this.getGestoreChiaviPDNDTimerLockIdleTime = this.getGestoreChiaviPDNDTimerLockIdleTime *1000;
  33895.             }
  33896.         }

  33898.         if(this.getGestoreChiaviPDNDTimerLockIdleTime!=null) {
  33899.             return this.getGestoreChiaviPDNDTimerLockIdleTime.intValue();
  33900.         }
  33901.         return -1;
  33902.     }
  33903.     
  33904.     private Long getGestoreChiaviPDNDTimerLockAttesaAttiva = null;
  33905.     public long getGestoreChiaviPDNDTimerLockAttesaAttiva() {   
  33906.         if(this.getGestoreChiaviPDNDTimerLockAttesaAttiva==null){
  33907.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.lock.attesaAttiva";
  33908.             try{ 
  33909.                 String name = null;
  33910.                 name = this.reader.getValueConvertEnvProperties(pName);

  33912.                 if(name!=null){
  33913.                     name = name.trim();
  33914.                     long time = java.lang.Long.parseLong(name);
  33915.                     this.getGestoreChiaviPDNDTimerLockAttesaAttiva = time*1000;
  33916.                 }else{
  33917.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
  33918.                     this.getGestoreChiaviPDNDTimerLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
  33919.                 }

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

  33927.         return this.getGestoreChiaviPDNDTimerLockAttesaAttiva;
  33928.     }

  33930.     private Integer getGestoreChiaviPDNDTimerLockCheckInterval = null;
  33931.     public int getGestoreChiaviPDNDTimerLockCheckInterval() {   
  33932.         if(this.getGestoreChiaviPDNDTimerLockCheckInterval==null){
  33933.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.lock.check";
  33934.             try{ 
  33935.                 String name = null;
  33936.                 name = this.reader.getValueConvertEnvProperties(pName);

  33938.                 if(name!=null){
  33939.                     name = name.trim();
  33940.                     int time = java.lang.Integer.parseInt(name);
  33941.                     this.getGestoreChiaviPDNDTimerLockCheckInterval = time;
  33942.                 }else{
  33943.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  33944.                     this.getGestoreChiaviPDNDTimerLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  33945.                 }
  33946.             }catch(java.lang.Exception e) {
  33947.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  33948.                 this.getGestoreChiaviPDNDTimerLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  33949.             }  
  33950.         }

  33952.         return this.getGestoreChiaviPDNDTimerLockCheckInterval;
  33953.     }
  33954.     
  33955.     private String getGestoreChiaviPDNDclientsPath = null;
  33956.     public String getGestoreChiaviPDNDclientsPath() throws CoreException {  
  33957.         if(this.getGestoreChiaviPDNDclientsPath==null){
  33958.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.clients.path";
  33959.             try{ 
  33960.                 String name = null;
  33961.                 name = this.reader.getValueConvertEnvProperties(pName);
  33962.                 if(name==null){
  33963.                     throw new CoreException("Proprieta' non impostata");
  33964.                 }
  33965.                 name = name.trim();
  33966.                 this.getGestoreChiaviPDNDclientsPath = name;
  33967.             } catch(java.lang.Exception e) {
  33968.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  33969.                 throw new CoreException(e.getMessage(),e);
  33970.             }    
  33971.         }

  33973.         return this.getGestoreChiaviPDNDclientsPath;
  33974.     }
  33975.         
  33976.     private String getGestoreChiaviPDNDclientsOrganizationJsonPath = null;
  33977.     public String getGestoreChiaviPDNDclientsOrganizationJsonPath() throws CoreException {  
  33978.         if(this.getGestoreChiaviPDNDclientsOrganizationJsonPath==null){
  33979.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.clients.organizationJsonPath";
  33980.             try{ 
  33981.                 String name = null;
  33982.                 name = this.reader.getValueConvertEnvProperties(pName);
  33983.                 if(name==null){
  33984.                     throw new CoreException("Proprieta' non impostata");
  33985.                 }
  33986.                 name = name.trim();
  33987.                 this.getGestoreChiaviPDNDclientsOrganizationJsonPath = name;
  33988.             } catch(java.lang.Exception e) {
  33989.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  33990.                 throw new CoreException(e.getMessage(),e);
  33991.             }    
  33992.         }

  33994.         return this.getGestoreChiaviPDNDclientsOrganizationJsonPath;
  33995.     }
  33996.     
  33997.     private String getGestoreChiaviPDNDorganizationsPath = null;
  33998.     public String getGestoreChiaviPDNDorganizationsPath() throws CoreException {    
  33999.         if(this.getGestoreChiaviPDNDorganizationsPath==null){
  34000.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.organizations.path";
  34001.             try{ 
  34002.                 String name = null;
  34003.                 name = this.reader.getValueConvertEnvProperties(pName);
  34004.                 if(name==null){
  34005.                     throw new CoreException("Proprieta' non impostata");
  34006.                 }
  34007.                 name = name.trim();
  34008.                 this.getGestoreChiaviPDNDorganizationsPath = name;
  34009.             } catch(java.lang.Exception e) {
  34010.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34011.                 throw new CoreException(e.getMessage(),e);
  34012.             }    
  34013.         }

  34015.         return this.getGestoreChiaviPDNDorganizationsPath;
  34016.     }
  34017.     
  34018.     
  34019.     
  34020.     private Boolean isGestoreChiaviPDNDclientInfoEnabled = null;
  34021.     public boolean isGestoreChiaviPDNDclientInfoEnabled() throws CoreException {    
  34022.         if(this.isGestoreChiaviPDNDclientInfoEnabled==null){
  34023.             String pName = "org.openspcoop2.pdd.gestorePDND.clientInfo.enabled";
  34024.             try{ 
  34025.                 String name = null;
  34026.                 name = this.reader.getValueConvertEnvProperties(pName);
  34027.                 if(name==null){
  34028.                     throw new CoreException("Proprieta' non impostata");
  34029.                 }
  34030.                 name = name.trim();
  34031.                 this.isGestoreChiaviPDNDclientInfoEnabled = Boolean.valueOf(name);
  34032.                 
  34033.                 if(this.isGestoreChiaviPDNDclientInfoEnabled.booleanValue() && !this.isGestoreChiaviPDNDEnabled()) {
  34034.                     throw new CoreException("per abilitare la proprietà è richiesto che sia abilitata la gestione delle chiavi PDND");
  34035.                 }
  34036.                 
  34037.             } catch(java.lang.Exception e) {
  34038.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34039.                 throw new CoreException(e.getMessage(),e);
  34040.             }    
  34041.         }

  34043.         return this.isGestoreChiaviPDNDclientInfoEnabled;
  34044.     }
  34045.     
  34046.     private Integer getGestoreChiaviPDNDclientInfoMaxLifeMinutes = null;
  34047.     public int getGestoreChiaviPDNDclientInfoMaxLifeMinutes() { 
  34048.         if(this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes==null){
  34049.             String pName = "org.openspcoop2.pdd.gestorePDND.clientInfo.maxLifeMinutes";
  34050.             int defaultValue = 43200;
  34051.             try{ 
  34052.                 String name = null;
  34053.                 name = this.reader.getValueConvertEnvProperties(pName);
  34054.                 if(name==null){
  34055.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
  34056.                     name=defaultValue+"";
  34057.                 }
  34058.                 name = name.trim();
  34059.                 this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes = Integer.valueOf(name);
  34060.                 /**if(this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes<=0) {
  34061.                     throw new CoreException("Atteso un limite maggiore di zero");
  34062.                 }*/ // Se la proprietà viene valorizzata con un valore <=0 le informazioni hanno vita infinita
  34063.             } catch(java.lang.Exception e) {
  34064.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
  34065.                 this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes = defaultValue;
  34066.             }    
  34067.         }

  34069.         return this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes;
  34070.     }
  34071.         
  34072.     private Boolean isGestoreChiaviPDNDclientsErrorAbortTransaction = null;
  34073.     public boolean isGestoreChiaviPDNDclientsErrorAbortTransaction() throws CoreException { 
  34074.         if(this.isGestoreChiaviPDNDclientsErrorAbortTransaction==null){
  34075.             String pName = "org.openspcoop2.pdd.gestorePDND.clients.error.abortTransaction";
  34076.             try{ 
  34077.                 String name = null;
  34078.                 name = this.reader.getValueConvertEnvProperties(pName);
  34079.                 if(name==null){
  34080.                     throw new CoreException("Proprieta' non impostata");
  34081.                 }
  34082.                 name = name.trim();
  34083.                 this.isGestoreChiaviPDNDclientsErrorAbortTransaction = Boolean.valueOf(name);
  34084.             } catch(java.lang.Exception e) {
  34085.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34086.                 throw new CoreException(e.getMessage(),e);
  34087.             }    
  34088.         }

  34090.         return this.isGestoreChiaviPDNDclientsErrorAbortTransaction;
  34091.     }
  34092.     
  34093.     private Boolean isGestoreChiaviPDNDorganizationsErrorAbortTransaction = null;
  34094.     public boolean isGestoreChiaviPDNDorganizationsErrorAbortTransaction() throws CoreException {   
  34095.         if(this.isGestoreChiaviPDNDorganizationsErrorAbortTransaction==null){
  34096.             String pName = "org.openspcoop2.pdd.gestorePDND.organizations.error.abortTransaction";
  34097.             try{ 
  34098.                 String name = null;
  34099.                 name = this.reader.getValueConvertEnvProperties(pName);
  34100.                 if(name==null){
  34101.                     throw new CoreException("Proprieta' non impostata");
  34102.                 }
  34103.                 name = name.trim();
  34104.                 this.isGestoreChiaviPDNDorganizationsErrorAbortTransaction = Boolean.valueOf(name);
  34105.             } catch(java.lang.Exception e) {
  34106.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34107.                 throw new CoreException(e.getMessage(),e);
  34108.             }    
  34109.         }

  34111.         return this.isGestoreChiaviPDNDorganizationsErrorAbortTransaction;
  34112.     }
  34113.     
  34114.     private Boolean isGestoreChiaviPDNDRateLimitingInfoNotAvailableAbortTransaction = null;
  34115.     public boolean isGestoreChiaviPDNDRateLimitingInfoNotAvailableAbortTransaction() throws CoreException { 
  34116.         if(this.isGestoreChiaviPDNDRateLimitingInfoNotAvailableAbortTransaction==null){
  34117.             String pName = "org.openspcoop2.pdd.gestorePDND.rateLimiting.infoNotAvailable.abortTransaction";
  34118.             try{ 
  34119.                 String name = null;
  34120.                 name = this.reader.getValueConvertEnvProperties(pName);
  34121.                 if(name==null){
  34122.                     throw new CoreException("Proprieta' non impostata");
  34123.                 }
  34124.                 name = name.trim();
  34125.                 this.isGestoreChiaviPDNDRateLimitingInfoNotAvailableAbortTransaction = Boolean.valueOf(name);
  34126.             } catch(java.lang.Exception e) {
  34127.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34128.                 throw new CoreException(e.getMessage(),e);
  34129.             }    
  34130.         }

  34132.         return this.isGestoreChiaviPDNDRateLimitingInfoNotAvailableAbortTransaction;
  34133.     }
  34134.     
  34135.     private Boolean isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation = null;
  34136.     public boolean isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation() throws CoreException { 
  34137.         if(this.isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation==null){
  34138.             String pName = "org.openspcoop2.pdd.gestorePDND.clientInfo.retrieveAfterVoucherPDNDValidation";
  34139.             try{ 
  34140.                 String name = null;
  34141.                 name = this.reader.getValueConvertEnvProperties(pName);
  34142.                 if(name==null){
  34143.                     throw new CoreException("Proprieta' non impostata");
  34144.                 }
  34145.                 name = name.trim();
  34146.                 this.isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation = Boolean.valueOf(name);
  34147.             } catch(java.lang.Exception e) {
  34148.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34149.                 throw new CoreException(e.getMessage(),e);
  34150.             }    
  34151.         }

  34153.         return this.isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation;
  34154.     }
  34155.     
  34156.     private Boolean isGestoreChiaviPDNDclientsTraceJsonResponse = null;
  34157.     public boolean isGestoreChiaviPDNDclientsTraceJsonResponse() throws CoreException { 
  34158.         if(this.isGestoreChiaviPDNDclientsTraceJsonResponse==null){
  34159.             String pName = "org.openspcoop2.pdd.gestorePDND.clients.traceJsonResponse";
  34160.             try{ 
  34161.                 String name = null;
  34162.                 name = this.reader.getValueConvertEnvProperties(pName);
  34163.                 if(name==null){
  34164.                     throw new CoreException("Proprieta' non impostata");
  34165.                 }
  34166.                 name = name.trim();
  34167.                 this.isGestoreChiaviPDNDclientsTraceJsonResponse = Boolean.valueOf(name);
  34168.             } catch(java.lang.Exception e) {
  34169.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34170.                 throw new CoreException(e.getMessage(),e);
  34171.             }    
  34172.         }

  34174.         return this.isGestoreChiaviPDNDclientsTraceJsonResponse;
  34175.     }
  34176.     
  34177.     private Boolean isGestoreChiaviPDNDorganizationsTraceJsonResponse = null;
  34178.     public boolean isGestoreChiaviPDNDorganizationsTraceJsonResponse() throws CoreException {   
  34179.         if(this.isGestoreChiaviPDNDorganizationsTraceJsonResponse==null){
  34180.             String pName = "org.openspcoop2.pdd.gestorePDND.organizations.traceJsonResponse";
  34181.             try{ 
  34182.                 String name = null;
  34183.                 name = this.reader.getValueConvertEnvProperties(pName);
  34184.                 if(name==null){
  34185.                     throw new CoreException("Proprieta' non impostata");
  34186.                 }
  34187.                 name = name.trim();
  34188.                 this.isGestoreChiaviPDNDorganizationsTraceJsonResponse = Boolean.valueOf(name);
  34189.             } catch(java.lang.Exception e) {
  34190.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34191.                 throw new CoreException(e.getMessage(),e);
  34192.             }    
  34193.         }

  34195.         return this.isGestoreChiaviPDNDorganizationsTraceJsonResponse;
  34196.     }
  34197.     
  34198.     private Boolean isGestoreChiaviPDNDorganizationsTraceName = null;
  34199.     public boolean isGestoreChiaviPDNDorganizationsTraceName() throws CoreException {   
  34200.         if(this.isGestoreChiaviPDNDorganizationsTraceName==null){
  34201.             String pName = "org.openspcoop2.pdd.gestorePDND.organizations.traceName";
  34202.             try{ 
  34203.                 String name = null;
  34204.                 name = this.reader.getValueConvertEnvProperties(pName);
  34205.                 if(name==null){
  34206.                     throw new CoreException("Proprieta' non impostata");
  34207.                 }
  34208.                 name = name.trim();
  34209.                 this.isGestoreChiaviPDNDorganizationsTraceName = Boolean.valueOf(name);
  34210.             } catch(java.lang.Exception e) {
  34211.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34212.                 throw new CoreException(e.getMessage(),e);
  34213.             }    
  34214.         }

  34216.         return this.isGestoreChiaviPDNDorganizationsTraceName;
  34217.     }
  34218.     
  34219.     private Integer headersPeerRegexpCacheSize = null;
  34220.     public Integer getHeadersPeerRegexpCacheSize() throws CoreException {
  34221.         if (this.headersPeerRegexpCacheSize == null) {
  34222.             String pName = "org.openspcoop2.pdd.headers.peer.regexp.cacheSize";
  34223.             try{ 
  34224.                 String value = null;
  34225.                 value = this.reader.getValueConvertEnvProperties(pName);
  34226.                 if(value == null){
  34227.                     throw new CoreException("Proprieta' non impostata");
  34228.                 }
  34229.                 this.headersPeerRegexpCacheSize = Integer.parseInt(value.trim());
  34230.             } catch(java.lang.Exception e) {
  34231.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '"+pName+"': "+e.getMessage(),e);
  34232.                 throw new CoreException(e.getMessage(),e);
  34233.             }    
  34234.         }

  34236.         return this.headersPeerRegexpCacheSize;
  34237.     }
  34238.     
  34239.     private List<PeerHeaderDescriptor> headersDescriptors = null;
  34240.     public List<PeerHeaderDescriptor> getHeadersPeer() throws CoreException {
  34241.         if (this.headersDescriptors == null) {
  34242.             this.headersDescriptors = new ArrayList<>();
  34243.             
  34244.             String startPName = "org.openspcoop2.pdd.headers.peer.";
  34245.             String endHeaderName = ".headers";
  34246.             String endRegexpName = ".regexp";
  34247.             
  34248.             try {
  34249.                 Properties prop = this.reader.readProperties(startPName);
  34250.                 prop.forEach((k, v) -> {
  34251.                     String key = k.toString();
  34252.                     String value = v.toString();
  34253.                     
  34254.                     PeerHeaderDescriptor desc;
  34255.                     
  34256.                     if (key.endsWith(endHeaderName)) {
  34257.                         key = key.substring(0, key.length() - endHeaderName.length());
  34258.                         desc = new StringPeerHeaderDescriptor(key, value);
  34259.                     } else if (key.endsWith(endRegexpName)) {
  34260.                         key = key.substring(0, key.length() - endRegexpName.length());
  34261.                         desc = new RegexpPeerHeaderDescriptor(key, value);
  34262.                     } else {
  34263.                         String suffix = key.substring(key.lastIndexOf('.'));
  34264.                         this.logWarn("Proprieta " + key + " con prefisso: " + startPName + "ha un suffisso '" + suffix + "' non conosciuto");
  34265.                         return;
  34266.                     }
  34267.                     
  34268.                     this.headersDescriptors.add(desc);
  34269.                 });
  34270.                 this.headersDescriptors = Collections.unmodifiableList(this.headersDescriptors);
  34271.                 
  34272.             } catch (UtilsException e) {
  34273.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '" + startPName + "<Peer-Header-Name>.header': " + e.getMessage(), e);
  34274.                 throw new CoreException(e.getMessage(),e);
  34275.             }
  34276.             
  34277.         }
  34278.         return this.headersDescriptors;
  34279.     }
  34280.     
  34281. }
Created with JaCoCo 0.8.8.202204050719