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.Arrays;
  38. import java.util.Collections;
  39. import java.util.Date;
  40. import java.util.Enumeration;
  41. import java.util.HashMap;
  42. import java.util.Iterator;
  43. import java.util.List;
  44. import java.util.Locale;
  45. import java.util.Map;
  46. import java.util.Properties;
  47. import java.util.Set;
  48. import java.util.stream.Collectors;

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

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


  189. public class OpenSPCoop2Properties {    

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

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

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




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

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





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

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

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

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

  372.     }

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

  398.     /**
  399.      * Ritorna l'istanza di questa classe
  400.      *
  401.      * @return Istanza di OpenSPCoopProperties
  402.      * 
  403.      */
  404.     public static OpenSPCoop2Properties getInstance(){
  405.         return OpenSPCoop2Properties.openspcoopProperties;
  406.     }


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












  424.     /* ********  VALIDATORE FILE PROPERTY  ******** */

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

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

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

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

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

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

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


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


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

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

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

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

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

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


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

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

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

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

  994.                 // TransactionManager (Warning)
  995.                 this.getTransactionManagerAttesaAttiva();
  996.                 this.getTransactionManagerCheckDBInterval();
  997.                 this.getTransactionManagerCheckInterval();
  998.                 this.singleConnectionTransactionManager();
  999.             }

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

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

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

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

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

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

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

  1251.                     if(!checkTipiIntegrazione(tipiIntegrazionePDprotocollo))
  1252.                         return false;
  1253.                 }
  1254.             }

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

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

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

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

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

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

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

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

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

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

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

  1569.             // Gestione JMX
  1570.             this.isRisorseJMXAbilitate();
  1571.             this.getJNDIName_MBeanServer();
  1572.             this.getJNDIContext_MBeanServer();

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

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

  1620.             // Gestione Attachments (Warning)
  1621.             this.isDeleteInstructionTargetMachineXml();
  1622.             this.isTunnelSOAP_loadMailcap();
  1623.             this.getTunnelSOAPKeyWord_headerTrasporto();
  1624.             this.getTunnelSOAPKeyWordMimeType_headerTrasporto();
  1625.             this.getTunnelSOAPKeyWord_urlBased();
  1626.             this.getTunnelSOAPKeyWordMimeType_urlBased();

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

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

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

  1773.             // Stateless
  1774.             if(this.getStatelessOneWay()==null)
  1775.                 return false;
  1776.             if(this.getStatelessSincrono()==null)
  1777.                 return false;
  1778.             if(this.getStatelessAsincroni()==null)
  1779.                 return false;
  1780.             if(this.getStatelessRouting()==null)
  1781.                 return false;

  1783.             // Warning
  1784.             this.isGestioneOnewayStateful_1_1();
  1785.             this.isRinegoziamentoConnessione();

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

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

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

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

  2515.                     isControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction();
  2516.                     getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva();
  2517.                     getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval();
  2518.                     
  2519.                     //case HAZELCAST:
  2520.                     if(isHazelcastEngineEnabled()) {
  2521.                         //case HAZELCAST_MAP:
  2522.                         getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath();
  2523.                         //case HAZELCAST_NEAR_CACHE:
  2524.                         getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath();
  2525.                         //case HAZELCAST_NEAR_CACHE_UNSAFE_SYNC_MAP:
  2526.                         getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath();
  2527.                         //case HAZELCAST_NEAR_CACHE_UNSAFE_ASYNC_MAP:
  2528.                         getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath();
  2529.                         // case HAZELCAST_REPLICATED_MAP
  2530.                         getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath();
  2531.                         //case HAZELCAST_LOCAL_CACHE:
  2532.                         getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath();
  2533.                         getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheTimerUpdate();

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

  2739.         }catch(java.lang.Exception e) {
  2740.             this.logError("Riscontrato errore durante la validazione lettura della proprieta' di openspcoop: "+e.getMessage(),e);
  2741.             return false;
  2742.         }
  2743.     }
  2744.     
  2745.     public boolean validaConfigurazioneDopoInizializzazioneProtocolManager(java.lang.ClassLoader loader) {  
  2746.         try{  
  2747.             
  2748.             if(loader!=null) {
  2749.                 // nop
  2750.             }
  2751.             
  2752.             // IdentitaPdD
  2753.             Enumeration<String> protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
  2754.             while (protocolli.hasMoreElements()) {
  2755.                 String protocollo = protocolli.nextElement();
  2756.                 getIdentitaPortaDefault(protocollo, null);
  2757.             }   
  2758.             
  2759.             // ByPass
  2760.             protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
  2761.             while (protocolli.hasMoreElements()) {
  2762.                 String protocollo = protocolli.nextElement();
  2763.                 getBypassFilterMustUnderstandProperties(protocollo);
  2764.             }
  2765.             
  2766.             // ControlliToken
  2767.             protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
  2768.             while (protocolli.hasMoreElements()) {
  2769.                 String protocollo = protocolli.nextElement();
  2770.                 isGestioneTokenIatRequired(true, protocollo);
  2771.                 isGestioneTokenIatRequired(false, protocollo);
  2772.                 isGestioneTokenExpRequired(true, protocollo);
  2773.                 isGestioneTokenExpRequired(false, protocollo);
  2774.                 isGestioneTokenNbfRequired(true, protocollo);
  2775.                 isGestioneTokenNbfRequired(false, protocollo);
  2776.                 if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo)) {
  2777.                     isGestioneTokenIatPdndRequired();
  2778.                     isGestioneTokenExpPdndRequired();
  2779.                     isGestioneTokenNbfPdndRequired();
  2780.                 }
  2781.             }
  2782.             
  2783.             return true;
  2784.             
  2785.         }catch(java.lang.Exception e) {
  2786.             this.logError("Riscontrato errore durante la validazione lettura della proprieta' di openspcoop: "+e.getMessage(),e);
  2787.             return false;
  2788.         }
  2789.     }

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


  3351.     public List<String> getKeywordsIntegrazioneGestioneToken(){
  3352.         List<String> keywords = new ArrayList<>();
  3353.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_PROCESS_TIME);
  3354.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ISSUER);
  3355.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SUBJECT);
  3356.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_USERNAME);
  3357.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_AUDIENCE);
  3358.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_CLIENT_ID);
  3359.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ISSUED_AT);
  3360.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_EXPIRED);
  3361.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_NBF);
  3362.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_ROLES);
  3363.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SCOPES);
  3364.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FULL_NAME);
  3365.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FIRST_NAME);
  3366.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_MIDDLE_NAME);
  3367.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_FAMILY_NAME);
  3368.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_EMAIL);
  3369.         return keywords;
  3370.     }

  3372.     private boolean checkTipiIntegrazioneGestioneToken(){
  3373.         
  3374.         Map<?,?> prop = this.getKeyValueGestioneTokenHeaderIntegrazioneTrasporto();
  3375.         if ( prop == null ){
  3376.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.keyword.*'.");
  3377.             return false;
  3378.         }
  3379.         
  3380.         Map<String, Boolean> propSetPDtrasporto = null;
  3381.         try {
  3382.             propSetPDtrasporto = this.getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto();
  3383.         }catch(Exception e) {
  3384.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled.*'.");
  3385.             return false;
  3386.         }
  3387.         
  3388.         Map<String, Boolean> propSetPDjson = null;
  3389.         try {
  3390.             propSetPDjson = this.getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson();
  3391.         }catch(Exception e) {
  3392.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled.*'.");
  3393.             return false;
  3394.         }
  3395.         
  3396.         Map<String, Boolean> propSetPAtrasporto = null;
  3397.         try {
  3398.             propSetPAtrasporto = this.getKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto();
  3399.         }catch(Exception e) {
  3400.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled.*'.");
  3401.             return false;
  3402.         }
  3403.         
  3404.         Map<String, Boolean> propSetPAjson = null;
  3405.         try {
  3406.             propSetPAjson = this.getKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson();
  3407.         }catch(Exception e) {
  3408.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled.*'.");
  3409.             return false;
  3410.         }
  3411.         
  3412.         List<String> keywords = this.getKeywordsIntegrazioneGestioneToken();
  3413.         for (String keyword : keywords) {
  3414.             if( prop.get(keyword) == null){
  3415.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.keyword."+
  3416.                         keyword+"'.");
  3417.                 return false;
  3418.             }
  3419.             if( !propSetPDtrasporto.containsKey(keyword)){
  3420.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled."+
  3421.                         keyword+"'.");
  3422.                 return false;
  3423.             }
  3424.             if( !propSetPDjson.containsKey(keyword)){
  3425.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled."+
  3426.                         keyword+"'.");
  3427.                 return false;
  3428.             }
  3429.             if( !propSetPAtrasporto.containsKey(keyword)){
  3430.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled."+
  3431.                         keyword+"'.");
  3432.                 return false;
  3433.             }
  3434.             if( !propSetPAjson.containsKey(keyword)){
  3435.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop: 'org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled."+
  3436.                         keyword+"'.");
  3437.                 return false;
  3438.             }
  3439.         }
  3440.                 

  3442.         return true;
  3443.     }

  3445.     public List<MapKey<String>> getKeywordsIntegrazione(){
  3446.         return getKeywordsIntegrazioneEngine(false);
  3447.     }
  3448.     private List<MapKey<String>> getKeywordsIntegrazioneEngine(boolean all){
  3449.         List<MapKey<String>> keywords = new ArrayList<>();
  3450.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_MITTENTE);
  3451.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_MITTENTE);
  3452.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_DESTINATARIO);
  3453.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_DESTINATARIO);
  3454.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_SERVIZIO);
  3455.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_SERVIZIO);
  3456.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_VERSIONE_SERVIZIO);
  3457.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_AZIONE);
  3458.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_ID_MESSAGGIO);
  3459.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_RIFERIMENTO_MESSAGGIO);
  3460.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_COLLABORAZIONE);
  3461.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_ID_APPLICATIVO);
  3462.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_SERVIZIO_APPLICATIVO);
  3463.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_MITTENTE_TOKEN);
  3464.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_MITTENTE_TOKEN);
  3465.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_SERVIZIO_APPLICATIVO_TOKEN);
  3466.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_ID_TRANSAZIONE);
  3467.         keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_PROTOCOL_INFO);
  3468.         if(all) {
  3469.             keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_INFO);
  3470.             keywords.add(CostantiPdD.HEADER_INTEGRAZIONE_USER_AGENT);
  3471.         }
  3472.         return keywords;
  3473.     }

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














  3862.     /* ********  CONF DIRECTORY  ******** */

  3864.     /**
  3865.      * Restituisce la directory di configurazione di OpenSPCoop.
  3866.      *
  3867.      * @return la directory di configurazione di OpenSPCoop.
  3868.      * 
  3869.      */
  3870.     private String rootDirectory = null;
  3871.     public String getRootDirectory() {  
  3872.         if(this.rootDirectory==null){
  3873.             try{ 
  3874.                 String root = null;
  3875.                 root = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.confDirectory");

  3877.                 if(root==null)
  3878.                     throw new CoreException(NON_DEFINITA);

  3880.                 root = root.trim();

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

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

  3892.         return this.rootDirectory;
  3893.     }

  3895.     /**
  3896.      * Restituisce L'indicazione se il server è un server J2EE o WEB
  3897.      *
  3898.      * @return indicazione se il server è un server J2EE o WEB
  3899.      * 
  3900.      */
  3901.     private Boolean serverJ2EE = null;
  3902.     public Boolean isServerJ2EE() { 
  3903.         if(this.serverJ2EE==null){
  3904.             try{ 
  3905.                 String server = null;
  3906.                 server = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.server");

  3908.                 if(server==null)
  3909.                     throw new CoreException(NON_DEFINITA);

  3911.                 server = server.trim();

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

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

  3927.         return this.serverJ2EE;
  3928.     }

  3930.     private Boolean getClassLoaderRead = null;
  3931.     private String getClassLoader = null;
  3932.     public String getClassLoader(){

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

  3938.                 if (value != null){
  3939.                     value = value.trim();
  3940.                     this.getClassLoader = value;
  3941.                 }

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

  3949.         return this.getClassLoader;
  3950.     }

  3952.     private String productName = null;
  3953.     public String getProductName() {    
  3954.         if(this.productName==null){
  3955.             try{ 
  3956.                 String v = null;
  3957.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.productName");
  3958.                 if(v!=null){
  3959.                     v = v.trim();
  3960.                     this.productName = v;
  3961.                 }else{
  3962.                     this.productName = CostantiPdD.OPENSPCOOP2_PRODUCT;
  3963.                 }
  3964.             }catch(java.lang.Exception e) {
  3965.                 this.productName = CostantiPdD.OPENSPCOOP2_PRODUCT;
  3966.             }    
  3967.         }
  3968.         return this.productName;
  3969.     }
  3970.     
  3971.     private String versione = null;
  3972.     public String getVersione() {   
  3973.         if(this.versione==null){
  3974.             try{ 
  3975.                 String v = null;
  3976.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.versione");
  3977.                 if(v!=null){
  3978.                     v = v.trim();
  3979.                     this.versione = v;
  3980.                 }else{
  3981.                     this.versione = getVersionePdD(null);
  3982.                 }
  3983.             }catch(java.lang.Exception e) {
  3984.                 this.versione = CostantiPdD.OPENSPCOOP2_PRODUCT_VERSION;
  3985.             }    
  3986.         }
  3987.         return this.versione;
  3988.     }
  3989.     public static String getVersionePdD(OpenSPCoop2Properties properties) {
  3990.         String versione = CostantiPdD.OPENSPCOOP2_PRODUCT_VERSION;
  3991.         if(properties!=null){
  3992.             versione = properties.getPddDetailsForServices();
  3993.         }
  3994.         
  3995.         try {
  3996.             String version = VersionUtilities.readVersion();
  3997.             if(version!=null && !StringUtils.isEmpty(version)) {
  3998.                 versione = version;
  3999.             }
  4000.         }catch(Exception e) {
  4001.             // ignore
  4002.         }
  4003.         
  4004.         String buildVersion = null;
  4005.         try {
  4006.             buildVersion = VersionUtilities.readBuildVersion();
  4007.         }catch(Exception e) {
  4008.             // ignore
  4009.         }
  4010.         if(buildVersion!=null) {
  4011.             versione = versione + " (build "+buildVersion+")";
  4012.         }
  4013.         return versione;
  4014.     }
  4015.     
  4016.     private String details = null;
  4017.     public String getDetails() {    
  4018.         if(this.details==null){
  4019.             try{ 
  4020.                 String v = null;
  4021.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.details");
  4022.                 if(v!=null){
  4023.                     v = v.trim();
  4024.                     this.details = v;
  4025.                 }else{
  4026.                     this.details = CostantiPdD.OPENSPCOOP2_DETAILS;
  4027.                 }
  4028.             }catch(java.lang.Exception e) {
  4029.                 this.details = CostantiPdD.OPENSPCOOP2_DETAILS;
  4030.             }    
  4031.         }
  4032.         return this.details;
  4033.     }
  4034.     
  4035.     private String getPddDetailsForLog = null;
  4036.     public String getPddDetailsForLog() {   
  4037.         if(this.getPddDetailsForLog==null){
  4038.             try{ 
  4039.                 String v = null;
  4040.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.log.details");
  4041.                 if(v!=null){
  4042.                     v = v.trim();
  4043.                     this.getPddDetailsForLog = v;
  4044.                 }else{
  4045.                     this.getPddDetailsForLog = getDefaultLogVersionDetails();
  4046.                 }
  4047.             }catch(java.lang.Exception e) {
  4048.                 this.getPddDetailsForLog = getDefaultLogVersionDetails();
  4049.             }    
  4050.         }
  4051.         return this.getPddDetailsForLog;
  4052.     }
  4053.     
  4054.     private String getDefaultLogVersionDetails() {
  4055.         String d = this.getDetails();
  4056.         if(d!=null && !"".equals(d))
  4057.             return this.getVersione()+" ("+d+")";
  4058.         else
  4059.             return this.getVersione();
  4060.     }

  4062.     private String getPddDetailsForServices = null;
  4063.     public String getPddDetailsForServices() {  
  4064.         if(this.getPddDetailsForServices==null){
  4065.             try{ 
  4066.                 String v = null;
  4067.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.details");
  4068.                 if(v!=null){
  4069.                     v = v.trim();
  4070.                     this.getPddDetailsForServices = v;
  4071.                 }else{
  4072.                     this.getPddDetailsForServices = this.getVersione();
  4073.                 }
  4074.             }catch(java.lang.Exception e) {
  4075.                 this.getPddDetailsForServices = this.getVersione();
  4076.             }    
  4077.         }
  4078.         return this.getPddDetailsForServices;
  4079.     }
  4080.     
  4081.     private StatoFunzionalitaConWarning getCheckOpenSPCoopHome = null;
  4082.     public StatoFunzionalitaConWarning getCheckOpenSPCoopHome() {   
  4083.         if(this.getCheckOpenSPCoopHome==null){
  4084.             try{ 
  4085.                 String v = null;
  4086.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.checkHomeProperty");
  4087.                 if(v!=null){
  4088.                     v = v.trim();
  4089.                     this.getCheckOpenSPCoopHome = (StatoFunzionalitaConWarning) StatoFunzionalitaConWarning.toEnumConstantFromString(v);
  4090.                     if(this.getCheckOpenSPCoopHome==null){
  4091.                         throw new CoreException("Valore inatteso: "+v);
  4092.                     }
  4093.                 }else{
  4094.                     this.getCheckOpenSPCoopHome = StatoFunzionalitaConWarning.DISABILITATO;
  4095.                 }
  4096.             }catch(java.lang.Exception e) {
  4097.                 e.printStackTrace(System.out);
  4098.                 this.getCheckOpenSPCoopHome = StatoFunzionalitaConWarning.DISABILITATO;
  4099.             }    
  4100.         }
  4101.         return this.getCheckOpenSPCoopHome;
  4102.     }
  4103.     
  4104.     public void checkOpenSPCoopHome() throws CoreException{
  4105.         if(!StatoFunzionalitaConWarning.DISABILITATO.equals(this.getCheckOpenSPCoopHome())){
  4106.             Exception e = null;
  4107.             boolean foundSystem = false;
  4108.             try{
  4109.                 String dir = System.getProperty(CostantiPdD.OPENSPCOOP2_LOCAL_HOME);
  4110.                 if(dir==null || "".equals(dir)){
  4111.                     throw new CoreException("Variabile java ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non trovata");
  4112.                 }
  4113.                 foundSystem = true;
  4114.                 File fDir = new File(dir);
  4115.                 if(!fDir.exists()){
  4116.                     throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile java ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non esiste");
  4117.                 }
  4118.                 if(!fDir.isDirectory()){
  4119.                     throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile java ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non è una directory");
  4120.                 }
  4121.                 if(!fDir.canRead()){
  4122.                     throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile java ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non è accessibile in lettura");
  4123.                 }
  4124.             }catch(Exception eTh){
  4125.                 e = eTh;
  4126.             }
  4127.             try{
  4128.                 // NOTA: nel caricamento la variabile di sistema vince sulla variabile java
  4129.                 String dir = System.getenv(CostantiPdD.OPENSPCOOP2_LOCAL_HOME);
  4130.                 if(dir==null || "".equals(dir)){
  4131.                     if(!foundSystem){
  4132.                         throw new CoreException("Ne variabile java ne variabile di sistema ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] trovata");
  4133.                     }
  4134.                 }
  4135.                 else{
  4136.                     File fDir = new File(dir);
  4137.                     if(!fDir.exists()){
  4138.                         throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile di sistema ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non esiste");
  4139.                     }
  4140.                     if(!fDir.isDirectory()){
  4141.                         throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile di sistema ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non è una directory");
  4142.                     }
  4143.                     if(!fDir.canRead()){
  4144.                         throw new CoreException("File ["+fDir.getAbsolutePath()+"] indicato nella variabile di sistema ["+CostantiPdD.OPENSPCOOP2_LOCAL_HOME+"] non è accessibile in lettura");
  4145.                     }
  4146.                     // trovata.
  4147.                     // annullo una eventuale eccezione di sistema
  4148.                     e = null;
  4149.                 }
  4150.             }catch(Exception eTh){
  4151.                 if(e==null)
  4152.                     e = eTh;
  4153.                 else{
  4154.                     e = new Exception(e.getMessage()+" - "+eTh.getMessage(),eTh);
  4155.                 }
  4156.             }
  4157.             if(e!=null){
  4158.                 throw new CoreException(e.getMessage(),e);
  4159.             }
  4160.         }
  4161.     }
  4162.     
  4163.     




  4168.     /* ********  CONFIGURAZIONE DI OPENSPCOOP  ******** */

  4170.     /**
  4171.      * Restituisce la location della configurazione della porta di dominio di OpenSPCoop,
  4172.      *
  4173.      * @return il path del file di configurazione della porta di dominio in caso di ricerca con successo, null altrimenti.
  4174.      * 
  4175.      */
  4176.     private String pathConfigurazionePDD = null;
  4177.     public String getPathConfigurazionePDD() {  
  4178.         if(this.pathConfigurazionePDD==null){
  4179.             try{  
  4180.                 String indirizzo = this.reader.getValue("org.openspcoop2.pdd.config.location"); 
  4181.                 if(indirizzo==null)
  4182.                     throw new CoreException(NON_DEFINITA);

  4184.                 indirizzo = indirizzo.trim();

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

  4188.                     if( (!indirizzo.startsWith("http://")) && (!indirizzo.startsWith("file://")) ){
  4189.                         if(!indirizzo.startsWith("${")){
  4190.                             String root = getRootDirectory();
  4191.                             indirizzo = root+indirizzo;
  4192.                         }
  4193.                         while (indirizzo.indexOf("${")!=-1){
  4194.                             int indexStart = indirizzo.indexOf("${");
  4195.                             int indexEnd = indirizzo.indexOf("}");
  4196.                             if(indexEnd==-1){
  4197.                                 throw new CoreException("errore durante l'interpretazione del path ["+indirizzo+"]: ${ utilizzato senza la rispettiva chiusura }");
  4198.                             }
  4199.                             String nameSystemProperty = indirizzo.substring(indexStart+"${".length(),indexEnd);
  4200.                             String valueSystemProperty = System.getProperty(nameSystemProperty);
  4201.                             if(valueSystemProperty==null){
  4202.                                 throw new CoreException("errore durante l'interpretazione del path ["+indirizzo+"]: variabile di sistema ${"+nameSystemProperty+"} non esistente");
  4203.                             }
  4204.                             indirizzo = indirizzo.replace("${"+nameSystemProperty+"}", valueSystemProperty);
  4205.                         }
  4206.                     }

  4208.                 }

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

  4217.         return this.pathConfigurazionePDD;
  4218.     } 

  4220.     private List<PreloadingConfiguration> configPreLoadingLocale = null;
  4221.     private Boolean configPreLoadingLocaleRead = null;
  4222.     public List<PreloadingConfiguration> getConfigPreLoadingLocale() {  
  4223.         if(this.configPreLoadingLocaleRead==null){
  4224.             try{ 
  4225.                 String resourceTmp = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.config.preLoading.locale");
  4226.                 if(resourceTmp!=null){
  4227.                     resourceTmp = resourceTmp.trim();
  4228.                     
  4229.                     List<String> lResources = new ArrayList<>();
  4230.                     initSplitValues(lResources, resourceTmp, false);
  4231.                     
  4232.                     this.configPreLoadingLocale = new ArrayList<>();
  4233.                     
  4234.                     for (String resource : lResources) {
  4235.                         File f = new File(resource);
  4236.                         if(f.exists()) {
  4237.                             PreloadingConfiguration pc = new PreloadingConfiguration(FileSystemUtilities.readBytesFromFile(f), resource);
  4238.                             this.configPreLoadingLocale.add(pc);
  4239.                         }
  4240.                         else {
  4241.                             if(!resource.startsWith("/")) {
  4242.                                 resource = "/" + resource;
  4243.                             }
  4244.                             InputStream is = OpenSPCoop2Properties.class.getResourceAsStream(resource);
  4245.                             if(is!=null) {
  4246.                                 try {
  4247.                                     PreloadingConfiguration pc = new PreloadingConfiguration(Utilities.getAsByteArray(is), resource);
  4248.                                     this.configPreLoadingLocale.add(pc);
  4249.                                 }finally {
  4250.                                     try {
  4251.                                         is.close();
  4252.                                     }catch(Exception eClose) {
  4253.                                         // close
  4254.                                     }
  4255.                                 }
  4256.                             }
  4257.                         }   
  4258.                     }
  4259.                     
  4260.                 }

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

  4270.         return this.configPreLoadingLocale;
  4271.     }
  4272.     
  4273.     /**
  4274.      * Restituisce il tipo di configurazione della porta di dominio di OpenSPCoop.
  4275.      *
  4276.      * @return il tipo di configurazione della porta di dominio, null altrimenti.
  4277.      * 
  4278.      */
  4279.     private String tipoConfigurazionePDD = null;
  4280.     public String getTipoConfigurazionePDD() {  
  4281.         if(this.tipoConfigurazionePDD==null){
  4282.             try{ 
  4283.                 String tipo = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.config.tipo");
  4284.                 if(tipo==null)
  4285.                     throw new CoreException(NON_DEFINITA);
  4286.                 tipo = tipo.trim();

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

  4295.         return this.tipoConfigurazionePDD;
  4296.     }

  4298.     /**
  4299.      * Restituisce l'indicazione Se si desidera condividere i due database config e regserv
  4300.      *
  4301.      * @return l'indicazione Se si desidera condividere i due database config e regserv
  4302.      * 
  4303.      */
  4304.     private Boolean isCondivisioneConfigurazioneRegistroDB = null;
  4305.     public boolean isCondivisioneConfigurazioneRegistroDB() {   
  4306.         if(this.isCondivisioneConfigurazioneRegistroDB==null){
  4307.             try{ 
  4308.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.config.db.condivisioneDBRegserv");
  4309.                 if(value==null)
  4310.                     this.isCondivisioneConfigurazioneRegistroDB = false;
  4311.                 else{
  4312.                     this.isCondivisioneConfigurazioneRegistroDB = Boolean.parseBoolean(value);
  4313.                 }
  4314.             }catch(java.lang.Exception e) {
  4315.                 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);
  4316.                 this.isCondivisioneConfigurazioneRegistroDB = false;
  4317.             }    
  4318.         }

  4320.         return this.isCondivisioneConfigurazioneRegistroDB;
  4321.     }

  4323.     /**
  4324.      * Restituisce le proprieta' da utilizzare con il contesto JNDI di lookup, se impostate.
  4325.      *
  4326.      * @return proprieta' da utilizzare con il contesto JNDI di lookup.
  4327.      * 
  4328.      */
  4329.     private java.util.Properties jndiContext_Configurazione = null;
  4330.     public java.util.Properties getJNDIContext_Configurazione() {   
  4331.         if(this.jndiContext_Configurazione==null){
  4332.             java.util.Properties prop = new java.util.Properties();
  4333.             try{ 

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

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

  4344.         return this.jndiContext_Configurazione;
  4345.     }

  4347.     
  4348.     private AccessoConfigurazionePdD accessoConfigurazionePdD = null;
  4349.     public AccessoConfigurazionePdD getAccessoConfigurazionePdD() throws OpenSPCoop2ConfigurationException{ 
  4350.         if(this.accessoConfigurazionePdD==null){
  4351.             try{  
  4352.                 AccessoConfigurazionePdD conf = new AccessoConfigurazionePdD();
  4353.                 conf.setTipo(this.getTipoConfigurazionePDD());
  4354.                 if(CostantiConfigurazione.CONFIGURAZIONE_DB.equalsIgnoreCase(this.getTipoConfigurazionePDD())){ 
  4355.                     String tipoDatabase = null;
  4356.                     String location = null;
  4357.                     if(this.getPathConfigurazionePDD().indexOf("@")!=-1){
  4358.                         // estrazione tipo database
  4359.                         tipoDatabase = DBUtils.estraiTipoDatabaseFromLocation(this.getPathConfigurazionePDD());
  4360.                         location = this.getPathConfigurazionePDD().substring(this.getPathConfigurazionePDD().indexOf("@")+1);
  4361.                     }else{
  4362.                         tipoDatabase = this.getDatabaseType();
  4363.                         location =this.getPathConfigurazionePDD();
  4364.                     }
  4365.                     conf.setLocation(location);
  4366.                     conf.setTipoDatabase(tipoDatabase);
  4367.                 }else{
  4368.                     conf.setLocation(this.getPathConfigurazionePDD());
  4369.                 }
  4370.                 conf.setContext(this.getJNDIContext_Configurazione());
  4371.                 conf.setCondivisioneDatabasePddRegistro(this.isCondivisioneConfigurazioneRegistroDB());
  4372.                 
  4373.                 this.accessoConfigurazionePdD = conf;
  4374.             }catch(java.lang.Exception e) {
  4375.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della modalita' di accesso alla configurazione della PdD OpenSPCoop",e);
  4376.             }
  4377.         }

  4379.         return this.accessoConfigurazionePdD;
  4380.     }

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

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

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

  4409.         return this.isConfigurazioneDinamica_value;
  4410.     }
  4411.     
  4412.     private Boolean isConfigurazioneCache_ConfigPrefill_value = null;
  4413.     public boolean isConfigurazioneCache_ConfigPrefill(){
  4414.         if(this.isConfigurazioneCache_ConfigPrefill_value==null){
  4415.             try{  
  4416.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cache.config.prefill"); 

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

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

  4432.         return this.isConfigurazioneCache_ConfigPrefill_value;
  4433.     }
  4434.     
  4435.     private Boolean isConfigurazioneCache_RegistryPrefill_value = null;
  4436.     public boolean isConfigurazioneCache_RegistryPrefill(){
  4437.         if(this.isConfigurazioneCache_RegistryPrefill_value==null){
  4438.             try{  
  4439.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cache.registry.prefill"); 

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

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

  4455.         return this.isConfigurazioneCache_RegistryPrefill_value;
  4456.     }
  4457.     
  4458.     private Boolean isConfigurazioneCache_accessiSynchronized = null;
  4459.     public boolean isConfigurazioneCache_accessiSynchronized(){
  4460.         if(this.isConfigurazioneCache_accessiSynchronized==null){
  4461.             try{  
  4462.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cache.get.synchronized"); 

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

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

  4478.         return this.isConfigurazioneCache_accessiSynchronized;
  4479.     }
  4480.     
  4481.     private Boolean isConfigurazioneCache_transactionContext_accessiSynchronized = null;
  4482.     public boolean isConfigurazioneCache_transactionContext_accessiSynchronized(){
  4483.         if(this.isConfigurazioneCache_transactionContext_accessiSynchronized==null){
  4484.             try{  
  4485.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cache.transactionContext.synchronized"); 

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

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

  4501.         return this.isConfigurazioneCache_transactionContext_accessiSynchronized;
  4502.     }

  4504.     private CacheType readCacheTypeConfig = null;
  4505.     public CacheType getCacheTypeConfig() {
  4506.         if(this.readCacheTypeConfig==null) {
  4507.             this.readCacheTypeConfig = readCacheType("org.openspcoop2.pdd.cache.impl.config");
  4508.         }
  4509.         return this.readCacheTypeConfig;
  4510.     }
  4511.     
  4512.     private CacheType readCacheTypeRegistry = null;
  4513.     public CacheType getCacheTypeRegistry() {
  4514.         if(this.readCacheTypeRegistry==null) {
  4515.             this.readCacheTypeRegistry = readCacheType("org.openspcoop2.pdd.cache.impl.registry");
  4516.         }
  4517.         return this.readCacheTypeRegistry;
  4518.     }
  4519.     
  4520.     private CacheType readCacheTypeAuthentication = null;
  4521.     public CacheType getCacheTypeAuthentication() {
  4522.         if(this.readCacheTypeAuthentication==null) {
  4523.             this.readCacheTypeAuthentication = readCacheType("org.openspcoop2.pdd.cache.impl.authentication");
  4524.         }
  4525.         return this.readCacheTypeAuthentication;
  4526.     }
  4527.     
  4528.     private CacheType readCacheTypeAuthorization = null;
  4529.     public CacheType getCacheTypeAuthorization() {
  4530.         if(this.readCacheTypeAuthorization==null) {
  4531.             this.readCacheTypeAuthorization = readCacheType("org.openspcoop2.pdd.cache.impl.authorization");
  4532.         }
  4533.         return this.readCacheTypeAuthorization;
  4534.     }
  4535.     
  4536.     private CacheType readCacheTypeResponseCaching = null;
  4537.     public CacheType getCacheTypeResponseCaching() {
  4538.         if(this.readCacheTypeResponseCaching==null) {
  4539.             this.readCacheTypeResponseCaching = readCacheType("org.openspcoop2.pdd.cache.impl.responseCaching");
  4540.         }
  4541.         return this.readCacheTypeResponseCaching;
  4542.     }

  4544.     private CacheType readCacheTypeToken = null;
  4545.     public CacheType getCacheTypeToken() {
  4546.         if(this.readCacheTypeToken==null) {
  4547.             this.readCacheTypeToken = readCacheType("org.openspcoop2.pdd.cache.impl.token");
  4548.         }
  4549.         return this.readCacheTypeToken;
  4550.     }
  4551.     
  4552.     private CacheType readCacheTypeAttributeAuthority = null;
  4553.     public CacheType getCacheTypeAttributeAuthority() {
  4554.         if(this.readCacheTypeAttributeAuthority==null) {
  4555.             this.readCacheTypeAttributeAuthority = readCacheType("org.openspcoop2.pdd.cache.impl.attributeAuthority");
  4556.         }
  4557.         return this.readCacheTypeAttributeAuthority;
  4558.     }
  4559.     
  4560.     private CacheType readCacheTypeKeystore = null;
  4561.     public CacheType getCacheTypeKeystore() {
  4562.         if(this.readCacheTypeKeystore==null) {
  4563.             this.readCacheTypeKeystore = readCacheType("org.openspcoop2.pdd.cache.impl.keystore");
  4564.         }
  4565.         return this.readCacheTypeKeystore;
  4566.     }
  4567.     
  4568.     private CacheType readCacheTypeLoadBalancer = null;
  4569.     public CacheType getCacheTypeLoadBalancer() {
  4570.         if(this.readCacheTypeLoadBalancer==null) {
  4571.             this.readCacheTypeLoadBalancer = readCacheType("org.openspcoop2.pdd.cache.impl.loadBalancer");
  4572.         }
  4573.         return this.readCacheTypeLoadBalancer;
  4574.     }
  4575.     
  4576.     private CacheType readCacheTypeTrafficControl = null;
  4577.     public CacheType getCacheTypeTrafficControl() {
  4578.         if(this.readCacheTypeTrafficControl==null) {
  4579.             this.readCacheTypeTrafficControl = readCacheType("org.openspcoop2.pdd.cache.impl.trafficControl");
  4580.         }
  4581.         return this.readCacheTypeTrafficControl;
  4582.     }
  4583.     
  4584.     private CacheType readCacheTypeMessage = null;
  4585.     public CacheType getCacheTypeMessage() {
  4586.         if(this.readCacheTypeMessage==null) {
  4587.             this.readCacheTypeMessage = readCacheType("org.openspcoop2.pdd.cache.impl.message");
  4588.         }
  4589.         return this.readCacheTypeMessage;
  4590.     }
  4591.     
  4592.     private CacheType readCacheTypeRequestManager = null;
  4593.     public CacheType getCacheTypeRequestManager() {
  4594.         if(this.readCacheTypeRequestManager==null) {
  4595.             this.readCacheTypeRequestManager = readCacheType("org.openspcoop2.pdd.cache.impl.requestManager");
  4596.         }
  4597.         return this.readCacheTypeRequestManager;
  4598.     }
  4599.     
  4600.     
  4601.     public CacheType readCacheType(String pName){
  4602.         try{  
  4603.             String value = this.reader.getValueConvertEnvProperties(pName); 

  4605.             if(value!=null){
  4606.                 value = value.trim();
  4607.                 return CacheType.valueOf(value);
  4608.             }else{
  4609.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,CacheType.JCS.toString()));
  4610.                 return CacheType.JCS;
  4611.             }

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

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

  4626.                 if(value!=null){
  4627.                     value = value.trim();
  4628.                     this.isConfigurazioneCacheDebug = Boolean.parseBoolean(value);
  4629.                 }else{
  4630.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  4631.                     this.isConfigurazioneCacheDebug = false;
  4632.                 }

  4634.             }catch(java.lang.Exception e) {
  4635.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  4636.                 this.isConfigurazioneCacheDebug = false;
  4637.             }
  4638.         }

  4640.         return this.isConfigurazioneCacheDebug;
  4641.     }
  4642.     
  4643.     private Boolean isConfigurazioneCacheRequestManagerUseCache = null;
  4644.     public boolean isConfigurazioneCacheRequestManagerUseCache(){
  4645.         if(this.isConfigurazioneCacheRequestManagerUseCache==null){
  4646.             String pName = "org.openspcoop2.pdd.cache.impl.requestManager.useCache";
  4647.             try{  
  4648.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  4650.                 if(value!=null){
  4651.                     value = value.trim();
  4652.                     this.isConfigurazioneCacheRequestManagerUseCache = Boolean.parseBoolean(value);
  4653.                 }else{
  4654.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4655.                     this.isConfigurazioneCacheRequestManagerUseCache = true;
  4656.                 }

  4658.             }catch(java.lang.Exception e) {
  4659.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  4660.                 this.isConfigurazioneCacheRequestManagerUseCache = true;
  4661.             }
  4662.         }

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

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

  4708.         return this.isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache;
  4709.     }
  4710.     
  4711.     private Boolean isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache = null;
  4712.     public boolean isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache() {    
  4713.         if(this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache==null){
  4714.             String pName = "org.openspcoop2.pdd.cache.impl.requestManager.remoteStore.saveInCache";
  4715.             try{ 
  4716.                 String name = null;
  4717.                 name = this.reader.getValueConvertEnvProperties(pName);
  4718.                 if(name==null){
  4719.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  4720.                     name="false";
  4721.                 }
  4722.                 name = name.trim();
  4723.                 this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache = Boolean.parseBoolean(name);
  4724.             } catch(java.lang.Exception e) {
  4725.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  4726.                 this.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache = false;
  4727.             }    
  4728.         }

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

  4754.         return this.isConfigurazioneKeystoreJksPasswordRequired;
  4755.     }
  4756.     private Boolean isConfigurazioneKeystoreJksKeyPasswordRequired = null;
  4757.     public boolean isConfigurazioneKeystoreJksKeyPasswordRequired() {   
  4758.         if(this.isConfigurazioneKeystoreJksKeyPasswordRequired==null){
  4759.             String pName = "org.openspcoop2.pdd.keystore.jks.key.passwordRequired";
  4760.             try{ 
  4761.                 String name = null;
  4762.                 name = this.reader.getValueConvertEnvProperties(pName);
  4763.                 if(name==null){
  4764.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4765.                     name="true";
  4766.                 }
  4767.                 name = name.trim();
  4768.                 this.isConfigurazioneKeystoreJksKeyPasswordRequired = Boolean.parseBoolean(name);
  4769.             } catch(java.lang.Exception e) {
  4770.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  4771.                 this.isConfigurazioneKeystoreJksKeyPasswordRequired = true;
  4772.             }    
  4773.         }

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

  4796.         return this.isConfigurazioneKeystorePkcs12PasswordRequired;
  4797.     }
  4798.     private Boolean isConfigurazioneKeystorePkcs12KeyPasswordRequired = null;
  4799.     public boolean isConfigurazioneKeystorePkcs12KeyPasswordRequired() {    
  4800.         if(this.isConfigurazioneKeystorePkcs12KeyPasswordRequired==null){
  4801.             String pName = "org.openspcoop2.pdd.keystore.pkcs12.key.passwordRequired";
  4802.             try{ 
  4803.                 String name = null;
  4804.                 name = this.reader.getValueConvertEnvProperties(pName);
  4805.                 if(name==null){
  4806.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4807.                     name="true";
  4808.                 }
  4809.                 name = name.trim();
  4810.                 this.isConfigurazioneKeystorePkcs12KeyPasswordRequired = Boolean.parseBoolean(name);
  4811.             } catch(java.lang.Exception e) {
  4812.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  4813.                 this.isConfigurazioneKeystorePkcs12KeyPasswordRequired = true;
  4814.             }    
  4815.         }

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

  4839.         return this.isConfigurazioneTruststoreJksPasswordRequired;
  4840.     }
  4841.     private Boolean isConfigurazioneTruststorePkcs12PasswordRequired = null;
  4842.     public boolean isConfigurazioneTruststorePkcs12PasswordRequired() { 
  4843.         if(this.isConfigurazioneTruststorePkcs12PasswordRequired==null){
  4844.             String pName = "org.openspcoop2.pdd.truststore.pkcs12.passwordRequired";
  4845.             try{ 
  4846.                 String name = null;
  4847.                 name = this.reader.getValueConvertEnvProperties(pName);
  4848.                 if(name==null){
  4849.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4850.                     name="true";
  4851.                 }
  4852.                 name = name.trim();
  4853.                 this.isConfigurazioneTruststorePkcs12PasswordRequired = Boolean.parseBoolean(name);
  4854.             } catch(java.lang.Exception e) {
  4855.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  4856.                 this.isConfigurazioneTruststorePkcs12PasswordRequired = true;
  4857.             }    
  4858.         }

  4860.         return this.isConfigurazioneTruststorePkcs12PasswordRequired;
  4861.     }


  4864.     
  4865.     
  4866.     /* ********  CONFIGURAZIONE PLUGINS  ******** */
  4867.     
  4868.     private Boolean isConfigurazionePluginsEnabled = null;
  4869.     public boolean isConfigurazionePluginsEnabled(){
  4870.         
  4871.         String pName = "org.openspcoop2.pdd.config.plugins.enabled";
  4872.         if(this.isConfigurazionePluginsEnabled==null){
  4873.             try{  
  4874.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  4876.                 if(value!=null){
  4877.                     value = value.trim();
  4878.                     this.isConfigurazionePluginsEnabled = Boolean.parseBoolean(value);
  4879.                 }else{
  4880.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4881.                     this.isConfigurazionePluginsEnabled = true;
  4882.                 }

  4884.             }catch(java.lang.Exception e) {
  4885.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  4886.                 this.isConfigurazionePluginsEnabled = true;
  4887.             }
  4888.         }

  4890.         return this.isConfigurazionePluginsEnabled;
  4891.     }
  4892.     
  4893.     private Boolean isConfigurazionePluginsDebug = null;
  4894.     public boolean isConfigurazionePluginsDebug(){
  4895.         
  4896.         String pName = "org.openspcoop2.pdd.config.plugins.debug";
  4897.         if(this.isConfigurazionePluginsDebug==null){
  4898.             try{  
  4899.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  4901.                 if(value!=null){
  4902.                     value = value.trim();
  4903.                     this.isConfigurazionePluginsDebug = Boolean.parseBoolean(value);
  4904.                 }else{
  4905.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  4906.                     this.isConfigurazionePluginsDebug = true;
  4907.                 }

  4909.             }catch(java.lang.Exception e) {
  4910.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  4911.                 this.isConfigurazionePluginsDebug = true;
  4912.             }
  4913.         }

  4915.         return this.isConfigurazionePluginsDebug;
  4916.     }
  4917.     
  4918.     private Integer getConfigurazionePluginsSeconds = null;
  4919.     public int getConfigurazionePluginsSeconds(){
  4920.         
  4921.         String pName = "org.openspcoop2.pdd.config.plugins.seconds";
  4922.         if(this.getConfigurazionePluginsSeconds==null){
  4923.             try{  
  4924.                 String value = this.reader.getValueConvertEnvProperties(pName); 

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

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

  4940.         return this.getConfigurazionePluginsSeconds;
  4941.     }






  4948.     /* ********  DATASOURCE DI OPENSPCOOP  ******** */

  4950.     /**
  4951.      * Restituisce il Nome JNDI del DataSource utilizzato da OpenSPCoop.
  4952.      *
  4953.      * @return il Nome JNDI del DataSource utilizzato da OpenSPCoop.
  4954.      * 
  4955.      */
  4956.     private String jndiNameDatasource = null;
  4957.     public String getJNDIName_DataSource() {    
  4958.         if(this.jndiNameDatasource==null){
  4959.             try{ 
  4960.                 String name = null;
  4961.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dataSource");
  4962.                 if(name==null)
  4963.                     throw new CoreException(NON_DEFINITA);
  4964.                 name = name.trim();

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

  4973.         return this.jndiNameDatasource;
  4974.     }

  4976.     /**
  4977.      * Restituisce le proprieta' da utilizzare con il contesto JNDI di lookup, se impostate.
  4978.      *
  4979.      * @return proprieta' da utilizzare con il contesto JNDI di lookup.
  4980.      * 
  4981.      */
  4982.     private java.util.Properties jndiContextDatasource = null;
  4983.     public java.util.Properties getJNDIContext_DataSource() {
  4984.         if(this.jndiContextDatasource == null){
  4985.             java.util.Properties prop = new java.util.Properties();
  4986.             try{ 

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

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

  4997.         return this.jndiContextDatasource;
  4998.     }











  5010.     /* ********  CONNECTION FACTORY DI OPENSPCOOP  ******** */

  5012.     /**
  5013.      * Restituisce il Nome JNDI del ConnectionFactory utilizzato da OpenSPCoop.
  5014.      *
  5015.      * @return il Nome JNDI del ConnectionFactory utilizzato da OpenSPCoop.
  5016.      * 
  5017.      */
  5018.     private String jndiNameConnectionFactory = null;
  5019.     public String getJNDIName_ConnectionFactory() { 
  5020.         if(this.jndiNameConnectionFactory==null){
  5021.             try{ 
  5022.                 String name = null;
  5023.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.queueConnectionFactory");
  5024.                 if(name==null)
  5025.                     throw new CoreException(NON_DEFINITA);
  5026.                 name = name.trim();

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

  5035.         return this.jndiNameConnectionFactory;
  5036.     }

  5038.     /**
  5039.      * Restituisce le proprieta' da utilizzare con il contesto JNDI di lookup, se impostate.
  5040.      *
  5041.      * @return proprieta' da utilizzare con il contesto JNDI di lookup.
  5042.      * 
  5043.      */
  5044.     private java.util.Properties jndiContextConnectionFactory = null;
  5045.     public java.util.Properties getJNDIContext_ConnectionFactory() {
  5046.         if(this.jndiContextConnectionFactory==null){
  5047.             java.util.Properties prop = new java.util.Properties();
  5048.             try{ 

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

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

  5059.         return this.jndiContextConnectionFactory;
  5060.     }

  5062.     /**
  5063.      * Restituisce acknowledgeMode della Sessione utilizzata da OpenSPCoop.
  5064.      *
  5065.      * @return acknowledgeMode della Sessione utilizzata da OpenSPCoop.
  5066.      * 
  5067.      */
  5068.     private int acknowledgeModeSessioneConnectionFactory = -1;
  5069.     public int getAcknowledgeModeSessioneConnectionFactory() {  
  5070.         if(this.acknowledgeModeSessioneConnectionFactory==-1){
  5071.             try{ 
  5072.                 String name = null;
  5073.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.queueConnectionFactory.session.AcknowledgeMode");

  5075.                 if(name!=null){
  5076.                     name = name.trim();
  5077.                     if(CostantiConfigurazione.AUTO_ACKNOWLEDGE.equals(name))
  5078.                         this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.AUTO_ACKNOWLEDGE;
  5079.                     else if(CostantiConfigurazione.CLIENT_ACKNOWLEDGE.equals(name))
  5080.                         this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.CLIENT_ACKNOWLEDGE;
  5081.                     else if(CostantiConfigurazione.DUPS_OK_ACKNOWLEDGE.equals(name))
  5082.                         this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.DUPS_OK_ACKNOWLEDGE;
  5083.                     else
  5084.                         throw new CoreException("Tipo di acknowledgeModeSessione non conosciuto (viene utilizzato il default:AUTO_ACKNOWLEDGE)");
  5085.                 }else{
  5086.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.queueConnectionFactory.session.AcknowledgeMode' non impostata, viene utilizzato il default=AUTO_ACKNOWLEDGE");
  5087.                     this.acknowledgeModeSessioneConnectionFactory = javax.jms.Session.AUTO_ACKNOWLEDGE; // Default
  5088.                 }

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

  5096.         return this.acknowledgeModeSessioneConnectionFactory;
  5097.     }








  5106.     /* ********  CODE JMS DI OPENSPCOOP  ******** */

  5108.     public java.util.Map<String,String> getJNDIQueueName(boolean receiverJMSActive,boolean senderJMSActive){
  5109.         java.util.Map<String,String> table = new java.util.HashMap<>();
  5110.         try{ 
  5111.             boolean ricezioneContenutiApplicativi = !receiverJMSActive;
  5112.             boolean ricezioneBuste = !receiverJMSActive;
  5113.             boolean consegnaContenutiApplicativi = !senderJMSActive;
  5114.             boolean inoltroBuste = !senderJMSActive;
  5115.             boolean inoltroRisposte = !senderJMSActive;
  5116.             boolean imbustamento = !senderJMSActive;
  5117.             boolean imbustamentoRisposte = !senderJMSActive;
  5118.             boolean sbustamento=!senderJMSActive;
  5119.             boolean sbustamentoRisposte=!senderJMSActive;
  5120.             java.util.Enumeration<?> en = this.reader.propertyNames();
  5121.             for (; en.hasMoreElements() ;) {
  5122.                 String property = (String) en.nextElement();
  5123.                 if(property.startsWith("org.openspcoop2.pdd.queue.")){
  5124.                     String key = (property.substring("org.openspcoop2.pdd.queue.".length()));
  5125.                     if(key != null)
  5126.                         key = key.trim();
  5127.                     String value = this.reader.getValueConvertEnvProperties(property);
  5128.                     if(value!=null)
  5129.                         value = value.trim();
  5130.                     if(receiverJMSActive){
  5131.                         if("ricezioneContenutiApplicativi".equals(key) && value!=null){
  5132.                             table.put(RicezioneContenutiApplicativi.ID_MODULO, value);
  5133.                             ricezioneContenutiApplicativi = true;
  5134.                         }else if("ricezioneBuste".equals(key) && value!=null){
  5135.                             table.put(RicezioneBuste.ID_MODULO, value);
  5136.                             ricezioneBuste = true;
  5137.                         }
  5138.                     }
  5139.                     if(senderJMSActive){
  5140.                         if("inoltroBuste".equals(key) && value!=null){
  5141.                             table.put(InoltroBuste.ID_MODULO, value);
  5142.                             inoltroBuste = true;
  5143.                         }else if("inoltroRisposte".equals(key) && value!=null){
  5144.                             table.put(InoltroRisposte.ID_MODULO, value);
  5145.                             inoltroRisposte = true;
  5146.                         }else if("consegnaContenutiApplicativi".equals(key) && value!=null){
  5147.                             table.put(ConsegnaContenutiApplicativi.ID_MODULO, value);
  5148.                             consegnaContenutiApplicativi = true;
  5149.                         }else if("imbustamento".equals(key) && value!=null){
  5150.                             table.put(Imbustamento.ID_MODULO, value);
  5151.                             imbustamento = true;
  5152.                         }else if("imbustamentoRisposte".equals(key) && value!=null){
  5153.                             table.put(ImbustamentoRisposte.ID_MODULO, value);
  5154.                             imbustamentoRisposte = true;
  5155.                         }else if("sbustamento".equals(key) && value!=null){
  5156.                             table.put(Sbustamento.ID_MODULO, value);
  5157.                             sbustamento = true;
  5158.                         }else if("sbustamentoRisposte".equals(key) && value!=null){
  5159.                             table.put(SbustamentoRisposte.ID_MODULO, value);
  5160.                             sbustamentoRisposte = true;
  5161.                         }
  5162.                     }
  5163.                 }
  5164.             }


  5167.             if(ricezioneContenutiApplicativi==false){
  5168.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.ricezioneContenutiApplicativi non definita");
  5169.                 return null;
  5170.             }
  5171.             if(ricezioneBuste==false){
  5172.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.ricezioneBuste non definita");
  5173.                 return null;
  5174.             }
  5175.             if(consegnaContenutiApplicativi==false){
  5176.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.consegnaContenutiApplicativi non definita");
  5177.                 return null;
  5178.             }
  5179.             if(inoltroBuste==false){
  5180.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.inoltroBuste non definita");
  5181.                 return null;
  5182.             }
  5183.             if(inoltroRisposte==false){
  5184.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.inoltroRisposte non definita");
  5185.                 return null;
  5186.             }
  5187.             if(imbustamento==false){
  5188.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.imbustamento non definita");
  5189.                 return null;
  5190.             }if(imbustamentoRisposte==false){
  5191.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.imbustamentoRisposte non definita");
  5192.                 return null;
  5193.             }else if(sbustamentoRisposte==false){
  5194.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.sbustamentoRisposte non definita");
  5195.                 return null;
  5196.             }
  5197.             if(sbustamento==false){
  5198.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI delle code di openspcoop: coda org.openspcoop2.pdd.queue.sbustamento non definita");
  5199.                 return null;
  5200.             }
  5201.             return table;

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

  5209.     /**
  5210.      * Restituisce le proprieta' da utilizzare nel contesto JNDI di lookup per localizzare le code.
  5211.      *
  5212.      * @return proprieta' da utilizzare con il contesto JNDI di lookup per localizzare le code.
  5213.      * 
  5214.      */
  5215.     private java.util.Properties jndiContext_CodeInterne = null;
  5216.     public java.util.Properties getJNDIContext_CodeInterne() {  
  5217.         if(this.jndiContext_CodeInterne==null){
  5218.             java.util.Properties prop = new java.util.Properties();
  5219.             try{ 

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

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

  5230.         return this.jndiContext_CodeInterne;
  5231.     }














  5246.     /* ********  Timer EJB DI OPENSPCOOP  ******** */

  5248.     public java.util.Map<String,String> getJNDITimerEJBName(){
  5249.         java.util.Map<String,String> table = new java.util.HashMap<>();
  5250.         try{ 
  5251.             boolean gestoreBusteNonRiscontrate = false;
  5252.             boolean gestoreMessaggi = false;
  5253.             boolean gestorePuliziaMessaggiAnomali = false;
  5254.             boolean gestoreRepositoryBuste = false;
  5255.             java.util.Enumeration<?> en = this.reader.propertyNames();
  5256.             for (; en.hasMoreElements() ;) {
  5257.                 String property = (String) en.nextElement();
  5258.                 if(property.startsWith("org.openspcoop2.pdd.timer.")){
  5259.                     String key = (property.substring("org.openspcoop2.pdd.timer.".length()));
  5260.                     if(key != null)
  5261.                         key = key.trim();
  5262.                     String value = this.reader.getValueConvertEnvProperties(property);
  5263.                     if(value!=null)
  5264.                         value = value.trim();
  5265.                     if("gestoreBusteNonRiscontrate".equals(key) && value!=null){
  5266.                         table.put(TimerGestoreBusteNonRiscontrate.ID_MODULO, value);
  5267.                         gestoreBusteNonRiscontrate = true;
  5268.                     }else if("gestoreMessaggi".equals(key) && value!=null){
  5269.                         table.put(TimerGestoreMessaggi.ID_MODULO, value);
  5270.                         gestoreMessaggi = true;
  5271.                     }else if("gestorePuliziaMessaggiAnomali".equals(key) && value!=null){
  5272.                         table.put(TimerGestorePuliziaMessaggiAnomali.ID_MODULO, value);
  5273.                         gestorePuliziaMessaggiAnomali = true;
  5274.                     }else if("gestoreRepositoryBuste".equals(key) && value!=null){
  5275.                         table.put(TimerGestoreRepositoryBuste.ID_MODULO, value);
  5276.                         gestoreRepositoryBuste = true;
  5277.                     }
  5278.                 }
  5279.             }


  5282.             if(gestoreBusteNonRiscontrate==false && this.isTimerGestoreRiscontriRicevuteAbilitato()){
  5283.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI dei timer openspcoop: timer org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate non definito");
  5284.                 return null;
  5285.             }
  5286.             if(gestoreMessaggi==false && this.isTimerGestoreMessaggiAbilitato()){
  5287.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI dei timer openspcoop: timer org.openspcoop2.pdd.timer.gestoreMessaggi non definito");
  5288.                 return null;
  5289.             }
  5290.             if(gestorePuliziaMessaggiAnomali==false && this.isTimerGestorePuliziaMessaggiAnomaliAbilitato()){
  5291.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI dei timer openspcoop: timer org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali non definito");
  5292.                 return null;
  5293.             }
  5294.             if(gestoreRepositoryBuste==false && this.isTimerGestoreRepositoryBusteAbilitato()){
  5295.                 this.logError("Riscontrato errore durante la lettura dei nomi JNDI dei timer openspcoop: timer org.openspcoop2.pdd.timer.gestoreRepositoryBuste  non definito");
  5296.                 return null;
  5297.             }
  5298.             return table;

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

  5306.     /**
  5307.      * Restituisce le proprieta' da utilizzare nel contesto JNDI di lookup per localizzare i timer.
  5308.      *
  5309.      * @return proprieta' da utilizzare con il contesto JNDI di lookup per localizzare i timer.
  5310.      * 
  5311.      */
  5312.     private java.util.Properties jndiContext_TimerEJB = null;
  5313.     public java.util.Properties getJNDIContext_TimerEJB() { 
  5314.         if(this.jndiContext_TimerEJB==null){
  5315.             java.util.Properties prop = new java.util.Properties();
  5316.             try{ 

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

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

  5327.         return this.jndiContext_TimerEJB;
  5328.     }
  5329.     
  5330.     private Boolean isTimerAutoStart_StopTimer = null;
  5331.     public boolean isTimerAutoStart_StopTimer(){
  5332.         if(this.isTimerAutoStart_StopTimer==null){
  5333.             try{  
  5334.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.autoStart.stop"); 

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

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

  5350.         return this.isTimerAutoStart_StopTimer;
  5351.     }
  5352.     
  5353.     
  5354.     

  5356.     
  5357.     // GestoreRiscontriRicevute
  5358.     
  5359.     /**
  5360.      * Restituisce l'indicazione se avviare il timer
  5361.      *
  5362.      * @return Restituisce indicazione se avviare il timer
  5363.      * 
  5364.      */
  5365.     private Boolean isTimerGestoreRiscontriRicevuteAbilitato = null;
  5366.     public boolean isTimerGestoreRiscontriRicevuteAbilitato(){
  5367.         if(this.isTimerGestoreRiscontriRicevuteAbilitato==null){
  5368.             try{  
  5369.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.enable"); 

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

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

  5385.         return this.isTimerGestoreRiscontriRicevuteAbilitato;
  5386.     }
  5387.     
  5388.     /**
  5389.      * Restituisce l'indicazione se registrare su log le queries
  5390.      *
  5391.      * @return Restituisce indicazione se registrare su log le queries
  5392.      * 
  5393.      */
  5394.     private Boolean isTimerGestoreRiscontriRicevuteAbilitatoLog = null;
  5395.     public boolean isTimerGestoreRiscontriRicevuteAbilitatoLog(){
  5396.         if(this.isTimerGestoreRiscontriRicevuteAbilitatoLog==null){
  5397.             try{  
  5398.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.logQuery"); 

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

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

  5414.         return this.isTimerGestoreRiscontriRicevuteAbilitatoLog;
  5415.     }
  5416.     
  5417.     /**
  5418.      * Restituisce l'indicazione sul numero di messaggi alla volta processati
  5419.      *
  5420.      * @return Restituisce indicazione sul numero di messaggi alla volta processati
  5421.      * 
  5422.      */
  5423.     private Integer getTimerGestoreRiscontriRicevuteLimit = null;
  5424.     public int getTimerGestoreRiscontriRicevuteLimit(){
  5425.         if(this.getTimerGestoreRiscontriRicevuteLimit==null){
  5426.             try{  
  5427.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.query.limit"); 

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

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

  5443.         return this.getTimerGestoreRiscontriRicevuteLimit;
  5444.     }
  5445.     
  5446.     private Integer getTimerGestoreRiscontriRicevuteLockMaxLife = null;
  5447.     public int getTimerGestoreRiscontriRicevuteLockMaxLife() {  
  5448.         if(this.getTimerGestoreRiscontriRicevuteLockMaxLife==null){
  5449.             try{ 
  5450.                 String name = null;
  5451.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.maxLife");

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

  5470.         if(this.getTimerGestoreRiscontriRicevuteLockMaxLife!=null) {
  5471.             return this.getTimerGestoreRiscontriRicevuteLockMaxLife.intValue();
  5472.         }
  5473.         return -1;
  5474.     }
  5475.     
  5476.     private Integer getTimerGestoreRiscontriRicevuteLockIdleTime = null;
  5477.     public int getTimerGestoreRiscontriRicevuteLockIdleTime() { 
  5478.         if(this.getTimerGestoreRiscontriRicevuteLockIdleTime==null){
  5479.             try{ 
  5480.                 String name = null;
  5481.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.idleTime");

  5483.                 if(name!=null){
  5484.                     name = name.trim();
  5485.                     this.getTimerGestoreRiscontriRicevuteLockIdleTime = java.lang.Integer.parseInt(name);
  5486.                 }else{
  5487.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  5488.                     this.getTimerGestoreRiscontriRicevuteLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  5489.                 }
  5490.             }catch(java.lang.Exception e) {
  5491.                 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);
  5492.                 this.getTimerGestoreRiscontriRicevuteLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  5493.             } 
  5494.             if(this.getTimerGestoreRiscontriRicevuteLockIdleTime!=null && this.getTimerGestoreRiscontriRicevuteLockIdleTime>0) {
  5495.                 // trasformo in millisecondi l'informazione fornita in secondi
  5496.                 this.getTimerGestoreRiscontriRicevuteLockIdleTime = this.getTimerGestoreRiscontriRicevuteLockIdleTime *1000;
  5497.             }
  5498.         }

  5500.         if(this.getTimerGestoreRiscontriRicevuteLockIdleTime!=null) {
  5501.             return this.getTimerGestoreRiscontriRicevuteLockIdleTime.intValue();
  5502.         }
  5503.         return -1;
  5504.     }
  5505.     
  5506.     private Long getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva = null;
  5507.     public long getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva() { 
  5508.         if(this.getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva==null){
  5509.             String pName = "org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.attesaAttiva";
  5510.             try{ 
  5511.                 String name = null;
  5512.                 name = this.reader.getValueConvertEnvProperties(pName);

  5514.                 if(name!=null){
  5515.                     name = name.trim();
  5516.                     long time = java.lang.Long.parseLong(name);
  5517.                     this.getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva = time*1000;
  5518.                 }else{
  5519.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
  5520.                     this.getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
  5521.                 }

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

  5529.         return this.getTimerGestoreRiscontriRicevuteGetLockAttesaAttiva;
  5530.     }

  5532.     private Integer getTimerGestoreRiscontriRicevuteGetLockCheckInterval = null;
  5533.     public int getTimerGestoreRiscontriRicevuteGetLockCheckInterval() { 
  5534.         if(this.getTimerGestoreRiscontriRicevuteGetLockCheckInterval==null){
  5535.             String pName = "org.openspcoop2.pdd.timer.gestoreBusteNonRiscontrate.lock.check";
  5536.             try{ 
  5537.                 String name = null;
  5538.                 name = this.reader.getValueConvertEnvProperties(pName);

  5540.                 if(name!=null){
  5541.                     name = name.trim();
  5542.                     int time = java.lang.Integer.parseInt(name);
  5543.                     this.getTimerGestoreRiscontriRicevuteGetLockCheckInterval = time;
  5544.                 }else{
  5545.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  5546.                     this.getTimerGestoreRiscontriRicevuteGetLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  5547.                 }
  5548.             }catch(java.lang.Exception e) {
  5549.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  5550.                 this.getTimerGestoreRiscontriRicevuteGetLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  5551.             }  
  5552.         }

  5554.         return this.getTimerGestoreRiscontriRicevuteGetLockCheckInterval;
  5555.     }
  5556.     
  5557.     
  5558.     
  5559.     
  5560.     // GestoreMessaggi
  5561.     
  5562.     /**
  5563.      * Restituisce l'indicazione se avviare il timer
  5564.      *
  5565.      * @return Restituisce indicazione se avviare il timer
  5566.      * 
  5567.      */
  5568.     private Boolean isTimerGestoreMessaggiAbilitato = null;
  5569.     public boolean isTimerGestoreMessaggiAbilitato(){
  5570.         if(this.isTimerGestoreMessaggiAbilitato==null){
  5571.             try{  
  5572.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.enable"); 

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

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

  5588.         return this.isTimerGestoreMessaggiAbilitato;
  5589.     }
  5590.     
  5591.     private Boolean isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata = null;
  5592.     public boolean isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata(){
  5593.         if(this.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata==null){
  5594.             try{  
  5595.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiEliminati.enable"); 

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

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

  5611.         return this.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata;
  5612.     }
  5613.     
  5614.     private Boolean isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata = null;
  5615.     public boolean isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata(){
  5616.         if(this.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata==null){
  5617.             try{  
  5618.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiScaduti.enable"); 

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

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

  5634.         return this.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata;
  5635.     }
  5636.     
  5637.     private Boolean isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata = null;
  5638.     public boolean isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata(){
  5639.         if(this.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata==null){
  5640.             try{  
  5641.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaMessaggiNonGestiti.enable"); 

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

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

  5657.         return this.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata;
  5658.     }
  5659.     
  5660.     private Boolean isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata = null;
  5661.     public boolean isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata(){
  5662.         if(this.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata==null){
  5663.             try{  
  5664.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.puliziaCorrelazioneApplicativa.enable"); 

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

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

  5680.         return this.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata;
  5681.     }
  5682.     
  5683.     /**
  5684.      * Restituisce l'indicazione se usare l'order by nelle queries
  5685.      *
  5686.      * @return Restituisce indicazione se usare l'order by nelle queries
  5687.      * 
  5688.      */
  5689.     private Boolean isTimerGestoreMessaggiAbilitatoOrderBy = null;
  5690.     public boolean isTimerGestoreMessaggiAbilitatoOrderBy(){
  5691.         if(this.isTimerGestoreMessaggiAbilitatoOrderBy==null){
  5692.             try{  
  5693.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.orderBy"); 

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

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

  5709.         return this.isTimerGestoreMessaggiAbilitatoOrderBy;
  5710.     }
  5711.     
  5712.     /**
  5713.      * Restituisce l'indicazione se registrare su log le queries
  5714.      *
  5715.      * @return Restituisce indicazione se registrare su log le queries
  5716.      * 
  5717.      */
  5718.     private Boolean isTimerGestoreMessaggiAbilitatoLog = null;
  5719.     public boolean isTimerGestoreMessaggiAbilitatoLog(){
  5720.         if(this.isTimerGestoreMessaggiAbilitatoLog==null){
  5721.             try{  
  5722.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.logQuery"); 

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

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

  5738.         return this.isTimerGestoreMessaggiAbilitatoLog;
  5739.     }
  5740.     
  5741.     /**
  5742.      * Restituisce l'indicazione sul numero di messaggi alla volta processati
  5743.      *
  5744.      * @return Restituisce indicazione sul numero di messaggi alla volta processati
  5745.      * 
  5746.      */
  5747.     private Integer getTimerGestoreMessaggiLimit = null;
  5748.     public int getTimerGestoreMessaggiLimit(){
  5749.         if(this.getTimerGestoreMessaggiLimit==null){
  5750.             try{  
  5751.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.query.limit"); 

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

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

  5767.         return this.getTimerGestoreMessaggiLimit;
  5768.     }
  5769.     
  5770.     /**
  5771.      * Restituisce l'indicazione se devono essere verificate anche le connessioni rimaste attive
  5772.      *
  5773.      * @return Restituisce indicazione se devono essere verificate anche le connessioni rimaste attive
  5774.      * 
  5775.      */
  5776.     private Boolean isTimerGestoreMessaggiVerificaConnessioniAttive = null;
  5777.     public boolean isTimerGestoreMessaggiVerificaConnessioniAttive(){
  5778.         if(this.isTimerGestoreMessaggiVerificaConnessioniAttive==null){
  5779.             try{  
  5780.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.verificaConnessioniAttive"); 

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

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

  5796.         return this.isTimerGestoreMessaggiVerificaConnessioniAttive;
  5797.     }
  5798.         
  5799.     private Integer getTimerGestoreMessaggiLockMaxLife = null;
  5800.     public int getTimerGestoreMessaggiLockMaxLife() {   
  5801.         if(this.getTimerGestoreMessaggiLockMaxLife==null){
  5802.             try{ 
  5803.                 String name = null;
  5804.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.lock.maxLife");

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

  5823.         if(this.getTimerGestoreMessaggiLockMaxLife!=null) {
  5824.             return this.getTimerGestoreMessaggiLockMaxLife.intValue();
  5825.         }
  5826.         return -1;
  5827.     }
  5828.     
  5829.     private Integer getTimerGestoreMessaggiLockIdleTime = null;
  5830.     public int getTimerGestoreMessaggiLockIdleTime() {  
  5831.         if(this.getTimerGestoreMessaggiLockIdleTime==null){
  5832.             try{ 
  5833.                 String name = null;
  5834.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreMessaggi.lock.idleTime");

  5836.                 if(name!=null){
  5837.                     name = name.trim();
  5838.                     this.getTimerGestoreMessaggiLockIdleTime = java.lang.Integer.parseInt(name);
  5839.                 }else{
  5840.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreMessaggi.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  5841.                     this.getTimerGestoreMessaggiLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  5842.                 }
  5843.             }catch(java.lang.Exception e) {
  5844.                 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);
  5845.                 this.getTimerGestoreMessaggiLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  5846.             }
  5847.             if(this.getTimerGestoreMessaggiLockIdleTime!=null && this.getTimerGestoreMessaggiLockIdleTime>0) {
  5848.                 // trasformo in millisecondi l'informazione fornita in secondi
  5849.                 this.getTimerGestoreMessaggiLockIdleTime = this.getTimerGestoreMessaggiLockIdleTime *1000;
  5850.             }
  5851.         }

  5853.         if(this.getTimerGestoreMessaggiLockIdleTime!=null) {
  5854.             return this.getTimerGestoreMessaggiLockIdleTime.intValue();
  5855.         }
  5856.         return -1;
  5857.     }
  5858.     
  5859.     private Long getTimerGestoreMessaggi_getLockAttesaAttiva = null;
  5860.     public long getTimerGestoreMessaggi_getLockAttesaAttiva() { 
  5861.         if(this.getTimerGestoreMessaggi_getLockAttesaAttiva==null){
  5862.             String pName = "org.openspcoop2.pdd.timer.gestoreMessaggi.lock.attesaAttiva";
  5863.             try{ 
  5864.                 String name = null;
  5865.                 name = this.reader.getValueConvertEnvProperties(pName);

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

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

  5882.         return this.getTimerGestoreMessaggi_getLockAttesaAttiva;
  5883.     }

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

  5893.                 if(name!=null){
  5894.                     name = name.trim();
  5895.                     int time = java.lang.Integer.parseInt(name);
  5896.                     this.getTimerGestoreMessaggi_getLockCheckInterval = time;
  5897.                 }else{
  5898.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  5899.                     this.getTimerGestoreMessaggi_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  5900.                 }
  5901.             }catch(java.lang.Exception e) {
  5902.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  5903.                 this.getTimerGestoreMessaggi_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  5904.             }  
  5905.         }

  5907.         return this.getTimerGestoreMessaggi_getLockCheckInterval;
  5908.     }
  5909.     
  5910.     
  5911.     
  5912.     
  5913.     // GestorePuliziaMessaggiAnomali
  5914.     
  5915.     /**
  5916.      * Restituisce l'indicazione se avviare il timer
  5917.      *
  5918.      * @return Restituisce indicazione se avviare il timer
  5919.      * 
  5920.      */
  5921.     private Boolean isTimerGestorePuliziaMessaggiAnomaliAbilitato = null;
  5922.     public boolean isTimerGestorePuliziaMessaggiAnomaliAbilitato(){
  5923.         if(this.isTimerGestorePuliziaMessaggiAnomaliAbilitato==null){
  5924.             try{  
  5925.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.enable"); 
  5926.                 if(value!=null){
  5927.                     value = value.trim();
  5928.                     this.isTimerGestorePuliziaMessaggiAnomaliAbilitato = Boolean.parseBoolean(value);
  5929.                 }else{
  5930.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.enable' non impostata, viene utilizzato il default=true");
  5931.                     this.isTimerGestorePuliziaMessaggiAnomaliAbilitato = true;
  5932.                 }

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

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

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

  5968.         return this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoOrderBy;
  5969.     }
  5970.     
  5971.     /**
  5972.      * Restituisce l'indicazione se registrare su log le queries
  5973.      *
  5974.      * @return Restituisce indicazione se registrare su log le queries
  5975.      * 
  5976.      */
  5977.     private Boolean isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog = null;
  5978.     public boolean isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog(){
  5979.         if(this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog==null){
  5980.             try{  
  5981.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.logQuery"); 
  5982.                 if(value!=null){
  5983.                     value = value.trim();
  5984.                     this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog = Boolean.parseBoolean(value);
  5985.                 }else{
  5986.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.logQuery' non impostata, viene utilizzato il default=false");
  5987.                     this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog = false;
  5988.                 }

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

  5996.         return this.isTimerGestorePuliziaMessaggiAnomaliAbilitatoLog;
  5997.     }

  5999.     /**
  6000.      * Restituisce l'indicazione sul numero di messaggi alla volta processati
  6001.      *
  6002.      * @return Restituisce indicazione sul numero di messaggi alla volta processati
  6003.      * 
  6004.      */
  6005.     private Integer getTimerGestorePuliziaMessaggiAnomaliLimit = null;
  6006.     public int getTimerGestorePuliziaMessaggiAnomaliLimit(){
  6007.         if(this.getTimerGestorePuliziaMessaggiAnomaliLimit==null){
  6008.             try{  
  6009.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.query.limit"); 

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

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

  6025.         return this.getTimerGestorePuliziaMessaggiAnomaliLimit;
  6026.     }
  6027.     
  6028.     private Integer getTimerGestorePuliziaMessaggiAnomaliLockMaxLife = null;
  6029.     public int getTimerGestorePuliziaMessaggiAnomaliLockMaxLife() { 
  6030.         if(this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife==null){
  6031.             try{ 
  6032.                 String name = null;
  6033.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.maxLife");

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

  6052.         if(this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife!=null) {
  6053.             return this.getTimerGestorePuliziaMessaggiAnomaliLockMaxLife.intValue();
  6054.         }
  6055.         return -1;
  6056.     }
  6057.     
  6058.     private Integer getTimerGestorePuliziaMessaggiAnomaliLockIdleTime = null;
  6059.     public int getTimerGestorePuliziaMessaggiAnomaliLockIdleTime() {    
  6060.         if(this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime==null){
  6061.             try{ 
  6062.                 String name = null;
  6063.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.idleTime");

  6065.                 if(name!=null){
  6066.                     name = name.trim();
  6067.                     this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime = java.lang.Integer.parseInt(name);
  6068.                 }else{
  6069.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  6070.                     this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  6071.                 }
  6072.             }catch(java.lang.Exception e) {
  6073.                 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);
  6074.                 this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  6075.             } 
  6076.             if(this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime!=null && this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime>0) {
  6077.                 // trasformo in millisecondi l'informazione fornita in secondi
  6078.                 this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime = this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime *1000;
  6079.             }
  6080.         }

  6082.         if(this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime!=null) {
  6083.             return this.getTimerGestorePuliziaMessaggiAnomaliLockIdleTime.intValue();
  6084.         }
  6085.         return -1;
  6086.     }
  6087.     
  6088.     private Long getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva = null;
  6089.     public long getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva() {   
  6090.         if(this.getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva==null){
  6091.             String pName = "org.openspcoop2.pdd.timer.gestorePuliziaMessaggiAnomali.lock.attesaAttiva";
  6092.             try{ 
  6093.                 String name = null;
  6094.                 name = this.reader.getValueConvertEnvProperties(pName);

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

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

  6111.         return this.getTimerGestorePuliziaMessaggiAnomali_getLockAttesaAttiva;
  6112.     }

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

  6122.                 if(name!=null){
  6123.                     name = name.trim();
  6124.                     int time = java.lang.Integer.parseInt(name);
  6125.                     this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval = time;
  6126.                 }else{
  6127.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  6128.                     this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  6129.                 }
  6130.             }catch(java.lang.Exception e) {
  6131.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  6132.                 this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  6133.             }  
  6134.         }

  6136.         return this.getTimerGestorePuliziaMessaggiAnomali_getLockCheckInterval;
  6137.     }
  6138.     
  6139.     
  6140.     
  6141.     // GestoreBuste
  6142.     
  6143.     /**
  6144.      * Restituisce l'indicazione se avviare il timer
  6145.      *
  6146.      * @return Restituisce indicazione se avviare il timer
  6147.      * 
  6148.      */
  6149.     private Boolean isTimerGestoreRepositoryBusteAbilitato = null;
  6150.     public boolean isTimerGestoreRepositoryBusteAbilitato(){
  6151.         if(this.isTimerGestoreRepositoryBusteAbilitato==null){
  6152.             try{  
  6153.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.enable"); 

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

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

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

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

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

  6191.         return this.isTimerGestoreRepositoryBusteAbilitatoInitialState;
  6192.     }

  6194.     /**
  6195.      * Restituisce l'indicazione se usare l'order by nelle queries
  6196.      *
  6197.      * @return Restituisce indicazione se usare l'order by nelle queries
  6198.      * 
  6199.      */
  6200.     private Boolean isTimerGestoreRepositoryBusteAbilitatoOrderBy = null;
  6201.     public boolean isTimerGestoreRepositoryBusteAbilitatoOrderBy(){
  6202.         if(this.isTimerGestoreRepositoryBusteAbilitatoOrderBy==null){
  6203.             try{  
  6204.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.orderBy"); 

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

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

  6220.         return this.isTimerGestoreRepositoryBusteAbilitatoOrderBy;
  6221.     }
  6222.     
  6223.     /**
  6224.      * Restituisce l'indicazione se registrare su log le queries
  6225.      *
  6226.      * @return Restituisce indicazione se registrare su log le queries
  6227.      * 
  6228.      */
  6229.     private Boolean isTimerGestoreRepositoryBusteAbilitatoLog = null;
  6230.     public boolean isTimerGestoreRepositoryBusteAbilitatoLog(){
  6231.         if(this.isTimerGestoreRepositoryBusteAbilitatoLog==null){
  6232.             try{  
  6233.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.logQuery"); 

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

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

  6249.         return this.isTimerGestoreRepositoryBusteAbilitatoLog;
  6250.     }
  6251.     
  6252.     /**
  6253.      * Restituisce l'indicazione sul numero di messaggi alla volta processati
  6254.      *
  6255.      * @return Restituisce indicazione sul numero di messaggi alla volta processati
  6256.      * 
  6257.      */
  6258.     private Integer getTimerGestoreRepositoryBusteLimit = null;
  6259.     public int getTimerGestoreRepositoryBusteLimit(){
  6260.         if(this.getTimerGestoreRepositoryBusteLimit==null){
  6261.             try{  
  6262.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.query.limit"); 

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

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

  6278.         return this.getTimerGestoreRepositoryBusteLimit;
  6279.     }
  6280.     
  6281.     private Integer getTimerGestoreRepositoryBusteLockMaxLife = null;
  6282.     public int getTimerGestoreRepositoryBusteLockMaxLife() {    
  6283.         if(this.getTimerGestoreRepositoryBusteLockMaxLife==null){
  6284.             try{ 
  6285.                 String name = null;
  6286.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.maxLife");

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

  6305.         if(this.getTimerGestoreRepositoryBusteLockMaxLife!=null) {
  6306.             return this.getTimerGestoreRepositoryBusteLockMaxLife.intValue();
  6307.         }
  6308.         return -1;
  6309.     }
  6310.     
  6311.     private Integer getTimerGestoreRepositoryBusteLockIdleTime = null;
  6312.     public int getTimerGestoreRepositoryBusteLockIdleTime() {   
  6313.         if(this.getTimerGestoreRepositoryBusteLockIdleTime==null){
  6314.             try{ 
  6315.                 String name = null;
  6316.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.idleTime");

  6318.                 if(name!=null){
  6319.                     name = name.trim();
  6320.                     this.getTimerGestoreRepositoryBusteLockIdleTime = java.lang.Integer.parseInt(name);
  6321.                 }else{
  6322.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.gestoreRepositoryBuste.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  6323.                     this.getTimerGestoreRepositoryBusteLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  6324.                 }
  6325.             }catch(java.lang.Exception e) {
  6326.                 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);
  6327.                 this.getTimerGestoreRepositoryBusteLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  6328.             }
  6329.             if(this.getTimerGestoreRepositoryBusteLockIdleTime!=null && this.getTimerGestoreRepositoryBusteLockIdleTime>0) {
  6330.                 // trasformo in millisecondi l'informazione fornita in secondi
  6331.                 this.getTimerGestoreRepositoryBusteLockIdleTime = this.getTimerGestoreRepositoryBusteLockIdleTime *1000;
  6332.             }
  6333.         }

  6335.         if(this.getTimerGestoreRepositoryBusteLockIdleTime!=null) {
  6336.             return this.getTimerGestoreRepositoryBusteLockIdleTime.intValue();
  6337.         }
  6338.         return -1;
  6339.     }

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

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

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

  6364.         return this.getTimerGestoreRepositoryBuste_getLockAttesaAttiva;
  6365.     }

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

  6375.                 if(name!=null){
  6376.                     name = name.trim();
  6377.                     int time = java.lang.Integer.parseInt(name);
  6378.                     this.getTimerGestoreRepositoryBuste_getLockCheckInterval = time;
  6379.                 }else{
  6380.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  6381.                     this.getTimerGestoreRepositoryBuste_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  6382.                 }
  6383.             }catch(java.lang.Exception e) {
  6384.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  6385.                 this.getTimerGestoreRepositoryBuste_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  6386.             }  
  6387.         }

  6389.         return this.getTimerGestoreRepositoryBuste_getLockCheckInterval;
  6390.     }
  6391.     


  6394.     
  6395.     
  6396.     // Gestore ConsegnaContenutiApplicativi
  6397.     
  6398.     /**
  6399.      * Restituisce l'indicazione se avviare il timer
  6400.      *
  6401.      * @return Restituisce indicazione se avviare il timer
  6402.      * 
  6403.      */
  6404.     private Boolean isTimerConsegnaContenutiApplicativiAbilitato = null;
  6405.     public boolean isTimerConsegnaContenutiApplicativiAbilitato(){
  6406.         
  6407.         if(this.isTimerConsegnaContenutiApplicativiAbilitato==null){
  6408.             if(this.isServerJ2EE()!=null && this.isServerJ2EE().booleanValue()){
  6409.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.enable' disabilitata poiche' il prodotto e' configurato in modalita' server j2ee");
  6410.                 this.isTimerConsegnaContenutiApplicativiAbilitato = false;
  6411.             }
  6412.             else{           
  6413.                 try{  
  6414.                     String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.enable"); 
  6415.                     if(value!=null){
  6416.                         value = value.trim();
  6417.                         this.isTimerConsegnaContenutiApplicativiAbilitato = Boolean.parseBoolean(value);
  6418.                     }else{
  6419.                         this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.enable' non impostata, viene utilizzato il default=true");
  6420.                         this.isTimerConsegnaContenutiApplicativiAbilitato = true;
  6421.                     }
  6422.     
  6423.                 }catch(java.lang.Exception e) {
  6424.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.enable', viene utilizzato il default=true, errore:"+e.getMessage(),e);
  6425.                     this.isTimerConsegnaContenutiApplicativiAbilitato = true;
  6426.                 }
  6427.             }

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

  6460.         }
  6461.         
  6462.         return this.isTimerConsegnaContenutiApplicativiSchedulingDebug;
  6463.     }
  6464.     
  6465.     private Boolean isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = null;
  6466.     public boolean isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica(){
  6467.         
  6468.         String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.scheduling.checkEliminazioneLogica";
  6469.         if(this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica==null){
  6470.             if(this.isServerJ2EE()!=null && this.isServerJ2EE().booleanValue()){
  6471.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' disabilitata poiche' il prodotto e' configurato in modalita' server j2ee");
  6472.                 this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = false;
  6473.             }
  6474.             else{           
  6475.                 try{  
  6476.                     String value = this.reader.getValueConvertEnvProperties(pName); 
  6477.                     if(value!=null){
  6478.                         value = value.trim();
  6479.                         this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = Boolean.parseBoolean(value);
  6480.                     }else{
  6481.                         this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6482.                         this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = true;
  6483.                     }
  6484.     
  6485.                 }catch(java.lang.Exception e) {
  6486.                     this.logWarn("Proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true, errore:"+e.getMessage(),e);
  6487.                     this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica = true;
  6488.                 }
  6489.             }

  6491.         }
  6492.         
  6493.         return this.isTimerConsegnaContenutiApplicativiSchedulingCheckEliminazioneLogica;
  6494.     }
  6495.     
  6496.     private Boolean isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare = null;
  6497.     public boolean isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare(){
  6498.         
  6499.         String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.scheduling.checkPassaggioOraLegaleVersoOraSolare";
  6500.         if(this.isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare==null){      
  6501.             try{  
  6502.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  6503.                 if(value!=null){
  6504.                     value = value.trim();
  6505.                     this.isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare = Boolean.parseBoolean(value);
  6506.                 }else{
  6507.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6508.                     this.isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare = true;
  6509.                 }

  6511.             }catch(java.lang.Exception e) {
  6512.                 this.logWarn("Proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true, errore:"+e.getMessage(),e);
  6513.                 this.isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare = true;
  6514.             }
  6515.         }
  6516.         
  6517.         return this.isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare;
  6518.     }
  6519.     
  6520.     private List<String> getTimerConsegnaContenutiApplicativiCode = null;
  6521.     private boolean getTimerConsegnaContenutiApplicativiCodeRead = false;
  6522.     public List<String> getTimerConsegnaContenutiApplicativiCode() {    
  6523.         if(!this.getTimerConsegnaContenutiApplicativiCodeRead){
  6524.             try{ 

  6526.                 String name = null;
  6527.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.code");
  6528.                 if(name==null){
  6529.                     this.getTimerConsegnaContenutiApplicativiCode = null;
  6530.                 }else{
  6531.                     String [] r = name.trim().split(",");
  6532.                     List<String> l = new ArrayList<>();
  6533.                     for(int i=0; i<r.length; i++){
  6534.                         r[i] = r[i].trim();
  6535.                         l.add(r[i]);
  6536.                     }
  6537.                     
  6538.                     if(!l.isEmpty()) {
  6539.                         this.getTimerConsegnaContenutiApplicativiCode = new ArrayList<>();
  6540.                         this.getTimerConsegnaContenutiApplicativiCode.addAll(l);
  6541.                     }
  6542.                 }
  6543.             }catch(java.lang.Exception e) {
  6544.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.code': "+e.getMessage(),e);
  6545.                 this.getTimerConsegnaContenutiApplicativiCode = null;
  6546.             }  
  6547.             this.getTimerConsegnaContenutiApplicativiCodeRead = true;
  6548.         }

  6550.         return this.getTimerConsegnaContenutiApplicativiCode;
  6551.     }
  6552.     
  6553.     private HashMap<String, ConfigurazioneCoda> getTimerConsegnaContenutiApplicativiConfigurazioneCoda = new HashMap<String, ConfigurazioneCoda>();
  6554.     public ConfigurazioneCoda getTimerConsegnaContenutiApplicativiConfigurazioneCoda(String nome) {
  6555.         
  6556.         ConfigurazioneCoda conf = this.getTimerConsegnaContenutiApplicativiConfigurazioneCoda.get(nome);
  6557.         if(conf!=null) {
  6558.             return conf;
  6559.         }
  6560.         
  6561.         String prefix = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.coda."+nome+".";
  6562.         try{ 
  6563.             Properties p = this.reader.readPropertiesConvertEnvProperties(prefix);
  6564.             if(p==null || p.isEmpty()) {
  6565.                 throw new CoreException("Configurazione non presente");
  6566.             }
  6567.             
  6568.             ConfigurazioneCoda confCoda = new ConfigurazioneCoda(nome, p);
  6569.             this.getTimerConsegnaContenutiApplicativiConfigurazioneCoda.put(nome, confCoda);
  6570.             return confCoda;
  6571.             
  6572.         }catch(java.lang.Exception e) {
  6573.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+prefix+"*': "+e.getMessage(),e);
  6574.             return null;
  6575.         }  

  6577.     }
  6578.     
  6579.     private List<String> getTimerConsegnaContenutiApplicativiPriorita = null;
  6580.     private boolean getTimerConsegnaContenutiApplicativiPrioritaRead = false;
  6581.     public List<String> getTimerConsegnaContenutiApplicativiPriorita() {    
  6582.         if(!this.getTimerConsegnaContenutiApplicativiPrioritaRead){
  6583.             try{ 

  6585.                 String name = null;
  6586.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.priorita");
  6587.                 if(name==null){
  6588.                     this.getTimerConsegnaContenutiApplicativiPriorita = null;
  6589.                 }else{
  6590.                     String [] r = name.trim().split(",");
  6591.                     List<String> l = new ArrayList<>();
  6592.                     for(int i=0; i<r.length; i++){
  6593.                         r[i] = r[i].trim();
  6594.                         l.add(r[i]);
  6595.                     }
  6596.                     
  6597.                     if(!l.isEmpty()) {
  6598.                         this.getTimerConsegnaContenutiApplicativiPriorita = new ArrayList<>();
  6599.                         this.getTimerConsegnaContenutiApplicativiPriorita.addAll(l);
  6600.                     }
  6601.                 }
  6602.             }catch(java.lang.Exception e) {
  6603.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.priorita': "+e.getMessage(),e);
  6604.                 this.getTimerConsegnaContenutiApplicativiPriorita = null;
  6605.             }  
  6606.             this.getTimerConsegnaContenutiApplicativiPrioritaRead = true;
  6607.         }

  6609.         return this.getTimerConsegnaContenutiApplicativiPriorita;
  6610.     }
  6611.     
  6612.     private HashMap<String, ConfigurazionePriorita> getTimerConsegnaContenutiApplicativiConfigurazionePriorita = new HashMap<>();
  6613.     public ConfigurazionePriorita getTimerConsegnaContenutiApplicativiConfigurazionePriorita(String nome) {
  6614.         
  6615.         ConfigurazionePriorita conf = this.getTimerConsegnaContenutiApplicativiConfigurazionePriorita.get(nome);
  6616.         if(conf!=null) {
  6617.             return conf;
  6618.         }
  6619.         
  6620.         String prefix = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.priorita."+nome+".";
  6621.         try{ 
  6622.             Properties p = this.reader.readPropertiesConvertEnvProperties(prefix);
  6623.             if(p==null || p.isEmpty()) {
  6624.                 throw new CoreException("Configurazione non presente");
  6625.             }
  6626.             
  6627.             ConfigurazionePriorita confPriorita = new ConfigurazionePriorita(nome, p);
  6628.             this.getTimerConsegnaContenutiApplicativiConfigurazionePriorita.put(nome, confPriorita);
  6629.             return confPriorita;
  6630.             
  6631.         }catch(java.lang.Exception e) {
  6632.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+prefix+"*': "+e.getMessage(),e);
  6633.             return null;
  6634.         }  

  6636.     }
  6637.     
  6638.     private Boolean isLoadBalancerDebug = null;
  6639.     public boolean isLoadBalancerDebug(){
  6640.         if(this.isLoadBalancerDebug==null){
  6641.             try{  
  6642.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.loadBalancer.debug"); 
  6643.                 if(value!=null){
  6644.                     value = value.trim();
  6645.                     this.isLoadBalancerDebug = Boolean.parseBoolean(value);
  6646.                 }else{
  6647.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.loadBalancer.debug' non impostata, viene utilizzato il default=false");
  6648.                     this.isLoadBalancerDebug = false;
  6649.                 }

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

  6657.         return this.isLoadBalancerDebug;
  6658.     }
  6659.     
  6660.     private Integer getTimerConsegnaContenutiApplicativiLockMaxLife = null;
  6661.     public int getTimerConsegnaContenutiApplicativiLockMaxLife() {  
  6662.         if(this.getTimerConsegnaContenutiApplicativiLockMaxLife==null){
  6663.             try{ 
  6664.                 String name = null;
  6665.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.maxLife");

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

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

  6697.                 if(name!=null){
  6698.                     name = name.trim();
  6699.                     this.getTimerConsegnaContenutiApplicativiLockIdleTime = java.lang.Integer.parseInt(name);
  6700.                 }else{
  6701.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  6702.                     this.getTimerConsegnaContenutiApplicativiLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  6703.                 }
  6704.             }catch(java.lang.Exception e) {
  6705.                 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);
  6706.                 this.getTimerConsegnaContenutiApplicativiLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  6707.             } 
  6708.             if(this.getTimerConsegnaContenutiApplicativiLockIdleTime!=null && this.getTimerConsegnaContenutiApplicativiLockIdleTime>0) {
  6709.                 // trasformo in millisecondi l'informazione fornita in secondi
  6710.                 this.getTimerConsegnaContenutiApplicativiLockIdleTime = this.getTimerConsegnaContenutiApplicativiLockIdleTime *1000;
  6711.             }
  6712.         }

  6714.         if(this.getTimerConsegnaContenutiApplicativiLockIdleTime!=null) {
  6715.             return this.getTimerConsegnaContenutiApplicativiLockIdleTime.intValue();
  6716.         }
  6717.         return -1;
  6718.     }
  6719.     
  6720.     private Integer getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife = null;
  6721.     public int getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife() {   
  6722.         if(this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife==null){
  6723.             try{ 
  6724.                 String name = null;
  6725.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.presaInConsegna.maxLife");

  6727.                 if(name!=null){
  6728.                     name = name.trim();
  6729.                     this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife = java.lang.Integer.parseInt(name);
  6730.                 }else{
  6731.                     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);
  6732.                     this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife = CostantiPdD.TIMER_RICONSEGNA_CONTENUTI_APPLICATIVI_PRESA_IN_CONSEGNA_MAX_LIFE;
  6733.                 }
  6734.             }catch(java.lang.Exception e) {
  6735.                 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);
  6736.                 this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife = CostantiPdD.TIMER_RICONSEGNA_CONTENUTI_APPLICATIVI_PRESA_IN_CONSEGNA_MAX_LIFE;
  6737.             }  
  6738.             if(this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife!=null && this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife>0) {
  6739.                 // trasformo in millisecondi l'informazione fornita in secondi
  6740.                 this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife = this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife *1000;
  6741.             }
  6742.         }

  6744.         if(this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife!=null) {
  6745.             return this.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife.intValue();
  6746.         }
  6747.         return -1;
  6748.     }
  6749.     
  6750.     private Long getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva = null;
  6751.     public long getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva() {    
  6752.         if(this.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva==null){
  6753.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.lock.attesaAttiva";
  6754.             try{ 
  6755.                 String name = null;
  6756.                 name = this.reader.getValueConvertEnvProperties(pName);

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

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

  6773.         return this.getTimerConsegnaContenutiApplicativi_getLockAttesaAttiva;
  6774.     }

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

  6784.                 if(name!=null){
  6785.                     name = name.trim();
  6786.                     int time = java.lang.Integer.parseInt(name);
  6787.                     this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval = time;
  6788.                 }else{
  6789.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  6790.                     this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  6791.                 }
  6792.             }catch(java.lang.Exception e) {
  6793.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  6794.                 this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  6795.             }  
  6796.         }

  6798.         return this.getTimerConsegnaContenutiApplicativi_getLockCheckInterval;
  6799.     }

  6801.     
  6802.     // *** Smistatore ***
  6803.     
  6804.     private Boolean isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager = null;
  6805.     public boolean isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager() { 
  6806.         if(this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager==null){
  6807.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.smistatore.runtime.useRuntimeManager";
  6808.             try{ 
  6809.                 String name = null;
  6810.                 name = this.reader.getValueConvertEnvProperties(pName);
  6811.                 if(name==null){
  6812.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6813.                     name="true";
  6814.                 }
  6815.                 name = name.trim();
  6816.                 this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager = Boolean.parseBoolean(name);
  6817.             } catch(java.lang.Exception e) {
  6818.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  6819.                 this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager = true;
  6820.             }    
  6821.         }

  6823.         return this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager;
  6824.     }
  6825.     
  6826.     private String getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource = null;
  6827.     public String getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource() throws CoreException {   
  6828.         if(this.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource==null){
  6829.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.smistatore.runtime.dataSource";
  6830.             try{ 
  6831.                 String name = null;
  6832.                 name = this.reader.getValueConvertEnvProperties(pName);
  6833.                 if(name==null){
  6834.                     throw new CoreException("Proprieta' non impostata");
  6835.                 }
  6836.                 name = name.trim();
  6837.                 this.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource = name;
  6838.             } catch(java.lang.Exception e) {
  6839.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  6840.                 throw new CoreException(e.getMessage(),e);
  6841.             }    
  6842.         }

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

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

  6881.         return this.isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils;
  6882.     }
  6883.     
  6884.     
  6885.     
  6886.     // *** Consegne, gestione runtime ***
  6887.     
  6888.     private Boolean isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager = null;
  6889.     public boolean isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager() {    
  6890.         if(this.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager==null){
  6891.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.runtime.useRuntimeManager";
  6892.             try{ 
  6893.                 String name = null;
  6894.                 name = this.reader.getValueConvertEnvProperties(pName);
  6895.                 if(name==null){
  6896.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6897.                     name="true";
  6898.                 }
  6899.                 name = name.trim();
  6900.                 this.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager = Boolean.parseBoolean(name);
  6901.             } catch(java.lang.Exception e) {
  6902.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  6903.                 this.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager = true;
  6904.             }    
  6905.         }

  6907.         return this.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager;
  6908.     }
  6909.     
  6910.     private String getTimerConsegnaContenutiApplicativi_runtime_dataSource = null;
  6911.     public String getTimerConsegnaContenutiApplicativi_runtime_dataSource() throws CoreException {  
  6912.         if(this.getTimerConsegnaContenutiApplicativi_runtime_dataSource==null){
  6913.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.runtime.dataSource";
  6914.             try{ 
  6915.                 String name = null;
  6916.                 name = this.reader.getValueConvertEnvProperties(pName);
  6917.                 if(name==null){
  6918.                     throw new CoreException("Proprieta' non impostata");
  6919.                 }
  6920.                 name = name.trim();
  6921.                 this.getTimerConsegnaContenutiApplicativi_runtime_dataSource = name;
  6922.             } catch(java.lang.Exception e) {
  6923.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  6924.                 throw new CoreException(e.getMessage(),e);
  6925.             }    
  6926.         }

  6928.         return this.getTimerConsegnaContenutiApplicativi_runtime_dataSource;
  6929.     }
  6930.     
  6931.     private Properties getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext = null;
  6932.     public Properties getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext() throws CoreException {   
  6933.         if(this.getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext==null){
  6934.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.runtime.dataSource.property.";
  6935.             try{ 
  6936.                 this.getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
  6937.             } catch(java.lang.Exception e) {
  6938.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  6939.                 throw new CoreException(e.getMessage(),e);
  6940.             }    
  6941.         }

  6943.         return this.getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext;
  6944.     }
  6945.     
  6946.     private Boolean isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils = null;
  6947.     public boolean isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils() {    
  6948.         if(this.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils==null){
  6949.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.runtime.datasource.useDSUtils";
  6950.             try{ 
  6951.                 String name = null;
  6952.                 name = this.reader.getValueConvertEnvProperties(pName);
  6953.                 if(name==null){
  6954.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6955.                     name="true";
  6956.                 }
  6957.                 name = name.trim();
  6958.                 this.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils = Boolean.parseBoolean(name);
  6959.             } catch(java.lang.Exception e) {
  6960.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  6961.                 this.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils = true;
  6962.             }    
  6963.         }

  6965.         return this.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils;
  6966.     }
  6967.     
  6968.     
  6969.     // *** Consegne, gestione tracce ***
  6970.     
  6971.     private Boolean isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager = null;
  6972.     public boolean isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager() {    
  6973.         if(this.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager==null){
  6974.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.transazioni.useTransactionManager";
  6975.             try{ 
  6976.                 String name = null;
  6977.                 name = this.reader.getValueConvertEnvProperties(pName);
  6978.                 if(name==null){
  6979.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  6980.                     name="true";
  6981.                 }
  6982.                 name = name.trim();
  6983.                 this.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager = Boolean.parseBoolean(name);
  6984.             } catch(java.lang.Exception e) {
  6985.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  6986.                 this.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager = true;
  6987.             }    
  6988.         }

  6990.         return this.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager;
  6991.     }
  6992.     
  6993.     private String getTimerConsegnaContenutiApplicativi_transazioni_dataSource = null;
  6994.     public String getTimerConsegnaContenutiApplicativi_transazioni_dataSource() throws CoreException {  
  6995.         if(this.getTimerConsegnaContenutiApplicativi_transazioni_dataSource==null){
  6996.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.transazioni.dataSource";
  6997.             try{ 
  6998.                 String name = null;
  6999.                 name = this.reader.getValueConvertEnvProperties(pName);
  7000.                 if(name==null){
  7001.                     throw new CoreException("Proprieta' non impostata");
  7002.                 }
  7003.                 name = name.trim();
  7004.                 this.getTimerConsegnaContenutiApplicativi_transazioni_dataSource = name;
  7005.             } catch(java.lang.Exception e) {
  7006.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  7007.                 throw new CoreException(e.getMessage(),e);
  7008.             }    
  7009.         }

  7011.         return this.getTimerConsegnaContenutiApplicativi_transazioni_dataSource;
  7012.     }
  7013.     
  7014.     private Properties getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext = null;
  7015.     public Properties getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext() throws CoreException {   
  7016.         if(this.getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext==null){
  7017.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.transazioni.dataSource.property.";
  7018.             try{ 
  7019.                 this.getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
  7020.             } catch(java.lang.Exception e) {
  7021.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  7022.                 throw new CoreException(e.getMessage(),e);
  7023.             }    
  7024.         }

  7026.         return this.getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext;
  7027.     }
  7028.     
  7029.     private Boolean isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils = null;
  7030.     public boolean isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils() {    
  7031.         if(this.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils==null){
  7032.             String pName = "org.openspcoop2.pdd.timer.consegnaContenutiApplicativi.transazioni.datasource.useDSUtils";
  7033.             try{ 
  7034.                 String name = null;
  7035.                 name = this.reader.getValueConvertEnvProperties(pName);
  7036.                 if(name==null){
  7037.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7038.                     name="true";
  7039.                 }
  7040.                 name = name.trim();
  7041.                 this.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils = Boolean.parseBoolean(name);
  7042.             } catch(java.lang.Exception e) {
  7043.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  7044.                 this.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils = true;
  7045.             }    
  7046.         }

  7048.         return this.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils;
  7049.     }
  7050.     

  7052.     /* ********  REPOSITORY DI OPENSPCOOP  ******** */

  7054.     /**
  7055.      * Restituisce il tipo di repository utilizzato da OpenSPCoop 
  7056.      *
  7057.      * @return Restituisce il tipo di repository utilizzato da OpenSPCoop 
  7058.      * 
  7059.      */
  7060.     private String repositoryType = null;
  7061.     public String getRepositoryType() { 
  7062.         if(this.repositoryType==null){
  7063.             try{ 
  7064.                 String name = null;
  7065.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.tipo");
  7066.                 if(name==null)
  7067.                     throw new CoreException(NON_DEFINITA);
  7068.                 name = name.trim();
  7069.                 this.repositoryType = name;
  7070.             }catch(java.lang.Exception e) {
  7071.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.tipo': "+e.getMessage(),e);
  7072.                 this.repositoryType = null;
  7073.             }    
  7074.         }

  7076.         return this.repositoryType;
  7077.     }

  7079.     /**
  7080.      * Restituisce il tipo di database utilizzato da OpenSPCoop 
  7081.      *
  7082.      * @return Restituisce il tipo di database utilizzato da OpenSPCoop 
  7083.      * 
  7084.      */
  7085.     private String databaseType = null;
  7086.     public String getDatabaseType() {   
  7087.         if(this.databaseType==null){
  7088.             try{ 
  7089.                 String name = null;
  7090.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.tipoDatabase");
  7091.                 if(name!=null)
  7092.                     name = name.trim();
  7093.                 this.databaseType = name;
  7094.             }catch(java.lang.Exception e) {
  7095.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.tipoDatabase': "+e.getMessage(),e);
  7096.                 this.databaseType = null;
  7097.             }    
  7098.         }

  7100.         return this.databaseType;
  7101.     }

  7103.     /**
  7104.      * Restituisce true se il tipo di repository utilizzato da OpenSPCoop  e' fs
  7105.      *
  7106.      * @return Restituisce true se il tipo di repository utilizzato da OpenSPCoop  e' su file system
  7107.      * 
  7108.      */
  7109.     private Boolean isRepositoryOnFS_value = null;
  7110.     public boolean isRepositoryOnFS() { 

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

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

  7119.                 if(name!=null){
  7120.                     name = name.trim();
  7121.                     if(CostantiConfigurazione.REPOSITORY_DB.equals(name)){
  7122.                         this.isRepositoryOnFS_value = false;
  7123.                     }else{
  7124.                         this.isRepositoryOnFS_value = true;
  7125.                     }
  7126.                 }else{
  7127.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.tipo' non impostata, viene utilizzato il default=true");
  7128.                     this.isRepositoryOnFS_value = true;
  7129.                 }

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

  7137.         return this.isRepositoryOnFS_value;
  7138.     }

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

  7162.         return this.repositoryDirectory;
  7163.     }

  7165.     /**
  7166.      * Restituisce il JDBC Adapter utilizzato da OpenSPCoop 
  7167.      *
  7168.      * @return Restituisce il JDBC Adapter utilizzato da OpenSPCoop.
  7169.      * 
  7170.      */
  7171.     private String repositoryJDBCAdapter = null;
  7172.     public String getRepositoryJDBCAdapter() {  
  7173.         if(this.repositoryJDBCAdapter==null){
  7174.             try{ 
  7175.                 String name = null;
  7176.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.jdbcAdapter");
  7177.                 if(name==null)
  7178.                     throw new CoreException(NON_DEFINITA);
  7179.                 name = name.trim();
  7180.                 this.repositoryJDBCAdapter = name;
  7181.             }catch(java.lang.Exception e) {
  7182.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.jdbcAdapter': "+e.getMessage(),e);
  7183.                 this.repositoryJDBCAdapter = null;
  7184.             }    
  7185.         }

  7187.         return this.repositoryJDBCAdapter;
  7188.     }


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

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

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

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

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

  7215.         return this.forceIndex;
  7216.     }
  7217.     
  7218.     

  7220.     private AttachmentsProcessingMode attachmentsProcessingMode = null;
  7221.     public AttachmentsProcessingMode getAttachmentsProcessingMode() {   
  7222.         if(this.attachmentsProcessingMode==null){
  7223.             if(this.isFileCacheEnable()){
  7224.                 try{ 
  7225.                     this.attachmentsProcessingMode=AttachmentsProcessingMode.getFileCacheProcessingMode(getAttachmentRepoDir(), getFileThreshold());
  7226.                 } catch(java.lang.Exception e) {
  7227.                     this.logError("Riscontrato errore durante l'identificazione della modalità di processing degli attachments: "+e.getMessage(),e);
  7228.                     this.attachmentsProcessingMode=AttachmentsProcessingMode.getMemoryCacheProcessingMode();
  7229.                 } 
  7230.             }else{
  7231.                 this.attachmentsProcessingMode=AttachmentsProcessingMode.getMemoryCacheProcessingMode();
  7232.             }
  7233.         }

  7235.         return this.attachmentsProcessingMode;
  7236.     }

  7238.     private Boolean isFileCacheEnable = null;
  7239.     private boolean isFileCacheEnable() {   
  7240.         if(this.isFileCacheEnable==null){
  7241.             try{ 
  7242.                 String name = null;
  7243.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.attachment.fileCacheEnable");
  7244.                 if(name==null){
  7245.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.fileCacheEnable' non impostata, viene utilizzato il default=false");
  7246.                     name="false";
  7247.                 }
  7248.                 name = name.trim();
  7249.                 this.isFileCacheEnable = Boolean.parseBoolean(name);
  7250.             } catch(java.lang.Exception e) {
  7251.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.attachment.fileCacheEnable': "+e.getMessage(),e);
  7252.                 this.isFileCacheEnable = false;
  7253.             }    
  7254.         }

  7256.         return this.isFileCacheEnable;
  7257.     }


  7260.     private String attachmentRepoDir = null;
  7261.     private String getAttachmentRepoDir() { 

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

  7268.                 if(name!=null){
  7269.                     name = name.trim();
  7270.                     this.attachmentRepoDir = name;
  7271.                 }else{
  7272.                     // Se fileCacheEnable == false allora puo' essere null; 
  7273.                     if(!isFileCacheEnable())
  7274.                         return null;
  7275.                     throw new CoreException(NON_DEFINITA);
  7276.                 }

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

  7284.         return this.attachmentRepoDir;
  7285.     }
  7286.     
  7287.     private String fileThreshold = null;
  7288.     private String getFileThreshold() { 

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

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

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

  7309.         return this.fileThreshold;
  7310.     }
  7311.     
  7312.     private String filePrefix = null;
  7313.     public String getFilePrefix() { 

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

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

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

  7334.         return this.filePrefix;
  7335.     }
  7336.     
  7337.     private String fileSuffix = null;
  7338.     public String getFileSuffix() { 

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

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

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

  7359.         return this.fileSuffix;
  7360.     }
  7361.     
  7362.     private int deleteInterval = 0;
  7363.     public int getDeleteInterval() {    

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

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

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

  7384.         return this.deleteInterval;
  7385.     }

  7387.     /**
  7388.      * Restituisce l'intervallo di pulizia del repository di OpenSPCoop 
  7389.      *
  7390.      * @return Restituisce l'intervallo di pulizia del repository di OpenSPCoo
  7391.      * 
  7392.      */
  7393.     private Long repositoryIntervalloEliminazioneMessaggi = null;
  7394.     public long getRepositoryIntervalloEliminazioneMessaggi() { 
  7395.         if(this.repositoryIntervalloEliminazioneMessaggi==null){
  7396.             try{ 
  7397.                 String name = null;
  7398.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.timer");
  7399.                 if(name==null)
  7400.                     throw new CoreException(NON_DEFINITA);
  7401.                 name = name.trim();
  7402.                 this.repositoryIntervalloEliminazioneMessaggi = java.lang.Long.parseLong(name);
  7403.             }catch(java.lang.Exception e) {
  7404.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.timer': "+e.getMessage(),e);
  7405.                 this.repositoryIntervalloEliminazioneMessaggi = -1L;
  7406.             }   
  7407.         }

  7409.         return this.repositoryIntervalloEliminazioneMessaggi;
  7410.     }

  7412.     /**
  7413.      * Restituisce l'intervallo di tempo che definisce un msg scaduto nel repository di OpenSPCoop 
  7414.      *
  7415.      * @return Restituisce l'intervallo di tempo che definisce un msg scaduto nel repository di OpenSPCoo
  7416.      * 
  7417.      */
  7418.     private Long repositoryIntervalloScadenzaMessaggi = null;
  7419.     public long getRepositoryIntervalloScadenzaMessaggi() { 
  7420.         if(this.repositoryIntervalloScadenzaMessaggi == null){
  7421.             try{ 
  7422.                 String name = null;
  7423.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaMessaggio");
  7424.                 if(name==null)
  7425.                     throw new CoreException(NON_DEFINITA);
  7426.                 name = name.trim();
  7427.                 this.repositoryIntervalloScadenzaMessaggi = java.lang.Long.parseLong(name);
  7428.             }catch(java.lang.Exception e) {
  7429.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaMessaggio': "+e.getMessage(),e);
  7430.                 this.repositoryIntervalloScadenzaMessaggi = -1L;
  7431.             }    
  7432.         }

  7434.         return this.repositoryIntervalloScadenzaMessaggi;
  7435.     }
  7436.     
  7437.     private Boolean useSoapMessageReader = null;
  7438.     public boolean useSoapMessageReader() { 
  7439.         if(this.useSoapMessageReader==null){
  7440.             String pName = "org.openspcoop2.pdd.soapMessage.reader";
  7441.             try{ 
  7442.                 String name = null;
  7443.                 name = this.reader.getValueConvertEnvProperties(pName);
  7444.                 if(name==null){
  7445.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7446.                     name="true";
  7447.                 }
  7448.                 name = name.trim();
  7449.                 this.useSoapMessageReader = Boolean.parseBoolean(name);
  7450.             } catch(java.lang.Exception e) {
  7451.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  7452.                 this.useSoapMessageReader = true;
  7453.             }    
  7454.         }

  7456.         return this.useSoapMessageReader;
  7457.     }
  7458.     
  7459.     private Integer soapMessageReaderBufferThresholdKb = null;
  7460.     public int getSoapMessageReaderBufferThresholdKb() {    

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

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

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

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

  7503.         return this.useSoapMessageReaderHeaderOptimization;
  7504.     }
  7505.     
  7506.     private Boolean useSoapMessagePassthrough = null;
  7507.     public boolean useSoapMessagePassthrough() {    
  7508.         if(this.useSoapMessagePassthrough==null){
  7509.             String pName = "org.openspcoop2.pdd.soapMessage.passthrough";
  7510.             try{ 
  7511.                 String name = null;
  7512.                 name = this.reader.getValueConvertEnvProperties(pName);
  7513.                 if(name==null){
  7514.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7515.                     name="true";
  7516.                 }
  7517.                 name = name.trim();
  7518.                 this.useSoapMessagePassthrough = Boolean.parseBoolean(name);
  7519.             } catch(java.lang.Exception e) {
  7520.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  7521.                 this.useSoapMessagePassthrough = true;
  7522.             }    
  7523.         }

  7525.         return this.useSoapMessagePassthrough;
  7526.     }
  7527.     
  7528.     private Integer soapMessageSaajSaxParserPoolSize = null;
  7529.     public int getSoapMessageSaajSaxParserPoolSize() {  

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

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

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

  7550.         return this.soapMessageSaajSaxParserPoolSize;
  7551.     }
  7552.     
  7553.     private List<String> alternativeContentTypeSoap12 = null;
  7554.     private boolean alternativeContentTypeSoap12Read = false;
  7555.     public List<String> getAlternativeContentTypeSoap12() { 
  7556.         if(!this.alternativeContentTypeSoap12Read){
  7557.             String pName = "org.openspcoop2.pdd.soapMessage.v12.alternativeContentTypes";
  7558.             try{ 
  7559.                 String name = null;
  7560.                 name = this.reader.getValueConvertEnvProperties(pName);
  7561.                 if(name==null){
  7562.                     this.alternativeContentTypeSoap12 = null;
  7563.                 }else{
  7564.                     String [] r = name.trim().split(",");
  7565.                     List<String> l = new ArrayList<>();
  7566.                     for(int i=0; i<r.length; i++){
  7567.                         r[i] = r[i].trim();
  7568.                         l.add(r[i]);
  7569.                     }
  7570.                     
  7571.                     if(!l.isEmpty()) {
  7572.                         this.alternativeContentTypeSoap12 = new ArrayList<>();
  7573.                         this.alternativeContentTypeSoap12.addAll(l);
  7574.                     }
  7575.                 }
  7576.             }catch(java.lang.Exception e) {
  7577.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+": "+e.getMessage(),e);
  7578.                 this.alternativeContentTypeSoap12 = null;
  7579.             }  
  7580.             this.alternativeContentTypeSoap12Read = true;
  7581.         }

  7583.         return this.alternativeContentTypeSoap12;
  7584.     }
  7585.     
  7586.     
  7587.     private Boolean useRestMultipartLazy = null;
  7588.     public boolean useRestMultipartLazy() { 
  7589.         if(this.useRestMultipartLazy==null){
  7590.             String pName = "org.openspcoop2.pdd.restMessage.multipart.lazy";
  7591.             try{ 
  7592.                 String name = null;
  7593.                 name = this.reader.getValueConvertEnvProperties(pName);
  7594.                 if(name==null){
  7595.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7596.                     name="true";
  7597.                 }
  7598.                 name = name.trim();
  7599.                 this.useRestMultipartLazy = Boolean.parseBoolean(name);
  7600.             } catch(java.lang.Exception e) {
  7601.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  7602.                 this.useRestMultipartLazy = true;
  7603.             }    
  7604.         }

  7606.         return this.useRestMultipartLazy;
  7607.     }
  7608.     
  7609.     
  7610.     
  7611.     /**
  7612.      * Restituisce L'indicazione se filtrare le buste rispetto alla scadenza della busta
  7613.      *
  7614.      * @return indicazione se filtrare le buste rispetto alla scadenza della busta
  7615.      * 
  7616.      */
  7617.     private Boolean repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione = null;
  7618.     public boolean isRepositoryBusteFiltraBusteScaduteRispettoOraRegistrazione() {  
  7619.         if(this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione==null){
  7620.             try{ 
  7621.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaMessaggio.filtraBusteScaduteRispettoOraRegistrazione");
  7622.                 if(value==null){
  7623.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaMessaggio.filtraBusteScaduteRispettoOraRegistrazione' non definita (Viene utilizzato il default:true)");
  7624.                     this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione = true;
  7625.                 }else{
  7626.                     this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione = Boolean.parseBoolean(value);
  7627.                 }
  7628.             }catch(java.lang.Exception e) {
  7629.                 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);
  7630.                 this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione = true;
  7631.             }    
  7632.         }

  7634.         return this.repositoryBusteFiltraBusteScaduteRispettoOraRegistrazione;
  7635.     }

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

  7805.     
  7806.     private Boolean isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione = null;
  7807.     public boolean isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione() {    
  7808.         
  7809.         if(this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione==null){
  7810.             try{ 
  7811.                 String name = null;
  7812.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione");
  7813.                 
  7814.                 if(name!=null){
  7815.                     name = name.trim();
  7816.                     this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione = Boolean.parseBoolean(name);
  7817.                 }else{
  7818.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione' non impostata, viene utilizzato il default=true");
  7819.                     this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione = true;
  7820.                 }
  7821.     
  7822.             }catch(java.lang.Exception e) {
  7823.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  7824.                 this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione = true;
  7825.             }    
  7826.         }
  7827.         
  7828.         return this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazione;
  7829.     }
  7830.     
  7831.     private Boolean isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata = null;
  7832.     public boolean isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata() { 
  7833.         
  7834.         if(this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata==null){
  7835.             try{ 
  7836.                 String name = null;
  7837.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione.soloCorrelazioniSenzaScadenza");
  7838.                 
  7839.                 if(name!=null){
  7840.                     name = name.trim();
  7841.                     this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata = Boolean.parseBoolean(name);
  7842.                 }else{
  7843.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione.soloCorrelazioniSenzaScadenza' non impostata, viene utilizzato il default=false");
  7844.                     this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata = false;
  7845.                 }
  7846.     
  7847.             }catch(java.lang.Exception e) {
  7848.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.scadenzaCorrelazioneApplicativa.filtraCorrelazioniScaduteRispettoOraRegistrazione.soloCorrelazioniSenzaScadenza' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  7849.                 this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata = false;
  7850.             }    
  7851.         }
  7852.         
  7853.         return this.isRepositoryScadenzaCorrelazioneApplicativaFiltraRispettoOraRegistrazioneEscludiConScadenzaImpostata;
  7854.     }
  7855.     

  7857.     private Boolean isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore = null;
  7858.     public boolean isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore() {  
  7859.         
  7860.         String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.richiesta.identificativoEstrattoIsNull.consideraErrore";
  7861.         if(this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore==null){
  7862.             try{ 
  7863.                 String name = null;
  7864.                 name = this.reader.getValueConvertEnvProperties(pName);
  7865.                 
  7866.                 if(name!=null){
  7867.                     name = name.trim();
  7868.                     this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore = Boolean.parseBoolean(name);
  7869.                 }else{
  7870.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7871.                     this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore = true;
  7872.                 }
  7873.     
  7874.             }catch(java.lang.Exception e) {
  7875.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true));
  7876.                 this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore = true;
  7877.             }    
  7878.         }
  7879.         
  7880.         return this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsNullConsideraErrore;
  7881.     }
  7882.     
  7883.     private Boolean isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore = null;
  7884.     public boolean isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore() {   
  7885.         
  7886.         String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.risposta.identificativoEstrattoIsNull.consideraErrore";
  7887.         if(this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore==null){
  7888.             try{ 
  7889.                 String name = null;
  7890.                 name = this.reader.getValueConvertEnvProperties(pName);
  7891.                 
  7892.                 if(name!=null){
  7893.                     name = name.trim();
  7894.                     this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore = Boolean.parseBoolean(name);
  7895.                 }else{
  7896.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7897.                     this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore = true;
  7898.                 }
  7899.     
  7900.             }catch(java.lang.Exception e) {
  7901.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true));
  7902.                 this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore = true;
  7903.             }    
  7904.         }
  7905.         
  7906.         return this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsNullConsideraErrore;
  7907.     }
  7908.     
  7909.     private Boolean isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore = null;
  7910.     public boolean isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore() { 
  7911.         
  7912.         String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.richiesta.identificativoEstrattoIsEmpty.consideraErrore";
  7913.         if(this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore==null){
  7914.             try{ 
  7915.                 String name = null;
  7916.                 name = this.reader.getValueConvertEnvProperties(pName);
  7917.                 
  7918.                 if(name!=null){
  7919.                     name = name.trim();
  7920.                     this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore = Boolean.parseBoolean(name);
  7921.                 }else{
  7922.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7923.                     this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore = true;
  7924.                 }
  7925.     
  7926.             }catch(java.lang.Exception e) {
  7927.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true));
  7928.                 this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore = true;
  7929.             }    
  7930.         }
  7931.         
  7932.         return this.isRepositoryCorrelazioneApplicativaRichiestaIdentificativoEstrattoIsEmptyConsideraErrore;
  7933.     }
  7934.     
  7935.     private Boolean isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore = null;
  7936.     public boolean isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore() {  
  7937.         
  7938.         String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.risposta.identificativoEstrattoIsEmpty.consideraErrore";
  7939.         if(this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore==null){
  7940.             try{ 
  7941.                 String name = null;
  7942.                 name = this.reader.getValueConvertEnvProperties(pName);
  7943.                 
  7944.                 if(name!=null){
  7945.                     name = name.trim();
  7946.                     this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore = Boolean.parseBoolean(name);
  7947.                 }else{
  7948.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  7949.                     this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore = true;
  7950.                 }
  7951.     
  7952.             }catch(java.lang.Exception e) {
  7953.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true));
  7954.                 this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore = true;
  7955.             }    
  7956.         }
  7957.         
  7958.         return this.isRepositoryCorrelazioneApplicativaRispostaIdentificativoEstrattoIsEmptyConsideraErrore;
  7959.     }
  7960.     
  7961.     
  7962.     private Boolean isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca = null;
  7963.     public boolean isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca() {   
  7964.         
  7965.         String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.richiesta.regolaCorrelazioneNonTrovata.blocca";
  7966.         if(this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca==null){
  7967.             try{ 
  7968.                 String name = null;
  7969.                 name = this.reader.getValueConvertEnvProperties(pName);
  7970.                 
  7971.                 if(name!=null){
  7972.                     name = name.trim();
  7973.                     this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca = Boolean.parseBoolean(name);
  7974.                 }else{
  7975.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  7976.                     this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca = false;
  7977.                 }
  7978.     
  7979.             }catch(java.lang.Exception e) {
  7980.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false));
  7981.                 this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca = false;
  7982.             }    
  7983.         }
  7984.         
  7985.         return this.isRepositoryCorrelazioneApplicativaRichiestaRegolaCorrelazioneNonTrovataBlocca;
  7986.     }
  7987.     
  7988.     private Boolean isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca = null;
  7989.     public boolean isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca() {    
  7990.         
  7991.         String pName = "org.openspcoop2.pdd.repository.correlazioneApplicativa.risposta.regolaCorrelazioneNonTrovata.blocca";
  7992.         if(this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca==null){
  7993.             try{ 
  7994.                 String name = null;
  7995.                 name = this.reader.getValueConvertEnvProperties(pName);
  7996.                 
  7997.                 if(name!=null){
  7998.                     name = name.trim();
  7999.                     this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca = Boolean.parseBoolean(name);
  8000.                 }else{
  8001.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  8002.                     this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca = false;
  8003.                 }
  8004.     
  8005.             }catch(java.lang.Exception e) {
  8006.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false));
  8007.                 this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca = false;
  8008.             }    
  8009.         }
  8010.         
  8011.         return this.isRepositoryCorrelazioneApplicativaRispostaRegolaCorrelazioneNonTrovataBlocca;
  8012.     }
  8013.     

  8015.     /**
  8016.      * Restituisce l'intervallo in millisecondi di attesa attiva per messaggi gia in processamento
  8017.      * 
  8018.      * @return Restituisce l'intervallo in millisecondi di attesa attiva per messaggi gia in processamento
  8019.      *  * 
  8020.      */
  8021.     private Long msgGiaInProcessamentoAttesaAttiva = null;
  8022.     public long getMsgGiaInProcessamentoAttesaAttiva() {    
  8023.         if(this.msgGiaInProcessamentoAttesaAttiva==null){
  8024.             try{ 
  8025.                 String name = null;
  8026.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.messaggioInProcessamento.attesaAttiva");

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

  8037.             }catch(java.lang.Exception e) {
  8038.                 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);
  8039.                 this.msgGiaInProcessamentoAttesaAttiva = CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_ATTESA_ATTIVA;
  8040.             }    
  8041.         }

  8043.         return this.msgGiaInProcessamentoAttesaAttiva;
  8044.     }

  8046.     /**
  8047.      * Restituisce l'intervallo maggiore per frequenza di check nell'attesa attiva effettuata dal TransactionManager, in millisecondi
  8048.      * 
  8049.      * @return Restituisce Intervallo maggiore per frequenza di check nell'attesa attiva effettuata dal TransactionManager, in millisecondi
  8050.      * 
  8051.      */
  8052.     private Integer msgGiaInProcessamentoCheckInterval = null;
  8053.     public int getMsgGiaInProcessamentoCheckInterval() {    
  8054.         String pName = "org.openspcoop2.pdd.repository.messaggioInProcessamento.check";
  8055.         if(this.msgGiaInProcessamentoCheckInterval==null){
  8056.             try{ 
  8057.                 String name = null;
  8058.                 name = this.reader.getValueConvertEnvProperties(pName);

  8060.                 if(name!=null){
  8061.                     name = name.trim();
  8062.                     int time = java.lang.Integer.parseInt(name);
  8063.                     this.msgGiaInProcessamentoCheckInterval = time;
  8064.                 }else{
  8065.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_CHECK_INTERVAL);
  8066.                     this.msgGiaInProcessamentoCheckInterval = CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_CHECK_INTERVAL;
  8067.                 }
  8068.             }catch(java.lang.Exception e) {
  8069.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  8070.                 this.msgGiaInProcessamentoCheckInterval = CostantiPdD.MSG_GIA_IN_PROCESSAMENTO_CHECK_INTERVAL;
  8071.             }  
  8072.         }

  8074.         return this.msgGiaInProcessamentoCheckInterval;
  8075.     }
  8076.     
  8077.     private Boolean msgGiaInProcessamentoUseLock = null;
  8078.     public boolean isMsgGiaInProcessamentoUseLock() {   
  8079.         if(this.msgGiaInProcessamentoUseLock==null){
  8080.             String pName = "org.openspcoop2.pdd.repository.messaggioInProcessamento.useLock";
  8081.             try{ 
  8082.                 String name = null;
  8083.                 name = this.reader.getValueConvertEnvProperties(pName);

  8085.                 if(name!=null){
  8086.                     name = name.trim();
  8087.                     this.msgGiaInProcessamentoUseLock = Boolean.valueOf(name);
  8088.                 }else{
  8089.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+false);
  8090.                     this.msgGiaInProcessamentoUseLock = false;
  8091.                 }
  8092.             }catch(java.lang.Exception e) {
  8093.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+false+", errore:"+e.getMessage(),e);
  8094.                 this.msgGiaInProcessamentoUseLock = false;
  8095.             }  
  8096.         }

  8098.         return this.msgGiaInProcessamentoUseLock;
  8099.     }

  8101.     /**
  8102.      * Restituisce l'IThreshold utilizzato da OpenSPCoop 
  8103.      *
  8104.      * @return Restituisce l'IThreshold utilizzato da OpenSPCoop.
  8105.      * 
  8106.      */
  8107.     private List<String> repositoryThresholdTypes = null;
  8108.     private boolean repositoryThresholdTypesRead = false;
  8109.     public List<String> getRepositoryThresholdTypes() { 
  8110.         if(!this.repositoryThresholdTypesRead){
  8111.             try{ 
  8112.                 String name = null;
  8113.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.threshold.tipi");
  8114.                 if(name==null){
  8115.                     this.repositoryThresholdTypes = null;
  8116.                 }else{
  8117.                     String [] r = name.trim().split(",");
  8118.                     List<String> l = new ArrayList<>();
  8119.                     for(int i=0; i<r.length; i++){
  8120.                         r[i] = r[i].trim();
  8121.                         l.add(r[i]);
  8122.                     }
  8123.                     
  8124.                     if(!l.isEmpty()) {
  8125.                         this.repositoryThresholdTypes = new ArrayList<>();
  8126.                         this.repositoryThresholdTypes.addAll(l);
  8127.                     }
  8128.                 }
  8129.             }catch(java.lang.Exception e) {
  8130.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.threshold.tipi': "+e.getMessage(),e);
  8131.                 this.repositoryThresholdTypes = null;
  8132.             }  
  8133.             this.repositoryThresholdTypesRead = true;
  8134.         }

  8136.         return this.repositoryThresholdTypes;
  8137.     }
  8138.     /**
  8139.      * Restituisce la soglia utilizzata dall'IThreshold utilizzato da OpenSPCoop 
  8140.      *
  8141.      * @return Restituisce la soglia utilizzata dall'IThreshold utilizzato da OpenSPCoop.
  8142.      * 
  8143.      */
  8144.     private Properties repositoryThresholdParameters = null;
  8145.     private boolean repositoryThresholdParametersRead = false;
  8146.     public Properties getRepositoryThresholdParameters(String tipoThreshould) { 
  8147.         if(!this.repositoryThresholdParametersRead){
  8148.             try{ 
  8149.                 this.repositoryThresholdParameters = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.repository.threshold."+tipoThreshould+".");
  8150.             }catch(java.lang.Exception e) {
  8151.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.threshold."+tipoThreshould+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  8152.                 this.repositoryThresholdParameters = null;
  8153.             }  
  8154.             this.repositoryThresholdParametersRead = true; 
  8155.         }

  8157.         return this.repositoryThresholdParameters;
  8158.     }

  8160.     /**
  8161.      * Restituisce l'intervallo per il timer di Threshold
  8162.      *
  8163.      * @return Restituisce l'intervallo per il timer di Threshold
  8164.      * 
  8165.      */
  8166.     private Long repositoryThresholdCheckInterval = null;
  8167.     public long getRepositoryThresholdCheckInterval() { 
  8168.         if(this.repositoryThresholdCheckInterval == null){
  8169.             try{ 
  8170.                 String name = null;
  8171.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.threshold.checkInterval");
  8172.                 if(name!=null){
  8173.                     name = name.trim();
  8174.                     this.repositoryThresholdCheckInterval = java.lang.Long.parseLong(name);
  8175.                 }else{
  8176.                     this.repositoryThresholdCheckInterval = 0L;
  8177.                 }
  8178.             }catch(java.lang.Exception e) {
  8179.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.threshold.checkInterval': "+e.getMessage(),e);
  8180.                 this.repositoryThresholdCheckInterval = -1L;
  8181.             }    
  8182.         }

  8184.         return this.repositoryThresholdCheckInterval;
  8185.     }

  8187.     /**
  8188.      * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione xml
  8189.      *   
  8190.      * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione xml
  8191.      * 
  8192.      */
  8193.     private Boolean isValidazioneSemanticaConfigurazioneStartupXML = null;
  8194.     public boolean isValidazioneSemanticaConfigurazioneStartupXML(){

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

  8200.                 if (value != null){
  8201.                     value = value.trim();
  8202.                     if(CostantiConfigurazione.ABILITATO.equals(value)){
  8203.                         this.isValidazioneSemanticaConfigurazioneStartupXML = true;
  8204.                     }else if(CostantiConfigurazione.DISABILITATO.equals(value)){
  8205.                         this.isValidazioneSemanticaConfigurazioneStartupXML = false;
  8206.                     }
  8207.                     else{
  8208.                         throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
  8209.                     }
  8210.                 }else{
  8211.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.config.xml.validazioneSemantica' non impostata, viene utilizzato il default=true");
  8212.                     this.isValidazioneSemanticaConfigurazioneStartupXML = true;
  8213.                 }

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

  8221.         return this.isValidazioneSemanticaConfigurazioneStartupXML;
  8222.     }
  8223.     /**
  8224.      * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione
  8225.      *   
  8226.      * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione
  8227.      * 
  8228.      */
  8229.     private Boolean isValidazioneSemanticaConfigurazioneStartup = null;
  8230.     public boolean isValidazioneSemanticaConfigurazioneStartup(){

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

  8236.                 if (value != null){
  8237.                     value = value.trim();
  8238.                     if(CostantiConfigurazione.ABILITATO.equals(value)){
  8239.                         this.isValidazioneSemanticaConfigurazioneStartup = true;
  8240.                     }else if(CostantiConfigurazione.DISABILITATO.equals(value)){
  8241.                         this.isValidazioneSemanticaConfigurazioneStartup = false;
  8242.                     }
  8243.                     else{
  8244.                         throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
  8245.                     }
  8246.                 }else{
  8247.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.config.validazioneSemantica' non impostata, viene utilizzato il default=false");
  8248.                     this.isValidazioneSemanticaConfigurazioneStartup = false;
  8249.                 }

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

  8257.         return this.isValidazioneSemanticaConfigurazioneStartup;
  8258.     }
  8259.     /**
  8260.      * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della registro servizi xml
  8261.      *   
  8262.      * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della registro servizi xml
  8263.      * 
  8264.      */
  8265.     private Boolean isValidazioneSemanticaRegistroServiziStartupXML = null;
  8266.     public boolean isValidazioneSemanticaRegistroServiziStartupXML(){

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

  8272.                 if (value != null){
  8273.                     value = value.trim();
  8274.                     if(CostantiConfigurazione.ABILITATO.equals(value)){
  8275.                         this.isValidazioneSemanticaRegistroServiziStartupXML = true;
  8276.                     }else if(CostantiConfigurazione.DISABILITATO.equals(value)){
  8277.                         this.isValidazioneSemanticaRegistroServiziStartupXML = false;
  8278.                     }
  8279.                     else{
  8280.                         throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
  8281.                     }
  8282.                 }else{
  8283.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.registri.xml.validazioneSemantica' non impostata, viene utilizzato il default=true");
  8284.                     this.isValidazioneSemanticaRegistroServiziStartupXML = true;
  8285.                 }

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

  8293.         return this.isValidazioneSemanticaRegistroServiziStartupXML;
  8294.     }
  8295.     /**
  8296.      * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della registro servizi
  8297.      *   
  8298.      * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della registro servizi
  8299.      * 
  8300.      */
  8301.     private Boolean isValidazioneSemanticaRegistroServiziStartup = null;
  8302.     public boolean isValidazioneSemanticaRegistroServiziStartup(){

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

  8308.                 if (value != null){
  8309.                     value = value.trim();
  8310.                     if(CostantiConfigurazione.ABILITATO.equals(value)){
  8311.                         this.isValidazioneSemanticaRegistroServiziStartup = true;
  8312.                     }else if(CostantiConfigurazione.DISABILITATO.equals(value)){
  8313.                         this.isValidazioneSemanticaRegistroServiziStartup = false;
  8314.                     }
  8315.                     else{
  8316.                         throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
  8317.                     }
  8318.                 }else{
  8319.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.registri.validazioneSemantica' non impostata, viene utilizzato il default=false");
  8320.                     this.isValidazioneSemanticaRegistroServiziStartup = false;
  8321.                 }

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

  8329.         return this.isValidazioneSemanticaRegistroServiziStartup;
  8330.     }
  8331.     /**
  8332.      * Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione
  8333.      *   
  8334.      * @return Indicazione se la porta di dominio deve attuare allo startup la validazione semantica della configurazione
  8335.      * 
  8336.      */
  8337.     private Boolean isValidazioneSemanticaRegistroServiziCheckURI = null;
  8338.     public boolean isValidazioneSemanticaRegistroServiziCheckURI(){

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

  8344.                 if (value != null){
  8345.                     value = value.trim();
  8346.                     if(CostantiConfigurazione.ABILITATO.equals(value)){
  8347.                         this.isValidazioneSemanticaRegistroServiziCheckURI = true;
  8348.                     }else if(CostantiConfigurazione.DISABILITATO.equals(value)){
  8349.                         this.isValidazioneSemanticaRegistroServiziCheckURI = false;
  8350.                     }
  8351.                     else{
  8352.                         throw new CoreException(VALORE_NON_CORRETTO_ABILITATO_DISABILITATO+value);
  8353.                     }
  8354.                 }else{
  8355.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.registri.validazioneSemantica.checkURI' non impostata, viene utilizzato il default=false");
  8356.                     this.isValidazioneSemanticaRegistroServiziCheckURI = false;
  8357.                 }

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

  8365.         return this.isValidazioneSemanticaRegistroServiziCheckURI;
  8366.     }
  8367.     

  8369.     private static final String RISORSE_DB = "db";
  8370.     private static final String RISORSE_JMS = "jms";
  8371.     private static final String RISORSE_TRACCIAMENTO = "tracciamento";
  8372.     private static final String RISORSE_MSGDIAGNOSTICI = "msgdiagnostici";
  8373.     private static final String RISORSE_CONFIGURAZIONE = "configurazione";
  8374.     private static final String RISORSE_CONFIGURAZIONE_VALIDAZIONE_SEMANTICA = "configurazione.validazioneSemantica";
  8375.     private static final String RISORSE_REGISTRI = "registri";
  8376.     private static final String RISORSE_REGISTRI_VALIDAZIONE_SEMANTICA = "registri.validazioneSemantica";
  8377.     
  8378.     private static final String RISORSE_PROPERTY_NAME_CHECK = "org.openspcoop2.pdd.risorse.check.";

  8380.     private Boolean isAbilitatoControlloRisorseDB = null;
  8381.     public boolean isAbilitatoControlloRisorseDB() {    
  8382.         if(this.isAbilitatoControlloRisorseDB==null){
  8383.             this.isAbilitatoControlloRisorseDB = isAbilitatoControlloRisorse(RISORSE_DB);
  8384.         }
  8385.         return this.isAbilitatoControlloRisorseDB;
  8386.     }
  8387.     private Boolean isAbilitatoControlloRisorseJMS = null;
  8388.     public boolean isAbilitatoControlloRisorseJMS() {   
  8389.         if(this.isAbilitatoControlloRisorseJMS==null){
  8390.             this.isAbilitatoControlloRisorseJMS = isAbilitatoControlloRisorse(RISORSE_JMS);
  8391.         }
  8392.         return this.isAbilitatoControlloRisorseJMS;
  8393.     }
  8394.     private Boolean isAbilitatoControlloRisorseTracciamentiPersonalizzati = null;
  8395.     public boolean isAbilitatoControlloRisorseTracciamentiPersonalizzati() {    
  8396.         if(this.isAbilitatoControlloRisorseTracciamentiPersonalizzati==null){
  8397.             this.isAbilitatoControlloRisorseTracciamentiPersonalizzati = isAbilitatoControlloRisorse(RISORSE_TRACCIAMENTO);
  8398.         }
  8399.         return this.isAbilitatoControlloRisorseTracciamentiPersonalizzati;
  8400.     }
  8401.     private Boolean isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati = null;
  8402.     public boolean isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati() {  
  8403.         if(this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati==null){
  8404.             this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati = isAbilitatoControlloRisorse(RISORSE_MSGDIAGNOSTICI);
  8405.         }
  8406.         return this.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati;
  8407.     }
  8408.     private Boolean isAbilitatoControlloRisorseConfigurazione = null;
  8409.     public boolean isAbilitatoControlloRisorseConfigurazione() {    
  8410.         if(this.isAbilitatoControlloRisorseConfigurazione==null){
  8411.             this.isAbilitatoControlloRisorseConfigurazione = isAbilitatoControlloRisorse(RISORSE_CONFIGURAZIONE);
  8412.         }
  8413.         return this.isAbilitatoControlloRisorseConfigurazione;
  8414.     }
  8415.     private Boolean isAbilitatoControlloValidazioneSemanticaConfigurazione = null;
  8416.     public boolean isAbilitatoControlloValidazioneSemanticaConfigurazione() {   
  8417.         if(this.isAbilitatoControlloValidazioneSemanticaConfigurazione==null){
  8418.             this.isAbilitatoControlloValidazioneSemanticaConfigurazione = isAbilitatoControlloRisorse(RISORSE_CONFIGURAZIONE_VALIDAZIONE_SEMANTICA);
  8419.         }
  8420.         return this.isAbilitatoControlloValidazioneSemanticaConfigurazione;
  8421.     }
  8422.     private Boolean isAbilitatoControlloRisorseRegistriServizi = null;
  8423.     public boolean isAbilitatoControlloRisorseRegistriServizi() {   
  8424.         if(this.isAbilitatoControlloRisorseRegistriServizi==null){
  8425.             this.isAbilitatoControlloRisorseRegistriServizi = isAbilitatoControlloRisorse(RISORSE_REGISTRI);
  8426.         }
  8427.         return this.isAbilitatoControlloRisorseRegistriServizi;
  8428.     }
  8429.     private Boolean isAbilitatoControlloValidazioneSemanticaRegistriServizi = null;
  8430.     public boolean isAbilitatoControlloValidazioneSemanticaRegistriServizi() {  
  8431.         if(this.isAbilitatoControlloValidazioneSemanticaRegistriServizi==null){
  8432.             this.isAbilitatoControlloValidazioneSemanticaRegistriServizi = isAbilitatoControlloRisorse(RISORSE_REGISTRI_VALIDAZIONE_SEMANTICA);
  8433.         }
  8434.         return this.isAbilitatoControlloValidazioneSemanticaRegistriServizi;
  8435.     }
  8436.     private boolean isAbilitatoControlloRisorse(String tipo) {  
  8437.         try{  
  8438.             String value = this.reader.getValueConvertEnvProperties(RISORSE_PROPERTY_NAME_CHECK+tipo); 
  8439.             if(value==null){
  8440.                 this.logWarn(getMessaggioProprietaNonImpostata(RISORSE_PROPERTY_NAME_CHECK+tipo, false));
  8441.                 return false;
  8442.             }
  8443.             return CostantiConfigurazione.ABILITATO.equals(value);
  8444.         }catch(java.lang.Exception e) {
  8445.             this.logWarn(getMessaggioProprietaNonImpostata(RISORSE_PROPERTY_NAME_CHECK+tipo, e, false));
  8446.             return false;
  8447.         }
  8448.     }
  8449.     private Boolean isControlloRisorseRegistriRaggiungibilitaTotale = null;
  8450.     public boolean isControlloRisorseRegistriRaggiungibilitaTotale() {  
  8451.         if(this.isControlloRisorseRegistriRaggiungibilitaTotale==null){
  8452.             try{  
  8453.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.risorse.check.registri.tipo"); 
  8454.                 if(value==null){
  8455.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.check.registri.tipo' non impostata, viene utilizzato il default=false");
  8456.                     this.isControlloRisorseRegistriRaggiungibilitaTotale = false;
  8457.                 }
  8458.                 else
  8459.                     this.isControlloRisorseRegistriRaggiungibilitaTotale = "singolo".equals(value);
  8460.             }catch(java.lang.Exception e) {
  8461.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.check.registri.tipo' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  8462.                 this.isControlloRisorseRegistriRaggiungibilitaTotale = false;
  8463.             }
  8464.         }

  8466.         return this.isControlloRisorseRegistriRaggiungibilitaTotale;
  8467.     }
  8468.     
  8469.     
  8470.     private Integer getNumeroIterazioniFalliteControlloRisorseDB = null;
  8471.     public int getNumeroIterazioniFalliteControlloRisorseDB() { 
  8472.         if(this.getNumeroIterazioniFalliteControlloRisorseDB==null){
  8473.             this.getNumeroIterazioniFalliteControlloRisorseDB = getNumeroIterazioniFalliteControlloRisorse(RISORSE_DB);
  8474.         }
  8475.         return this.getNumeroIterazioniFalliteControlloRisorseDB;
  8476.     }
  8477.     private Integer getNumeroIterazioniFalliteControlloRisorseJMS = null;
  8478.     public int getNumeroIterazioniFalliteControlloRisorseJMS() {    
  8479.         if(this.getNumeroIterazioniFalliteControlloRisorseJMS==null){
  8480.             this.getNumeroIterazioniFalliteControlloRisorseJMS = getNumeroIterazioniFalliteControlloRisorse(RISORSE_JMS);
  8481.         }
  8482.         return this.getNumeroIterazioniFalliteControlloRisorseJMS;
  8483.     }
  8484.     private Integer getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati = null;
  8485.     public int getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati() { 
  8486.         if(this.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati==null){
  8487.             this.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati = getNumeroIterazioniFalliteControlloRisorse(RISORSE_TRACCIAMENTO);
  8488.         }
  8489.         return this.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati;
  8490.     }
  8491.     private Integer getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati = null;
  8492.     public int getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati() {   
  8493.         if(this.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati==null){
  8494.             this.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati = getNumeroIterazioniFalliteControlloRisorse(RISORSE_MSGDIAGNOSTICI);
  8495.         }
  8496.         return this.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati;
  8497.     }
  8498.     private Integer getNumeroIterazioniFalliteControlloRisorseConfigurazione = null;
  8499.     public int getNumeroIterazioniFalliteControlloRisorseConfigurazione() { 
  8500.         if(this.getNumeroIterazioniFalliteControlloRisorseConfigurazione==null){
  8501.             this.getNumeroIterazioniFalliteControlloRisorseConfigurazione = getNumeroIterazioniFalliteControlloRisorse(RISORSE_CONFIGURAZIONE);
  8502.         }
  8503.         return this.getNumeroIterazioniFalliteControlloRisorseConfigurazione;
  8504.     }
  8505.     private Integer getNumeroIterazioniFalliteControlloRisorseRegistriServizi = null;
  8506.     public int getNumeroIterazioniFalliteControlloRisorseRegistriServizi() {    
  8507.         if(this.getNumeroIterazioniFalliteControlloRisorseRegistriServizi==null){
  8508.             this.getNumeroIterazioniFalliteControlloRisorseRegistriServizi = getNumeroIterazioniFalliteControlloRisorse(RISORSE_REGISTRI);
  8509.         }
  8510.         return this.getNumeroIterazioniFalliteControlloRisorseRegistriServizi;
  8511.     }
  8512.     private int getNumeroIterazioniFalliteControlloRisorse(String tipo) {   
  8513.         try{  
  8514.             String value = this.reader.getValueConvertEnvProperties(RISORSE_PROPERTY_NAME_CHECK+tipo+".iterazioni"); 
  8515.             if(value==null){
  8516.                 this.logWarn("Proprieta' di openspcoop '"+RISORSE_PROPERTY_NAME_CHECK+""+tipo+".iterazioni' non impostata, viene utilizzato il default=1");
  8517.                 return 1;
  8518.             }
  8519.             return Integer.parseInt(value);
  8520.         }catch(java.lang.Exception e) {
  8521.             this.logWarn("Proprieta' di openspcoop '"+RISORSE_PROPERTY_NAME_CHECK+""+tipo+"' non impostata, viene utilizzato il default=1, errore:"+e.getMessage(),e);
  8522.             return 1;
  8523.         }
  8524.     }
  8525.     
  8526.     private Integer getIterazioniFalliteCheckIntervalControlloRisorseDB = null;
  8527.     public int getIterazioniFalliteCheckIntervalControlloRisorseDB() {  
  8528.         if(this.getIterazioniFalliteCheckIntervalControlloRisorseDB==null){
  8529.             this.getIterazioniFalliteCheckIntervalControlloRisorseDB = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_DB);
  8530.         }
  8531.         return this.getIterazioniFalliteCheckIntervalControlloRisorseDB;
  8532.     }
  8533.     private Integer getIterazioniFalliteCheckIntervalControlloRisorseJMS = null;
  8534.     public int getIterazioniFalliteCheckIntervalControlloRisorseJMS() { 
  8535.         if(this.getIterazioniFalliteCheckIntervalControlloRisorseJMS==null){
  8536.             this.getIterazioniFalliteCheckIntervalControlloRisorseJMS = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_JMS);
  8537.         }
  8538.         return this.getIterazioniFalliteCheckIntervalControlloRisorseJMS;
  8539.     }
  8540.     private Integer getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati = null;
  8541.     public int getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati() {  
  8542.         if(this.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati==null){
  8543.             this.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_TRACCIAMENTO);
  8544.         }
  8545.         return this.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati;
  8546.     }
  8547.     private Integer getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati = null;
  8548.     public int getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati() {    
  8549.         if(this.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati==null){
  8550.             this.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_MSGDIAGNOSTICI);
  8551.         }
  8552.         return this.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati;
  8553.     }
  8554.     private Integer getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione = null;
  8555.     public int getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione() {  
  8556.         if(this.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione==null){
  8557.             this.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_CONFIGURAZIONE);
  8558.         }
  8559.         return this.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione;
  8560.     }
  8561.     private Integer getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi = null;
  8562.     public int getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi() { 
  8563.         if(this.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi==null){
  8564.             this.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi = getIterazioniFalliteCheckIntervalControlloRisorse(RISORSE_REGISTRI);
  8565.         }
  8566.         return this.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi;
  8567.     }
  8568.     private int getIterazioniFalliteCheckIntervalControlloRisorse(String tipo) {    
  8569.         try{  
  8570.             String value = this.reader.getValueConvertEnvProperties(RISORSE_PROPERTY_NAME_CHECK+tipo+".checkInterval"); 
  8571.             if(value==null){
  8572.                 this.logWarn("Proprieta' di openspcoop '"+RISORSE_PROPERTY_NAME_CHECK+""+tipo+".checkInterval' non impostata, viene utilizzato il default=500");
  8573.                 return 500;
  8574.             }
  8575.             return Integer.parseInt(value);
  8576.         }catch(java.lang.Exception e) {
  8577.             this.logWarn("Proprieta' di openspcoop '"+RISORSE_PROPERTY_NAME_CHECK+""+tipo+".checkInterval' non impostata, viene utilizzato il default=500, errore:"+e.getMessage(),e);
  8578.             return 500;
  8579.         }
  8580.     }
  8581.     
  8582.     /**
  8583.      * Restituisce l'intervallo per il timer di Threshold
  8584.      *
  8585.      * @return Restituisce l'intervallo per il timer di Threshold
  8586.      * 
  8587.      */
  8588.     private Long controlloRisorseCheckInterval = null;
  8589.     public long getControlloRisorseCheckInterval() {    
  8590.         if(this.controlloRisorseCheckInterval==null){
  8591.             try{ 
  8592.                 String name = null;
  8593.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.risorse.checkInterval");
  8594.                 if(name!=null){
  8595.                     name = name.trim();
  8596.                     this.controlloRisorseCheckInterval = java.lang.Long.parseLong(name);
  8597.                 }else{
  8598.                     this.controlloRisorseCheckInterval = 0L;
  8599.                 }
  8600.             }catch(java.lang.Exception e) {
  8601.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.checkInterval': "+e.getMessage(),e);
  8602.                 this.controlloRisorseCheckInterval = -1L;
  8603.             }    
  8604.         }

  8606.         return this.controlloRisorseCheckInterval;
  8607.     }

  8609.     private Boolean isControlloRisorseRegistrazioneEvento = null;
  8610.     public boolean isControlloRisorseRegistrazioneEvento() {    
  8611.         if(this.isControlloRisorseRegistrazioneEvento==null){
  8612.             try{ 
  8613.                 String name = null;
  8614.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.risorse.registraEvento");
  8615.                 if(name==null){
  8616.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.registraEvento' non impostata, viene utilizzato il default=true");
  8617.                     name="true";
  8618.                 }
  8619.                 name = name.trim();
  8620.                 this.isControlloRisorseRegistrazioneEvento = Boolean.parseBoolean(name);
  8621.             } catch(java.lang.Exception e) {
  8622.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.risorse.registraEvento', viene utilizzato il default=true : "+e.getMessage(),e);
  8623.                 this.isControlloRisorseRegistrazioneEvento = true;
  8624.             }    
  8625.         }

  8627.         return this.isControlloRisorseRegistrazioneEvento;
  8628.     }






  8635.     /* ******** ERRORE APPLICATIVO  ******** */

  8637.     /**
  8638.      * Restituisce le proprieta' di default utilizzate dalla porta di dominio per invocazioni di porte delegate che generano errori
  8639.      *
  8640.      * @return Restituisce le proprieta' di default utilizzate dalla porta di dominio per invocazioni di porte delegate che generano errori
  8641.      * 
  8642.      */
  8643.     private ProprietaErroreApplicativo proprietaGestioneErrorePD = null;
  8644.     public ProprietaErroreApplicativo getProprietaGestioneErrorePD(IProtocolManager protocolManager){
  8645.         return getProprietaGestioneErrorePD_engine(protocolManager,false);
  8646.     }
  8647.     private ProprietaErroreApplicativo getProprietaGestioneErrorePD_engine(IProtocolManager protocolManager,boolean testPerValidazione){
  8648.         if(this.proprietaGestioneErrorePD==null){
  8649.             String fault = null;
  8650.             try{  
  8651.                 fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.fault"); 
  8652.                 if(fault==null)
  8653.                     throw new CoreException(NON_DEFINITA);
  8654.                 fault = fault.trim();       
  8655.             }catch(java.lang.Exception e) {
  8656.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.fault': "+e.getMessage(),e);
  8657.                 return null;
  8658.             }

  8660.             String faultCodeIntegrationNamespace = null;
  8661.             try{  
  8662.                 faultCodeIntegrationNamespace = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultCode.integrationNamespace"); 
  8663.                 if(faultCodeIntegrationNamespace!=null) {
  8664.                     faultCodeIntegrationNamespace = faultCodeIntegrationNamespace.trim();
  8665.                 }
  8666.             }catch(java.lang.Exception e) {
  8667.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultCode.integrationNamespace': "+e.getMessage(),e);
  8668.             }
  8669.             
  8670.             String faultCodeProtocolNamespace = null;
  8671.             try{  
  8672.                 faultCodeProtocolNamespace = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultCode.protocolNamespace"); 
  8673.                 if(faultCodeProtocolNamespace!=null) {
  8674.                     faultCodeProtocolNamespace = faultCodeProtocolNamespace.trim();
  8675.                 }
  8676.             }catch(java.lang.Exception e) {
  8677.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultCode.protocolNamespace': "+e.getMessage(),e);
  8678.             }
  8679.             
  8680.             String faultActor = null;
  8681.             try{  
  8682.                 faultActor = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultActor"); 
  8683.                 if(faultActor==null)
  8684.                     throw new CoreException(NON_DEFINITA);
  8685.                 faultActor = faultActor.trim();     
  8686.             }catch(java.lang.Exception e) {
  8687.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultActor': "+e.getMessage(),e);
  8688.                 return null;
  8689.             }

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

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

  8711.             ProprietaErroreApplicativo gestione = new ProprietaErroreApplicativo();
  8712.             if(CostantiConfigurazione.ERRORE_APPLICATIVO_XML.equals(fault))
  8713.                 gestione.setFaultAsXML(true);
  8714.             else
  8715.                 gestione.setFaultAsXML(false); // default: ERRORE_APPLICATIVO_SOAP
  8716.             gestione.setDefaultFaultCodeIntegrationNamespace(faultCodeIntegrationNamespace);
  8717.             gestione.setDefaultFaultCodeProtocolNamespace(faultCodeProtocolNamespace);
  8718.             gestione.setFaultActor(faultActor);
  8719.             if(CostantiConfigurazione.ABILITATO.equals(faultGeneric))
  8720.                 gestione.setFaultAsGenericCode(true);
  8721.             else
  8722.                 gestione.setFaultAsGenericCode(false); // default: false
  8723.             gestione.setFaultPrefixCode(faultPrefix);

  8725.             gestione.setInsertAsDetails(this.isErroreApplicativoIntoDetails());
  8726.             
  8727.             gestione.setAggiungiDetailErroreApplicativo_SoapFaultApplicativo(this.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo());
  8728.             
  8729.             gestione.setAggiungiDetailErroreApplicativo_SoapFaultPdD(this.isAggiungiDetailErroreApplicativo_SoapFaultPdD());

  8731.             this.proprietaGestioneErrorePD = gestione;
  8732.         }

  8734.         ProprietaErroreApplicativo pNew = new ProprietaErroreApplicativo();
  8735.         pNew.setDominio(this.proprietaGestioneErrorePD.getDominio());
  8736.         pNew.setDefaultFaultCodeIntegrationNamespace(this.proprietaGestioneErrorePD.getDefaultFaultCodeIntegrationNamespace());
  8737.         pNew.setDefaultFaultCodeProtocolNamespace(this.proprietaGestioneErrorePD.getDefaultFaultCodeProtocolNamespace());
  8738.         pNew.setFaultActor(this.proprietaGestioneErrorePD.getFaultActor());
  8739.         pNew.setFaultAsGenericCode(this.proprietaGestioneErrorePD.isFaultAsGenericCode());
  8740.         pNew.setFaultAsXML(this.proprietaGestioneErrorePD.isFaultAsXML());
  8741.         pNew.setFaultPrefixCode(this.proprietaGestioneErrorePD.getFaultPrefixCode());
  8742.         pNew.setIdModulo(this.proprietaGestioneErrorePD.getIdModulo());
  8743.         pNew.setInsertAsDetails(this.proprietaGestioneErrorePD.isInsertAsDetails());
  8744.         pNew.setAggiungiDetailErroreApplicativo_SoapFaultApplicativo(this.proprietaGestioneErrorePD.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo());
  8745.         pNew.setAggiungiDetailErroreApplicativo_SoapFaultPdD(this.proprietaGestioneErrorePD.isAggiungiDetailErroreApplicativo_SoapFaultPdD());
  8746.         if(protocolManager!=null){
  8747.             FaultIntegrationGenericInfoMode sf = protocolManager.getModalitaGenerazioneInformazioniGeneriche_DetailsFaultIntegrazione();
  8748.             if(FaultIntegrationGenericInfoMode.SERVIZIO_APPLICATIVO.equals(sf)){
  8749.                 pNew.setInformazioniGenericheDetailsOpenSPCoop(null);
  8750.             }
  8751.             else if(FaultIntegrationGenericInfoMode.ABILITATO.equals(sf)){
  8752.                 pNew.setInformazioniGenericheDetailsOpenSPCoop(true);
  8753.             } 
  8754.             else if(FaultIntegrationGenericInfoMode.DISABILITATO.equals(sf)){
  8755.                 pNew.setInformazioniGenericheDetailsOpenSPCoop(false);
  8756.             } 
  8757.             
  8758.             BooleanNullable enrichNullable = protocolManager.isAggiungiDetailErroreApplicativo_FaultApplicativo();
  8759.             if(enrichNullable!=null && enrichNullable.getValue()!=null){
  8760.                 pNew.setAggiungiDetailErroreApplicativo_SoapFaultApplicativo(enrichNullable.getValue());
  8761.             }
  8762.             
  8763.             enrichNullable = protocolManager.isAggiungiDetailErroreApplicativo_FaultPdD();
  8764.             if(enrichNullable!=null && enrichNullable.getValue()!=null){
  8765.                 pNew.setAggiungiDetailErroreApplicativo_SoapFaultPdD(enrichNullable.getValue());
  8766.             }
  8767.             
  8768.         }else{
  8769.             pNew.setInformazioniGenericheDetailsOpenSPCoop(null); // default
  8770.         }
  8771.         return pNew;
  8772.     }


  8775.     private Locale localeSOAPFaultString = null;
  8776.     private Boolean localeSOAPFaultStringRead = null;
  8777.     public Locale getLocaleSOAPFaultString(){
  8778.         if(this.localeSOAPFaultStringRead==null){
  8779.             try{  
  8780.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultString.language"); 
  8781.                 if (value != null){
  8782.                     value = value.trim();
  8783.                     
  8784.                     String language = value;
  8785.                     
  8786.                     String country = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultString.country"); 
  8787.                     if(country!=null) {
  8788.                         country = country.trim();
  8789.                     }
  8790.                     
  8791.                     String variant = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultString.variant"); 
  8792.                     if(variant!=null) {
  8793.                         variant = variant.trim();
  8794.                     }
  8795.                     
  8796.                     this.localeSOAPFaultString = new Locale(language, country, variant);
  8797.                 }else{
  8798.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultString.language' non impostata, viene utilizzato il default="+Locale.getDefault());
  8799.                 }
  8800.             }catch(java.lang.Exception e) {
  8801.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.erroreApplicativo.faultString.language' non impostata, viene utilizzato il default="+Locale.getDefault()+", errore:"+e.getMessage(),e);
  8802.             }
  8803.             this.localeSOAPFaultStringRead = true;
  8804.         }

  8806.         return this.localeSOAPFaultString;
  8807.     }
  8808.     

  8810.     /**
  8811.      * Indicazione se l'errore applicativo deve essere inserito in un details.
  8812.      *   
  8813.      * @return Indicazione se l'errore applicativo deve essere inserito in un details.
  8814.      * 
  8815.      */
  8816.     private Boolean isErroreApplicativoIntoDetails = null;
  8817.     public boolean isErroreApplicativoIntoDetails(){
  8818.         if(this.isErroreApplicativoIntoDetails==null){
  8819.             try{  
  8820.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.fault.details"); 

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

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

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

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

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

  8865.         return this.isAggiungiDetailErroreApplicativo_SoapFaultApplicativo;
  8866.     }
  8867.     
  8868.     
  8869.     /**
  8870.      * Indicazione se aggiungere un detail contenente descrizione dell'errore nel SoapFaultPdD originale
  8871.      * 
  8872.      * @return Indicazione se aggiungere un detail contenente descrizione dell'errore nel SoapFaultPdD originale
  8873.      */
  8874.     private Boolean isAggiungiDetailErroreApplicativo_SoapFaultPdD = null;
  8875.     public boolean isAggiungiDetailErroreApplicativo_SoapFaultPdD(){
  8876.         if(this.isAggiungiDetailErroreApplicativo_SoapFaultPdD==null){
  8877.             try{  
  8878.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.erroreApplicativo.faultPdD.enrichDetails"); 

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

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

  8894.         return this.isAggiungiDetailErroreApplicativo_SoapFaultPdD;
  8895.     }
  8896.     
  8897.     
  8898.     
  8899.     private String getErroriHttpHeaderGovWayStatus = null;
  8900.     public String getErroriHttpHeaderGovWayStatus(){
  8901.         
  8902.         String pName = "org.openspcoop2.pdd.errori.http.govwayStatus";
  8903.         if(this.getErroriHttpHeaderGovWayStatus==null){
  8904.             try{  
  8905.                 String name = this.reader.getValueConvertEnvProperties(pName); 
  8906.                 if(name==null)
  8907.                     throw new CoreException(NON_DEFINITA);
  8908.                 name = name.trim();
  8909.                 this.getErroriHttpHeaderGovWayStatus = name;

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

  8917.         return this.getErroriHttpHeaderGovWayStatus;
  8918.     }
  8919.     
  8920.     private String getErroriHttpHeaderGovWayType = null;
  8921.     public String getErroriHttpHeaderGovWayType(){
  8922.         
  8923.         String pName = "org.openspcoop2.pdd.errori.http.govwayType";
  8924.         if(this.getErroriHttpHeaderGovWayType==null){
  8925.             try{  
  8926.                 String name = this.reader.getValueConvertEnvProperties(pName); 
  8927.                 if(name==null)
  8928.                     throw new CoreException(NON_DEFINITA);
  8929.                 name = name.trim();
  8930.                 this.getErroriHttpHeaderGovWayType = name;

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

  8938.         return this.getErroriHttpHeaderGovWayType;
  8939.     }
  8940.     
  8941.     private String getErroriHttpHeaderGovWayCode = null;
  8942.     public String getErroriHttpHeaderGovWayCode(){
  8943.         
  8944.         String pName = "org.openspcoop2.pdd.errori.http.govwayCode";
  8945.         if(this.getErroriHttpHeaderGovWayCode==null){
  8946.             try{  
  8947.                 String name = this.reader.getValueConvertEnvProperties(pName); 
  8948.                 if(name==null)
  8949.                     throw new CoreException(NON_DEFINITA);
  8950.                 name = name.trim();
  8951.                 this.getErroriHttpHeaderGovWayCode = name;

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

  8959.         return this.getErroriHttpHeaderGovWayCode;
  8960.     }
  8961.     
  8962.     
  8963.     
  8964.     private Boolean isErroriSoapUseGovWayStatusAsFaultCode = null;
  8965.     public boolean isErroriSoapUseGovWayStatusAsFaultCode(){
  8966.         if(this.isErroriSoapUseGovWayStatusAsFaultCode==null){
  8967.             String pName = "org.openspcoop2.pdd.errori.soap.useGovWayStatusAsFaultCode";
  8968.             try{  
  8969.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  8971.                 if (value != null){
  8972.                     value = value.trim();
  8973.                     this.isErroriSoapUseGovWayStatusAsFaultCode = Boolean.parseBoolean(value);
  8974.                 }else{
  8975.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  8976.                     this.isErroriSoapUseGovWayStatusAsFaultCode = false;
  8977.                 }

  8979.             }catch(java.lang.Exception e) {
  8980.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  8981.                 this.isErroriSoapUseGovWayStatusAsFaultCode = false;
  8982.             }
  8983.         }

  8985.         return this.isErroriSoapUseGovWayStatusAsFaultCode;
  8986.     }
  8987.     
  8988.     private Boolean isErroriSoapHttpHeaderGovWayCodeEnabled = null;
  8989.     public boolean isErroriSoapHttpHeaderGovWayCodeEnabled(){
  8990.         if(this.isErroriSoapHttpHeaderGovWayCodeEnabled==null){
  8991.             String pName = "org.openspcoop2.pdd.errori.soap.HttpHeaderGovWayCode.enabled";
  8992.             try{  
  8993.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  8995.                 if (value != null){
  8996.                     value = value.trim();
  8997.                     this.isErroriSoapHttpHeaderGovWayCodeEnabled = Boolean.parseBoolean(value);
  8998.                 }else{
  8999.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9000.                     this.isErroriSoapHttpHeaderGovWayCodeEnabled = false;
  9001.                 }

  9003.             }catch(java.lang.Exception e) {
  9004.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9005.                 this.isErroriSoapHttpHeaderGovWayCodeEnabled = false;
  9006.             }
  9007.         }

  9009.         return this.isErroriSoapHttpHeaderGovWayCodeEnabled;
  9010.     }
  9011.     
  9012.     private Boolean isErroriGovWayStatusEnabled = null;
  9013.     public boolean isErroriGovWayStatusEnabled(){
  9014.         if(this.isErroriGovWayStatusEnabled==null){
  9015.             String pName = "org.openspcoop2.pdd.errori.status";
  9016.             try{  
  9017.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9019.                 if (value != null){
  9020.                     value = value.trim();
  9021.                     this.isErroriGovWayStatusEnabled = Boolean.parseBoolean(value);
  9022.                 }else{
  9023.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9024.                     this.isErroriGovWayStatusEnabled = false;
  9025.                 }

  9027.             }catch(java.lang.Exception e) {
  9028.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9029.                 this.isErroriGovWayStatusEnabled = false;
  9030.             }
  9031.         }

  9033.         return this.isErroriGovWayStatusEnabled;
  9034.     }
  9035.     
  9036.     private Boolean isErroriGovWayInstanceEnabled = null;
  9037.     public boolean isErroriGovWayInstanceEnabled(){
  9038.         if(this.isErroriGovWayInstanceEnabled==null){
  9039.             String pName = "org.openspcoop2.pdd.errori.instance";
  9040.             try{  
  9041.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9043.                 if (value != null){
  9044.                     value = value.trim();
  9045.                     this.isErroriGovWayInstanceEnabled = Boolean.parseBoolean(value);
  9046.                 }else{
  9047.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9048.                     this.isErroriGovWayInstanceEnabled = false;
  9049.                 }

  9051.             }catch(java.lang.Exception e) {
  9052.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9053.                 this.isErroriGovWayInstanceEnabled = false;
  9054.             }
  9055.         }

  9057.         return this.isErroriGovWayInstanceEnabled;
  9058.     }
  9059.     
  9060.     private Boolean isErroriGovWayForceSpecificDetails = null;
  9061.     public boolean isErroriGovWayForceSpecificDetails(){
  9062.         if(this.isErroriGovWayForceSpecificDetails==null){
  9063.             String pName = "org.openspcoop2.pdd.errori.forceSpecificDetails";
  9064.             try{  
  9065.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9067.                 if (value != null){
  9068.                     value = value.trim();
  9069.                     this.isErroriGovWayForceSpecificDetails = Boolean.parseBoolean(value);
  9070.                 }else{
  9071.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9072.                     this.isErroriGovWayForceSpecificDetails = false;
  9073.                 }

  9075.             }catch(java.lang.Exception e) {
  9076.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9077.                 this.isErroriGovWayForceSpecificDetails = false;
  9078.             }
  9079.         }

  9081.         return this.isErroriGovWayForceSpecificDetails;
  9082.     }
  9083.     
  9084.     private Boolean isErroriGovWayFaultDetailsWithProblemRFC7807 = null;
  9085.     public boolean isErroriGovWayFaultDetailsWithProblemRFC7807(){
  9086.         if(this.isErroriGovWayFaultDetailsWithProblemRFC7807==null){
  9087.             String pName = "org.openspcoop2.pdd.errori.faultDetailsWithProblemRFC7807";
  9088.             try{  
  9089.                 String value = this.reader.getValueConvertEnvProperties(pName); 

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

  9099.             }catch(java.lang.Exception e) {
  9100.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9101.                 this.isErroriGovWayFaultDetailsWithProblemRFC7807 = false;
  9102.             }
  9103.         }

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

  9118.                 if (value != null){
  9119.                     value = value.trim();
  9120.                     this.isProblemRFC7807_enrichTitleAsGovWayType = Boolean.parseBoolean(value);
  9121.                 }else{
  9122.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  9123.                     this.isProblemRFC7807_enrichTitleAsGovWayType = true;
  9124.                 }

  9126.             }catch(java.lang.Exception e) {
  9127.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  9128.                 this.isProblemRFC7807_enrichTitleAsGovWayType = true;
  9129.             }
  9130.         }

  9132.         return this.isProblemRFC7807_enrichTitleAsGovWayType;
  9133.     }
  9134.     
  9135.     
  9136.     private Boolean isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode = null;
  9137.     public boolean isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode(){
  9138.         if(this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode==null){
  9139.             String pName = "org.openspcoop2.pdd.problemRFC7807.enrichTitleAsGovWayType.camelCaseDecode";
  9140.             try{  
  9141.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9143.                 if (value != null){
  9144.                     value = value.trim();
  9145.                     this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode = Boolean.parseBoolean(value);
  9146.                 }else{
  9147.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9148.                     this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode = false;
  9149.                 }

  9151.             }catch(java.lang.Exception e) {
  9152.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9153.                 this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode = false;
  9154.             }
  9155.         }

  9157.         return this.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode;
  9158.     }
  9159.     
  9160.     
  9161.     private Boolean isProblemRFC7807_enrichTitleAsGovWayType_customClaim = null;
  9162.     public boolean isProblemRFC7807_enrichTitleAsGovWayType_customClaim(){
  9163.         if(this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim==null){
  9164.             String pName = "org.openspcoop2.pdd.problemRFC7807.enrichTitleAsGovWayType.customClaim";
  9165.             try{  
  9166.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9168.                 if (value != null){
  9169.                     value = value.trim();
  9170.                     this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim = Boolean.parseBoolean(value);
  9171.                 }else{
  9172.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9173.                     this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim = false;
  9174.                 }

  9176.             }catch(java.lang.Exception e) {
  9177.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9178.                 this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim = false;
  9179.             }
  9180.         }

  9182.         return this.isProblemRFC7807_enrichTitleAsGovWayType_customClaim;
  9183.     }
  9184.     

  9186.     private String getProblemRFC7807_transactionId_claim = null;
  9187.     public String getProblemRFC7807_transactionId_claim(){
  9188.         
  9189.         String pName = "org.openspcoop2.pdd.problemRFC7807.transactionId.claim";
  9190.         if(this.getProblemRFC7807_transactionId_claim==null){
  9191.             try{  
  9192.                 String fault = this.reader.getValueConvertEnvProperties(pName); 
  9193.                 if(fault==null)
  9194.                     throw new CoreException(NON_DEFINITA);
  9195.                 fault = fault.trim();
  9196.                 this.getProblemRFC7807_transactionId_claim = fault;

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

  9204.         return this.getProblemRFC7807_transactionId_claim;
  9205.     }
  9206.     
  9207.     private String getProblemRFC7807_code_claim = null;
  9208.     public String getProblemRFC7807_code_claim(){
  9209.         
  9210.         String pName = "org.openspcoop2.pdd.problemRFC7807.code.claim";
  9211.         if(this.getProblemRFC7807_code_claim==null){
  9212.             try{  
  9213.                 String fault = this.reader.getValueConvertEnvProperties(pName); 
  9214.                 if(fault==null)
  9215.                     throw new CoreException(NON_DEFINITA);
  9216.                 fault = fault.trim();
  9217.                 this.getProblemRFC7807_code_claim = fault;

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

  9225.         return this.getProblemRFC7807_code_claim;
  9226.     }
  9227.     
  9228.     private String getProblemRFC7807_type_claim = null;
  9229.     public String getProblemRFC7807_type_claim(){
  9230.         
  9231.         String pName = "org.openspcoop2.pdd.problemRFC7807.type.claim";
  9232.         if(this.getProblemRFC7807_type_claim==null){
  9233.             try{  
  9234.                 String fault = this.reader.getValueConvertEnvProperties(pName); 
  9235.                 if(fault==null)
  9236.                     throw new CoreException(NON_DEFINITA);
  9237.                 fault = fault.trim();
  9238.                 this.getProblemRFC7807_type_claim = fault;

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

  9246.         return this.getProblemRFC7807_type_claim;
  9247.     }


  9250.     private Boolean isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta = null;
  9251.     public boolean isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta(){
  9252.         if(this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta==null){
  9253.             String pName = "org.openspcoop2.pdd.erroreApplicativo.inoltraClientBustaRispostaErroreRicevuta";
  9254.             try{  
  9255.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9257.                 if (value != null){
  9258.                     value = value.trim();
  9259.                     this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta = Boolean.parseBoolean(value);
  9260.                 }else{
  9261.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9262.                     this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta = false;
  9263.                 }

  9265.             }catch(java.lang.Exception e) {
  9266.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9267.                 this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta = false;
  9268.             }
  9269.         }

  9271.         return this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta;
  9272.     }
  9273.     
  9274.     private Map<String,Boolean> isErroreApplicativoInoltraClientBustaRispostaErroreRicevutaMap = new HashMap<>();
  9275.     public boolean isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta(String protocollo){
  9276.         Boolean v = this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevutaMap.get(protocollo);
  9277.         if(v==null){
  9278.             String pName = "org.openspcoop2.pdd.erroreApplicativo.inoltraClientBustaRispostaErroreRicevuta."+protocollo;
  9279.             try{  
  9280.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9282.                 if (value != null){
  9283.                     value = value.trim();
  9284.                     v = Boolean.parseBoolean(value);
  9285.                 }else{
  9286.                     v = isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta(); // default per qualsiasi protocollo
  9287.                 }

  9289.             }catch(java.lang.Exception e) {
  9290.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta()),e);
  9291.                 v = isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta();
  9292.             }
  9293.             this.isErroreApplicativoInoltraClientBustaRispostaErroreRicevutaMap.put(protocollo, v);
  9294.         }

  9296.         return v;
  9297.     }
  9298.     



  9302.     /* ******** PORTA DI DOMINIO  ******** */

  9304.     /**
  9305.      * Restituisce il nome di default dell'identificativo porta utilizzato dalla porta di dominio
  9306.      *
  9307.      * @return Restituisce il nome di default dell'identificativo porta utilizzato dalla porta di dominio
  9308.      * 
  9309.      */
  9310.     private String identificativoPortaDefault = null;
  9311.     private String getIdentificativoPortaDefault(){
  9312.         if(this.identificativoPortaDefault==null){
  9313.             try{  
  9314.                 String fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.identificativoPorta.dominio"); 
  9315.                 if(fault==null)
  9316.                     throw new CoreException(NON_DEFINITA);
  9317.                 fault = fault.trim();
  9318.                 this.identificativoPortaDefault = fault;

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

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

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

  9350.         return this.nomePortaDefault;
  9351.     }


  9354.     /**
  9355.      * Restituisce il nome di default della porta utilizzato dalla porta di dominio
  9356.      *
  9357.      * @return Restituisce il nome di default della porta utilizzato dalla porta di dominio
  9358.      * 
  9359.      */
  9360.     private String tipoPortaDefault = null;
  9361.     private String getTipoPortaDefault(){
  9362.         if(this.tipoPortaDefault==null){
  9363.             try{  
  9364.                 String fault = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.identificativoPorta.tipo"); 
  9365.                 if(fault==null)
  9366.                     throw new CoreException(NON_DEFINITA);
  9367.                 fault = fault.trim();
  9368.                 this.tipoPortaDefault = fault;

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

  9378.     /**
  9379.      * Restituisce l'identita di default della porta utilizzato dalla porta di dominio
  9380.      *
  9381.      * @return Restituisce l'identita di default della porta utilizzato dalla porta di dominio
  9382.      * 
  9383.      */
  9384.     private IDSoggetto identitaPortaDefault = null;
  9385.     private IDSoggetto getIdentitaPortaDefault(){
  9386.         if(this.identitaPortaDefault==null){
  9387.             String pdd = getIdentificativoPortaDefault();
  9388.             String nome = getNomePortaDefault();
  9389.             String tipo = getTipoPortaDefault();
  9390.             if(tipo==null || nome==null || pdd==null)
  9391.                 this.identitaPortaDefault = null;
  9392.             else    
  9393.                 this.identitaPortaDefault = new IDSoggetto(tipo,nome,pdd);
  9394.         }

  9396.         if(this.identitaPortaDefault!=null){
  9397.             IDSoggetto idNew = new IDSoggetto();
  9398.             idNew.setCodicePorta(this.identitaPortaDefault.getCodicePorta());
  9399.             idNew.setNome(this.identitaPortaDefault.getNome());
  9400.             idNew.setTipo(this.identitaPortaDefault.getTipo());
  9401.             return idNew;
  9402.         }
  9403.         else{
  9404.             return null;
  9405.         }
  9406.     }


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

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

  9436.         return this.identificativoPortaDefault_mappingProtocol.get(protocol);
  9437.     }

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

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

  9464.         return this.nomePortaDefault_mappingProtocol.get(protocol);
  9465.     }
  9466.     
  9467.     private Map<String,String> tipoPortaDefault_mappingProtocol = new HashMap<>();
  9468.     private String _getTipoPortaDefault(String protocol){
  9469.         
  9470.         if(protocol==null){
  9471.             return getTipoPortaDefault();
  9472.         }
  9473.         
  9474.         if(this.tipoPortaDefault_mappingProtocol.containsKey(protocol)==false){
  9475.             
  9476.             try{  
  9477.                 
  9478.                 String tipo = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd."+protocol+".identificativoPorta.tipo"); 
  9479.                 if(tipo==null){
  9480.                     tipo = this.getTipoPortaDefault();
  9481.                 }else{
  9482.                     tipo = tipo.trim();
  9483.                 }
  9484.                 this.tipoPortaDefault_mappingProtocol.put(protocol, tipo);

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

  9492.         return this.tipoPortaDefault_mappingProtocol.get(protocol);
  9493.     }

  9495.     public IDSoggetto getIdentitaPortaDefaultWithoutProtocol(){
  9496.         return getIdentitaPortaDefault();
  9497.     }
  9498.     
  9499.     private Map<String,IDSoggetto> identitaPortaDefault_mappingProtocol = new HashMap<String, IDSoggetto>();
  9500.     public IDSoggetto getIdentitaPortaDefault(String protocol, RequestInfo requestInfo){
  9501.         
  9502.         if(requestInfo!=null && requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getDominioDefault()!=null) {
  9503.             IDSoggetto identitaPortaDefault = requestInfo.getRequestConfig().getDominioDefault();
  9504.             
  9505.             IDSoggetto idNew = new IDSoggetto();
  9506.             idNew.setCodicePorta(identitaPortaDefault.getCodicePorta());
  9507.             idNew.setNome(identitaPortaDefault.getNome());
  9508.             idNew.setTipo(identitaPortaDefault.getTipo());
  9509.             return idNew;
  9510.         }
  9511.         
  9512.         if(protocol==null){
  9513.             return getIdentitaPortaDefault();
  9514.         }
  9515.         
  9516.         if(this.identitaPortaDefault_mappingProtocol.containsKey(protocol)==false){
  9517.             String pdd = _getIdentificativoPortaDefault(protocol);
  9518.             String nome = _getNomePortaDefault(protocol);
  9519.             String tipo = _getTipoPortaDefault(protocol);
  9520.             if(tipo!=null && nome!=null && pdd!=null){
  9521.                 IDSoggetto identitaPortaDefault = new IDSoggetto(tipo,nome,pdd);
  9522.                 this.identitaPortaDefault_mappingProtocol.put(protocol, identitaPortaDefault);
  9523.             }
  9524.         }
  9525.         
  9526.         IDSoggetto identitaPortaDefault = this.identitaPortaDefault_mappingProtocol.get(protocol);
  9527.         
  9528.         if(identitaPortaDefault!=null){
  9529.             
  9530.             if(requestInfo!=null && requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getDominioDefault()==null) {
  9531.                 requestInfo.getRequestConfig().setDominioDefault(identitaPortaDefault);
  9532.             }
  9533.             
  9534.             IDSoggetto idNew = new IDSoggetto();
  9535.             idNew.setCodicePorta(identitaPortaDefault.getCodicePorta());
  9536.             idNew.setNome(identitaPortaDefault.getNome());
  9537.             idNew.setTipo(identitaPortaDefault.getTipo());
  9538.             return idNew;
  9539.         }
  9540.         else{
  9541.             return null;
  9542.         }
  9543.     }
  9544.     public String getIdentificativoPortaDefault(String protocol, RequestInfo requestInfo){
  9545.         IDSoggetto identitaPortaDefault = getIdentitaPortaDefault(protocol, requestInfo);
  9546.         if(identitaPortaDefault!=null) {
  9547.             return identitaPortaDefault.getCodicePorta();
  9548.         }
  9549.         return null;
  9550.     }






  9557.     /************ AUTORIZZAZIONE *******************/

  9559.     private Boolean getAutorizzazioneLockPermitsRead = null;
  9560.     private Integer getAutorizzazioneLockPermits = null;
  9561.     public Integer getAutorizzazioneLockPermits() {

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

  9568.                 if (value != null){
  9569.                     value = value.trim();
  9570.                     int permits = Integer.parseInt(value); 
  9571.                     if(permits>1) {
  9572.                         // altrimenti è un normale semaphore binario
  9573.                         this.getAutorizzazioneLockPermits = permits;
  9574.                     }
  9575.                 }
  9576.                 
  9577.                 
  9578.             }catch(java.lang.Exception e) {
  9579.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  9580.             }
  9581.             
  9582.             this.getAutorizzazioneLockPermitsRead = true;
  9583.         }

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

  9591.         String pName = "org.openspcoop2.pdd.core.autorizzazione.lock.permits.";
  9592.         if(this.getTipoAutorizzazioneLockPermits==null){
  9593.             
  9594.             this.getTipoAutorizzazioneLockPermits = new HashMap<>();
  9595.             
  9596.             try{  
  9597.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  9598.                 if(p!=null && !p.isEmpty()) {
  9599.                     for (Object oKey : p.keySet()) {
  9600.                         if(oKey!=null) {
  9601.                             String key = (String) oKey;
  9602.                             String value = p.getProperty(key);
  9603.                             if(value!=null) {
  9604.                                 int permits = Integer.parseInt(value);
  9605.                                 if(permits>1) {
  9606.                                     // altrimenti è un normale semaphore binario
  9607.                                     this.getTipoAutorizzazioneLockPermits.put(key, permits);
  9608.                                 }
  9609.                             }
  9610.                         }
  9611.                     }
  9612.                 }
  9613.                 
  9614.             }catch(java.lang.Exception e) {
  9615.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  9616.             }
  9617.             
  9618.         }

  9620.         return this.getTipoAutorizzazioneLockPermits.get(tipoAutorizzazione);
  9621.     }
  9622.     
  9623.     /**
  9624.      * Restituisce il tipo di autorizzazione delle buste effettuato dalla porta di dominio
  9625.      *
  9626.      * @return Restituisce il tipo di autorizzazione delle buste effettuato dalla porta di dominio
  9627.      * 
  9628.      */
  9629.     private String tipoAutorizzazioneBuste = null;
  9630.     public String getTipoAutorizzazioneBuste(){
  9631.         if(this.tipoAutorizzazioneBuste==null){
  9632.             try{  
  9633.                 String autorizzazione = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.autorizzazioneBuste.tipo");
  9634.                 if(autorizzazione==null)
  9635.                     throw new CoreException(NON_DEFINITA);
  9636.                 autorizzazione = autorizzazione.trim();
  9637.                 this.tipoAutorizzazioneBuste = autorizzazione;

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

  9645.         return this.tipoAutorizzazioneBuste;
  9646.     }
  9647.     
  9648.     
  9649.     private Boolean isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta = null;
  9650.     public boolean isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta() { 
  9651.         if(this.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta==null){
  9652.             String pName = "org.openspcoop2.pdd.autorizzazioneBusta.autenticazioneOpzionale.soggettoFruitoreProfiloInteroperabilitaDifferenteServizio.bloccaRichiesta";
  9653.             try{ 
  9654.                 String name = null;
  9655.                 name = this.reader.getValueConvertEnvProperties(pName);
  9656.                 if(name==null){
  9657.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  9658.                     name="true";
  9659.                 }
  9660.                 name = name.trim();
  9661.                 this.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta = Boolean.parseBoolean(name);
  9662.             } catch(java.lang.Exception e) {
  9663.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  9664.                 this.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta = true;
  9665.             }    
  9666.         }

  9668.         return this.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta;
  9669.     }

  9671.     



  9675.     
  9676.     /************ AUTORIZZAZIONE CONTENUTI *******************/

  9678.     private Boolean getAutorizzazioneContenutiLockPermitsRead = null;
  9679.     private Integer getAutorizzazioneContenutiLockPermits = null;
  9680.     public Integer getAutorizzazioneContenutiLockPermits() {

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

  9687.                 if (value != null){
  9688.                     value = value.trim();
  9689.                     int permits = Integer.parseInt(value); 
  9690.                     if(permits>1) {
  9691.                         // altrimenti è un normale semaphore binario
  9692.                         this.getAutorizzazioneContenutiLockPermits = permits;
  9693.                     }
  9694.                 }
  9695.                 
  9696.                 
  9697.             }catch(java.lang.Exception e) {
  9698.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  9699.             }
  9700.             
  9701.             this.getAutorizzazioneContenutiLockPermitsRead = true;
  9702.         }

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

  9710.         String pName = "org.openspcoop2.pdd.core.autorizzazioneContenuti.lock.permits.";
  9711.         if(this.getTipoAutorizzazioneContenutiLockPermits==null){
  9712.             
  9713.             this.getTipoAutorizzazioneContenutiLockPermits = new HashMap<>();
  9714.             
  9715.             try{  
  9716.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  9717.                 if(p!=null && !p.isEmpty()) {
  9718.                     for (Object oKey : p.keySet()) {
  9719.                         if(oKey!=null) {
  9720.                             String key = (String) oKey;
  9721.                             String value = p.getProperty(key);
  9722.                             if(value!=null) {
  9723.                                 int permits = Integer.parseInt(value);
  9724.                                 if(permits>1) {
  9725.                                     // altrimenti è un normale semaphore binario
  9726.                                     this.getTipoAutorizzazioneContenutiLockPermits.put(key, permits);
  9727.                                 }
  9728.                             }
  9729.                         }
  9730.                     }
  9731.                 }
  9732.                 
  9733.             }catch(java.lang.Exception e) {
  9734.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  9735.             }
  9736.             
  9737.         }

  9739.         return this.getTipoAutorizzazioneContenutiLockPermits.get(tipoAutorizzazioneContenuti);
  9740.     }
  9741.     
  9742.     
  9743.     
  9744.     



  9748.     /* ********  Bypass Filtri  ******** */

  9750.     /**
  9751.      * Restituisce le proprieta' che localizzano gli header element su cui deve essere applicato il filtro bypass.
  9752.      *
  9753.      * @return proprieta' che localizzano gli header element su cui deve essere applicato il filtro bypass.
  9754.      * 
  9755.      */
  9756.     private Map<String,List<NameValue>> mapGetBypassFilterMustUnderstandProperties = null;
  9757.     public List<NameValue> getBypassFilterMustUnderstandProperties(String protocol) {
  9758.         if(this.mapGetBypassFilterMustUnderstandProperties==null){
  9759.             initBypassFilterMustUnderstandProperties();
  9760.         }
  9761.         return this.mapGetBypassFilterMustUnderstandProperties.get(protocol);
  9762.     }
  9763.     private void initBypassFilterMustUnderstandProperties(){
  9764.         if(this.mapGetBypassFilterMustUnderstandProperties==null){
  9765.             
  9766.             this.mapGetBypassFilterMustUnderstandProperties = new HashMap<>();
  9767.             
  9768.             List<NameValue> resultList = new ArrayList<>();
  9769.             try{ 
  9770.                 java.util.Properties tmpP = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.");
  9771.                 if(tmpP!=null && tmpP.size()>0){
  9772.                     Enumeration<Object> keys = tmpP.keys();
  9773.                     while (keys.hasMoreElements()) {
  9774.                         Object object = keys.nextElement();
  9775.                         if(object instanceof String){
  9776.                             String key = (String) object;
  9777.                             String localName = key;
  9778.                             String namespace = tmpP.getProperty(key);
  9779.                             if(key.contains("!")){
  9780.                                 // serve a fornire più proprietà con stesso localName e namespace differente
  9781.                                 // tramite la formula 
  9782.                                 // org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.nomeHeader=http://prova
  9783.                                 // org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.nomeHeader!1=http://prova2
  9784.                                 // org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.nomeHeader!2=http://prova3
  9785.                                 localName = key.split("!")[0];
  9786.                             }
  9787.                             NameValue nameValue = new NameValue();
  9788.                             nameValue.setName(localName);
  9789.                             nameValue.setValue(namespace);
  9790.                             resultList.add(nameValue);
  9791.                         }
  9792.                     }
  9793.                 }
  9794.                 
  9795.                 
  9796.                 // aggiungo i bypass specifici dei protocolli
  9797.                 Enumeration<String> protocolli = ProtocolFactoryManager.getInstance().getProtocolFactories().keys();
  9798.                 while (protocolli.hasMoreElements()) {
  9799.                     String protocollo = protocolli.nextElement();
  9800.                     IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactories().get(protocollo);
  9801.                     IProtocolConfiguration pc = pf.createProtocolConfiguration();
  9802.                     List<BypassMustUnderstandCheck> list = pc.getBypassMustUnderstandCheck();
  9803.                     
  9804.                     List<NameValue> resultListForProtocol = new ArrayList<>();
  9805.                     if(resultList!=null && !resultList.isEmpty()){
  9806.                         resultListForProtocol.addAll(resultList);
  9807.                     }
  9808.                     
  9809.                     if(list!=null && !list.isEmpty()){
  9810.                         for (Iterator<?> iterator = list.iterator(); iterator.hasNext();) {
  9811.                             BypassMustUnderstandCheck bypassMustUnderstandCheck = (BypassMustUnderstandCheck) iterator.next();
  9812.                             
  9813.                             NameValue nameValue = new NameValue();
  9814.                             nameValue.setName(bypassMustUnderstandCheck.getElementName());
  9815.                             nameValue.setValue(bypassMustUnderstandCheck.getNamespace());
  9816.                             resultListForProtocol.add(nameValue);
  9817.                             
  9818.                         }
  9819.                     }
  9820.                     
  9821.                     for (NameValue nameValue : resultListForProtocol) {
  9822.                         this.logDebug("["+protocollo+"] ["+nameValue.getName()+"]=["+nameValue.getValue()+"]");
  9823.                     }
  9824.                     
  9825.                     this.mapGetBypassFilterMustUnderstandProperties.put(protocollo, resultListForProtocol);
  9826.                 }
  9827.                 
  9828.             }catch(java.lang.Exception e) {
  9829.                 this.logError("Riscontrato errore durante la lettura delle propriete' 'org.openspcoop2.pdd.services.BypassMustUnderstandHandler.header.*': "+e.getMessage(),e);
  9830.                 this.mapGetBypassFilterMustUnderstandProperties = null;
  9831.             }    
  9832.             
  9833.         }

  9835.     }

  9837.     /**
  9838.      * Restituisce l'indicazione se il BypassFilterMustUnderstand e' abilitato per tutti gli header
  9839.      *
  9840.      * @return Restituisce l'indicazione se il BypassFilterMustUnderstand e' abilitato per tutti gli header
  9841.      * 
  9842.      */
  9843.     private Boolean isBypassFilterMustUnderstandEnabledForAllHeaders = null;
  9844.     public boolean isBypassFilterMustUnderstandEnabledForAllHeaders(){
  9845.         if(this.isBypassFilterMustUnderstandEnabledForAllHeaders==null){
  9846.             try{  
  9847.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.BypassMustUnderstandHandler.allHeaders"); 

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

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

  9863.         return this.isBypassFilterMustUnderstandEnabledForAllHeaders;
  9864.     }





  9870.     
  9871.     
  9872.     /* ------------- ContentType ---------------------*/
  9873.     
  9874.     private Boolean isControlloContentTypeAbilitatoRicezioneContenutiApplicativi= null;
  9875.     public boolean isControlloContentTypeAbilitatoRicezioneContenutiApplicativi(){
  9876.         if(this.isControlloContentTypeAbilitatoRicezioneContenutiApplicativi==null){
  9877.             try{  
  9878.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.contentType.checkEnabled"); 

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

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

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

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

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

  9926.                 if(value!=null){
  9927.                     value = value.trim();
  9928.                     if("*".equals(value)) {
  9929.                         this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = false;
  9930.                     }
  9931.                     else {
  9932.                         List<String> l = new ArrayList<>();
  9933.                         initSplitValues(l, value, false);
  9934.                         if(!l.isEmpty()) {
  9935.                             this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = true;
  9936.                             this.listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = l;
  9937.                         }
  9938.                         else {
  9939.                             this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = false;
  9940.                         }
  9941.                     }
  9942.                 }else{
  9943.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9944.                     this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = false;
  9945.                 }

  9947.             }catch(java.lang.Exception e) {
  9948.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9949.                 this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap = false;
  9950.             }
  9951.         }
  9952.         return this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap;
  9953.     }
  9954.     public List<String> getControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap(){
  9955.         List<String> lNull = null;
  9956.         if(isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap()) {
  9957.             return this.listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiSoap;
  9958.         }
  9959.         return lNull;
  9960.     }
  9961.     
  9962.     private Boolean isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest= null;
  9963.     private List<String> listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = null;
  9964.     public boolean isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest(){
  9965.         if(this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest==null){
  9966.             String pName = "org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.rest.charsetExpected";
  9967.             try{  
  9968.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  9970.                 if(value!=null){
  9971.                     value = value.trim();
  9972.                     if("*".equals(value)) {
  9973.                         this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = false;
  9974.                     }
  9975.                     else {
  9976.                         List<String> l = new ArrayList<>();
  9977.                         initSplitValues(l, value, false);
  9978.                         if(!l.isEmpty()) {
  9979.                             this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = true;
  9980.                             this.listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = l;
  9981.                         }
  9982.                         else {
  9983.                             this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = false;
  9984.                         }
  9985.                     }
  9986.                 }else{
  9987.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  9988.                     this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = false;
  9989.                 }

  9991.             }catch(java.lang.Exception e) {
  9992.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  9993.                 this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest = false;
  9994.             }
  9995.         }
  9996.         return this.isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest;
  9997.     }
  9998.     public List<String> getControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest(){
  9999.         List<String> lNull = null;
  10000.         if(isControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest()) {
  10001.             return this.listControlloCharsetContentTypeAbilitatoRicezioneContenutiApplicativiRest;
  10002.         }
  10003.         return lNull;
  10004.     }
  10005.     
  10006.     private Boolean isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap= null;
  10007.     private List<String> listControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = null;
  10008.     public boolean isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap(){
  10009.         if(this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap==null){
  10010.             String pName = "org.openspcoop2.pdd.services.ricezioneBuste.soap.charsetExpected";
  10011.             try{  
  10012.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10014.                 if(value!=null){
  10015.                     value = value.trim();
  10016.                     if("*".equals(value)) {
  10017.                         this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = false;
  10018.                     }
  10019.                     else {
  10020.                         List<String> l = new ArrayList<>();
  10021.                         initSplitValues(l, value, false);
  10022.                         if(!l.isEmpty()) {
  10023.                             this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = true;
  10024.                             this.listControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = l;
  10025.                         }
  10026.                         else {
  10027.                             this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = false;
  10028.                         }
  10029.                     }
  10030.                 }else{
  10031.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10032.                     this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = false;
  10033.                 }

  10035.             }catch(java.lang.Exception e) {
  10036.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10037.                 this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap = false;
  10038.             }
  10039.         }
  10040.         return this.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap;
  10041.     }
  10042.     public List<String> getControlloCharsetContentTypeAbilitatoRicezioneBusteSoap(){
  10043.         List<String> lNull = null;
  10044.         if(isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap()) {
  10045.             return this.listControlloCharsetContentTypeAbilitatoRicezioneBusteSoap;
  10046.         }
  10047.         return lNull;
  10048.     }
  10049.     
  10050.     private Boolean isControlloCharsetContentTypeAbilitatoRicezioneBusteRest= null;
  10051.     private List<String> listControlloCharsetContentTypeAbilitatoRicezioneBusteRest = null;
  10052.     public boolean isControlloCharsetContentTypeAbilitatoRicezioneBusteRest(){
  10053.         if(this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest==null){
  10054.             String pName = "org.openspcoop2.pdd.services.ricezioneBuste.rest.charsetExpected";
  10055.             try{  
  10056.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10058.                 if(value!=null){
  10059.                     value = value.trim();
  10060.                     if("*".equals(value)) {
  10061.                         this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = false;
  10062.                     }
  10063.                     else {
  10064.                         List<String> l = new ArrayList<>();
  10065.                         initSplitValues(l, value, false);
  10066.                         if(!l.isEmpty()) {
  10067.                             this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = true;
  10068.                             this.listControlloCharsetContentTypeAbilitatoRicezioneBusteRest = l;
  10069.                         }
  10070.                         else {
  10071.                             this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = false;
  10072.                         }
  10073.                     }
  10074.                 }else{
  10075.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10076.                     this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = false;
  10077.                 }

  10079.             }catch(java.lang.Exception e) {
  10080.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10081.                 this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest = false;
  10082.             }
  10083.         }
  10084.         return this.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest;
  10085.     }
  10086.     public List<String> getControlloCharsetContentTypeAbilitatoRicezioneBusteRest(){
  10087.         List<String> lNull = null;
  10088.         if(isControlloCharsetContentTypeAbilitatoRicezioneBusteRest()) {
  10089.             return this.listControlloCharsetContentTypeAbilitatoRicezioneBusteRest;
  10090.         }
  10091.         return lNull;
  10092.     }
  10093.     
  10094.     private Boolean isPrintInfoCertificate= null;
  10095.     public boolean isPrintInfoCertificate(){
  10096.         if(this.isPrintInfoCertificate==null){
  10097.             try{  
  10098.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.certificate.printInfo"); 

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

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

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

  10128.                         if(value!=null){
  10129.                                 value = value.trim();
  10130.                                 this.isGestoreCredenzialiPortaDelegataEnabled = Boolean.parseBoolean(value);
  10131.                         }else{
  10132.                                 this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10133.                                 this.isGestoreCredenzialiPortaDelegataEnabled = false;
  10134.                         }

  10136.                 }catch(java.lang.Exception e) {
  10137.                         this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10138.                         this.isGestoreCredenzialiPortaDelegataEnabled = false;
  10139.                 }
  10140.         }
  10141.         return this.isGestoreCredenzialiPortaDelegataEnabled;
  10142.     }

  10144.     
  10145.     private Properties getGestoreCredenzialiPortaDelegataProperties = null;
  10146.     public Properties getGestoreCredenzialiPortaDelegataProperties() {
  10147.         if(this.getGestoreCredenzialiPortaDelegataProperties==null){
  10148.             try{  
  10149.                 this.getGestoreCredenzialiPortaDelegataProperties=this.reader.readProperties(prefixGestoreCredenzialiPortaDelegataProperties);
  10150.                 if(this.getGestoreCredenzialiPortaDelegataProperties==null) {
  10151.                     this.getGestoreCredenzialiPortaDelegataProperties=new Properties();
  10152.                 }
  10153.             }catch(java.lang.Exception e) {
  10154.                 this.logError("Proprieta' di openspcoop '"+prefixGestoreCredenzialiPortaDelegataProperties+"*' non impostate correttamente, errore:"+e.getMessage(),e);
  10155.                 this.getGestoreCredenzialiPortaDelegataProperties = null;
  10156.             }
  10157.         }
  10158.         return this.getGestoreCredenzialiPortaDelegataProperties;
  10159.     }

  10161.     
  10162.     
  10163.     /* ------------- Gestore Credenziali (Porta Applicativa) ---------------------*/

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

  10174.                         if(value!=null){
  10175.                                 value = value.trim();
  10176.                                 this.isGestoreCredenzialiPortaApplicativaEnabled = Boolean.parseBoolean(value);
  10177.                         }else{
  10178.                                 this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10179.                                 this.isGestoreCredenzialiPortaApplicativaEnabled = false;
  10180.                         }

  10182.                 }catch(java.lang.Exception e) {
  10183.                         this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10184.                         this.isGestoreCredenzialiPortaApplicativaEnabled = false;
  10185.                 }
  10186.         }
  10187.         return this.isGestoreCredenzialiPortaApplicativaEnabled;
  10188.     }

  10190.     
  10191.     private Properties getGestoreCredenzialiPortaApplicativaProperties = null;
  10192.     public Properties getGestoreCredenzialiPortaApplicativaProperties() {
  10193.         if(this.getGestoreCredenzialiPortaApplicativaProperties==null){
  10194.             try{  
  10195.                 this.getGestoreCredenzialiPortaApplicativaProperties=this.reader.readProperties(prefixGestoreCredenzialiPortaApplicativaProperties);
  10196.                 if(this.getGestoreCredenzialiPortaApplicativaProperties==null) {
  10197.                     this.getGestoreCredenzialiPortaApplicativaProperties=new Properties();
  10198.                 }
  10199.             }catch(java.lang.Exception e) {
  10200.                 this.logError("Proprieta' di openspcoop '"+prefixGestoreCredenzialiPortaApplicativaProperties+"*' non impostate correttamente, errore:"+e.getMessage(),e);
  10201.                 this.getGestoreCredenzialiPortaApplicativaProperties = null;
  10202.             }
  10203.         }
  10204.         return this.getGestoreCredenzialiPortaApplicativaProperties;
  10205.     }
  10206.     

  10208.     
  10209.     
  10210.     
  10211.     /* ********  MAP  ******** */
  10212.     
  10213.     private String getEnvMapConfig = null;
  10214.     public String getEnvMapConfig(){
  10215.         if(this.getEnvMapConfig==null){
  10216.             String pName = "org.openspcoop2.pdd.env.map.config";
  10217.             try{  
  10218.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  10219.                 if(value!=null){
  10220.                     value = value.trim();
  10221.                     if(!"".equals(value)) {
  10222.                         this.getEnvMapConfig = value;
  10223.                     }
  10224.                 }

  10226.             }catch(java.lang.Exception e) {
  10227.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verranno caricate variabili errore:"+e.getMessage(),e);
  10228.                 this.getEnvMapConfig = null;
  10229.             }
  10230.         }
  10231.         return this.getEnvMapConfig;
  10232.     }
  10233.     
  10234.     private Boolean isEnvMapConfigRequired= null;
  10235.     public boolean isEnvMapConfigRequired(){
  10236.         if(this.isEnvMapConfigRequired==null){
  10237.             String pName = "org.openspcoop2.pdd.env.map.required";
  10238.             try{  
  10239.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10241.                 if(value!=null){
  10242.                     value = value.trim();
  10243.                     this.isEnvMapConfigRequired = Boolean.parseBoolean(value);
  10244.                 }else{
  10245.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10246.                     this.isEnvMapConfigRequired = false;
  10247.                 }

  10249.             }catch(java.lang.Exception e) {
  10250.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10251.                 this.isEnvMapConfigRequired = false;
  10252.             }
  10253.         }
  10254.         return this.isEnvMapConfigRequired;
  10255.     }
  10256.     
  10257.     
  10258.     
  10259.     
  10260.     /* ********  HSM  ******** */
  10261.     
  10262.     private String getHSMConfig = null;
  10263.     public String getHSMConfig(){
  10264.         if(this.getHSMConfig==null){
  10265.             String pName = "org.openspcoop2.pdd.hsm.config";
  10266.             try{  
  10267.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  10268.                 if(value!=null){
  10269.                     value = value.trim();
  10270.                     if(!"".equals(value)) {
  10271.                         this.getHSMConfig = value;
  10272.                     }
  10273.                 }

  10275.             }catch(java.lang.Exception e) {
  10276.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verrà abilitato l'engine HSM errore:"+e.getMessage(),e);
  10277.                 this.getHSMConfig = null;
  10278.             }
  10279.         }
  10280.         return this.getHSMConfig;
  10281.     }
  10282.     
  10283.     private Boolean isHSMConfigRequired= null;
  10284.     public boolean isHSMConfigRequired(){
  10285.         if(this.isHSMConfigRequired==null){
  10286.             String pName = "org.openspcoop2.pdd.hsm.required";
  10287.             try{  
  10288.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10290.                 if(value!=null){
  10291.                     value = value.trim();
  10292.                     this.isHSMConfigRequired = Boolean.parseBoolean(value);
  10293.                 }else{
  10294.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10295.                     this.isHSMConfigRequired = false;
  10296.                 }

  10298.             }catch(java.lang.Exception e) {
  10299.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10300.                 this.isHSMConfigRequired = false;
  10301.             }
  10302.         }
  10303.         return this.isHSMConfigRequired;
  10304.     }
  10305.     
  10306.     private Boolean isHSMConfigUniqueProviderInstance= null;
  10307.     public boolean isHSMConfigUniqueProviderInstance(){
  10308.         if(this.isHSMConfigUniqueProviderInstance==null){
  10309.             String pName = "org.openspcoop2.pdd.hsm.uniqueProviderInstance";
  10310.             try{  
  10311.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10313.                 if(value!=null){
  10314.                     value = value.trim();
  10315.                     this.isHSMConfigUniqueProviderInstance = Boolean.parseBoolean(value);
  10316.                 }else{
  10317.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  10318.                     this.isHSMConfigUniqueProviderInstance = true;
  10319.                 }

  10321.             }catch(java.lang.Exception e) {
  10322.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, true),e);
  10323.                 this.isHSMConfigUniqueProviderInstance = true;
  10324.             }
  10325.         }
  10326.         return this.isHSMConfigUniqueProviderInstance;
  10327.     }
  10328.     

  10330.     
  10331.     
  10332.     /* ********  OCSP  ******** */
  10333.     
  10334.     private String getOCSPConfig = null;
  10335.     public String getOCSPConfig(){
  10336.         if(this.getOCSPConfig==null){
  10337.             String pName = "org.openspcoop2.pdd.ocsp.config";
  10338.             try{  
  10339.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  10340.                 if(value!=null){
  10341.                     value = value.trim();
  10342.                     if(!"".equals(value)) {
  10343.                         this.getOCSPConfig = value;
  10344.                     }
  10345.                 }

  10347.             }catch(java.lang.Exception e) {
  10348.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verrà abilitato l'engine OCSP errore:"+e.getMessage(),e);
  10349.                 this.getOCSPConfig = null;
  10350.             }
  10351.         }
  10352.         return this.getOCSPConfig;
  10353.     }
  10354.     
  10355.     private Boolean isOCSPConfigRequired= null;
  10356.     public boolean isOCSPConfigRequired(){
  10357.         if(this.isOCSPConfigRequired==null){
  10358.             String pName = "org.openspcoop2.pdd.ocsp.required";
  10359.             try{  
  10360.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10362.                 if(value!=null){
  10363.                     value = value.trim();
  10364.                     this.isOCSPConfigRequired = Boolean.parseBoolean(value);
  10365.                 }else{
  10366.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10367.                     this.isOCSPConfigRequired = false;
  10368.                 }

  10370.             }catch(java.lang.Exception e) {
  10371.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10372.                 this.isOCSPConfigRequired = false;
  10373.             }
  10374.         }
  10375.         return this.isOCSPConfigRequired;
  10376.     }
  10377.     
  10378.     private Boolean isOCSPConfigLoadDefault= null;
  10379.     public boolean isOCSPConfigLoadDefault(){
  10380.         if(this.isOCSPConfigLoadDefault==null){
  10381.             String pName = "org.openspcoop2.pdd.ocsp.loadDefault";
  10382.             try{  
  10383.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10385.                 if(value!=null){
  10386.                     value = value.trim();
  10387.                     this.isOCSPConfigLoadDefault = Boolean.parseBoolean(value);
  10388.                 }else{
  10389.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  10390.                     this.isOCSPConfigLoadDefault = true;
  10391.                 }

  10393.             }catch(java.lang.Exception e) {
  10394.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, true),e);
  10395.                 this.isOCSPConfigLoadDefault = true;
  10396.             }
  10397.         }
  10398.         return this.isOCSPConfigLoadDefault;
  10399.     }
  10400.     
  10401.     
  10402.     
  10403.     
  10404.     
  10405.     /* ********  BYOK  ******** */
  10406.     
  10407.     private String getBYOKConfig = null;
  10408.     public String getBYOKConfig(){
  10409.         if(this.getBYOKConfig==null){
  10410.             String pName = "org.openspcoop2.pdd.byok.config";
  10411.             try{  
  10412.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  10413.                 if(value!=null){
  10414.                     value = value.trim();
  10415.                     if(!"".equals(value)) {
  10416.                         this.getBYOKConfig = value;
  10417.                     }
  10418.                 }

  10420.             }catch(java.lang.Exception e) {
  10421.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verrà abilitato l'engine BYOK errore:"+e.getMessage(),e);
  10422.                 this.getBYOKConfig = null;
  10423.             }
  10424.         }
  10425.         return this.getBYOKConfig;
  10426.     }
  10427.     
  10428.     private Boolean isBYOKConfigRequired= null;
  10429.     public boolean isBYOKConfigRequired(){
  10430.         if(this.isBYOKConfigRequired==null){
  10431.             String pName = "org.openspcoop2.pdd.byok.required";
  10432.             try{  
  10433.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10435.                 if(value!=null){
  10436.                     value = value.trim();
  10437.                     this.isBYOKConfigRequired = Boolean.parseBoolean(value);
  10438.                 }else{
  10439.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10440.                     this.isBYOKConfigRequired = false;
  10441.                 }

  10443.             }catch(java.lang.Exception e) {
  10444.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10445.                 this.isBYOKConfigRequired = false;
  10446.             }
  10447.         }
  10448.         return this.isBYOKConfigRequired;
  10449.     }
  10450.     
  10451.     private Boolean isBYOKJmxWrapEnbled= null;
  10452.     public boolean isBYOKJmxWrapEnbled(){
  10453.         if(this.isBYOKJmxWrapEnbled==null){
  10454.             String pName = "org.openspcoop2.pdd.byok.jmx.wrap.enabled";
  10455.             try{  
  10456.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10458.                 if(value!=null){
  10459.                     value = value.trim();
  10460.                     this.isBYOKJmxWrapEnbled = Boolean.parseBoolean(value);
  10461.                 }else{
  10462.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10463.                     this.isBYOKJmxWrapEnbled = false;
  10464.                 }

  10466.             }catch(java.lang.Exception e) {
  10467.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10468.                 this.isBYOKJmxWrapEnbled = false;
  10469.             }
  10470.         }
  10471.         return this.isBYOKJmxWrapEnbled;
  10472.     }
  10473.     
  10474.     private Boolean isBYOKJmxUnwrapEnbled= null;
  10475.     public boolean isBYOKJmxUnwrapEnbled(){
  10476.         if(this.isBYOKJmxUnwrapEnbled==null){
  10477.             String pName = "org.openspcoop2.pdd.byok.jmx.unwrap.enabled";
  10478.             try{  
  10479.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10481.                 if(value!=null){
  10482.                     value = value.trim();
  10483.                     this.isBYOKJmxUnwrapEnbled = Boolean.parseBoolean(value);
  10484.                 }else{
  10485.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10486.                     this.isBYOKJmxUnwrapEnbled = false;
  10487.                 }

  10489.             }catch(java.lang.Exception e) {
  10490.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10491.                 this.isBYOKJmxUnwrapEnbled = false;
  10492.             }
  10493.         }
  10494.         return this.isBYOKJmxUnwrapEnbled;
  10495.     }
  10496.         
  10497.     private String getBYOKEnvSecretsConfig = null;
  10498.     public String getBYOKEnvSecretsConfig(){
  10499.         if(this.getBYOKEnvSecretsConfig==null){
  10500.             String pName = "org.openspcoop2.pdd.byok.env.secrets.config";
  10501.             try{  
  10502.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  10503.                 if(value!=null){
  10504.                     value = value.trim();
  10505.                     if(!"".equals(value)) {
  10506.                         this.getBYOKEnvSecretsConfig = value;
  10507.                     }
  10508.                 }

  10510.             }catch(java.lang.Exception e) {
  10511.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, non verranno caricati secrets errore:"+e.getMessage(),e);
  10512.                 this.getBYOKEnvSecretsConfig = null;
  10513.             }
  10514.         }
  10515.         return this.getBYOKEnvSecretsConfig;
  10516.     }
  10517.     
  10518.     private Boolean isBYOKEnvSecretsConfigRequired= null;
  10519.     public boolean isBYOKEnvSecretsConfigRequired(){
  10520.         if(this.isBYOKEnvSecretsConfigRequired==null){
  10521.             String pName = "org.openspcoop2.pdd.byok.env.secrets.required";
  10522.             try{  
  10523.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  10525.                 if(value!=null){
  10526.                     value = value.trim();
  10527.                     this.isBYOKEnvSecretsConfigRequired = Boolean.parseBoolean(value);
  10528.                 }else{
  10529.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  10530.                     this.isBYOKEnvSecretsConfigRequired = false;
  10531.                 }

  10533.             }catch(java.lang.Exception e) {
  10534.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, false),e);
  10535.                 this.isBYOKEnvSecretsConfigRequired = false;
  10536.             }
  10537.         }
  10538.         return this.isBYOKEnvSecretsConfigRequired;
  10539.     }
  10540.     
  10541.     
  10542.     
  10543.     

  10545.     /* ********  NODE RECEIVER  ******** */


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

  10573.         return this.nodeReceiverTimeout;
  10574.     } 
  10575.     /**
  10576.      * Restituisce il Timeout di attesa di una risposta applicativa
  10577.      *
  10578.      * @return Restituisce il Timeout di attesa di una risposta applicativa
  10579.      * 
  10580.      */
  10581.     private Long nodeReceiverTimeoutRicezioneContenutiApplicativi = null;
  10582.     public long getNodeReceiverTimeoutRicezioneContenutiApplicativi() { 
  10583.         if(this.nodeReceiverTimeoutRicezioneContenutiApplicativi == null){
  10584.             try{ 
  10585.                 String name = null;
  10586.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.ricezioneContenutiApplicativi.timeout");
  10587.                 if(name!=null){
  10588.                     name = name.trim();
  10589.                     this.nodeReceiverTimeoutRicezioneContenutiApplicativi = java.lang.Long.parseLong(name);
  10590.                 }else{
  10591.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.ricezioneContenutiApplicativi.timeout' non impostata, viene utilizzato il default="+this.getNodeReceiverTimeout());
  10592.                     this.nodeReceiverTimeoutRicezioneContenutiApplicativi = this.getNodeReceiverTimeout();
  10593.                 }
  10594.             }catch(java.lang.Exception e) {
  10595.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.ricezioneContenutiApplicativi.timeout' non impostata, viene utilizzato il default="+this.getNodeReceiverTimeout()+", errore:"+e.getMessage(),e);
  10596.                 this.nodeReceiverTimeoutRicezioneContenutiApplicativi = this.getNodeReceiverTimeout();
  10597.             }    
  10598.         }

  10600.         return this.nodeReceiverTimeoutRicezioneContenutiApplicativi;
  10601.     } 
  10602.     /**
  10603.      * Restituisce il Timeout di attesa di una busta
  10604.      *
  10605.      * @return Restituisce il Timeout di attesa di una busta
  10606.      * 
  10607.      */
  10608.     private Long nodeReceiverTimeoutRicezioneBuste = null;
  10609.     public long getNodeReceiverTimeoutRicezioneBuste() {    
  10610.         if(this.nodeReceiverTimeoutRicezioneBuste == null){
  10611.             try{ 
  10612.                 String name = null;
  10613.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.ricezioneBuste.timeout");

  10615.                 if(name!=null){
  10616.                     name = name.trim();
  10617.                     this.nodeReceiverTimeoutRicezioneBuste = java.lang.Long.parseLong(name);
  10618.                 }else{
  10619.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.ricezioneBuste.timeout' non impostata, viene utilizzato il default="+this.getNodeReceiverTimeout());
  10620.                     this.nodeReceiverTimeoutRicezioneBuste = this.getNodeReceiverTimeout();
  10621.                 }
  10622.             }catch(java.lang.Exception e) {
  10623.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.ricezioneBuste.timeout' non impostata, viene utilizzato il default="+this.getNodeReceiverTimeout()+", errore:"+e.getMessage(),e);
  10624.                 this.nodeReceiverTimeoutRicezioneBuste = this.getNodeReceiverTimeout();
  10625.             }    
  10626.         }

  10628.         return this.nodeReceiverTimeoutRicezioneBuste;
  10629.     } 
  10630.     /**
  10631.      * Restituisce la Frequenza di check sulla coda RicezioneBuste/RicezioneContenutiApplicativi
  10632.      *
  10633.      * @return Restituisce la Frequenza di check sulla coda RicezioneBuste/RicezioneContenutiApplicativi
  10634.      * 
  10635.      */
  10636.     private Integer nodeReceiverCheckInterval = null;
  10637.     public int getNodeReceiverCheckInterval() { 
  10638.         if(this.nodeReceiverCheckInterval==null){
  10639.             try{ 
  10640.                 String name = null;
  10641.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.check");
  10642.                 if(name!=null){
  10643.                     name = name.trim();
  10644.                     this.nodeReceiverCheckInterval = java.lang.Integer.parseInt(name);
  10645.                 }else{
  10646.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.check' non impostata, viene utilizzato il default="+CostantiPdD.NODE_RECEIVER_CHECK_INTERVAL);
  10647.                     this.nodeReceiverCheckInterval = CostantiPdD.NODE_RECEIVER_CHECK_INTERVAL;
  10648.                 }
  10649.             }catch(java.lang.Exception e) {
  10650.                 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);
  10651.                 this.nodeReceiverCheckInterval = CostantiPdD.NODE_RECEIVER_CHECK_INTERVAL;
  10652.             }    
  10653.         }

  10655.         return this.nodeReceiverCheckInterval;
  10656.     }

  10658.     /**
  10659.      * Restituisce l'intervallo di check su DB effettuata dal TransactionManager, in caso di cache attiva
  10660.      * 
  10661.      * @return Restituisce intervallo di check su DB effettuata dal TransactionManager, in caso di cache attiva
  10662.      * 
  10663.      */
  10664.     private Integer nodeReceiverCheckDBInterval = null;
  10665.     public int getNodeReceiverCheckDBInterval() {   
  10666.         if(this.nodeReceiverCheckDBInterval==null){
  10667.             try{ 
  10668.                 String name = null;
  10669.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver.checkDB");

  10671.                 if(name!=null){
  10672.                     name = name.trim();
  10673.                     int time = java.lang.Integer.parseInt(name);
  10674.                     this.nodeReceiverCheckDBInterval = time;
  10675.                 }else{
  10676.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.checkDB' non impostata, viene utilizzato il default="+CostantiPdD.NODE_RECEIVER_CHECK_DB_INTERVAL);
  10677.                     this.nodeReceiverCheckDBInterval = CostantiPdD.NODE_RECEIVER_CHECK_DB_INTERVAL;
  10678.                 }
  10679.             }catch(java.lang.Exception e) {
  10680.                 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);
  10681.                 this.nodeReceiverCheckDBInterval = CostantiPdD.NODE_RECEIVER_CHECK_DB_INTERVAL;
  10682.             }  
  10683.         }

  10685.         return this.nodeReceiverCheckDBInterval;
  10686.     }

  10688.     /**
  10689.      * Restituisce il nodeReceiver da utilizzare per le comunicazioni infrastrutturali 
  10690.      * 
  10691.      * @return  il nodeReceiver da utilizzare per le comunicazioni infrastrutturali 
  10692.      */
  10693.     private String nodeReceiver = null;
  10694.     public String getNodeReceiver() {
  10695.         if(this.nodeReceiver==null){
  10696.             try{ 
  10697.                 this.nodeReceiver = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeReceiver");
  10698.                 if(this.nodeReceiver==null)
  10699.                     throw new CoreException(NON_DEFINITA);
  10700.                 this.nodeReceiver = this.nodeReceiver.trim();

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

  10708.         return this.nodeReceiver;
  10709.     }

  10711.     /**
  10712.      * Restituisce l'indicazione se il NodeReceiver deve essere utilizzato in single connection
  10713.      *
  10714.      * @return Restituisce l'indicazione se il NodeReceiver deve essere utilizzato in single connection
  10715.      * 
  10716.      */
  10717.     private Boolean singleConnectionNodeReceiverValue = null;
  10718.     public boolean singleConnectionNodeReceiver(){

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

  10724.                 if(value!=null){
  10725.                     value = value.trim();
  10726.                     this.singleConnectionNodeReceiverValue = Boolean.parseBoolean(value);
  10727.                 }else{
  10728.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.nodeReceiver.singleConnection' non impostata, viene utilizzato il default=false");
  10729.                     this.singleConnectionNodeReceiverValue = false;
  10730.                 }

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

  10738.         return this.singleConnectionNodeReceiverValue;

  10740.     }




  10745.     /* ********  NODE SENDER  ******** */

  10747.     /**
  10748.      * Restituisce il nodeSender da utilizzare per le comunicazioni infrastrutturali 
  10749.      * 
  10750.      * @return  il nodeSender da utilizzare per le comunicazioni infrastrutturali 
  10751.      */
  10752.     private String nodeSender = null;
  10753.     public String getNodeSender() {
  10754.         if(this.nodeSender==null){
  10755.             try{ 
  10756.                 this.nodeSender = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.nodeSender");
  10757.                 if(this.nodeSender==null)
  10758.                     throw new CoreException(NON_DEFINITA);
  10759.                 this.nodeSender = this.nodeSender.trim();

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

  10767.         return this.nodeSender;
  10768.     }








  10777.     /* ********  EJB  ******** */

  10779.     /**
  10780.      * Restituisce il Timeout di attesa per i deploy dei timer
  10781.      *
  10782.      * @return Restituisce il Timeout di attesa per i deploy dei timer
  10783.      * 
  10784.      */
  10785.     private Long timerEJBDeployTimeout = null;
  10786.     public long getTimerEJBDeployTimeout() {    
  10787.         if(this.timerEJBDeployTimeout==null){
  10788.             try{ 
  10789.                 String name = null;
  10790.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.timeout");

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

  10805.         return this.timerEJBDeployTimeout;
  10806.     } 
  10807.     /**
  10808.      * Restituisce la Frequenza di check per il deploy dei timer
  10809.      *
  10810.      * @return Restituisce la Frequenza di check per il deploy dei timer
  10811.      * 
  10812.      */
  10813.     private Integer timerEJBDeployCheckInterval = null;
  10814.     public int getTimerEJBDeployCheckInterval() {   
  10815.         if(this.timerEJBDeployCheckInterval==null){
  10816.             try{ 
  10817.                 String name = null;
  10818.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.check");

  10820.                 if(name!=null){
  10821.                     name = name.trim();
  10822.                     this.timerEJBDeployCheckInterval = java.lang.Integer.parseInt(name);
  10823.                 }else{
  10824.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.check' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_EJB_CHECK_INTERVAL);
  10825.                     this.timerEJBDeployCheckInterval = CostantiPdD.TIMER_EJB_CHECK_INTERVAL;
  10826.                 }
  10827.             }catch(java.lang.Exception e) {
  10828.                 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);
  10829.                 this.timerEJBDeployCheckInterval = CostantiPdD.TIMER_EJB_CHECK_INTERVAL;
  10830.             }  
  10831.         }

  10833.         return this.timerEJBDeployCheckInterval;
  10834.     }








  10843.     /* ********  TRANSACTION MANAGER  ******** */

  10845.     /**
  10846.      * Restituisce l'intervallo in millisecondi di attesa attiva effettuato dal Transaction Manager (Default 2 minuti)
  10847.      * 
  10848.      * @return Restituisce l'intervallo in millisecondi di attesa attiva effettuato dal Transaction Manager (Default 2 minuti)
  10849.      *  * 
  10850.      */
  10851.     private Long transactionManagerAttesaAttiva = null;
  10852.     public long getTransactionManagerAttesaAttiva() {   
  10853.         if(this.transactionManagerAttesaAttiva==null){
  10854.             try{ 
  10855.                 String name = null;
  10856.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.TransactionManager.attesaAttiva");

  10858.                 if(name!=null){
  10859.                     name = name.trim();
  10860.                     long time = java.lang.Long.parseLong(name);
  10861.                     this.transactionManagerAttesaAttiva = time*1000;
  10862.                 }else{
  10863.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.attesaAttiva' non impostata, viene utilizzato il default="+CostantiPdD.TRANSACTION_MANAGER_ATTESA_ATTIVA);
  10864.                     this.transactionManagerAttesaAttiva = CostantiPdD.TRANSACTION_MANAGER_ATTESA_ATTIVA;
  10865.                 }
  10866.             }catch(java.lang.Exception e) {
  10867.                 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);
  10868.                 this.transactionManagerAttesaAttiva = CostantiPdD.TRANSACTION_MANAGER_ATTESA_ATTIVA;
  10869.             }    
  10870.         }

  10872.         return this.transactionManagerAttesaAttiva;
  10873.     }

  10875.     /**
  10876.      * Restituisce l'intervallo maggiore per frequenza di check nell'attesa attiva effettuata dal TransactionManager, in millisecondi
  10877.      * 
  10878.      * @return Restituisce Intervallo maggiore per frequenza di check nell'attesa attiva effettuata dal TransactionManager, in millisecondi
  10879.      * 
  10880.      */
  10881.     private Integer transactionManagerCheckInterval = null;
  10882.     public int getTransactionManagerCheckInterval() {   
  10883.         if(this.transactionManagerCheckInterval==null){
  10884.             try{ 
  10885.                 String name = null;
  10886.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.TransactionManager.check");

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

  10902.         return this.transactionManagerCheckInterval;
  10903.     }

  10905.     /**
  10906.      * Restituisce l'intervallo di check su DB effettuata dal TransactionManager, in caso di cache attiva
  10907.      * 
  10908.      * @return Restituisce intervallo di check su DB effettuata dal TransactionManager, in caso di cache attiva
  10909.      * 
  10910.      */
  10911.     private Integer transactionManagerCheckDBInterval = null;
  10912.     public int getTransactionManagerCheckDBInterval() { 
  10913.         if(this.transactionManagerCheckDBInterval==null){
  10914.             try{ 
  10915.                 String name = null;
  10916.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.TransactionManager.checkDB");

  10918.                 if(name!=null){
  10919.                     name = name.trim();
  10920.                     int time = java.lang.Integer.parseInt(name);
  10921.                     this.transactionManagerCheckDBInterval = time;
  10922.                 }else{
  10923.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.TransactionManager.checkDB' non impostata, viene utilizzato il default="+CostantiPdD.TRANSACTION_MANAGER_CHECK_DB_INTERVAL);
  10924.                     this.transactionManagerCheckDBInterval = CostantiPdD.TRANSACTION_MANAGER_CHECK_DB_INTERVAL;
  10925.                 }
  10926.             }catch(java.lang.Exception e) {
  10927.                 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);
  10928.                 this.transactionManagerCheckDBInterval = CostantiPdD.TRANSACTION_MANAGER_CHECK_DB_INTERVAL;
  10929.             }  
  10930.         }

  10932.         return this.transactionManagerCheckDBInterval;
  10933.     }


  10936.     /**
  10937.      * Restituisce l'indicazione se il TransactionManager deve essere utilizzato in single connection
  10938.      *
  10939.      * @return Restituisce l'indicazione se il TransactionManager deve essere utilizzato in single connection
  10940.      * 
  10941.      */
  10942.     private Boolean singleConnectionTransactionManagerValue = null;
  10943.     public boolean singleConnectionTransactionManager(){

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

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

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

  10963.         return this.singleConnectionTransactionManagerValue;

  10965.     }






  10972.     /* ********  SERIALIZABLE  ******** */

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

  11000.         return this.gestioneSerializableDBAttesaAttiva;
  11001.     }

  11003.     /**
  11004.      * Restituisce l'intervallo maggiore per frequenza di check nell'attesa attiva effettuata per la gestione del livello serializable nel DB, in millisecondi
  11005.      * 
  11006.      * @return Restituisce Intervallo maggiore per frequenza di check nell'attesa attiva effettuata per la gestione del livello serializable nel DB, in millisecondi
  11007.      */
  11008.     private Integer gestioneSerializableDBCheckInterval = null;
  11009.     public int getGestioneSerializableDBCheckInterval() {   
  11010.         if(this.gestioneSerializableDBCheckInterval==null){
  11011.             try{ 
  11012.                 String name = null;
  11013.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.jdbc.serializable.check");
  11014.                 if (name != null){
  11015.                     name = name.trim();
  11016.                     int time = java.lang.Integer.parseInt(name);
  11017.                     this.gestioneSerializableDBCheckInterval = time;
  11018.                 } else{
  11019.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jdbc.serializable.check' non impostata, viene utilizzato il default="+Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL);
  11020.                     this.gestioneSerializableDBCheckInterval = Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL;
  11021.                 }
  11022.             }catch(java.lang.Exception e) {
  11023.                 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);
  11024.                 this.gestioneSerializableDBCheckInterval = Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL;
  11025.             }    
  11026.         }

  11028.         return this.gestioneSerializableDBCheckInterval;
  11029.     }

  11031.     private Boolean isJdbcCloseConnectionCheckIsClosed = null;
  11032.     public boolean isJdbcCloseConnectionCheckIsClosed(){

  11034.         if(this.isJdbcCloseConnectionCheckIsClosed==null){
  11035.             String pName = "org.openspcoop2.pdd.jdbc.closeConnection.checkIsClosed";
  11036.             try{  
  11037.                 String value = this.reader.getValueConvertEnvProperties(pName); 

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

  11047.             }catch(java.lang.Exception e) {
  11048.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  11049.                 this.isJdbcCloseConnectionCheckIsClosed = true;
  11050.             }
  11051.         }

  11053.         return this.isJdbcCloseConnectionCheckIsClosed;

  11055.     }
  11056.     
  11057.     private Boolean isJdbcCloseConnectionCheckAutocommit = null;
  11058.     public boolean isJdbcCloseConnectionCheckAutocommit(){

  11060.         if(this.isJdbcCloseConnectionCheckAutocommit==null){
  11061.             String pName = "org.openspcoop2.pdd.jdbc.closeConnection.checkAutocommit";
  11062.             try{  
  11063.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  11065.                 if(value!=null){
  11066.                     value = value.trim();
  11067.                     this.isJdbcCloseConnectionCheckAutocommit = Boolean.parseBoolean(value);
  11068.                 }else{
  11069.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  11070.                     this.isJdbcCloseConnectionCheckAutocommit = true;
  11071.                 }

  11073.             }catch(java.lang.Exception e) {
  11074.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  11075.                 this.isJdbcCloseConnectionCheckAutocommit = true;
  11076.             }
  11077.         }

  11079.         return this.isJdbcCloseConnectionCheckAutocommit;

  11081.     }






  11088.     /* ********  LIBRERIA PROTOCOL  ******** */

  11090.     /**
  11091.      * Restituisce il tipo di gestione del RepositoryBuste
  11092.      * 
  11093.      * @return Restituisce il tipo di gestione  del RepositoryBuste
  11094.      */
  11095.     private String gestoreRepositoryBuste = null;
  11096.     public String getGestoreRepositoryBuste() {
  11097.         if(this.gestoreRepositoryBuste==null){
  11098.             try{ 
  11099.                 String name = null;
  11100.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.repository.gestore");
  11101.                 if(name==null)
  11102.                     throw new CoreException(NON_DEFINITA);
  11103.                 name = name.trim();
  11104.                 
  11105.                 if(CostantiConfigurazione.REPOSITORY_BUSTE_AUTO_BYTEWISE.equals(name)){
  11106.                     if(this.getDatabaseType()!=null){
  11107.                         name = GestoreRepositoryFactory.getTipoRepositoryBuste(this.getDatabaseType());
  11108.                     }
  11109.                     else{
  11110.                         this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.protocol.repository.gestore': il valore '"+
  11111.                                 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: "+
  11112.                                 CostantiConfigurazione.REPOSITORY_BUSTE_DEFAULT);
  11113.                         name = CostantiConfigurazione.REPOSITORY_BUSTE_DEFAULT;
  11114.                     }
  11115.                 }
  11116.                 
  11117.                 this.gestoreRepositoryBuste = name;
  11118.             
  11119.             }catch(java.lang.Exception e) {
  11120.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.protocol.repository.gestore': "+e.getMessage(),e);
  11121.                 this.gestoreRepositoryBuste = null;
  11122.             }    
  11123.         }

  11125.         return this.gestoreRepositoryBuste;
  11126.     }

  11128.     /**
  11129.      * Restituisce il tipo di filtro duplicati utilizzato dal RepositoryBuste
  11130.      * 
  11131.      * @return Restituisce il tipo di filtro duplicati utilizzato dal RepositoryBuste
  11132.      */
  11133.     private String gestoreFiltroDuplicatiRepositoryBuste = null;
  11134.     public String getGestoreFiltroDuplicatiRepositoryBuste() {
  11135.         if(this.gestoreFiltroDuplicatiRepositoryBuste==null){
  11136.             try{ 
  11137.                 String name = null;
  11138.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.filtroDuplicati");
  11139.                 if(name==null){
  11140.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.filtroDuplicati' non impostata, viene utilizzato il default="+CostantiConfigurazione.FILTRO_DUPLICATI_OPENSPCOOP);
  11141.                     this.gestoreFiltroDuplicatiRepositoryBuste = CostantiConfigurazione.FILTRO_DUPLICATI_OPENSPCOOP;
  11142.                 }else{
  11143.                     name = name.trim();
  11144.                     this.gestoreFiltroDuplicatiRepositoryBuste = name;
  11145.                 }
  11146.             
  11147.             }catch(java.lang.Exception e) {
  11148.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.filtroDuplicati' non impostata, viene utilizzato il default="+CostantiConfigurazione.FILTRO_DUPLICATI_OPENSPCOOP+", errore:"+e.getMessage(),e);
  11149.                 this.gestoreFiltroDuplicatiRepositoryBuste = CostantiConfigurazione.FILTRO_DUPLICATI_OPENSPCOOP;
  11150.             }    
  11151.         }

  11153.         return this.gestoreFiltroDuplicatiRepositoryBuste;
  11154.     }

  11156.     /**
  11157.      * Restituisce la Generazione attributi 'tipo' e 'servizioCorrelato' nell'elemento 'ProfiloCollaborazione' della richiesta asincrona simmetrica 
  11158.      * e della ricevuta alla richiesta asincrona asimmetrica
  11159.      *   
  11160.      * @return Restituisce la Generazione attributi 'tipo' e 'servizioCorrelato' nell'elemento 'ProfiloCollaborazione' della richiesta asincrona simmetrica 
  11161.      *         e della ricevuta alla richiesta asincrona asimmetrica
  11162.      * 
  11163.      */
  11164.     private Boolean isGenerazioneAttributiAsincroni = null;
  11165.     public boolean isGenerazioneAttributiAsincroni(String implementazionePdDSoggetto){

  11167.         // ovverriding per implementazione porta di dominio
  11168.         if(this.pddReader!=null){
  11169.             String tipo = this.pddReader.getBusta_AsincroniAttributiCorrelatiEnable(implementazionePdDSoggetto);
  11170.             if(tipo!=null && ( 
  11171.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11172.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11173.             ){
  11174.                 return CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo);
  11175.             }
  11176.         }

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

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

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

  11196.         return this.isGenerazioneAttributiAsincroni;
  11197.     }

  11199.     

  11201.     /**
  11202.      * Indicazione se ritenere una busta malformata se la validazione ha rilevato eccezioni di livello non gravi
  11203.      *   
  11204.      * @return Indicazione se ritenere una busta malformata se la validazione ha rilevato eccezioni di livello non gravi
  11205.      * 
  11206.      */
  11207.     private Boolean ignoraEccezioniNonGraviValidazione = null;
  11208.     public boolean ignoraEccezioniNonGraviValidazione(){
  11209.         if(this.ignoraEccezioniNonGraviValidazione==null){
  11210.             try{  
  11211.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.validazione.ignoraEccezioniNonGravi"); 

  11213.                 if (value != null){
  11214.                     value = value.trim();
  11215.                     this.ignoraEccezioniNonGraviValidazione = Boolean.parseBoolean(value);
  11216.                 }else{
  11217.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.protocol.validazione.ignoraEccezioniNonGravi' non impostata, viene utilizzato il default=false");
  11218.                     this.ignoraEccezioniNonGraviValidazione = false;
  11219.                 }

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

  11227.         return this.ignoraEccezioniNonGraviValidazione;
  11228.     }
  11229.     
  11230.     /**
  11231.      * Indicazione se forzare la generazione del prefix 'soap' per i fault spcoop (compatibilita' con OpenSPCoop v1).
  11232.      *   
  11233.      * @return Indicazione se forzare la generazione del prefix 'soap' per i fault spcoop (compatibilita' con OpenSPCoop v1).
  11234.      * 
  11235.      */
  11236.     private Boolean forceSoapPrefixCompatibilitaOpenSPCoopV1 = null;
  11237.     public boolean isForceSoapPrefixCompatibilitaOpenSPCoopV1(){
  11238.         if(this.forceSoapPrefixCompatibilitaOpenSPCoopV1==null){
  11239.             try{  
  11240.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.spcoop.backwardCompatibility.forceSoapPrefix"); 

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

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

  11256.         return this.forceSoapPrefixCompatibilitaOpenSPCoopV1;
  11257.     }
  11258.     

  11260.     /**
  11261.      * Indicazione se generare la lista Trasmissione
  11262.      *   
  11263.      * @return Indicazione se generare la lista Trasmissione
  11264.      * 
  11265.      */
  11266.     private Boolean isGenerazioneListaTrasmissioni = null;
  11267.     public boolean isGenerazioneListaTrasmissioni(String implementazionePdDSoggetto){

  11269.         // ovverriding per implementazione porta di dominio
  11270.         if(this.pddReader!=null){           
  11271.             String tipo = this.pddReader.getBusta_TrasmissioneEnable(implementazionePdDSoggetto);
  11272.             if(tipo!=null && ( 
  11273.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11274.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11275.             ){
  11276.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11277.                     return true;
  11278.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11279.                     return false;
  11280.             }
  11281.         }

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

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

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

  11301.         return this.isGenerazioneListaTrasmissioni;
  11302.     }

  11304.     /**
  11305.      * Indicazione se generare un msg di Protocollo errore in caso di filtro duplicati anche per il profilo oneway
  11306.      *   
  11307.      * @return Indicazione se generare un msg di Protocollo errore in caso di filtro duplicati  anche per il profilo oneway
  11308.      * 
  11309.      */
  11310.     private Boolean isGenerazioneErroreFiltroDuplicati = null;
  11311.     public boolean isGenerazioneErroreProtocolloFiltroDuplicati(String implementazionePdDSoggetto){

  11313.         // ovverriding per implementazione porta di dominio
  11314.         if(this.pddReader!=null){
  11315.             String tipo = this.pddReader.getBusta_FiltroduplicatiGenerazioneBustaErrore(implementazionePdDSoggetto);
  11316.             if(tipo!=null && ( 
  11317.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11318.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11319.             ){
  11320.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11321.                     return true;
  11322.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11323.                     return false;
  11324.             }
  11325.         }

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

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

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

  11345.         return this.isGenerazioneErroreFiltroDuplicati;
  11346.     }

  11348.     /**
  11349.      * Indicazione se leggere dal registro se abilitato il filtro duplicati
  11350.      *   
  11351.      * @return Indicazione se leggere dal registro se abilitato il filtro duplicati
  11352.      * 
  11353.      */
  11354.     private Boolean isCheckFromRegistroFiltroDuplicatiAbilitato = null;
  11355.     public boolean isCheckFromRegistroFiltroDuplicatiAbilitato(String implementazionePdDSoggetto){

  11357.         // ovverriding per implementazione porta di dominio
  11358.         if(this.pddReader!=null){
  11359.             String tipo = this.pddReader.getValidazione_FiltroDuplicatiLetturaRegistro(implementazionePdDSoggetto);
  11360.             if(tipo!=null && ( 
  11361.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11362.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11363.             ){
  11364.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11365.                     return true;
  11366.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11367.                     return false;
  11368.             }
  11369.         }

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

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

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

  11389.         return this.isCheckFromRegistroFiltroDuplicatiAbilitato;
  11390.     }

  11392.     /**
  11393.      * Indicazione se leggere dal registro se abilitato la gestione dei riscontri
  11394.      *   
  11395.      * @return Indicazione se leggere dal registro se abilitato la gestione dei riscontri
  11396.      * 
  11397.      */
  11398.     private Boolean isCheckFromRegistroConfermaRicezioneAbilitato = null;
  11399.     public boolean isCheckFromRegistroConfermaRicezioneAbilitato(String implementazionePdDSoggetto){

  11401.         // ovverriding per implementazione porta di dominio
  11402.         if(this.pddReader!=null){
  11403.             String tipo = this.pddReader.getValidazione_ConfermaRicezioneLetturaRegistro(implementazionePdDSoggetto);
  11404.             if(tipo!=null && ( 
  11405.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11406.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11407.             ){
  11408.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11409.                     return true;
  11410.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11411.                     return false;
  11412.             }
  11413.         }

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

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

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

  11433.         return this.isCheckFromRegistroConfermaRicezioneAbilitato;
  11434.     }

  11436.     /**
  11437.      * Indicazione se leggere dal registro se abilitato la consegna in ordine
  11438.      *   
  11439.      * @return Indicazione se leggere dal registro se abilitato la gestione dei riscontri
  11440.      * 
  11441.      */
  11442.     private Boolean isCheckFromRegistroConsegnaInOrdineAbilitato = null;
  11443.     public boolean isCheckFromRegistroConsegnaInOrdineAbilitato(String implementazionePdDSoggetto){

  11445.         // ovverriding per implementazione porta di dominio
  11446.         if(this.pddReader!=null){
  11447.             String tipo = this.pddReader.getValidazione_ConsegnaInOrdineLetturaRegistro(implementazionePdDSoggetto);
  11448.             if(tipo!=null && ( 
  11449.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11450.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11451.             ){
  11452.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11453.                     return true;
  11454.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11455.                     return false;
  11456.             }
  11457.         }

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

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

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

  11477.         return this.isCheckFromRegistroConsegnaInOrdineAbilitato;
  11478.     }

  11480.     /**
  11481.      * Indicazione se l'elemento collaborazione deve essere gestito
  11482.      *   
  11483.      * @return Indicazione se l'elemento collaborazione deve essere gestito
  11484.      * 
  11485.      */
  11486.     private Boolean isGestioneElementoCollaborazione = null;
  11487.     public boolean isGestioneElementoCollaborazione(String implementazionePdDSoggetto){

  11489.         // ovverriding per implementazione porta di dominio
  11490.         if(this.pddReader!=null){
  11491.             String tipo = this.pddReader.getBusta_CollaborazioneEnable(implementazionePdDSoggetto);
  11492.             if(tipo!=null && ( 
  11493.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11494.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11495.             ){
  11496.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11497.                     return true;
  11498.                 else 
  11499.                     return false;
  11500.             }
  11501.         }

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

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

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

  11521.         return this.isGestioneElementoCollaborazione;
  11522.     }
  11523.     
  11524.     private Boolean isGestioneElementoIdRiferimentoRichiesta = null;
  11525.     public boolean isGestioneElementoIdRiferimentoRichiesta(String implementazionePdDSoggetto){

  11527.         // ovverriding per implementazione porta di dominio
  11528.         if(this.pddReader!=null){
  11529.             String tipo = this.pddReader.getBusta_IdRiferimentoRichiestaEnable(implementazionePdDSoggetto);
  11530.             if(tipo!=null && ( 
  11531.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11532.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11533.             ){
  11534.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11535.                     return true;
  11536.                 else 
  11537.                     return false;
  11538.             }
  11539.         }

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

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

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

  11559.         return this.isGestioneElementoIdRiferimentoRichiesta;
  11560.     }

  11562.     /**
  11563.      * Indicazione se la funzionalita' di consegna in ordine deve essere gestita
  11564.      *   
  11565.      * @return Indicazione se la funzionalita' di consegna in ordine deve essere gestita
  11566.      * 
  11567.      */
  11568.     private Boolean isGestioneConsegnaInOrdine = null;
  11569.     public boolean isGestioneConsegnaInOrdine(String implementazionePdDSoggetto){

  11571.         // ovverriding per implementazione porta di dominio
  11572.         if(this.pddReader!=null){
  11573.             String tipo = this.pddReader.getBusta_ConsegnaInOrdineEnable(implementazionePdDSoggetto);
  11574.             if(tipo!=null && ( 
  11575.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11576.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11577.             ){
  11578.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11579.                     return true;
  11580.                 else 
  11581.                     return false;
  11582.             }
  11583.         }

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

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

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

  11603.         return this.isGestioneConsegnaInOrdine;
  11604.     }

  11606.     /**
  11607.      * Indicazione se la funzionalita' dei riscontri deve essere gestita
  11608.      *   
  11609.      * @return Indicazione se la funzionalita' dei riscontri deve essere gestita
  11610.      * 
  11611.      */
  11612.     private Boolean isGestioneRiscontri = null;
  11613.     public boolean isGestioneRiscontri(String implementazionePdDSoggetto){

  11615.         // ovverriding per implementazione porta di dominio
  11616.         if(this.pddReader!=null){
  11617.             String tipo = this.pddReader.getBusta_RiscontriEnable(implementazionePdDSoggetto);
  11618.             if(tipo!=null && ( 
  11619.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11620.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11621.             ){
  11622.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11623.                     return true;
  11624.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11625.                     return false;
  11626.             }
  11627.         }

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

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

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

  11647.         return this.isGestioneRiscontri;
  11648.     }
  11649.     
  11650.    

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

  11665.         // ovverriding per implementazione porta di dominio
  11666.         if(this.pddReader!=null){
  11667.             String tipo = this.pddReader.getValidazione_readQualifiedAttribute(implementazionePdDSoggetto);
  11668.             if(tipo!=null && ( 
  11669.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11670.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11671.             ){
  11672.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11673.                     return true;
  11674.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11675.                     return false;
  11676.             }
  11677.         }

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

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

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

  11697.         return this.isReadQualifiedAttribute;
  11698.     }

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

  11713.         // ovverriding per implementazione porta di dominio
  11714.         if(this.pddReader!=null){
  11715.             String tipo = this.pddReader.getValidazione_ValidazioneIDBustaCompleta(implementazionePdDSoggetto);
  11716.             if(tipo!=null && ( 
  11717.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  11718.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  11719.             ){
  11720.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  11721.                     return true;
  11722.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  11723.                     return false;
  11724.             }
  11725.         }

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

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

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

  11745.         return this.isValidazioneIDBustaCompleta;
  11746.     }
  11747.     
  11748.     public ProprietaManifestAttachments getProprietaManifestAttachments(String implementazionePdDSoggetto){
  11749.         ProprietaManifestAttachments properties = new ProprietaManifestAttachments();
  11750.         properties.setReadQualifiedAttribute(this.isReadQualifiedAttribute(implementazionePdDSoggetto));
  11751.         return properties;
  11752.     }


  11755.     /**
  11756.      * Restituisce l'eventuale location del file govway.pdd.properties
  11757.      * 
  11758.      * @return Restituisce la location del file govway.pdd.properties
  11759.      */
  11760.     private String filePddProperties = null;
  11761.     private boolean filePddPropertiesLetto = false;
  11762.     public String getLocationPddProperties() {
  11763.         if(this.filePddPropertiesLetto==false){
  11764.             try{ 
  11765.                 String name = null;
  11766.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.protocol.pddProperties");
  11767.                 if(name!=null){
  11768.                     name = name.trim();
  11769.                     this.filePddProperties = name;
  11770.                 }
  11771.                 this.filePddPropertiesLetto= true;
  11772.             }catch(java.lang.Exception e) {
  11773.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.protocol.pddProperties': "+e.getMessage(),e);
  11774.                 this.filePddProperties = null;
  11775.             }               
  11776.         }

  11778.         return this.filePddProperties;
  11779.     }






  11786.     /* ********  INTEGRAZIONE  ******** */

  11788.     /**
  11789.      * Restituisce l'elenco dei tipi di integrazione da gestire lato PortaDelegata
  11790.      * 
  11791.      * @return  Restituisce l'elenco dei tipi di integrazione da gestire lato PortaDelegata
  11792.      */
  11793.     private String[] tipoIntegrazionePD = null;
  11794.     private boolean tipoIntegrazionePDRead = false;
  11795.     public String[] getTipoIntegrazionePD() {
  11796.         if(!this.tipoIntegrazionePDRead){
  11797.             try{  
  11798.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pd"); 
  11799.                 if(value==null)
  11800.                     throw new CoreException(NON_DEFINITA);
  11801.                 value = value.trim();
  11802.                 String [] r = value.split(",");
  11803.                 this.tipoIntegrazionePD = r;

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

  11812.         return this.tipoIntegrazionePD;
  11813.     }
  11814.     /**
  11815.      * Restituisce l'elenco dei tipi di integrazione da gestire lato PortaApplicativa
  11816.      * 
  11817.      * @return  Restituisce l'elenco dei tipi di integrazione da gestire lato PortaApplicativa
  11818.      */
  11819.     private String[] tipoIntegrazionePA = null;
  11820.     private boolean tipoIntegrazionePARead = false;
  11821.     public String[] getTipoIntegrazionePA() {
  11822.         if(!this.tipoIntegrazionePARead){
  11823.             try{ 
  11824.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pa");
  11825.                 if(value==null)
  11826.                     throw new CoreException(NON_DEFINITA);
  11827.                 value = value.trim();
  11828.                 String [] r = value.split(",");
  11829.                 this.tipoIntegrazionePA = r;
  11830.             }catch(java.lang.Exception e) {
  11831.                 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);
  11832.                 this.tipoIntegrazionePA = null;
  11833.             }   
  11834.             this.tipoIntegrazionePARead = true;
  11835.         }

  11837.         return this.tipoIntegrazionePA;
  11838.     }
  11839.     
  11840.     /**
  11841.      * Restituisce l'elenco dei tipi di integrazione da gestire lato PortaDelegata specifici per protocollo
  11842.      * 
  11843.      * @return  Restituisce l'elenco dei tipi di integrazione da gestire lato PortaDelegata specifici per protocollo
  11844.      */
  11845.     private Map<String, String[]> tipoIntegrazionePD_perProtocollo = new HashMap<>();
  11846.     private Map<String, Boolean> tipoIntegrazionePD_perProtocollo_notExists = new HashMap<>();
  11847.     public String[] getTipoIntegrazionePD(String protocollo) {
  11848.         
  11849.         if( 
  11850.             (!this.tipoIntegrazionePD_perProtocollo.containsKey(protocollo)) 
  11851.             &&
  11852.             (!this.tipoIntegrazionePD_perProtocollo_notExists.containsKey(protocollo)) 
  11853.         ){
  11854.             try{  
  11855.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pd."+protocollo); 
  11856.                 if(value==null){
  11857.                     this.tipoIntegrazionePD_perProtocollo_notExists.put(protocollo, false);
  11858.                 }
  11859.                 else{
  11860.                     value = value.trim();
  11861.                     String [] r = value.split(",");
  11862.                     this.tipoIntegrazionePD_perProtocollo.put(protocollo, r);
  11863.                 }

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

  11870.         if(this.tipoIntegrazionePD_perProtocollo.containsKey(protocollo)){
  11871.             return this.tipoIntegrazionePD_perProtocollo.get(protocollo);
  11872.         }else{
  11873.             return null;
  11874.         }
  11875.     }
  11876.     
  11877.     /**
  11878.      * Restituisce l'elenco dei tipi di integrazione da gestire lato PortaApplicativa specifici per protocollo
  11879.      * 
  11880.      * @return  Restituisce l'elenco dei tipi di integrazione da gestire lato PortaApplicativa specifici per protocollo
  11881.      */
  11882.     private Map<String, String[]> tipoIntegrazionePA_perProtocollo = new HashMap<>();
  11883.     private Map<String, Boolean> tipoIntegrazionePA_perProtocollo_notExists = new HashMap<>();
  11884.     public String[] getTipoIntegrazionePA(String protocollo) {
  11885.         
  11886.         if( 
  11887.             (!this.tipoIntegrazionePA_perProtocollo.containsKey(protocollo)) 
  11888.             &&
  11889.             (!this.tipoIntegrazionePA_perProtocollo_notExists.containsKey(protocollo)) 
  11890.         ){
  11891.             try{  
  11892.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.tipo.pa."+protocollo); 
  11893.                 if(value==null){
  11894.                     this.tipoIntegrazionePA_perProtocollo_notExists.put(protocollo, false);
  11895.                 }
  11896.                 else{
  11897.                     value = value.trim();
  11898.                     String [] r = value.split(",");
  11899.                     this.tipoIntegrazionePA_perProtocollo.put(protocollo, r);
  11900.                 }

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

  11907.         if(this.tipoIntegrazionePA_perProtocollo.containsKey(protocollo)){
  11908.             return this.tipoIntegrazionePA_perProtocollo.get(protocollo);
  11909.         }else{
  11910.             return null;
  11911.         }
  11912.     }
  11913.     

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

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

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

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

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

  11995.         return this.newOldMapping_backward_compatibility_trasparente_servizio;
  11996.     }

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

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

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

  12069.         return this.newOldMapping_backward_compatibility_sdi_soggetto;
  12070.     }
  12071.     private Map<String, String> newOldMapping_backward_compatibility_sdi_servizio = null;
  12072.     public Map<String, String> getNewOldMapping_backward_compatibility_sdi_servizio() { 
  12073.         if(this.newOldMapping_backward_compatibility_sdi_servizio==null){
  12074.             String pName = "org.openspcoop2.pdd.integrazione.backward_compatibility.sdi.servizio.tipo.";
  12075.             try{ 
  12076.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  12077.                 this.newOldMapping_backward_compatibility_sdi_servizio=new HashMap<>();
  12078.                 if(p!=null && !p.isEmpty()) {
  12079.                     for (Object oKey : p.keySet()) {
  12080.                         if(oKey!=null && oKey instanceof String) {
  12081.                             String key = (String) oKey;
  12082.                             String old = p.getProperty(key);
  12083.                             this.newOldMapping_backward_compatibility_sdi_servizio.put(key, old);
  12084.                         }
  12085.                     }
  12086.                 }
  12087.             }catch(java.lang.Exception e) {
  12088.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+"*': "+e.getMessage(),e);
  12089.                 this.newOldMapping_backward_compatibility_sdi_servizio = null;
  12090.             }    
  12091.         }

  12093.         return this.newOldMapping_backward_compatibility_sdi_servizio;
  12094.     }
  12095.     
  12096.     


  12099.     private <T> Map<MapKey<String>, T> _convertMapToCostantiIntegrazione(Map<String, T> map) throws CoreException{
  12100.         List<MapKey<String>> keywordsIntegrazione = getKeywordsIntegrazioneEngine(true);
  12101.         Map<MapKey<String>, T> newMap = new HashMap<MapKey<String>, T>();
  12102.         for (String key : map.keySet()) {
  12103.             boolean find = false;
  12104.             for (MapKey<String> mapKey : keywordsIntegrazione) {
  12105.                 if(key.equals(mapKey.getValue())){
  12106.                     newMap.put(mapKey, map.get(key));
  12107.                     find = true;
  12108.                 }
  12109.             }
  12110.             if(!find) {
  12111.                 throw new CoreException("Chiave '"+key+"' sconosciuta, non risulta essere una keyword di integrazione");
  12112.             }
  12113.         }
  12114.         return newMap;
  12115.     }
  12116.     
  12117.     /**
  12118.      * Restituisce le proprieta' che identificano gli header di integrazione in caso di 'trasporto' 
  12119.      *
  12120.      * @return Restituisce le proprieta' che identificano gli header di integrazione in caso di 'trasporto'
  12121.      *  
  12122.      */
  12123.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneTrasporto = null;
  12124.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneTrasporto() {  
  12125.         if(this.keyValue_HeaderIntegrazioneTrasporto==null){

  12127.             try{ 

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

  12137.         return this.keyValue_HeaderIntegrazioneTrasporto;
  12138.     }
  12139.     
  12140.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2 = null;
  12141.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2() {    
  12142.         if(this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2==null){

  12144.             try{ 

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

  12156.         return this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop2;
  12157.     }
  12158.     
  12159.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1 = null;
  12160.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1() {    
  12161.         if(this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1==null){

  12163.             try{ 

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

  12175.         return this.keyValue_HeaderIntegrazioneTrasporto_backwardCompatibility_openspcoop1;
  12176.     }
  12177.     
  12178.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_setPD_request = null;
  12179.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_setPD_response = null;
  12180.     public Map<MapKey<String>, Boolean> getKeyPDSetEnabled_HeaderIntegrazioneTrasporto(boolean request) throws CoreException {  
  12181.                 
  12182.         if( (request && this.keyValue_HeaderIntegrazioneTrasporto_setPD_request==null)
  12183.             ||
  12184.             (!request && this.keyValue_HeaderIntegrazioneTrasporto_setPD_response==null)
  12185.             ){

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

  12195.                 prop = this.reader.readPropertiesConvertEnvProperties(pName);
  12196.                 Map<String, Boolean> _tmp = new HashMap<>();
  12197.                 Iterator<?> it = prop.keySet().iterator();
  12198.                 while (it.hasNext()) {
  12199.                     Object object = (Object) it.next();
  12200.                     if(object instanceof String) {
  12201.                         String key = (String) object;
  12202.                         String value = prop.getProperty(key);
  12203.                         try {
  12204.                             boolean b = Boolean.parseBoolean(value);
  12205.                             _tmp.put(key, b);
  12206.                         }catch(Exception e) {
  12207.                             throw new CoreException("Rilevato errore durante il parsing della property '"+pName+"."+key+"' (atteso: true/false): "+e.getMessage(),e);
  12208.                         }
  12209.                     }
  12210.                 }
  12211.                 if(request) {
  12212.                     this.keyValue_HeaderIntegrazioneTrasporto_setPD_request = _convertMapToCostantiIntegrazione(_tmp);
  12213.                 }
  12214.                 else {
  12215.                     this.keyValue_HeaderIntegrazioneTrasporto_setPD_response = _convertMapToCostantiIntegrazione(_tmp);
  12216.                 }
  12217.                 
  12218.             }catch(java.lang.Exception e) {
  12219.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  12220.                 throw new CoreException(e.getMessage(),e);
  12221.             }    
  12222.         }

  12224.         if(request) {
  12225.             return this.keyValue_HeaderIntegrazioneTrasporto_setPD_request;
  12226.         }
  12227.         else {
  12228.             return this.keyValue_HeaderIntegrazioneTrasporto_setPD_response;
  12229.         }
  12230.     }
  12231.     
  12232.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_readPD = null;
  12233.     public Map<MapKey<String>, Boolean> getKeyPDReadEnabled_HeaderIntegrazioneTrasporto() throws CoreException {    
  12234.         if(this.keyValue_HeaderIntegrazioneTrasporto_readPD==null){

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

  12239.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.trasporto.pd.read.enabled.");
  12240.                 Map<String, Boolean> _tmp = new HashMap<>();
  12241.                 Iterator<?> it = prop.keySet().iterator();
  12242.                 while (it.hasNext()) {
  12243.                     Object object = (Object) it.next();
  12244.                     if(object instanceof String) {
  12245.                         String key = (String) object;
  12246.                         String value = prop.getProperty(key);
  12247.                         try {
  12248.                             boolean b = Boolean.parseBoolean(value);
  12249.                             _tmp.put(key, b);
  12250.                         }catch(Exception e) {
  12251.                             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);
  12252.                         }
  12253.                     }
  12254.                 }
  12255.                 this.keyValue_HeaderIntegrazioneTrasporto_readPD = _convertMapToCostantiIntegrazione(_tmp);
  12256.                 
  12257.             }catch(java.lang.Exception e) {
  12258.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.trasporto.pd.read.enabled.*': "+e.getMessage(),e);
  12259.                 throw new CoreException(e.getMessage(),e);
  12260.             }    
  12261.         }

  12263.         return this.keyValue_HeaderIntegrazioneTrasporto_readPD;
  12264.     }
  12265.     
  12266.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_setPA_request = null;
  12267.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_setPA_response = null;
  12268.     public Map<MapKey<String>, Boolean> getKeyPASetEnabled_HeaderIntegrazioneTrasporto(boolean request) throws CoreException {
  12269.                 
  12270.         if( (request && this.keyValue_HeaderIntegrazioneTrasporto_setPA_request==null)
  12271.                 ||
  12272.                 (!request && this.keyValue_HeaderIntegrazioneTrasporto_setPA_response==null)
  12273.                 ){

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

  12283.                 prop = this.reader.readPropertiesConvertEnvProperties(pName);
  12284.                 Map<String, Boolean> _tmp = new HashMap<>();
  12285.                 Iterator<?> it = prop.keySet().iterator();
  12286.                 while (it.hasNext()) {
  12287.                     Object object = (Object) it.next();
  12288.                     if(object instanceof String) {
  12289.                         String key = (String) object;
  12290.                         String value = prop.getProperty(key);
  12291.                         try {
  12292.                             boolean b = Boolean.parseBoolean(value);
  12293.                             //if(request) {
  12294.                             //  _tmp.put(key, b);
  12295.                             //}
  12296.                             //else {
  12297.                             _tmp.put(key, b);
  12298.                             //}
  12299.                         }catch(Exception e) {
  12300.                             throw new CoreException("Rilevato errore durante il parsing della property '"+pName+"."+key+"' (atteso: true/false): "+e.getMessage(),e);
  12301.                         }
  12302.                     }
  12303.                 }
  12304.                 if(request) {
  12305.                     this.keyValue_HeaderIntegrazioneTrasporto_setPA_request = _convertMapToCostantiIntegrazione(_tmp);
  12306.                 }
  12307.                 else {
  12308.                     this.keyValue_HeaderIntegrazioneTrasporto_setPA_response = _convertMapToCostantiIntegrazione(_tmp);
  12309.                 }
  12310.                 
  12311.             }catch(java.lang.Exception e) {
  12312.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  12313.                 throw new CoreException(e.getMessage(),e);
  12314.             }    
  12315.         }

  12317.         if(request) {
  12318.             return this.keyValue_HeaderIntegrazioneTrasporto_setPA_request;
  12319.         }
  12320.         else {
  12321.             return this.keyValue_HeaderIntegrazioneTrasporto_setPA_response;
  12322.         }
  12323.     }
  12324.     
  12325.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneTrasporto_readPA = null;
  12326.     public Map<MapKey<String>, Boolean> getKeyPAReadEnabled_HeaderIntegrazioneTrasporto() throws CoreException {    
  12327.         if(this.keyValue_HeaderIntegrazioneTrasporto_readPA==null){

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

  12332.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.trasporto.pa.read.enabled.");
  12333.                 Map<String, Boolean> _tmp = new HashMap<>();
  12334.                 Iterator<?> it = prop.keySet().iterator();
  12335.                 while (it.hasNext()) {
  12336.                     Object object = (Object) it.next();
  12337.                     if(object instanceof String) {
  12338.                         String key = (String) object;
  12339.                         String value = prop.getProperty(key);
  12340.                         try {
  12341.                             boolean b = Boolean.parseBoolean(value);
  12342.                             _tmp.put(key, b);
  12343.                         }catch(Exception e) {
  12344.                             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);
  12345.                         }
  12346.                     }
  12347.                 }
  12348.                 this.keyValue_HeaderIntegrazioneTrasporto_readPA = _convertMapToCostantiIntegrazione(_tmp);
  12349.                                 
  12350.             }catch(java.lang.Exception e) {
  12351.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.trasporto.pa.read.enabled.*': "+e.getMessage(),e);
  12352.                 throw new CoreException(e.getMessage(),e);
  12353.             }    
  12354.         }

  12356.         return this.keyValue_HeaderIntegrazioneTrasporto_readPA;
  12357.     }
  12358.     
  12359.     /**
  12360.      * Restituisce le proprieta' che identificano gli header di integrazione in caso di 'urlBased'.
  12361.      *
  12362.      * @return Restituisce le proprieta' che identificano gli header di integrazione in caso di 'urlBased'.
  12363.      *  
  12364.      */
  12365.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneUrlBased = null;
  12366.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneUrlBased() {   
  12367.         if(this.keyValue_HeaderIntegrazioneUrlBased==null){

  12369.             try{ 

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

  12381.         return this.keyValue_HeaderIntegrazioneUrlBased;
  12382.     }
  12383.     
  12384.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2 = null;
  12385.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2() { 
  12386.         if(this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2==null){

  12388.             try{ 

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

  12400.         return this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop2;
  12401.     }
  12402.     
  12403.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1 = null;
  12404.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1() { 
  12405.         if(this.keyValue_HeaderIntegrazioneUrlBased_backwardCompatibility_openspcoop1==null){

  12407.             try{ 

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

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

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

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

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

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

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

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

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

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

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

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

  12531.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.urlBased.pa.read.enabled.");
  12532.                 Map<String, Boolean> _tmp = new HashMap<>();
  12533.                 Iterator<?> it = prop.keySet().iterator();
  12534.                 while (it.hasNext()) {
  12535.                     Object object = (Object) it.next();
  12536.                     if(object instanceof String) {
  12537.                         String key = (String) object;
  12538.                         String value = prop.getProperty(key);
  12539.                         try {
  12540.                             boolean b = Boolean.parseBoolean(value);
  12541.                             _tmp.put(key, b);
  12542.                         }catch(Exception e) {
  12543.                             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);
  12544.                         }
  12545.                     }
  12546.                 }
  12547.                 this.keyValue_HeaderIntegrazioneUrlBased_readPA = _convertMapToCostantiIntegrazione(_tmp);
  12548.                 
  12549.             }catch(java.lang.Exception e) {
  12550.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.urlBased.pa.read.enabled.*': "+e.getMessage(),e);
  12551.                 throw new CoreException(e.getMessage(),e);
  12552.             }    
  12553.         }

  12555.         return this.keyValue_HeaderIntegrazioneUrlBased_readPA;
  12556.     }
  12557.     
  12558.     /**
  12559.      * Restituisce le proprieta' che identificano gli header di integrazione in caso di 'soap'.
  12560.      *
  12561.      * @return Restituisce le proprieta' che identificano gli header di integrazione in caso di 'soap'.
  12562.      *  
  12563.      */
  12564.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneSoap = null;
  12565.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneSoap() {   
  12566.         if(this.keyValue_HeaderIntegrazioneSoap==null){

  12568.             try{ 

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

  12580.         return this.keyValue_HeaderIntegrazioneSoap;
  12581.     }
  12582.     
  12583.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2 = null;
  12584.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2() { 
  12585.         if(this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2==null){

  12587.             try{ 

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

  12599.         return this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop2;
  12600.     }
  12601.     
  12602.     private Map<MapKey<String>, String> keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1 = null;
  12603.     public Map<MapKey<String>, String> getKeyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1() { 
  12604.         if(this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1==null){

  12606.             try{ 

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

  12618.         return this.keyValue_HeaderIntegrazioneSoap_backwardCompatibility_openspcoop1;
  12619.     }
  12620.     
  12621.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_setPD_request = null;
  12622.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_setPD_response = null;
  12623.     public Map<MapKey<String>, Boolean> getKeyPDSetEnabled_HeaderIntegrazioneSoap(boolean request) throws CoreException {
  12624.         
  12625.         if( (request && this.keyValue_HeaderIntegrazioneSoap_setPD_request==null)
  12626.                 ||
  12627.                 (!request && this.keyValue_HeaderIntegrazioneSoap_setPD_response==null)
  12628.                 ){

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

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

  12638.                 prop = this.reader.readPropertiesConvertEnvProperties(pName);
  12639.                 Map<String, Boolean> _tmp = new HashMap<>();
  12640.                 Iterator<?> it = prop.keySet().iterator();
  12641.                 while (it.hasNext()) {
  12642.                     Object object = (Object) it.next();
  12643.                     if(object instanceof String) {
  12644.                         String key = (String) object;
  12645.                         String value = prop.getProperty(key);
  12646.                         try {
  12647.                             boolean b = Boolean.parseBoolean(value);
  12648.                             _tmp.put(key, b);
  12649.                         }catch(Exception e) {
  12650.                             throw new CoreException("Rilevato errore durante il parsing della property '"+pName+"."+key+"' (atteso: true/false): "+e.getMessage(),e);
  12651.                         }
  12652.                     }
  12653.                 }
  12654.                 if(request) {
  12655.                     this.keyValue_HeaderIntegrazioneSoap_setPD_request = _convertMapToCostantiIntegrazione(_tmp);
  12656.                 }
  12657.                 else {
  12658.                     this.keyValue_HeaderIntegrazioneSoap_setPD_response = _convertMapToCostantiIntegrazione(_tmp);
  12659.                 }
  12660.                 
  12661.             }catch(java.lang.Exception e) {
  12662.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  12663.                 throw new CoreException(e.getMessage(),e);
  12664.             }    
  12665.         }

  12667.         if(request) {
  12668.             return this.keyValue_HeaderIntegrazioneSoap_setPD_request;
  12669.         }
  12670.         else {
  12671.             return this.keyValue_HeaderIntegrazioneSoap_setPD_response;
  12672.         }
  12673.     }
  12674.     
  12675.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_readPD = null;
  12676.     public Map<MapKey<String>, Boolean> getKeyPDReadEnabled_HeaderIntegrazioneSoap() throws CoreException { 
  12677.         if(this.keyValue_HeaderIntegrazioneSoap_readPD==null){

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

  12682.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.pd.read.enabled.");
  12683.                 Map<String, Boolean> _tmp = new HashMap<>();
  12684.                 Iterator<?> it = prop.keySet().iterator();
  12685.                 while (it.hasNext()) {
  12686.                     Object object = (Object) it.next();
  12687.                     if(object instanceof String) {
  12688.                         String key = (String) object;
  12689.                         String value = prop.getProperty(key);
  12690.                         try {
  12691.                             boolean b = Boolean.parseBoolean(value);
  12692.                             _tmp.put(key, b);
  12693.                         }catch(Exception e) {
  12694.                             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);
  12695.                         }
  12696.                     }
  12697.                 }
  12698.                 this.keyValue_HeaderIntegrazioneSoap_readPD = _convertMapToCostantiIntegrazione(_tmp);
  12699.                 
  12700.             }catch(java.lang.Exception e) {
  12701.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.soap.pd.read.enabled.*': "+e.getMessage(),e);
  12702.                 throw new CoreException(e.getMessage(),e);
  12703.             }    
  12704.         }

  12706.         return this.keyValue_HeaderIntegrazioneSoap_readPD;
  12707.     }
  12708.     
  12709.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_setPA_request = null;
  12710.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_setPA_response = null;
  12711.     public Map<MapKey<String>, Boolean> getKeyPASetEnabled_HeaderIntegrazioneSoap(boolean request) throws CoreException {   
  12712.         if( (request && this.keyValue_HeaderIntegrazioneSoap_setPA_request==null)
  12713.                 ||
  12714.                 (!request && this.keyValue_HeaderIntegrazioneSoap_setPA_response==null)
  12715.                 ){

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

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

  12725.                 prop = this.reader.readPropertiesConvertEnvProperties(pName);
  12726.                 Map<String, Boolean> _tmp = new HashMap<>();
  12727.                 Iterator<?> it = prop.keySet().iterator();
  12728.                 while (it.hasNext()) {
  12729.                     Object object = (Object) it.next();
  12730.                     if(object instanceof String) {
  12731.                         String key = (String) object;
  12732.                         String value = prop.getProperty(key);
  12733.                         try {
  12734.                             boolean b = Boolean.parseBoolean(value);
  12735.                             //if(request) {
  12736.                             //  _tmp.put(key, b);
  12737.                             //}
  12738.                             //else {
  12739.                             _tmp.put(key, b);
  12740.                             //}
  12741.                         }catch(Exception e) {
  12742.                             throw new CoreException("Rilevato errore durante il parsing della property '"+pName+"."+key+"' (atteso: true/false): "+e.getMessage(),e);
  12743.                         }
  12744.                     }
  12745.                 }
  12746.                 if(request) {
  12747.                     this.keyValue_HeaderIntegrazioneSoap_setPA_request = _convertMapToCostantiIntegrazione(_tmp);
  12748.                 }
  12749.                 else {
  12750.                     this.keyValue_HeaderIntegrazioneSoap_setPA_response = _convertMapToCostantiIntegrazione(_tmp);
  12751.                 }
  12752.                 
  12753.             }catch(java.lang.Exception e) {
  12754.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+pName+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  12755.                 throw new CoreException(e.getMessage(),e);
  12756.             }    
  12757.         }

  12759.         if(request) {
  12760.             return this.keyValue_HeaderIntegrazioneSoap_setPA_request;
  12761.         }
  12762.         else {
  12763.             return this.keyValue_HeaderIntegrazioneSoap_setPA_response;
  12764.         }
  12765.     }
  12766.     
  12767.     private Map<MapKey<String>, Boolean> keyValue_HeaderIntegrazioneSoap_readPA = null;
  12768.     public Map<MapKey<String>, Boolean> getKeyPAReadEnabled_HeaderIntegrazioneSoap() throws CoreException { 
  12769.         if(this.keyValue_HeaderIntegrazioneSoap_readPA==null){

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

  12774.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.pa.read.enabled.");
  12775.                 Map<String, Boolean> _tmp = new HashMap<>();
  12776.                 Iterator<?> it = prop.keySet().iterator();
  12777.                 while (it.hasNext()) {
  12778.                     Object object = (Object) it.next();
  12779.                     if(object instanceof String) {
  12780.                         String key = (String) object;
  12781.                         String value = prop.getProperty(key);
  12782.                         try {
  12783.                             boolean b = Boolean.parseBoolean(value);
  12784.                             _tmp.put(key, b);
  12785.                         }catch(Exception e) {
  12786.                             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);
  12787.                         }
  12788.                     }
  12789.                 }
  12790.                 this.keyValue_HeaderIntegrazioneSoap_readPA = _convertMapToCostantiIntegrazione(_tmp);
  12791.                                 
  12792.             }catch(java.lang.Exception e) {
  12793.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.integrazione.soap.pa.read.enabled.*': "+e.getMessage(),e);
  12794.                 throw new CoreException(e.getMessage(),e);
  12795.             }    
  12796.         }

  12798.         return this.keyValue_HeaderIntegrazioneSoap_readPA;
  12799.     }
  12800.     
  12801.     private String headerIntegrazioneSOAPPdDVersione = null;
  12802.     public String getHeaderIntegrazioneSOAPPdDVersione(){
  12803.         if(this.headerIntegrazioneSOAPPdDVersione==null){
  12804.             try{  
  12805.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.pddVersion"); 

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

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

  12821.         return this.headerIntegrazioneSOAPPdDVersione;
  12822.     }
  12823.     
  12824.     private Boolean readHeaderIntegrazioneSOAPPdDDetails = null;
  12825.     private String headerIntegrazioneSOAPPdDDetails = null;
  12826.     public String getHeaderIntegrazioneSOAPPdDDetails(){
  12827.         if(this.readHeaderIntegrazioneSOAPPdDDetails==null){
  12828.             try{  
  12829.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.pddDetails"); 

  12831.                 if (value != null){
  12832.                     value = value.trim();
  12833.                     this.headerIntegrazioneSOAPPdDDetails = value;
  12834.                 }else{
  12835.                     this.headerIntegrazioneSOAPPdDDetails = this.getDetails();
  12836.                 }

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

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

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

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

  12876.         return this.deleteHeaderIntegrazioneRequestPD;
  12877.     }
  12878.     
  12879.     /**
  12880.      * Restituisce l'indicazione l'header di integrazione letto
  12881.      * durante l'integrazione tra servizio applicativo e PdD
  12882.      * deve essere eliminato o meno
  12883.      *  
  12884.      * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
  12885.      * 
  12886.      */
  12887.     private Boolean deleteHeaderIntegrazioneResponsePD = null;
  12888.     public boolean deleteHeaderIntegrazioneResponsePD(){
  12889.         if(this.deleteHeaderIntegrazioneResponsePD==null){
  12890.             try{  
  12891.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pd.response.readAndDelete"); 

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

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

  12907.         return this.deleteHeaderIntegrazioneResponsePD;
  12908.     }

  12910.     /**
  12911.      * Restituisce l'indicazione l'header di integrazione letto
  12912.      * durante l'integrazione tra servizio applicativo e PdD
  12913.      * deve essere eliminato o meno
  12914.      *  
  12915.      * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
  12916.      * 
  12917.      */
  12918.     private Boolean processHeaderIntegrazionePDResponse = null;
  12919.     public boolean processHeaderIntegrazionePDResponse(boolean functionAsRouter){
  12920.         if(functionAsRouter){
  12921.             return false;
  12922.         }
  12923.         if(this.processHeaderIntegrazionePDResponse==null){
  12924.             try{  
  12925.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pd.response.process"); 

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

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

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

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

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

  12974.         return this.deleteHeaderIntegrazioneRequestPA;
  12975.     }
  12976.     
  12977.     /**
  12978.      * Restituisce l'indicazione l'header di integrazione letto
  12979.      * durante l'integrazione tra servizio applicativo e PdD
  12980.      * deve essere eliminato o meno
  12981.      *  
  12982.      * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
  12983.      * 
  12984.      */
  12985.     private Boolean deleteHeaderIntegrazioneResponsePA = null;
  12986.     public boolean deleteHeaderIntegrazioneResponsePA(){
  12987.         if(this.deleteHeaderIntegrazioneResponsePA==null){
  12988.             try{  
  12989.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pa.response.readAndDelete"); 

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

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

  13005.         return this.deleteHeaderIntegrazioneResponsePA;
  13006.     }

  13008.     /**
  13009.      * Restituisce l'indicazione l'header di integrazione letto
  13010.      * durante l'integrazione tra servizio applicativo e PdD
  13011.      * deve essere eliminato o meno
  13012.      *  
  13013.      * @return Restituisce l'indicazione sull'eventuale eliminazione dell'header di integrazione
  13014.      * 
  13015.      */
  13016.     private Boolean processHeaderIntegrazionePARequest = null;
  13017.     public boolean processHeaderIntegrazionePARequest(boolean functionAsRouter){
  13018.         if(functionAsRouter){
  13019.             return false;
  13020.         }
  13021.         if(this.processHeaderIntegrazionePARequest==null){
  13022.             try{  
  13023.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.pa.request.process"); 

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

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

  13039.         return this.processHeaderIntegrazionePARequest;
  13040.     }
  13041.     

  13043.     /**
  13044.      * Restituisce il nome dell'header Soap di integrazione di default
  13045.      * 
  13046.      * @return Restituisce il nome dell'header Soap di integrazione di default
  13047.      */
  13048.     private String headerSoapNameIntegrazione = null;
  13049.     public String getHeaderSoapNameIntegrazione() {
  13050.         if(this.headerSoapNameIntegrazione==null){
  13051.             try{ 
  13052.                 String name = null;
  13053.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.headerName");
  13054.                 if(name==null)
  13055.                     throw new CoreException(NON_DEFINITA);
  13056.                 name = name.trim();
  13057.                 this.headerSoapNameIntegrazione = name;
  13058.             }catch(java.lang.Exception e) {
  13059.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.headerName': "+e.getMessage(),e);
  13060.                 this.headerSoapNameIntegrazione = null;
  13061.             }    
  13062.         }

  13064.         return this.headerSoapNameIntegrazione;
  13065.     }
  13066.     
  13067.     private String headerSoapNameIntegrazione_backwardCompatibility_openspcoop2 = null;
  13068.     public String getHeaderSoapNameIntegrazione_backwardCompatibility_openspcoop2() {
  13069.         if(this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop2==null){
  13070.             try{ 
  13071.                 String name = null;
  13072.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerName");
  13073.                 if(name==null)
  13074.                     throw new CoreException(NON_DEFINITA);
  13075.                 name = name.trim();
  13076.                 this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop2 = name;
  13077.             }catch(java.lang.Exception e) {
  13078.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerName': "+e.getMessage(),e);
  13079.                 this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop2 = null;
  13080.             }    
  13081.         }

  13083.         return this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop2;
  13084.     }
  13085.     
  13086.     private String headerSoapNameIntegrazione_backwardCompatibility_openspcoop1 = null;
  13087.     public String getHeaderSoapNameIntegrazione_backwardCompatibility_openspcoop1() {
  13088.         if(this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop1==null){
  13089.             try{ 
  13090.                 String name = null;
  13091.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerName");
  13092.                 if(name==null)
  13093.                     throw new CoreException(NON_DEFINITA);
  13094.                 name = name.trim();
  13095.                 this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop1 = name;
  13096.             }catch(java.lang.Exception e) {
  13097.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerName': "+e.getMessage(),e);
  13098.                 this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop1 = null;
  13099.             }    
  13100.         }

  13102.         return this.headerSoapNameIntegrazione_backwardCompatibility_openspcoop1;
  13103.     }

  13105.     /**
  13106.      * Restituisce l'actord dell'header Soap di integrazione di default
  13107.      * 
  13108.      * @return Restituisce l'actor dell'header Soap di integrazione di default
  13109.      */
  13110.     private String headerSoapActorIntegrazione = null;
  13111.     public String getHeaderSoapActorIntegrazione() {
  13112.         if(this.headerSoapActorIntegrazione==null){
  13113.             try{ 
  13114.                 String name = null;
  13115.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.headerActor");
  13116.                 if(name==null)
  13117.                     throw new CoreException(NON_DEFINITA);
  13118.                 name = name.trim();
  13119.                 this.headerSoapActorIntegrazione = name;
  13120.             }catch(java.lang.Exception e) {
  13121.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.headerActor': "+e.getMessage(),e);
  13122.                 this.headerSoapActorIntegrazione = null;
  13123.             }    
  13124.         }

  13126.         return this.headerSoapActorIntegrazione;
  13127.     }
  13128.     
  13129.     private String headerSoapActorIntegrazione_backwardCompatibility_openspcoop2 = null;
  13130.     public String getHeaderSoapActorIntegrazione_backwardCompatibility_openspcoop2() {
  13131.         if(this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop2==null){
  13132.             try{ 
  13133.                 String name = null;
  13134.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerActor");
  13135.                 if(name==null)
  13136.                     throw new CoreException(NON_DEFINITA);
  13137.                 name = name.trim();
  13138.                 this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop2 = name;
  13139.             }catch(java.lang.Exception e) {
  13140.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerActor': "+e.getMessage(),e);
  13141.                 this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop2 = null;
  13142.             }    
  13143.         }

  13145.         return this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop2;
  13146.     }
  13147.     
  13148.     private String headerSoapActorIntegrazione_backwardCompatibility_openspcoop1 = null;
  13149.     public String getHeaderSoapActorIntegrazione_backwardCompatibility_openspcoop1() {
  13150.         if(this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop1==null){
  13151.             try{ 
  13152.                 String name = null;
  13153.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerActor");
  13154.                 if(name==null)
  13155.                     throw new CoreException(NON_DEFINITA);
  13156.                 name = name.trim();
  13157.                 this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop1 = name;
  13158.             }catch(java.lang.Exception e) {
  13159.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerActor': "+e.getMessage(),e);
  13160.                 this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop1 = null;
  13161.             }    
  13162.         }

  13164.         return this.headerSoapActorIntegrazione_backwardCompatibility_openspcoop1;
  13165.     }

  13167.     /**
  13168.      * Restituisce il prefix dell'header Soap di integrazione di default
  13169.      * 
  13170.      * @return Restituisce il prefix dell'header Soap di integrazione di default
  13171.      */
  13172.     private String headerSoapPrefixIntegrazione = null;
  13173.     public String getHeaderSoapPrefixIntegrazione() {
  13174.         if(this.headerSoapPrefixIntegrazione==null){
  13175.             try{ 
  13176.                 String name = null;
  13177.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.headerPrefix");
  13178.                 if(name==null)
  13179.                     throw new CoreException(NON_DEFINITA);
  13180.                 name = name.trim();
  13181.                 this.headerSoapPrefixIntegrazione = name;
  13182.             }catch(java.lang.Exception e) {
  13183.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.headerPrefix': "+e.getMessage(),e);
  13184.                 this.headerSoapPrefixIntegrazione = null;
  13185.             }    
  13186.         }

  13188.         return this.headerSoapPrefixIntegrazione;
  13189.     }
  13190.     
  13191.     private String headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2 = null;
  13192.     public String getHeaderSoapPrefixIntegrazione_backwardCompatibility_openspcoop2() {
  13193.         if(this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2==null){
  13194.             try{ 
  13195.                 String name = null;
  13196.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerPrefix");
  13197.                 if(name==null)
  13198.                     throw new CoreException(NON_DEFINITA);
  13199.                 name = name.trim();
  13200.                 this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2 = name;
  13201.             }catch(java.lang.Exception e) {
  13202.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.headerPrefix': "+e.getMessage(),e);
  13203.                 this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2 = null;
  13204.             }    
  13205.         }

  13207.         return this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop2;
  13208.     }
  13209.     
  13210.     private String headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1 = null;
  13211.     public String getHeaderSoapPrefixIntegrazione_backwardCompatibility_openspcoop1() {
  13212.         if(this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1==null){
  13213.             try{ 
  13214.                 String name = null;
  13215.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerPrefix");
  13216.                 if(name==null)
  13217.                     throw new CoreException(NON_DEFINITA);
  13218.                 name = name.trim();
  13219.                 this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1 = name;
  13220.             }catch(java.lang.Exception e) {
  13221.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.headerPrefix': "+e.getMessage(),e);
  13222.                 this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1 = null;
  13223.             }    
  13224.         }

  13226.         return this.headerSoapPrefixIntegrazione_backwardCompatibility_openspcoop1;
  13227.     }
  13228.     
  13229.     /**
  13230.      * Restituisce il nome dell'elemento che contiene le informazioni di protocollo
  13231.      * 
  13232.      * @return Restituisce il nome dell'elemento che contiene le informazioni di protocollo
  13233.      */
  13234.     private String headerSoapExtProtocolInfoNomeElementoIntegrazione = null;
  13235.     public String getHeaderSoapExtProtocolInfoNomeElementoIntegrazione() {
  13236.         if(this.headerSoapExtProtocolInfoNomeElementoIntegrazione==null){
  13237.             try{ 
  13238.                 String name = null;
  13239.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.extProtocolInfo.elemento.nome");
  13240.                 if(name==null)
  13241.                     throw new CoreException(NON_DEFINITA);
  13242.                 name = name.trim();
  13243.                 this.headerSoapExtProtocolInfoNomeElementoIntegrazione = name;
  13244.             }catch(java.lang.Exception e) {
  13245.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.extProtocolInfo.elemento.nome': "+e.getMessage(),e);
  13246.                 this.headerSoapExtProtocolInfoNomeElementoIntegrazione = null;
  13247.             }    
  13248.         }

  13250.         return this.headerSoapExtProtocolInfoNomeElementoIntegrazione;
  13251.     }
  13252.     private String headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2 = null;
  13253.     public String getHeaderSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2() {
  13254.         if(this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2==null){
  13255.             try{ 
  13256.                 String name = null;
  13257.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.extProtocolInfo.elemento.nome");
  13258.                 if(name==null)
  13259.                     throw new CoreException(NON_DEFINITA);
  13260.                 name = name.trim();
  13261.                 this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2 = name;
  13262.             }catch(java.lang.Exception e) {
  13263.                 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);
  13264.                 this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2 = null;
  13265.             }    
  13266.         }

  13268.         return this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop2;
  13269.     }
  13270.     private String headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1 = null;
  13271.     public String getHeaderSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1() {
  13272.         if(this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1==null){
  13273.             try{ 
  13274.                 String name = null;
  13275.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.extProtocolInfo.elemento.nome");
  13276.                 if(name==null)
  13277.                     throw new CoreException(NON_DEFINITA);
  13278.                 name = name.trim();
  13279.                 this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1 = name;
  13280.             }catch(java.lang.Exception e) {
  13281.                 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);
  13282.                 this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1 = null;
  13283.             }    
  13284.         }

  13286.         return this.headerSoapExtProtocolInfoNomeElementoIntegrazione_backwardCompatibility_openspcoop1;
  13287.     }
  13288.     /**
  13289.      * Restituisce il nome del tipo dell'elemento che contiene le informazioni di protocollo
  13290.      * 
  13291.      * @return Restituisce il nome del tipo dell'elemento che contiene le informazioni di protocollo
  13292.      */
  13293.     private String headerSoapExtProtocolInfoNomeAttributoIntegrazione = null;
  13294.     public String getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione() {
  13295.         if(this.headerSoapExtProtocolInfoNomeAttributoIntegrazione==null){
  13296.             try{ 
  13297.                 String name = null;
  13298.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.extProtocolInfo.attributo.nome");
  13299.                 if(name==null)
  13300.                     throw new CoreException(NON_DEFINITA);
  13301.                 name = name.trim();
  13302.                 this.headerSoapExtProtocolInfoNomeAttributoIntegrazione = name;
  13303.             }catch(java.lang.Exception e) {
  13304.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrazione.soap.extProtocolInfo.attributo.nome': "+e.getMessage(),e);
  13305.                 this.headerSoapExtProtocolInfoNomeAttributoIntegrazione = null;
  13306.             }    
  13307.         }

  13309.         return this.headerSoapExtProtocolInfoNomeAttributoIntegrazione;
  13310.     }
  13311.     
  13312.     private String headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2 = null;
  13313.     public String getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2() {
  13314.         if(this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2==null){
  13315.             try{ 
  13316.                 String name = null;
  13317.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop2.extProtocolInfo.attributo.nome");
  13318.                 if(name==null)
  13319.                     throw new CoreException(NON_DEFINITA);
  13320.                 name = name.trim();
  13321.                 this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2 = name;
  13322.             }catch(java.lang.Exception e) {
  13323.                 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);
  13324.                 this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2 = null;
  13325.             }    
  13326.         }

  13328.         return this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop2;
  13329.     }
  13330.     
  13331.     private String headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1 = null;
  13332.     public String getHeaderSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1() {
  13333.         if(this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1==null){
  13334.             try{ 
  13335.                 String name = null;
  13336.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrazione.soap.backward_compatibility.openspcoop1.extProtocolInfo.attributo.nome");
  13337.                 if(name==null)
  13338.                     throw new CoreException(NON_DEFINITA);
  13339.                 name = name.trim();
  13340.                 this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1 = name;
  13341.             }catch(java.lang.Exception e) {
  13342.                 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);
  13343.                 this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1 = null;
  13344.             }    
  13345.         }

  13347.         return this.headerSoapExtProtocolInfoNomeAttributoIntegrazione_backwardCompatibility_openspcoop1;
  13348.     }

  13350.     
  13351.     
  13352.     /* ********  INTEGRAZIONE INFORMAZIONI DINAMICHE  ******** */
  13353.     
  13354.     private Boolean isIntegrazioneDynamicInfoEnabled = null;
  13355.     public boolean isIntegrazioneDynamicInfoEnabled() {
  13356.         String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.enabled";
  13357.         if(this.isIntegrazioneDynamicInfoEnabled==null){
  13358.             try{ 
  13359.                 String name = null;
  13360.                 name = this.reader.getValueConvertEnvProperties(pName);
  13361.                 if(name==null)
  13362.                     throw new CoreException(NON_DEFINITA);
  13363.                 name = name.trim();
  13364.                 this.isIntegrazioneDynamicInfoEnabled = Boolean.parseBoolean(name);
  13365.             }catch(java.lang.Exception e) {
  13366.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13367.                 this.isIntegrazioneDynamicInfoEnabled = false;
  13368.             }    
  13369.         }

  13371.         if(this.isIntegrazioneDynamicInfoEnabled==null){
  13372.             return false;
  13373.         }
  13374.         return this.isIntegrazioneDynamicInfoEnabled;
  13375.     }
  13376.     
  13377.     private InformazioniIntegrazioneSorgente getIntegrazioneDynamicInfoType = null;
  13378.     public InformazioniIntegrazioneSorgente getIntegrazioneDynamicInfoType() {
  13379.         String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.type";
  13380.         if(this.getIntegrazioneDynamicInfoType==null){
  13381.             try{ 
  13382.                 String name = null;
  13383.                 name = this.reader.getValueConvertEnvProperties(pName);
  13384.                 if(name==null)
  13385.                     throw new CoreException(NON_DEFINITA);
  13386.                 name = name.trim();
  13387.                 this.getIntegrazioneDynamicInfoType = InformazioniIntegrazioneSorgente.valueOf(name);
  13388.             }catch(java.lang.Exception e) {
  13389.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13390.             }    
  13391.         }

  13393.         return this.getIntegrazioneDynamicInfoType;
  13394.     }
  13395.     
  13396.     private String getIntegrazioneDynamicInfoName = null;
  13397.     public String getIntegrazioneDynamicInfoName() {
  13398.         String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.name";
  13399.         if(this.getIntegrazioneDynamicInfoName==null){
  13400.             try{ 
  13401.                 String name = null;
  13402.                 name = this.reader.getValueConvertEnvProperties(pName);
  13403.                 if(name==null)
  13404.                     throw new CoreException(NON_DEFINITA);
  13405.                 name = name.trim();
  13406.                 this.getIntegrazioneDynamicInfoName = name;
  13407.             }catch(java.lang.Exception e) {
  13408.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13409.             }    
  13410.         }

  13412.         return this.getIntegrazioneDynamicInfoName;
  13413.     }
  13414.     
  13415.     private InformazioniIntegrazioneCodifica getIntegrazioneDynamicInfoEncodeType = null;
  13416.     public InformazioniIntegrazioneCodifica getIntegrazioneDynamicInfoEncodeType() {
  13417.         String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.encode";
  13418.         if(this.getIntegrazioneDynamicInfoEncodeType==null){
  13419.             try{ 
  13420.                 String name = null;
  13421.                 name = this.reader.getValueConvertEnvProperties(pName);
  13422.                 if(name==null)
  13423.                     throw new CoreException(NON_DEFINITA);
  13424.                 name = name.trim();
  13425.                 this.getIntegrazioneDynamicInfoEncodeType = InformazioniIntegrazioneCodifica.valueOf(name);
  13426.             }catch(java.lang.Exception e) {
  13427.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13428.             }    
  13429.         }

  13431.         return this.getIntegrazioneDynamicInfoEncodeType;
  13432.     }
  13433.     
  13434.     private Boolean isIntegrazioneDynamicInfoRequired = null;
  13435.     public boolean isIntegrazioneDynamicInfoRequired() {
  13436.         String pName = "org.openspcoop2.pdd.integrazione.dynamicInfo.required";
  13437.         if(this.isIntegrazioneDynamicInfoRequired==null){
  13438.             try{ 
  13439.                 String name = null;
  13440.                 name = this.reader.getValueConvertEnvProperties(pName);
  13441.                 if(name==null)
  13442.                     throw new CoreException(NON_DEFINITA);
  13443.                 name = name.trim();
  13444.                 this.isIntegrazioneDynamicInfoRequired = Boolean.parseBoolean(name);
  13445.             }catch(java.lang.Exception e) {
  13446.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13447.                 this.isIntegrazioneDynamicInfoRequired = false;
  13448.             }    
  13449.         }

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

  13476.         if(this.isIntegrazioneResponseDynamicInfoEnabled==null){
  13477.             return false;
  13478.         }
  13479.         return this.isIntegrazioneResponseDynamicInfoEnabled;
  13480.     }
  13481.     
  13482.     private String getIntegrazioneResponseDynamicInfoName = null;
  13483.     public String getIntegrazioneResponseDynamicInfoName() {
  13484.         String pName = "org.openspcoop2.pdd.integrazione.responseDynamicInfo.name";
  13485.         if(this.getIntegrazioneResponseDynamicInfoName==null){
  13486.             try{ 
  13487.                 String name = null;
  13488.                 name = this.reader.getValueConvertEnvProperties(pName);
  13489.                 if(name==null)
  13490.                     throw new CoreException(NON_DEFINITA);
  13491.                 name = name.trim();
  13492.                 this.getIntegrazioneResponseDynamicInfoName = name;
  13493.             }catch(java.lang.Exception e) {
  13494.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13495.             }    
  13496.         }

  13498.         return this.getIntegrazioneResponseDynamicInfoName;
  13499.     }
  13500.     
  13501.     private InformazioniIntegrazioneCodifica getIntegrazioneResponseDynamicInfoEncodeType = null;
  13502.     public InformazioniIntegrazioneCodifica getIntegrazioneResponseDynamicInfoEncodeType() {
  13503.         String pName = "org.openspcoop2.pdd.integrazione.responseDynamicInfo.encode";
  13504.         if(this.getIntegrazioneResponseDynamicInfoEncodeType==null){
  13505.             try{ 
  13506.                 String name = null;
  13507.                 name = this.reader.getValueConvertEnvProperties(pName);
  13508.                 if(name==null)
  13509.                     throw new CoreException(NON_DEFINITA);
  13510.                 name = name.trim();
  13511.                 this.getIntegrazioneResponseDynamicInfoEncodeType = InformazioniIntegrazioneCodifica.valueOf(name);
  13512.             }catch(java.lang.Exception e) {
  13513.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13514.             }    
  13515.         }

  13517.         return this.getIntegrazioneResponseDynamicInfoEncodeType;
  13518.     }
  13519.     
  13520.     private Boolean isIntegrazioneResponseDynamicInfoRequired = null;
  13521.     public boolean isIntegrazioneResponseDynamicInfoRequired() {
  13522.         String pName = "org.openspcoop2.pdd.integrazione.responseDynamicInfo.required";
  13523.         if(this.isIntegrazioneResponseDynamicInfoRequired==null){
  13524.             try{ 
  13525.                 String name = null;
  13526.                 name = this.reader.getValueConvertEnvProperties(pName);
  13527.                 if(name==null)
  13528.                     throw new CoreException(NON_DEFINITA);
  13529.                 name = name.trim();
  13530.                 this.isIntegrazioneResponseDynamicInfoRequired = Boolean.parseBoolean(name);
  13531.             }catch(java.lang.Exception e) {
  13532.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13533.                 this.isIntegrazioneResponseDynamicInfoRequired = false;
  13534.             }    
  13535.         }

  13537.         if(this.isIntegrazioneResponseDynamicInfoRequired==null){
  13538.             return false;
  13539.         }
  13540.         return this.isIntegrazioneResponseDynamicInfoRequired;
  13541.     }
  13542.     
  13543.     
  13544.     
  13545.     /* ********  INTEGRAZIONE TEMPLATE  ******** */
  13546.     
  13547.     private String getIntegrazioneTemplateRequestPropertyTipo = null;
  13548.     public String getIntegrazioneTemplateRequestPropertyTipo() {
  13549.         String pName = "org.openspcoop2.pdd.integrazione.template.request.property.tipo";
  13550.         if(this.getIntegrazioneTemplateRequestPropertyTipo==null){
  13551.             try{ 
  13552.                 String name = null;
  13553.                 name = this.reader.getValueConvertEnvProperties(pName);
  13554.                 if(name==null)
  13555.                     throw new CoreException(NON_DEFINITA);
  13556.                 name = name.trim();
  13557.                 this.getIntegrazioneTemplateRequestPropertyTipo = name;
  13558.             }catch(java.lang.Exception e) {
  13559.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13560.                 this.getIntegrazioneTemplateRequestPropertyTipo = null;
  13561.             }    
  13562.         }

  13564.         return this.getIntegrazioneTemplateRequestPropertyTipo;
  13565.     }
  13566.     
  13567.     private String getIntegrazioneTemplateRequestPropertyFile = null;
  13568.     public String getIntegrazioneTemplateRequestPropertyFile() {
  13569.         String pName = "org.openspcoop2.pdd.integrazione.template.request.property.file";
  13570.         if(this.getIntegrazioneTemplateRequestPropertyFile==null){
  13571.             try{ 
  13572.                 String name = null;
  13573.                 name = this.reader.getValueConvertEnvProperties(pName);
  13574.                 if(name==null)
  13575.                     throw new CoreException(NON_DEFINITA);
  13576.                 name = name.trim();
  13577.                 this.getIntegrazioneTemplateRequestPropertyFile = name;
  13578.             }catch(java.lang.Exception e) {
  13579.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13580.                 this.getIntegrazioneTemplateRequestPropertyFile = null;
  13581.             }    
  13582.         }

  13584.         return this.getIntegrazioneTemplateRequestPropertyFile;
  13585.     }
  13586.     
  13587.     private String getIntegrazioneTemplateResponsePropertyTipo = null;
  13588.     public String getIntegrazioneTemplateResponsePropertyTipo() {
  13589.         String pName = "org.openspcoop2.pdd.integrazione.template.response.property.tipo";
  13590.         if(this.getIntegrazioneTemplateResponsePropertyTipo==null){
  13591.             try{ 
  13592.                 String name = null;
  13593.                 name = this.reader.getValueConvertEnvProperties(pName);
  13594.                 if(name==null)
  13595.                     throw new CoreException(NON_DEFINITA);
  13596.                 name = name.trim();
  13597.                 this.getIntegrazioneTemplateResponsePropertyTipo = name;
  13598.             }catch(java.lang.Exception e) {
  13599.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13600.                 this.getIntegrazioneTemplateResponsePropertyTipo = null;
  13601.             }    
  13602.         }

  13604.         return this.getIntegrazioneTemplateResponsePropertyTipo;
  13605.     }
  13606.     
  13607.     private String getIntegrazioneTemplateResponsePropertyFile = null;
  13608.     public String getIntegrazioneTemplateResponsePropertyFile() {
  13609.         String pName = "org.openspcoop2.pdd.integrazione.template.response.property.file";
  13610.         if(this.getIntegrazioneTemplateResponsePropertyFile==null){
  13611.             try{ 
  13612.                 String name = null;
  13613.                 name = this.reader.getValueConvertEnvProperties(pName);
  13614.                 if(name==null)
  13615.                     throw new CoreException(NON_DEFINITA);
  13616.                 name = name.trim();
  13617.                 this.getIntegrazioneTemplateResponsePropertyFile = name;
  13618.             }catch(java.lang.Exception e) {
  13619.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13620.                 this.getIntegrazioneTemplateResponsePropertyFile = null;
  13621.             }    
  13622.         }

  13624.         return this.getIntegrazioneTemplateResponsePropertyFile;
  13625.     }
  13626.     
  13627.     
  13628.     
  13629.     private Boolean getIntegrazioneTemplatePortaDelegataRequestTipo_read = null;
  13630.     private TipoTrasformazione getIntegrazioneTemplatePortaDelegataRequestTipo = null;
  13631.     public TipoTrasformazione getIntegrazioneTemplatePortaDelegataRequestTipo() throws CoreException{
  13632.         String pName = "org.openspcoop2.pdd.integrazione.template.pd.request.tipo";
  13633.         if(this.getIntegrazioneTemplatePortaDelegataRequestTipo_read==null){
  13634.             try{ 
  13635.                 String name = null;
  13636.                 name = this.reader.getValueConvertEnvProperties(pName);
  13637.                 if(name!=null) {
  13638.                     name = name.trim();
  13639.                     this.getIntegrazioneTemplatePortaDelegataRequestTipo = UtilitiesTemplate.convert(name);
  13640.                     
  13641.                     this.getIntegrazioneTemplatePortaDelegataRequestTipo_read = true;
  13642.                 }
  13643.             }catch(java.lang.Exception e) {
  13644.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13645.                 throw new CoreException (e);
  13646.             }    
  13647.         }

  13649.         return this.getIntegrazioneTemplatePortaDelegataRequestTipo;
  13650.     }
  13651.     
  13652.     private Boolean getIntegrazioneTemplatePortaDelegataRequestFile_read = null;
  13653.     private String getIntegrazioneTemplatePortaDelegataRequestFile = null;
  13654.     public String getIntegrazioneTemplatePortaDelegataRequestFile() throws CoreException{
  13655.         String pName = "org.openspcoop2.pdd.integrazione.template.pd.request.file";
  13656.         if(this.getIntegrazioneTemplatePortaDelegataRequestFile_read==null){
  13657.             try{ 
  13658.                 String name = null;
  13659.                 name = this.reader.getValueConvertEnvProperties(pName);
  13660.                 if(name!=null) {
  13661.                     name = name.trim();
  13662.                     this.getIntegrazioneTemplatePortaDelegataRequestFile = name;
  13663.                     
  13664.                     this.getIntegrazioneTemplatePortaDelegataRequestFile_read = true;
  13665.                 }
  13666.             }catch(java.lang.Exception e) {
  13667.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13668.                 throw new CoreException (e);
  13669.             }    
  13670.         }

  13672.         return this.getIntegrazioneTemplatePortaDelegataRequestFile;
  13673.     }
  13674.     
  13675.     private Boolean getIntegrazioneTemplatePortaDelegataResponseTipo_read = null;
  13676.     private TipoTrasformazione getIntegrazioneTemplatePortaDelegataResponseTipo = null;
  13677.     public TipoTrasformazione getIntegrazioneTemplatePortaDelegataResponseTipo() throws CoreException{
  13678.         String pName = "org.openspcoop2.pdd.integrazione.template.pd.response.tipo";
  13679.         if(this.getIntegrazioneTemplatePortaDelegataResponseTipo_read==null){
  13680.             try{ 
  13681.                 String name = null;
  13682.                 name = this.reader.getValueConvertEnvProperties(pName);
  13683.                 if(name!=null) {
  13684.                     name = name.trim();
  13685.                     this.getIntegrazioneTemplatePortaDelegataResponseTipo = UtilitiesTemplate.convert(name);

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

  13695.         return this.getIntegrazioneTemplatePortaDelegataResponseTipo;
  13696.     }
  13697.     
  13698.     private Boolean getIntegrazioneTemplatePortaDelegataResponseFile_read = null;
  13699.     private String getIntegrazioneTemplatePortaDelegataResponseFile = null;
  13700.     public String getIntegrazioneTemplatePortaDelegataResponseFile() throws CoreException{
  13701.         String pName = "org.openspcoop2.pdd.integrazione.template.pd.response.file";
  13702.         if(this.getIntegrazioneTemplatePortaDelegataResponseFile_read==null){
  13703.             try{ 
  13704.                 String name = null;
  13705.                 name = this.reader.getValueConvertEnvProperties(pName);
  13706.                 if(name!=null) {
  13707.                     name = name.trim();
  13708.                     this.getIntegrazioneTemplatePortaDelegataResponseFile = name;
  13709.                     
  13710.                     this.getIntegrazioneTemplatePortaDelegataResponseFile_read = true;
  13711.                 }
  13712.             }catch(java.lang.Exception e) {
  13713.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13714.                 throw new CoreException (e);
  13715.             }    
  13716.         }

  13718.         return this.getIntegrazioneTemplatePortaDelegataResponseFile;
  13719.     }
  13720.     
  13721.     
  13722.     private Boolean getIntegrazioneTemplatePortaApplicativaRequestTipo_read = null;
  13723.     private TipoTrasformazione getIntegrazioneTemplatePortaApplicativaRequestTipo = null;
  13724.     public TipoTrasformazione getIntegrazioneTemplatePortaApplicativaRequestTipo() throws CoreException{
  13725.         String pName = "org.openspcoop2.pdd.integrazione.template.pa.request.tipo";
  13726.         if(this.getIntegrazioneTemplatePortaApplicativaRequestTipo_read==null){
  13727.             try{ 
  13728.                 String name = null;
  13729.                 name = this.reader.getValueConvertEnvProperties(pName);
  13730.                 if(name!=null) {
  13731.                     name = name.trim();
  13732.                     this.getIntegrazioneTemplatePortaApplicativaRequestTipo = UtilitiesTemplate.convert(name);
  13733.                     
  13734.                     this.getIntegrazioneTemplatePortaApplicativaRequestTipo_read = true;
  13735.                 }
  13736.             }catch(java.lang.Exception e) {
  13737.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13738.                 throw new CoreException (e);
  13739.             }    
  13740.         }

  13742.         return this.getIntegrazioneTemplatePortaApplicativaRequestTipo;
  13743.     }
  13744.     
  13745.     private Boolean getIntegrazioneTemplatePortaApplicativaRequestFile_read = null;
  13746.     private String getIntegrazioneTemplatePortaApplicativaRequestFile = null;
  13747.     public String getIntegrazioneTemplatePortaApplicativaRequestFile() throws CoreException{
  13748.         String pName = "org.openspcoop2.pdd.integrazione.template.pa.request.file";
  13749.         if(this.getIntegrazioneTemplatePortaApplicativaRequestFile_read==null){
  13750.             try{ 
  13751.                 String name = null;
  13752.                 name = this.reader.getValueConvertEnvProperties(pName);
  13753.                 if(name!=null) {
  13754.                     name = name.trim();
  13755.                     this.getIntegrazioneTemplatePortaApplicativaRequestFile = name;
  13756.                     
  13757.                     this.getIntegrazioneTemplatePortaApplicativaRequestFile_read = true;
  13758.                 }
  13759.             }catch(java.lang.Exception e) {
  13760.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13761.                 throw new CoreException (e);
  13762.             }    
  13763.         }

  13765.         return this.getIntegrazioneTemplatePortaApplicativaRequestFile;
  13766.     }
  13767.     
  13768.     private Boolean getIntegrazioneTemplatePortaApplicativaResponseTipo_read = null;
  13769.     private TipoTrasformazione getIntegrazioneTemplatePortaApplicativaResponseTipo = null;
  13770.     public TipoTrasformazione getIntegrazioneTemplatePortaApplicativaResponseTipo() throws CoreException{
  13771.         String pName = "org.openspcoop2.pdd.integrazione.template.pa.response.tipo";
  13772.         if(this.getIntegrazioneTemplatePortaApplicativaResponseTipo_read==null){
  13773.             try{ 
  13774.                 String name = null;
  13775.                 name = this.reader.getValueConvertEnvProperties(pName);
  13776.                 if(name!=null) {
  13777.                     name = name.trim();
  13778.                     this.getIntegrazioneTemplatePortaApplicativaResponseTipo = UtilitiesTemplate.convert(name);
  13779.                     
  13780.                     this.getIntegrazioneTemplatePortaApplicativaResponseTipo_read = true;
  13781.                 }
  13782.             }catch(java.lang.Exception e) {
  13783.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13784.                 throw new CoreException (e);
  13785.             }    
  13786.         }

  13788.         return this.getIntegrazioneTemplatePortaApplicativaResponseTipo;
  13789.     }
  13790.     
  13791.     private Boolean getIntegrazioneTemplatePortaApplicativaResponseFile_read = null;
  13792.     private String getIntegrazioneTemplatePortaApplicativaResponseFile = null;
  13793.     public String getIntegrazioneTemplatePortaApplicativaResponseFile() throws CoreException{
  13794.         String pName = "org.openspcoop2.pdd.integrazione.template.pa.response.file";
  13795.         if(this.getIntegrazioneTemplatePortaApplicativaResponseFile_read==null){
  13796.             try{ 
  13797.                 String name = null;
  13798.                 name = this.reader.getValueConvertEnvProperties(pName);
  13799.                 if(name!=null) {
  13800.                     name = name.trim();
  13801.                     this.getIntegrazioneTemplatePortaApplicativaResponseFile = name;
  13802.                     
  13803.                     this.getIntegrazioneTemplatePortaApplicativaResponseFile_read = true;
  13804.                 }
  13805.             }catch(java.lang.Exception e) {
  13806.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13807.                 throw new CoreException (e);
  13808.             }    
  13809.         }

  13811.         return this.getIntegrazioneTemplatePortaApplicativaResponseFile;
  13812.     }
  13813.     
  13814.     
  13815.     /* ********  INTEGRAZIONE AUTENTICAZIONE  ******** */
  13816.     
  13817.     private List<String> getIntegrazioneAutenticazionePortaDelegataRequestHeaders = null;
  13818.     public List<String> getIntegrazioneAutenticazionePortaDelegataRequestHeaders() throws CoreException{
  13819.         String pName = "org.openspcoop2.pdd.integrazione.autenticazione.pd.request.headers";
  13820.         if(this.getIntegrazioneAutenticazionePortaDelegataRequestHeaders==null){
  13821.             try{
  13822.                 
  13823.                 this.getIntegrazioneAutenticazionePortaDelegataRequestHeaders = new ArrayList<>();
  13824.                 
  13825.                 String name = null;
  13826.                 name = this.reader.getValueConvertEnvProperties(pName);
  13827.                 if(name!=null) {
  13828.                     name = name.trim();
  13829.                     String [] split = name.split(",");
  13830.                     if(split!=null){
  13831.                         for (int i = 0; i < split.length; i++) {
  13832.                             String v = split[i];
  13833.                             if(v!=null) {
  13834.                                 v = v.trim();
  13835.                             }
  13836.                             if(!"".equals(v)) {
  13837.                                 this.getIntegrazioneAutenticazionePortaDelegataRequestHeaders.add(v);
  13838.                             }
  13839.                         }
  13840.                     }
  13841.                 }
  13842.             }catch(java.lang.Exception e) {
  13843.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13844.                 throw new CoreException (e);
  13845.             }    
  13846.         }

  13848.         return this.getIntegrazioneAutenticazionePortaDelegataRequestHeaders;
  13849.     }
  13850.    
  13851.     private Map<String, String> getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap = null;
  13852.     public Map<String, String> getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap() throws CoreException{
  13853.         String pNamePrefix = "org.openspcoop2.pdd.integrazione.autenticazione.pd.request.header.";
  13854.         if(this.getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap==null){
  13855.             try{
  13856.                 
  13857.                 this.getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap = new HashMap<>();
  13858.                 List<String> getIntegrazioneAutenticazionePortaDelegataRequestHeaders = getIntegrazioneAutenticazionePortaDelegataRequestHeaders();
  13859.                 if(getIntegrazioneAutenticazionePortaDelegataRequestHeaders!=null && !getIntegrazioneAutenticazionePortaDelegataRequestHeaders.isEmpty()) {
  13860.                     for (String hdrName : getIntegrazioneAutenticazionePortaDelegataRequestHeaders) {
  13861.                         String pName = pNamePrefix+hdrName;
  13862.                         try {
  13863.                             String hdrValue = this.reader.getValueConvertEnvProperties(pName);
  13864.                             if(hdrValue==null) {
  13865.                                 throw new CoreException(NON_DEFINITA);
  13866.                             }
  13867.                             hdrValue = hdrValue.trim();
  13868.                             this.getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap.put(hdrName, hdrValue);
  13869.                         }catch(java.lang.Exception e) {
  13870.                             throw new CoreException ("Proprietà '"+pName+"' "+e.getMessage(),e);
  13871.                         }   
  13872.                     }
  13873.                 }
  13874.             }catch(java.lang.Exception e) {
  13875.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNamePrefix+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  13876.                 throw new CoreException (e);
  13877.             }    
  13878.         }

  13880.         return this.getIntegrazioneAutenticazionePortaDelegataRequestHeadersMap;
  13881.     }
  13882.     
  13883.     private List<String> getIntegrazioneAutenticazionePortaApplicativaRequestHeaders = null;
  13884.     public List<String> getIntegrazioneAutenticazionePortaApplicativaRequestHeaders() throws CoreException{
  13885.         String pName = "org.openspcoop2.pdd.integrazione.autenticazione.pa.request.headers";
  13886.         if(this.getIntegrazioneAutenticazionePortaApplicativaRequestHeaders==null){
  13887.             try{
  13888.                 
  13889.                 this.getIntegrazioneAutenticazionePortaApplicativaRequestHeaders = new ArrayList<>();
  13890.                 
  13891.                 String name = null;
  13892.                 name = this.reader.getValueConvertEnvProperties(pName);
  13893.                 if(name!=null) {
  13894.                     name = name.trim();
  13895.                     String [] split = name.split(",");
  13896.                     if(split!=null){
  13897.                         for (int i = 0; i < split.length; i++) {
  13898.                             String v = split[i];
  13899.                             if(v!=null) {
  13900.                                 v = v.trim();
  13901.                             }
  13902.                             if(!"".equals(v)) {
  13903.                                 this.getIntegrazioneAutenticazionePortaApplicativaRequestHeaders.add(v);
  13904.                             }
  13905.                         }
  13906.                     }
  13907.                 }
  13908.             }catch(java.lang.Exception e) {
  13909.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13910.                 throw new CoreException (e);
  13911.             }    
  13912.         }

  13914.         return this.getIntegrazioneAutenticazionePortaApplicativaRequestHeaders;
  13915.     }
  13916.    
  13917.     private Map<String, String> getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap = null;
  13918.     public Map<String, String> getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap() throws CoreException{
  13919.         String pNamePrefix = "org.openspcoop2.pdd.integrazione.autenticazione.pa.request.header.";
  13920.         if(this.getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap==null){
  13921.             try{
  13922.                 
  13923.                 this.getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap = new HashMap<>();
  13924.                 List<String> getIntegrazioneAutenticazionePortaApplicativaRequestHeaders = getIntegrazioneAutenticazionePortaApplicativaRequestHeaders();
  13925.                 if(getIntegrazioneAutenticazionePortaApplicativaRequestHeaders!=null && !getIntegrazioneAutenticazionePortaApplicativaRequestHeaders.isEmpty()) {
  13926.                     for (String hdrName : getIntegrazioneAutenticazionePortaApplicativaRequestHeaders) {
  13927.                         String pName = pNamePrefix+hdrName;
  13928.                         try {
  13929.                             String hdrValue = this.reader.getValueConvertEnvProperties(pName);
  13930.                             if(hdrValue==null) {
  13931.                                 throw new CoreException(NON_DEFINITA);
  13932.                             }
  13933.                             hdrValue = hdrValue.trim();
  13934.                             this.getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap.put(hdrName, hdrValue);
  13935.                         }catch(java.lang.Exception e) {
  13936.                             throw new CoreException ("Proprietà '"+pName+"' "+e.getMessage(),e);
  13937.                         }   
  13938.                     }
  13939.                 }
  13940.             }catch(java.lang.Exception e) {
  13941.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNamePrefix+PROPERTY_START_SUFFIX_ERRORE+e.getMessage(),e);
  13942.                 throw new CoreException (e);
  13943.             }    
  13944.         }

  13946.         return this.getIntegrazioneAutenticazionePortaApplicativaRequestHeadersMap;
  13947.     }
  13948.     
  13949.     private String getIntegrazioneAutenticazionePropertyHeaders = null;
  13950.     public String getIntegrazioneAutenticazionePropertyHeaders() {
  13951.         String pName = "org.openspcoop2.pdd.integrazione.autenticazione.request.property.headers";
  13952.         if(this.getIntegrazioneAutenticazionePropertyHeaders==null){
  13953.             try{ 
  13954.                 String name = null;
  13955.                 name = this.reader.getValueConvertEnvProperties(pName);
  13956.                 if(name==null)
  13957.                     throw new CoreException(NON_DEFINITA);
  13958.                 name = name.trim();
  13959.                 this.getIntegrazioneAutenticazionePropertyHeaders = name;
  13960.             }catch(java.lang.Exception e) {
  13961.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13962.                 this.getIntegrazioneAutenticazionePropertyHeaders = null;
  13963.             }    
  13964.         }

  13966.         return this.getIntegrazioneAutenticazionePropertyHeaders;
  13967.     }
  13968.     
  13969.     private String getIntegrazioneAutenticazionePropertyHeaderPrefix = null;
  13970.     public String getIntegrazioneAutenticazionePropertyHeaderPrefix() {
  13971.         String pName = "org.openspcoop2.pdd.integrazione.autenticazione.request.property.header.prefix";
  13972.         if(this.getIntegrazioneAutenticazionePropertyHeaderPrefix==null){
  13973.             try{ 
  13974.                 String name = null;
  13975.                 name = this.reader.getValueConvertEnvProperties(pName);
  13976.                 if(name==null)
  13977.                     throw new CoreException(NON_DEFINITA);
  13978.                 name = name.trim();
  13979.                 this.getIntegrazioneAutenticazionePropertyHeaderPrefix = name;
  13980.             }catch(java.lang.Exception e) {
  13981.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  13982.                 this.getIntegrazioneAutenticazionePropertyHeaderPrefix = null;
  13983.             }    
  13984.         }

  13986.         return this.getIntegrazioneAutenticazionePropertyHeaderPrefix;
  13987.     }


  13990.     /* ********  CONNETTORI  ******** */

  13992.     private Boolean isRitardoConsegnaAbilitato = null;
  13993.     public boolean isRitardoConsegnaAbilitato() throws CoreException{
  13994.         if(this.isRitardoConsegnaAbilitato==null){
  13995.             try{ 
  13996.                 String name = null;
  13997.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettore.ritardo.stato");
  13998.                 if(name==null)
  13999.                     throw new CoreException(NON_DEFINITA);
  14000.                 name = name.trim();
  14001.                 this.isRitardoConsegnaAbilitato = CostantiConfigurazione.ABILITATO.equals(name);

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

  14009.         return this.isRitardoConsegnaAbilitato;
  14010.     }

  14012.     private Long ritardoConsegnaEsponenziale = null;
  14013.     public long getRitardoConsegnaEsponenziale() {  
  14014.         if(this.ritardoConsegnaEsponenziale==null){
  14015.             try{ 
  14016.                 long r = -1;
  14017.                 String name = null;
  14018.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettore.ritardo.fattore");
  14019.                 if (name != null) {
  14020.                     name = name.trim();
  14021.                     r = java.lang.Long.parseLong(name);
  14022.                 }
  14023.                 if(r<0)
  14024.                     throw new CoreException("Il ritardo deve essere > 0");
  14025.                 this.ritardoConsegnaEsponenziale = r;
  14026.             }catch(java.lang.Exception e) {
  14027.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettore.ritardo.fattore': "+e.getMessage(),e);
  14028.                 this.ritardoConsegnaEsponenziale = -1L;
  14029.             }    
  14030.         }

  14032.         return this.ritardoConsegnaEsponenziale;
  14033.     }

  14035.     private Boolean isRitardoConsegnaEsponenzialeConMoltiplicazione = null;
  14036.     public boolean isRitardoConsegnaEsponenzialeConMoltiplicazione() throws CoreException{
  14037.         if(this.isRitardoConsegnaEsponenzialeConMoltiplicazione==null){
  14038.             try{ 
  14039.                 String name = null;
  14040.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettore.ritardo.operazione");
  14041.                 if (name != null) {
  14042.                     name = name.trim();
  14043.                     if(name.equals("+")){
  14044.                         this.isRitardoConsegnaEsponenzialeConMoltiplicazione = false;
  14045.                     }else if(name.equals("*")){
  14046.                         this.isRitardoConsegnaEsponenzialeConMoltiplicazione = true;
  14047.                     }else{
  14048.                         throw new CoreException("Tipo di operazione non conosciuta: "+name);
  14049.                     }
  14050.                 }else{
  14051.                     throw new CoreException("Tipo di operazione non definita");
  14052.                 }
  14053.             }catch(java.lang.Exception e) {
  14054.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettore.ritardo.operazione': "+e.getMessage(),e);
  14055.                 throw new CoreException (e);
  14056.             }    
  14057.         }

  14059.         return this.isRitardoConsegnaEsponenzialeConMoltiplicazione;
  14060.     }

  14062.     private Long ritardoConsegnaEsponenzialeLimite = null;
  14063.     public long getRitardoConsegnaEsponenzialeLimite() {    
  14064.         if(this.ritardoConsegnaEsponenzialeLimite==null){
  14065.             try{ 
  14066.                 long r = 0;
  14067.                 String name = null;
  14068.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettore.ritardo.limite");
  14069.                 if (name != null) {
  14070.                     name = name.trim();
  14071.                     r = java.lang.Long.parseLong(name);
  14072.                 }
  14073.                 if(r<=0)
  14074.                     throw new CoreException("Il limite deve essere > 0");
  14075.                 this.ritardoConsegnaEsponenzialeLimite = r;
  14076.             }catch(java.lang.Exception e) {
  14077.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettore.ritardo.limite': "+e.getMessage(),e);
  14078.                 this.ritardoConsegnaEsponenzialeLimite = -1L;
  14079.             }    
  14080.         }

  14082.         return this.ritardoConsegnaEsponenzialeLimite;
  14083.     }














  14098.     /* ************* CACHE GESTORE MESSAGGIO *******************/

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

  14111.                 if (value != null){
  14112.                     value = value.trim();
  14113.                     this.isAbilitataCacheGestoreMessaggi_value = Boolean.parseBoolean(value);
  14114.                 }else{
  14115.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.enable' non impostata, viene utilizzato il default=false");
  14116.                     this.isAbilitataCacheGestoreMessaggi_value = false;
  14117.                 }
  14118.             }catch(java.lang.Exception e) {
  14119.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.enable' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  14120.                 this.isAbilitataCacheGestoreMessaggi_value = false;
  14121.             }
  14122.         }

  14124.         return this.isAbilitataCacheGestoreMessaggi_value;
  14125.     }

  14127.     /**
  14128.      * Restituisce la dimensione della cache
  14129.      *
  14130.      * @return Restituisce la dimensione della cache
  14131.      */
  14132.     private Integer dimensioneCacheGestoreMessaggi_value = null;
  14133.     public int getDimensioneCacheGestoreMessaggi() throws OpenSPCoop2ConfigurationException{    
  14134.         if(this.dimensioneCacheGestoreMessaggi_value==null){
  14135.             try{  
  14136.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.dimensione"); 
  14137.                 if(value!=null){
  14138.                     value = value.trim();
  14139.                     this.dimensioneCacheGestoreMessaggi_value = Integer.parseInt(value);
  14140.                 }else{
  14141.                     this.dimensioneCacheGestoreMessaggi_value = -1;
  14142.                 }
  14143.             }catch(java.lang.Exception e) {
  14144.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.dimensione': "+e.getMessage(),e);
  14145.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.dimensione'",e);
  14146.             }
  14147.         }

  14149.         return this.dimensioneCacheGestoreMessaggi_value;
  14150.     }

  14152.     /**
  14153.      * Restituisce l'algoritmo della cache
  14154.      *
  14155.      * @return Restituisce l'algoritmo della cache
  14156.      */
  14157.     private String algoritmoCacheGestoreMessaggi_value = null;
  14158.     public String getAlgoritmoCacheGestoreMessaggi() throws OpenSPCoop2ConfigurationException{  
  14159.         if(this.algoritmoCacheGestoreMessaggi_value==null){
  14160.             try{  
  14161.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.algoritmo"); 
  14162.                 if(value!=null){
  14163.                     value = value.trim();
  14164.                     this.algoritmoCacheGestoreMessaggi_value = value;
  14165.                 }else{
  14166.                     this.algoritmoCacheGestoreMessaggi_value = null;
  14167.                 }
  14168.             }catch(java.lang.Exception e) {
  14169.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.algoritmo': "+e.getMessage(),e);
  14170.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.algoritmo'",e);
  14171.             }
  14172.         }

  14174.         return this.algoritmoCacheGestoreMessaggi_value;
  14175.     }

  14177.     /**
  14178.      * Restituisce la itemIdleTime della cache
  14179.      *
  14180.      * @return Restituisce la itemIdleTime della cache
  14181.      */
  14182.     private Integer itemIdleTimeCacheGestoreMessaggi_value = null;
  14183.     public int getItemIdleTimeCacheGestoreMessaggi() throws OpenSPCoop2ConfigurationException{  
  14184.         if(this.itemIdleTimeCacheGestoreMessaggi_value==null){
  14185.             try{  
  14186.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemIdleTime"); 
  14187.                 if(value!=null){
  14188.                     value = value.trim();
  14189.                     this.itemIdleTimeCacheGestoreMessaggi_value = Integer.parseInt(value);
  14190.                 }else{
  14191.                     this.itemIdleTimeCacheGestoreMessaggi_value = -1;
  14192.                 }
  14193.             }catch(java.lang.Exception e) {
  14194.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemIdleTime': "+e.getMessage(),e);
  14195.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemIdleTime'",e);
  14196.             }
  14197.         }

  14199.         return this.itemIdleTimeCacheGestoreMessaggi_value;
  14200.     }

  14202.     /**
  14203.      * Restituisce la  itemLifeSecond della cache
  14204.      *
  14205.      * @return Restituisce la itemLifeSecond della cache
  14206.      */
  14207.     private Integer itemLifeSecondCacheGestoreMessaggi_value = null;
  14208.     public int getItemLifeSecondCacheGestoreMessaggi() throws OpenSPCoop2ConfigurationException{
  14209.         if(this.itemLifeSecondCacheGestoreMessaggi_value==null){
  14210.             try{  
  14211.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemLifeSecond"); 
  14212.                 if(value!=null){
  14213.                     value = value.trim();
  14214.                     this.itemLifeSecondCacheGestoreMessaggi_value = Integer.parseInt(value);
  14215.                 }else{
  14216.                     this.itemLifeSecondCacheGestoreMessaggi_value = -1;
  14217.                 }
  14218.             }catch(java.lang.Exception e) {
  14219.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemLifeSecond': "+e.getMessage(),e);
  14220.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.repository.gestoreMessaggi.cache.itemLifeSecond'",e);
  14221.             }
  14222.         }

  14224.         return this.itemLifeSecondCacheGestoreMessaggi_value;
  14225.     }





  14231.     /* ******* GESTORE JMX *********** */
  14232.     /**
  14233.      * Restituisce l'indicazione se istanziare le risorse JMX
  14234.      *
  14235.      * @return Restituisce Restituisce l'indicazione se istanziare le risorse JMX
  14236.      * 
  14237.      */
  14238.     private Boolean isRisorseJMXAbilitate = null;
  14239.     public boolean isRisorseJMXAbilitate(){
  14240.         if(this.isRisorseJMXAbilitate==null){
  14241.             try{  
  14242.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.jmx.enable"); 

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

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

  14258.         return this.isRisorseJMXAbilitate;
  14259.     }

  14261.     /**
  14262.      * Restituisce il Nome JNDI del MBeanServer
  14263.      *
  14264.      * @return il Nome JNDI del MBeanServer
  14265.      * 
  14266.      */
  14267.     private String jndiNameMBeanServer = null;
  14268.     public String getJNDIName_MBeanServer() {   
  14269.         if(this.jndiNameMBeanServer==null){
  14270.             try{ 
  14271.                 String name = null;
  14272.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.jmx.jndi.mbeanServer");
  14273.                 if(name!=null)
  14274.                     name = name.trim();
  14275.                 this.jndiNameMBeanServer = name;
  14276.             }catch(java.lang.Exception e) {
  14277.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.core.jmx.jndi.mbeanServer': "+e.getMessage(),e);
  14278.                 this.jndiNameMBeanServer = null;
  14279.             }    
  14280.         }

  14282.         return this.jndiNameMBeanServer;
  14283.     }

  14285.     /**
  14286.      * Restituisce le proprieta' da utilizzare con il contesto JNDI di lookup, se impostate.
  14287.      *
  14288.      * @return proprieta' da utilizzare con il contesto JNDI di lookup.
  14289.      * 
  14290.      */
  14291.     private java.util.Properties jndiContextMBeanServer = null;
  14292.     public java.util.Properties getJNDIContext_MBeanServer() {
  14293.         if(this.jndiContextMBeanServer==null){
  14294.             java.util.Properties prop = new java.util.Properties();
  14295.             try{ 

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

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

  14306.         return this.jndiContextMBeanServer;
  14307.     }









  14317.     /* ************* CONNETTORI ***************** */
  14318.     
  14319.     private Boolean isConnettoriUseLimitedInputStream = null;
  14320.     public boolean isConnettoriUseLimitedInputStream() {    
  14321.         if(this.isConnettoriUseLimitedInputStream==null){
  14322.             String pName = "org.openspcoop2.pdd.connettori.useLimitedInputStream";
  14323.             try{ 
  14324.                 String name = null;
  14325.                 name = this.reader.getValueConvertEnvProperties(pName);
  14326.                 if(name!=null){
  14327.                     name = name.trim();
  14328.                     this.isConnettoriUseLimitedInputStream = Boolean.parseBoolean(name);
  14329.                 }else{
  14330.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  14331.                     this.isConnettoriUseLimitedInputStream = false;
  14332.                 }
  14333.             }catch(java.lang.Exception e) {
  14334.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  14335.                 this.isConnettoriUseLimitedInputStream = false;
  14336.             }  
  14337.         }

  14339.         return this.isConnettoriUseLimitedInputStream;
  14340.     }
  14341.     
  14342.     private Long getLimitedInputStreamThreshold = null;
  14343.     private boolean limitedInputStreamThresholdDefined = false;
  14344.     public boolean isLimitedInputStreamThresholdDefined() {
  14345.         return this.limitedInputStreamThresholdDefined;
  14346.     }
  14347.     public long getLimitedInputStreamThresholdKb() {    
  14348.         if(this.getLimitedInputStreamThreshold==null){
  14349.             String pName = "org.openspcoop2.pdd.connettori.limitedInputStream.threshold";
  14350.             try{ 
  14351.                 String name = null;
  14352.                 name = this.reader.getValueConvertEnvProperties(pName);
  14353.                 if(name!=null){
  14354.                     name = name.trim();
  14355.                     this.getLimitedInputStreamThreshold = java.lang.Long.valueOf(name);
  14356.                     this.limitedInputStreamThresholdDefined = true;
  14357.                 }else{
  14358.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, Integer.MAX_VALUE));
  14359.                     this.getLimitedInputStreamThreshold = (long)Integer.MAX_VALUE;
  14360.                 }
  14361.             }catch(java.lang.Exception e) {
  14362.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, Integer.MAX_VALUE),e);
  14363.                 this.getLimitedInputStreamThreshold = (long)Integer.MAX_VALUE;
  14364.             }  
  14365.         }

  14367.         return this.getLimitedInputStreamThreshold;
  14368.     }
  14369.     
  14370.     private Boolean isLimitedInputStreamUseContentLength = null;
  14371.     public boolean isLimitedInputStreamUseContentLength() { 
  14372.         if(this.isLimitedInputStreamUseContentLength==null){
  14373.             String pName = "org.openspcoop2.pdd.connettori.limitedInputStream.useContentLength";
  14374.             try{ 
  14375.                 String name = null;
  14376.                 name = this.reader.getValueConvertEnvProperties(pName);
  14377.                 if(name!=null){
  14378.                     name = name.trim();
  14379.                     this.isLimitedInputStreamUseContentLength = Boolean.parseBoolean(name);
  14380.                 }else{
  14381.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  14382.                     this.isLimitedInputStreamUseContentLength = true;
  14383.                 }
  14384.             }catch(java.lang.Exception e) {
  14385.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  14386.                 this.isLimitedInputStreamUseContentLength = true;
  14387.             }  
  14388.         }

  14390.         return this.isLimitedInputStreamUseContentLength;
  14391.     }
  14392.     
  14393.     private Boolean isLimitedInputStreamUseContentLengthAcceptZeroValue = null;
  14394.     public boolean isLimitedInputStreamUseContentLengthAcceptZeroValue() {  
  14395.         if(this.isLimitedInputStreamUseContentLengthAcceptZeroValue==null){
  14396.             String pName = "org.openspcoop2.pdd.connettori.limitedInputStream.useContentLength.acceptZeroValue";
  14397.             try{ 
  14398.                 String name = null;
  14399.                 name = this.reader.getValueConvertEnvProperties(pName);
  14400.                 if(name!=null){
  14401.                     name = name.trim();
  14402.                     this.isLimitedInputStreamUseContentLengthAcceptZeroValue = Boolean.parseBoolean(name);
  14403.                 }else{
  14404.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  14405.                     this.isLimitedInputStreamUseContentLengthAcceptZeroValue = true;
  14406.                 }
  14407.             }catch(java.lang.Exception e) {
  14408.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  14409.                 this.isLimitedInputStreamUseContentLengthAcceptZeroValue = true;
  14410.             }  
  14411.         }

  14413.         return this.isLimitedInputStreamUseContentLengthAcceptZeroValue;
  14414.     }
  14415.     
  14416.     private Boolean isConnettoriUseTimeoutInputStream = null;
  14417.     public boolean isConnettoriUseTimeoutInputStream() {    
  14418.         if(this.isConnettoriUseTimeoutInputStream==null){
  14419.             String pName = "org.openspcoop2.pdd.connettori.useTimeoutInputStream";
  14420.             try{ 
  14421.                 String name = null;
  14422.                 name = this.reader.getValueConvertEnvProperties(pName);
  14423.                 if(name!=null){
  14424.                     name = name.trim();
  14425.                     this.isConnettoriUseTimeoutInputStream = Boolean.parseBoolean(name);
  14426.                 }else{
  14427.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  14428.                     this.isConnettoriUseTimeoutInputStream = false;
  14429.                 }
  14430.             }catch(java.lang.Exception e) {
  14431.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  14432.                 this.isConnettoriUseTimeoutInputStream = false;
  14433.             }  
  14434.         }

  14436.         return this.isConnettoriUseTimeoutInputStream;
  14437.     }
  14438.     
  14439.     /**
  14440.      * Restituisce timeout per la istanziazione della connessione
  14441.      *
  14442.      * @return Restituisce timeout per la istanziazione della connessione
  14443.      * 
  14444.      */
  14445.     private Integer connectionTimeout_inoltroBuste = null;
  14446.     public int getConnectionTimeout_inoltroBuste() {    
  14447.         if(this.connectionTimeout_inoltroBuste==null){
  14448.             try{ 
  14449.                 String name = null;
  14450.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.connection.timeout");
  14451.                 if(name!=null){
  14452.                     name = name.trim();
  14453.                     this.connectionTimeout_inoltroBuste = java.lang.Integer.parseInt(name);
  14454.                 }else{
  14455.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.connection.timeout' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_INOLTRO_BUSTE);
  14456.                     this.connectionTimeout_inoltroBuste = CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14457.                 }
  14458.             }catch(java.lang.Exception e) {
  14459.                 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);
  14460.                 this.connectionTimeout_inoltroBuste = CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14461.             }  
  14462.         }

  14464.         return this.connectionTimeout_inoltroBuste;
  14465.     }


  14468.     /**
  14469.      * Restituisce timeout per la istanziazione della connessione
  14470.      *
  14471.      * @return Restituisce timeout per la istanziazione della connessione
  14472.      * 
  14473.      */
  14474.     private Integer connectionTimeout_consegnaContenutiApplicativi = null;
  14475.     public int getConnectionTimeout_consegnaContenutiApplicativi() {    
  14476.         if(this.connectionTimeout_consegnaContenutiApplicativi==null){
  14477.             try{ 
  14478.                 String name = null;
  14479.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.connection.timeout");
  14480.                 if(name!=null){
  14481.                     name = name.trim();
  14482.                     this.connectionTimeout_consegnaContenutiApplicativi = java.lang.Integer.parseInt(name);
  14483.                 }else{
  14484.                     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);
  14485.                     this.connectionTimeout_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI;
  14486.                 }
  14487.             }catch(java.lang.Exception e) {
  14488.                 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);
  14489.                 this.connectionTimeout_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI;
  14490.             }  
  14491.         }

  14493.         return this.connectionTimeout_consegnaContenutiApplicativi;
  14494.     }


  14497.     /**
  14498.      * Restituisce timeout per la lettura dalla connessione
  14499.      *
  14500.      * @return Restituisce timeout per la lettura dalla connessione
  14501.      * 
  14502.      */
  14503.     private Integer readConnectionTimeout_inoltroBuste = null;
  14504.     public int getReadConnectionTimeout_inoltroBuste() {    
  14505.         if(this.readConnectionTimeout_inoltroBuste==null){
  14506.             try{ 
  14507.                 String name = null;
  14508.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.readConnection.timeout");
  14509.                 if(name!=null){
  14510.                     name = name.trim();
  14511.                     this.readConnectionTimeout_inoltroBuste = java.lang.Integer.parseInt(name);
  14512.                 }else{
  14513.                     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);
  14514.                     this.readConnectionTimeout_inoltroBuste = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14515.                 }
  14516.             }catch(java.lang.Exception e) {
  14517.                 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);
  14518.                 this.readConnectionTimeout_inoltroBuste = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14519.             }  
  14520.         }

  14522.         return this.readConnectionTimeout_inoltroBuste;
  14523.     }


  14526.     /**
  14527.      * Restituisce timeout per la lettura dalla connessione
  14528.      *
  14529.      * @return Restituisce timeout per la lettura dalla connessione
  14530.      * 
  14531.      */
  14532.     private Integer readConnectionTimeout_consegnaContenutiApplicativi = null;
  14533.     public int getReadConnectionTimeout_consegnaContenutiApplicativi() {    
  14534.         if(this.readConnectionTimeout_consegnaContenutiApplicativi==null){
  14535.             try{ 
  14536.                 String name = null;
  14537.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.readConnection.timeout");
  14538.                 if(name!=null){
  14539.                     name = name.trim();
  14540.                     this.readConnectionTimeout_consegnaContenutiApplicativi = java.lang.Integer.parseInt(name);
  14541.                 }else{
  14542.                     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);
  14543.                     this.readConnectionTimeout_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI;
  14544.                 }
  14545.             }catch(java.lang.Exception e) {
  14546.                 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);
  14547.                 this.readConnectionTimeout_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_CONSEGNA_CONTENUTI_APPLICATIVI;
  14548.             }  
  14549.         }

  14551.         return this.readConnectionTimeout_consegnaContenutiApplicativi;
  14552.     }

  14554.     /**
  14555.      * Restituisce timeout in millisecondi massimi durante il quale una connessione viene mantenuta aperta dalla PdD. 
  14556.      *
  14557.      * @return Restituisce timeout in millisecondi massimi durante il quale una connessione viene mantenuta aperta dalla PdD. 
  14558.      * 
  14559.      */
  14560.     private Integer connectionLife_inoltroBuste = null;
  14561.     public int getConnectionLife_inoltroBuste() {   
  14562.         if(this.connectionLife_inoltroBuste==null){
  14563.             try{ 
  14564.                 String name = null;
  14565.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.connection.life");
  14566.                 if(name!=null){
  14567.                     name = name.trim();
  14568.                     this.connectionLife_inoltroBuste = java.lang.Integer.parseInt(name);
  14569.                 }else{
  14570.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.connection.life' non impostata, viene utilizzato il default="+CostantiPdD.CONNETTORE_CONNECTION_LIFE_INOLTRO_BUSTE);
  14571.                     this.connectionLife_inoltroBuste = CostantiPdD.CONNETTORE_CONNECTION_LIFE_INOLTRO_BUSTE;
  14572.                 }
  14573.             }catch(java.lang.Exception e) {
  14574.                 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);
  14575.                 this.connectionLife_inoltroBuste = CostantiPdD.CONNETTORE_CONNECTION_LIFE_INOLTRO_BUSTE;
  14576.             }  
  14577.         }

  14579.         return this.connectionLife_inoltroBuste;
  14580.     }


  14583.     /**
  14584.      * Restituisce timeout in millisecondi massimi durante il quale una connessione viene mantenuta aperta dalla PdD. 
  14585.      *
  14586.      * @return Restituisce timeout in millisecondi massimi durante il quale una connessione viene mantenuta aperta dalla PdD. 
  14587.      * 
  14588.      */
  14589.     private Integer connectionLife_consegnaContenutiApplicativi = null;
  14590.     public int getConnectionLife_consegnaContenutiApplicativi() {   
  14591.         if(this.connectionLife_consegnaContenutiApplicativi==null){
  14592.             try{ 
  14593.                 String name = null;
  14594.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.connection.life");
  14595.                 if(name!=null){
  14596.                     name = name.trim();
  14597.                     this.connectionLife_consegnaContenutiApplicativi = java.lang.Integer.parseInt(name);
  14598.                 }else{
  14599.                     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);
  14600.                     this.connectionLife_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_CONNECTION_LIFE_CONSEGNA_CONTENUTI_APPLICATIVI;
  14601.                 }
  14602.             }catch(java.lang.Exception e) {
  14603.                 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);
  14604.                 this.connectionLife_consegnaContenutiApplicativi = CostantiPdD.CONNETTORE_CONNECTION_LIFE_CONSEGNA_CONTENUTI_APPLICATIVI;
  14605.             }  
  14606.         }

  14608.         return this.connectionLife_consegnaContenutiApplicativi;
  14609.     }

  14611.     
  14612.     private Integer readConnectionTimeout_ricezioneContenutiApplicativi = null;
  14613.     public int getReadConnectionTimeout_ricezioneContenutiApplicativi() {   
  14614.         String pName = "org.openspcoop2.pdd.connettori.ricezioneContenutiApplicativi.readConnection.timeout";
  14615.         if(this.readConnectionTimeout_ricezioneContenutiApplicativi==null){
  14616.             try{ 
  14617.                 String name = null;
  14618.                 name = this.reader.getValueConvertEnvProperties(pName);
  14619.                 if(name!=null){
  14620.                     name = name.trim();
  14621.                     this.readConnectionTimeout_ricezioneContenutiApplicativi = java.lang.Integer.parseInt(name);
  14622.                 }else{
  14623.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE));
  14624.                     this.readConnectionTimeout_ricezioneContenutiApplicativi = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14625.                 }
  14626.             }catch(java.lang.Exception e) {
  14627.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE),e);
  14628.                 this.readConnectionTimeout_ricezioneContenutiApplicativi = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14629.             }  
  14630.         }

  14632.         return this.readConnectionTimeout_ricezioneContenutiApplicativi;
  14633.     }
  14634.     
  14635.     private Integer readConnectionTimeout_ricezioneBuste = null;
  14636.     public int getReadConnectionTimeout_ricezioneBuste() {  
  14637.         String pName = "org.openspcoop2.pdd.connettori.ricezioneBuste.readConnection.timeout";
  14638.         if(this.readConnectionTimeout_ricezioneBuste==null){
  14639.             try{ 
  14640.                 String name = null;
  14641.                 name = this.reader.getValueConvertEnvProperties(pName);
  14642.                 if(name!=null){
  14643.                     name = name.trim();
  14644.                     this.readConnectionTimeout_ricezioneBuste = java.lang.Integer.parseInt(name);
  14645.                 }else{
  14646.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE));
  14647.                     this.readConnectionTimeout_ricezioneBuste = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14648.                 }
  14649.             }catch(java.lang.Exception e) {
  14650.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE),e);
  14651.                 this.readConnectionTimeout_ricezioneBuste = CostantiPdD.CONNETTORE_READ_CONNECTION_TIMEOUT_INOLTRO_BUSTE;
  14652.             }  
  14653.         }

  14655.         return this.readConnectionTimeout_ricezioneBuste;
  14656.     }
  14657.     
  14658.     
  14659.     
  14660.     private Boolean isConnettoriUseDiagnosticInputStream_inoltroBuste = null;
  14661.     public boolean isConnettoriUseDiagnosticInputStream_inoltroBuste() {    
  14662.         if(this.isConnettoriUseDiagnosticInputStream_inoltroBuste==null){
  14663.             String pName = "org.openspcoop2.pdd.connettori.inoltroBuste.useDiagnosticInputStream";
  14664.             try{ 
  14665.                 String name = null;
  14666.                 name = this.reader.getValueConvertEnvProperties(pName);
  14667.                 if(name!=null){
  14668.                     name = name.trim();
  14669.                     this.isConnettoriUseDiagnosticInputStream_inoltroBuste = Boolean.parseBoolean(name);
  14670.                 }else{
  14671.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  14672.                     this.isConnettoriUseDiagnosticInputStream_inoltroBuste = true;
  14673.                 }
  14674.             }catch(java.lang.Exception e) {
  14675.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  14676.                 this.isConnettoriUseDiagnosticInputStream_inoltroBuste = true;
  14677.             }  
  14678.         }

  14680.         return this.isConnettoriUseDiagnosticInputStream_inoltroBuste;
  14681.     }
  14682.     
  14683.     private Boolean isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi = null;
  14684.     public boolean isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi() {    
  14685.         if(this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi==null){
  14686.             String pName = "org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.useDiagnosticInputStream";
  14687.             try{ 
  14688.                 String name = null;
  14689.                 name = this.reader.getValueConvertEnvProperties(pName);
  14690.                 if(name!=null){
  14691.                     name = name.trim();
  14692.                     this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
  14693.                 }else{
  14694.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  14695.                     this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi = true;
  14696.                 }
  14697.             }catch(java.lang.Exception e) {
  14698.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  14699.                 this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi = true;
  14700.             }  
  14701.         }

  14703.         return this.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi;
  14704.     }
  14705.     
  14706.     private Boolean isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi = null;
  14707.     public boolean isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi() {   
  14708.         if(this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi==null){
  14709.             String pName = "org.openspcoop2.pdd.connettori.ricezioneContenutiApplicativi.useDiagnosticInputStream";
  14710.             try{ 
  14711.                 String name = null;
  14712.                 name = this.reader.getValueConvertEnvProperties(pName);
  14713.                 if(name!=null){
  14714.                     name = name.trim();
  14715.                     this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi = Boolean.parseBoolean(name);
  14716.                 }else{
  14717.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  14718.                     this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi = true;
  14719.                 }
  14720.             }catch(java.lang.Exception e) {
  14721.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  14722.                 this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi = true;
  14723.             }  
  14724.         }

  14726.         return this.isConnettoriUseDiagnosticInputStream_ricezioneContenutiApplicativi;
  14727.     }
  14728.     
  14729.     private Boolean isConnettoriUseDiagnosticInputStream_ricezioneBuste = null;
  14730.     public boolean isConnettoriUseDiagnosticInputStream_ricezioneBuste() {  
  14731.         if(this.isConnettoriUseDiagnosticInputStream_ricezioneBuste==null){
  14732.             String pName = "org.openspcoop2.pdd.connettori.ricezioneBuste.useDiagnosticInputStream";
  14733.             try{ 
  14734.                 String name = null;
  14735.                 name = this.reader.getValueConvertEnvProperties(pName);
  14736.                 if(name!=null){
  14737.                     name = name.trim();
  14738.                     this.isConnettoriUseDiagnosticInputStream_ricezioneBuste = Boolean.parseBoolean(name);
  14739.                 }else{
  14740.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  14741.                     this.isConnettoriUseDiagnosticInputStream_ricezioneBuste = true;
  14742.                 }
  14743.             }catch(java.lang.Exception e) {
  14744.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  14745.                 this.isConnettoriUseDiagnosticInputStream_ricezioneBuste = true;
  14746.             }  
  14747.         }

  14749.         return this.isConnettoriUseDiagnosticInputStream_ricezioneBuste;
  14750.     }
  14751.     
  14752.     
  14753.     private Boolean isConnettoriUseDiagnosticInputStream_setDateEmptyStream = null;
  14754.     public boolean isConnettoriUseDiagnosticInputStream_setDateEmptyStream() {  
  14755.         if(this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream==null){
  14756.             String pName = "org.openspcoop2.pdd.connettori.useDiagnosticInputStream.setDateEmptyStream";
  14757.             try{ 
  14758.                 String name = null;
  14759.                 name = this.reader.getValueConvertEnvProperties(pName);
  14760.                 if(name!=null){
  14761.                     name = name.trim();
  14762.                     this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream = Boolean.parseBoolean(name);
  14763.                 }else{
  14764.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  14765.                     this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream = false;
  14766.                 }
  14767.             }catch(java.lang.Exception e) {
  14768.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  14769.                 this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream = false;
  14770.             }  
  14771.         }

  14773.         return this.isConnettoriUseDiagnosticInputStream_setDateEmptyStream;
  14774.     }
  14775.     
  14776.     
  14777.     

  14779.     /* ***************** HTTPS  ************* */
  14780.     
  14781.     private Boolean isConnettoreHttps_useSecureRandom = null;
  14782.     public boolean isConnettoreHttps_useSecureRandom() {    
  14783.         if(this.isConnettoreHttps_useSecureRandom==null){
  14784.             String pName = "org.openspcoop2.pdd.connettori.secureRandom";
  14785.             try{ 
  14786.                 String name = null;
  14787.                 name = this.reader.getValueConvertEnvProperties(pName);
  14788.                 if(name!=null){
  14789.                     name = name.trim();
  14790.                     this.isConnettoreHttps_useSecureRandom = Boolean.parseBoolean(name);
  14791.                 }else{
  14792.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  14793.                     this.isConnettoreHttps_useSecureRandom = false;
  14794.                 }
  14795.             }catch(java.lang.Exception e) {
  14796.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  14797.                 this.isConnettoreHttps_useSecureRandom = false;
  14798.             }  
  14799.         }

  14801.         return this.isConnettoreHttps_useSecureRandom;
  14802.     }
  14803.     private String getConnettoreHttps_secureRandomAlgo = null;
  14804.     private Boolean getConnettoreHttps_secureRandomAlgoRead = null;
  14805.     public String getConnettoreHttps_secureRandomAlgo() {   
  14806.         if(this.getConnettoreHttps_secureRandomAlgoRead==null){
  14807.             String pName = "org.openspcoop2.pdd.connettori.secureRandomAlgorithm";
  14808.             try{ 
  14809.                 String name = null;
  14810.                 name = this.reader.getValueConvertEnvProperties(pName);
  14811.                 if(name!=null){
  14812.                     name = name.trim();
  14813.                     this.getConnettoreHttps_secureRandomAlgo = name;
  14814.                 }
  14815.             }catch(java.lang.Exception e) {
  14816.                 this.logWarn("Proprieta' di openspcoop '"+pName+"', errore:"+e.getMessage(),e);
  14817.             }  
  14818.             
  14819.             this.getConnettoreHttps_secureRandomAlgoRead=true;
  14820.         }

  14822.         return this.getConnettoreHttps_secureRandomAlgo;
  14823.     }
  14824.     
  14825.     private Boolean isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste = null;
  14826.     public boolean isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste() {  
  14827.         if(this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste==null){
  14828.             try{ 
  14829.                 String name = null;
  14830.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.overrideDefaultConfiguration");
  14831.                 if(name!=null){
  14832.                     name = name.trim();
  14833.                     this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste = Boolean.parseBoolean(name);
  14834.                 }else{
  14835.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.overrideDefaultConfiguration' non impostata, viene utilizzato il default="+true);
  14836.                     this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste = true;
  14837.                 }
  14838.             }catch(java.lang.Exception e) {
  14839.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.overrideDefaultConfiguration' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
  14840.                 this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste = true;
  14841.             }  
  14842.         }

  14844.         return this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste;
  14845.     }
  14846.     
  14847.     private Boolean isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi = null;
  14848.     public boolean isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi() {  
  14849.         if(this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi==null){
  14850.             try{ 
  14851.                 String name = null;
  14852.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.overrideDefaultConfiguration");
  14853.                 if(name!=null){
  14854.                     name = name.trim();
  14855.                     this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
  14856.                 }else{
  14857.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.overrideDefaultConfiguration' non impostata, viene utilizzato il default="+true);
  14858.                     this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi = true;
  14859.                 }
  14860.             }catch(java.lang.Exception e) {
  14861.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.overrideDefaultConfiguration' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
  14862.                 this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi = true;
  14863.             }  
  14864.         }

  14866.         return this.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi;
  14867.     }
  14868.     
  14869.     private File getConnettoreHttp_urlHttps_repository_inoltroBuste = null;
  14870.     public File getConnettoreHttp_urlHttps_repository_inoltroBuste() throws CoreException { 
  14871.         if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste==null){
  14872.             try{ 
  14873.                 String name = null;
  14874.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.repository");
  14875.                 if(name==null){
  14876.                     throw new CoreException("Proprieta' non impostata");
  14877.                 }
  14878.                 name = name.trim();
  14879.                 this.getConnettoreHttp_urlHttps_repository_inoltroBuste = new File(name);
  14880.                 if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste.exists()) {
  14881.                     if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste.isDirectory()==false) {
  14882.                         throw newCoreExceptionNotDir(this.getConnettoreHttp_urlHttps_repository_inoltroBuste,true);
  14883.                     }
  14884.                     if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste.canRead()==false) {
  14885.                         throw newCoreExceptionCannotRead(this.getConnettoreHttp_urlHttps_repository_inoltroBuste,true);
  14886.                     }
  14887.                     if(this.getConnettoreHttp_urlHttps_repository_inoltroBuste.canWrite()==false) {
  14888.                         throw newCoreExceptionCannotWrite(this.getConnettoreHttp_urlHttps_repository_inoltroBuste,true);
  14889.                     }
  14890.                 }
  14891.                 else {
  14892.                     // viene creata automaticamente
  14893.                 }
  14894.             } catch(java.lang.Exception e) {
  14895.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.http.urlHttps.repository': "+e.getMessage(),e);
  14896.                 throw new CoreException(e.getMessage(),e);
  14897.             }    
  14898.         }

  14900.         return this.getConnettoreHttp_urlHttps_repository_inoltroBuste;
  14901.     }
  14902.     
  14903.     private File getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi = null;
  14904.     public File getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi() throws CoreException { 
  14905.         if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi==null){
  14906.             try{ 
  14907.                 String name = null;
  14908.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.repository");
  14909.                 if(name==null){
  14910.                     throw new CoreException("Proprieta' non impostata");
  14911.                 }
  14912.                 name = name.trim();
  14913.                 this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi = new File(name);
  14914.                 if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi.exists()) {
  14915.                     if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi.isDirectory()==false) {
  14916.                         throw newCoreExceptionNotDir(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi,true);
  14917.                     }
  14918.                     if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi.canRead()==false) {
  14919.                         throw newCoreExceptionCannotRead(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi,true);
  14920.                     }
  14921.                     if(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi.canWrite()==false) {
  14922.                         throw newCoreExceptionCannotWrite(this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi,true);
  14923.                     }
  14924.                 }
  14925.                 else {
  14926.                     // viene creata automaticamente
  14927.                 }
  14928.             } catch(java.lang.Exception e) {
  14929.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.http.urlHttps.repository': "+e.getMessage(),e);
  14930.                 throw new CoreException(e.getMessage(),e);
  14931.             }    
  14932.         }

  14934.         return this.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi;
  14935.     }
  14936.     
  14937.     private Boolean isConnettoreHttp_urlHttps_cacheEnabled = null;
  14938.     public boolean isConnettoreHttp_urlHttps_cacheEnabled() {   
  14939.         if(this.isConnettoreHttp_urlHttps_cacheEnabled==null){
  14940.             try{ 
  14941.                 String name = null;
  14942.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.http.urlHttps.cache.enabled");
  14943.                 if(name!=null){
  14944.                     name = name.trim();
  14945.                     this.isConnettoreHttp_urlHttps_cacheEnabled = Boolean.parseBoolean(name);
  14946.                 }else{
  14947.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.http.urlHttps.cache.enabled' non impostata, viene utilizzato il default="+true);
  14948.                     this.isConnettoreHttp_urlHttps_cacheEnabled = true;
  14949.                 }
  14950.             }catch(java.lang.Exception e) {
  14951.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.http.urlHttps.cache.enabled' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
  14952.                 this.isConnettoreHttp_urlHttps_cacheEnabled = true;
  14953.             }  
  14954.         }

  14956.         return this.isConnettoreHttp_urlHttps_cacheEnabled;
  14957.     }
  14958.     
  14959.     private Integer getConnettoreHttp_urlHttps_cacheSize = null;
  14960.     public int getConnettoreHttp_urlHttps_cacheSize() { 
  14961.         if(this.getConnettoreHttp_urlHttps_cacheSize==null){
  14962.             try{ 
  14963.                 String name = null;
  14964.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.http.urlHttps.cache.size");
  14965.                 if(name!=null){
  14966.                     name = name.trim();
  14967.                     this.getConnettoreHttp_urlHttps_cacheSize = java.lang.Integer.parseInt(name);
  14968.                 }else{
  14969.                     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);
  14970.                     this.getConnettoreHttp_urlHttps_cacheSize = CostantiPdD.CONNETTORE_HTTP_URL_HTTPS_CACHE_SIZE;
  14971.                 }
  14972.             }catch(java.lang.Exception e) {
  14973.                 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);
  14974.                 this.getConnettoreHttp_urlHttps_cacheSize = CostantiPdD.CONNETTORE_HTTP_URL_HTTPS_CACHE_SIZE;
  14975.             }  
  14976.         }

  14978.         return this.getConnettoreHttp_urlHttps_cacheSize;
  14979.     }
  14980.     
  14981.     
  14982.     
  14983.     
  14984.     /* ***************** Servizi HTTP  ************* */
  14985.     
  14986.     private Boolean isHttpDisableKeepAlive = null;
  14987.     public boolean isHttpDisableKeepAlive() {   
  14988.         String pName = "org.openspcoop2.pdd.services.http.disableKeepAlive";
  14989.         if(this.isHttpDisableKeepAlive==null){
  14990.             try{ 
  14991.                 String name = null;
  14992.                 name = this.reader.getValueConvertEnvProperties(pName);
  14993.                 if(name!=null){
  14994.                     name = name.trim();
  14995.                     this.isHttpDisableKeepAlive = Boolean.parseBoolean(name);
  14996.                 }else{
  14997.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  14998.                     this.isHttpDisableKeepAlive = false;
  14999.                 }
  15000.             }catch(java.lang.Exception e) {
  15001.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  15002.                 this.isHttpDisableKeepAlive = false;
  15003.             }  
  15004.         }

  15006.         return this.isHttpDisableKeepAlive;
  15007.     }
  15008.     
  15009.     private Boolean serviceRequestHttpMethodPatchEnabled = null;
  15010.     public boolean isServiceRequestHttpMethodPatchEnabled() {   
  15011.         if(this.serviceRequestHttpMethodPatchEnabled==null){
  15012.             try{ 
  15013.                 String name = null;
  15014.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.request.method.PATCH");
  15015.                 if(name!=null){
  15016.                     name = name.trim();
  15017.                     this.serviceRequestHttpMethodPatchEnabled = Boolean.parseBoolean(name);
  15018.                 }else{
  15019.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.PATCH' non impostata, viene utilizzato il default="+true);
  15020.                     this.serviceRequestHttpMethodPatchEnabled = true;
  15021.                 }
  15022.             }catch(java.lang.Exception e) {
  15023.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.PATCH' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
  15024.                 this.serviceRequestHttpMethodPatchEnabled = true;
  15025.             }  
  15026.         }

  15028.         return this.serviceRequestHttpMethodPatchEnabled;
  15029.     }
  15030.     
  15031.     private Boolean serviceRequestHttpMethodLinkEnabled = null;
  15032.     public boolean isServiceRequestHttpMethodLinkEnabled() {    
  15033.         if(this.serviceRequestHttpMethodLinkEnabled==null){
  15034.             try{ 
  15035.                 String name = null;
  15036.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.request.method.LINK");
  15037.                 if(name!=null){
  15038.                     name = name.trim();
  15039.                     this.serviceRequestHttpMethodLinkEnabled = Boolean.parseBoolean(name);
  15040.                 }else{
  15041.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.LINK' non impostata, viene utilizzato il default="+true);
  15042.                     this.serviceRequestHttpMethodLinkEnabled = true;
  15043.                 }
  15044.             }catch(java.lang.Exception e) {
  15045.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.LINK' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
  15046.                 this.serviceRequestHttpMethodLinkEnabled = true;
  15047.             }  
  15048.         }

  15050.         return this.serviceRequestHttpMethodLinkEnabled;
  15051.     }
  15052.     
  15053.     private Boolean serviceRequestHttpMethodUnlinkEnabled = null;
  15054.     public boolean isServiceRequestHttpMethodUnlinkEnabled() {  
  15055.         if(this.serviceRequestHttpMethodUnlinkEnabled==null){
  15056.             try{ 
  15057.                 String name = null;
  15058.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.request.method.UNLINK");
  15059.                 if(name!=null){
  15060.                     name = name.trim();
  15061.                     this.serviceRequestHttpMethodUnlinkEnabled = Boolean.parseBoolean(name);
  15062.                 }else{
  15063.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.UNLINK' non impostata, viene utilizzato il default="+true);
  15064.                     this.serviceRequestHttpMethodUnlinkEnabled = true;
  15065.                 }
  15066.             }catch(java.lang.Exception e) {
  15067.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.request.method.UNLINK' non impostata, viene utilizzato il default="+true+", errore:"+e.getMessage(),e);
  15068.                 this.serviceRequestHttpMethodUnlinkEnabled = true;
  15069.             }  
  15070.         }

  15072.         return this.serviceRequestHttpMethodUnlinkEnabled;
  15073.     }
  15074.     
  15075.     
  15076.     private TransferLengthModes readTransferLengthModes_ricezioneContenutiApplicativi = null;
  15077.     public TransferLengthModes getTransferLengthModes_ricezioneContenutiApplicativi() { 
  15078.         if(this.readTransferLengthModes_ricezioneContenutiApplicativi==null){
  15079.             try{ 
  15080.                 String name = null;
  15081.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.httpTransferLength");
  15082.                 if(name!=null){
  15083.                     name = name.trim();
  15084.                     this.readTransferLengthModes_ricezioneContenutiApplicativi = TransferLengthModes.getTransferLengthModes(name);
  15085.                 }else{
  15086.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.WEBSERVER_DEFAULT);
  15087.                     this.readTransferLengthModes_ricezioneContenutiApplicativi = TransferLengthModes.WEBSERVER_DEFAULT;
  15088.                 }
  15089.             }catch(java.lang.Exception e) {
  15090.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.WEBSERVER_DEFAULT+", errore:"+e.getMessage(),e);
  15091.                 this.readTransferLengthModes_ricezioneContenutiApplicativi = TransferLengthModes.WEBSERVER_DEFAULT;
  15092.             }  
  15093.         }

  15095.         return this.readTransferLengthModes_ricezioneContenutiApplicativi;
  15096.     }
  15097.     
  15098.     private TransferLengthModes readTransferLengthModes_ricezioneBuste = null;
  15099.     public TransferLengthModes getTransferLengthModes_ricezioneBuste() {    
  15100.         if(this.readTransferLengthModes_ricezioneBuste==null){
  15101.             try{ 
  15102.                 String name = null;
  15103.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.httpTransferLength");
  15104.                 if(name!=null){
  15105.                     name = name.trim();
  15106.                     this.readTransferLengthModes_ricezioneBuste = TransferLengthModes.getTransferLengthModes(name);
  15107.                 }else{
  15108.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.WEBSERVER_DEFAULT);
  15109.                     this.readTransferLengthModes_ricezioneBuste = TransferLengthModes.WEBSERVER_DEFAULT;
  15110.                 }
  15111.             }catch(java.lang.Exception e) {
  15112.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.WEBSERVER_DEFAULT+", errore:"+e.getMessage(),e);
  15113.                 this.readTransferLengthModes_ricezioneBuste = TransferLengthModes.WEBSERVER_DEFAULT;
  15114.             }  
  15115.         }

  15117.         return this.readTransferLengthModes_ricezioneBuste;
  15118.     }
  15119.     
  15120.     private TransferLengthModes readTransferLengthModes_inoltroBuste = null;
  15121.     public TransferLengthModes getTransferLengthModes_inoltroBuste() {  
  15122.         if(this.readTransferLengthModes_inoltroBuste==null){
  15123.             try{ 
  15124.                 String name = null;
  15125.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength");
  15126.                 if(name!=null){
  15127.                     name = name.trim();
  15128.                     this.readTransferLengthModes_inoltroBuste = TransferLengthModes.getTransferLengthModes(name);
  15129.                 }else{
  15130.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.CONTENT_LENGTH);
  15131.                     this.readTransferLengthModes_inoltroBuste = TransferLengthModes.CONTENT_LENGTH;
  15132.                 }
  15133.             }catch(java.lang.Exception e) {
  15134.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.CONTENT_LENGTH+", errore:"+e.getMessage(),e);
  15135.                 this.readTransferLengthModes_inoltroBuste = TransferLengthModes.CONTENT_LENGTH;
  15136.             }  
  15137.         }

  15139.         return this.readTransferLengthModes_inoltroBuste;
  15140.     }
  15141.     
  15142.     private Integer getChunkLength_inoltroBuste = null;
  15143.     public int getChunkLength_inoltroBuste() {  
  15144.         if(this.getChunkLength_inoltroBuste==null){
  15145.             try{ 
  15146.                 String name = null;
  15147.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength.chunkLength");
  15148.                 if(name!=null){
  15149.                     name = name.trim();
  15150.                     this.getChunkLength_inoltroBuste = Integer.parseInt(name);
  15151.                 }else{
  15152.                     int DEFAULT_CHUNKLEN = 0;
  15153.                     this.getChunkLength_inoltroBuste = DEFAULT_CHUNKLEN;
  15154.                 }
  15155.             }catch(java.lang.Exception e) {
  15156.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.httpTransferLength.chunkLength' posside un valore non corretto:"+e.getMessage(),e);
  15157.                 this.getChunkLength_inoltroBuste = -1;
  15158.             }  
  15159.         }

  15161.         return this.getChunkLength_inoltroBuste;
  15162.     }
  15163.     
  15164.     private TransferLengthModes readTransferLengthModes_consegnaContenutiApplicativi = null;
  15165.     public TransferLengthModes getTransferLengthModes_consegnaContenutiApplicativi() {  
  15166.         if(this.readTransferLengthModes_consegnaContenutiApplicativi==null){
  15167.             try{ 
  15168.                 String name = null;
  15169.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength");
  15170.                 if(name!=null){
  15171.                     name = name.trim();
  15172.                     this.readTransferLengthModes_consegnaContenutiApplicativi = TransferLengthModes.getTransferLengthModes(name);
  15173.                 }else{
  15174.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.CONTENT_LENGTH);
  15175.                     this.readTransferLengthModes_consegnaContenutiApplicativi = TransferLengthModes.CONTENT_LENGTH;
  15176.                 }
  15177.             }catch(java.lang.Exception e) {
  15178.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength' non impostata, viene utilizzato il default="+TransferLengthModes.CONTENT_LENGTH+", errore:"+e.getMessage(),e);
  15179.                 this.readTransferLengthModes_consegnaContenutiApplicativi = TransferLengthModes.CONTENT_LENGTH;
  15180.             }  
  15181.         }

  15183.         return this.readTransferLengthModes_consegnaContenutiApplicativi;
  15184.     }
  15185.     
  15186.     private Integer getChunkLength_consegnaContenutiApplicativi = null;
  15187.     public int getChunkLength_consegnaContenutiApplicativi() {  
  15188.         if(this.getChunkLength_consegnaContenutiApplicativi==null){
  15189.             try{ 
  15190.                 String name = null;
  15191.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength.chunkLength");
  15192.                 if(name!=null){
  15193.                     name = name.trim();
  15194.                     this.getChunkLength_consegnaContenutiApplicativi = Integer.parseInt(name);
  15195.                 }else{
  15196.                     int DEFAULT_CHUNKLEN = 0;
  15197.                     this.getChunkLength_consegnaContenutiApplicativi = DEFAULT_CHUNKLEN;
  15198.                 }
  15199.             }catch(java.lang.Exception e) {
  15200.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.httpTransferLength.chunkLength' posside un valore non corretto:"+e.getMessage(),e);
  15201.                 this.getChunkLength_consegnaContenutiApplicativi = -1;
  15202.             }  
  15203.         }

  15205.         return this.getChunkLength_consegnaContenutiApplicativi;
  15206.     }
  15207.     
  15208.     private Boolean isAcceptOnlyReturnCode_200_202_inoltroBuste = null;
  15209.     public boolean isAcceptOnlyReturnCode_200_202_inoltroBuste() {  
  15210.         if(this.isAcceptOnlyReturnCode_200_202_inoltroBuste==null){
  15211.             try{ 
  15212.                 String name = null;
  15213.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.2xx.acceptOnly_202_200");
  15214.                 if(name!=null){
  15215.                     name = name.trim();
  15216.                     this.isAcceptOnlyReturnCode_200_202_inoltroBuste = Boolean.parseBoolean(name);
  15217.                 }else{
  15218.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.2xx.acceptOnly_202_200' non impostata, viene utilizzato il default=true");
  15219.                     this.isAcceptOnlyReturnCode_200_202_inoltroBuste = true;
  15220.                 }
  15221.             }catch(java.lang.Exception e) {
  15222.                 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);
  15223.                 this.isAcceptOnlyReturnCode_200_202_inoltroBuste = true;
  15224.             }  
  15225.         }

  15227.         return this.isAcceptOnlyReturnCode_200_202_inoltroBuste;
  15228.     }
  15229.     
  15230.     private Boolean isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi = null;
  15231.     public boolean isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi() {  
  15232.         if(this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi==null){
  15233.             try{ 
  15234.                 String name = null;
  15235.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.2xx.acceptOnly_202_200");
  15236.                 if(name!=null){
  15237.                     name = name.trim();
  15238.                     this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
  15239.                 }else{
  15240.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.2xx.acceptOnly_202_200' non impostata, viene utilizzato il default=true");
  15241.                     this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi = true;
  15242.                 }
  15243.             }catch(java.lang.Exception e) {
  15244.                 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);
  15245.                 this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi = true;
  15246.             }  
  15247.         }

  15249.         return this.isAcceptOnlyReturnCode_200_202_consegnaContenutiApplicativi;
  15250.     }
  15251.     
  15252.     private Boolean isAcceptOnlyReturnCode_307_inoltroBuste = null;
  15253.     public boolean isAcceptOnlyReturnCode_307_inoltroBuste() {  
  15254.         if(this.isAcceptOnlyReturnCode_307_inoltroBuste==null){
  15255.             try{ 
  15256.                 String name = null;
  15257.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.3xx.acceptOnly_307");
  15258.                 if(name!=null){
  15259.                     name = name.trim();
  15260.                     this.isAcceptOnlyReturnCode_307_inoltroBuste = Boolean.parseBoolean(name);
  15261.                 }else{
  15262.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.returnCode.3xx.acceptOnly_307' non impostata, viene utilizzato il default=false");
  15263.                     this.isAcceptOnlyReturnCode_307_inoltroBuste = false;
  15264.                 }
  15265.             }catch(java.lang.Exception e) {
  15266.                 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);
  15267.                 this.isAcceptOnlyReturnCode_307_inoltroBuste = false;
  15268.             }  
  15269.         }

  15271.         return this.isAcceptOnlyReturnCode_307_inoltroBuste;
  15272.     }
  15273.     
  15274.     private Boolean isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi = null;
  15275.     public boolean isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi() {  
  15276.         if(this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi==null){
  15277.             try{ 
  15278.                 String name = null;
  15279.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.3xx.acceptOnly_307");
  15280.                 if(name!=null){
  15281.                     name = name.trim();
  15282.                     this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi = Boolean.parseBoolean(name);
  15283.                 }else{
  15284.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.returnCode.3xx.acceptOnly_307' non impostata, viene utilizzato il default=false");
  15285.                     this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi = false;
  15286.                 }
  15287.             }catch(java.lang.Exception e) {
  15288.                 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);
  15289.                 this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi = false;
  15290.             }  
  15291.         }

  15293.         return this.isAcceptOnlyReturnCode_307_consegnaContenutiApplicativi;
  15294.     }
  15295.     
  15296.     private Boolean isFollowRedirects_inoltroBuste_soap = null;
  15297.     public boolean isFollowRedirects_inoltroBuste_soap() {  
  15298.         if(this.isFollowRedirects_inoltroBuste_soap==null){
  15299.             try{ 
  15300.                 String name = null;
  15301.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.soap");
  15302.                 if(name!=null){
  15303.                     name = name.trim();
  15304.                     this.isFollowRedirects_inoltroBuste_soap = Boolean.parseBoolean(name);
  15305.                 }else{
  15306.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.soap' non impostata, viene utilizzato il default=false");
  15307.                     this.isFollowRedirects_inoltroBuste_soap = false;
  15308.                 }
  15309.             }catch(java.lang.Exception e) {
  15310.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.soap' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  15311.                 this.isFollowRedirects_inoltroBuste_soap = false;
  15312.             }  
  15313.         }

  15315.         return this.isFollowRedirects_inoltroBuste_soap;
  15316.     }
  15317.     
  15318.     private Boolean isFollowRedirects_inoltroBuste_rest = null;
  15319.     public boolean isFollowRedirects_inoltroBuste_rest() {  
  15320.         if(this.isFollowRedirects_inoltroBuste_rest==null){
  15321.             try{ 
  15322.                 String name = null;
  15323.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.rest");
  15324.                 if(name!=null){
  15325.                     name = name.trim();
  15326.                     this.isFollowRedirects_inoltroBuste_rest = Boolean.parseBoolean(name);
  15327.                 }else{
  15328.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.rest' non impostata, viene utilizzato il default=false");
  15329.                     this.isFollowRedirects_inoltroBuste_rest = false;
  15330.                 }
  15331.             }catch(java.lang.Exception e) {
  15332.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.rest' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  15333.                 this.isFollowRedirects_inoltroBuste_rest = false;
  15334.             }  
  15335.         }

  15337.         return this.isFollowRedirects_inoltroBuste_rest;
  15338.     }
  15339.     

  15341.     
  15342.     private Boolean isFollowRedirects_consegnaContenutiApplicativi_soap = null;
  15343.     public boolean isFollowRedirects_consegnaContenutiApplicativi_soap() {  
  15344.         if(this.isFollowRedirects_consegnaContenutiApplicativi_soap==null){
  15345.             try{ 
  15346.                 String name = null;
  15347.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.soap");
  15348.                 if(name!=null){
  15349.                     name = name.trim();
  15350.                     this.isFollowRedirects_consegnaContenutiApplicativi_soap = Boolean.parseBoolean(name);
  15351.                 }else{
  15352.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.soap' non impostata, viene utilizzato il default=false");
  15353.                     this.isFollowRedirects_consegnaContenutiApplicativi_soap = false;
  15354.                 }
  15355.             }catch(java.lang.Exception e) {
  15356.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.soap' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  15357.                 this.isFollowRedirects_consegnaContenutiApplicativi_soap = false;
  15358.             }  
  15359.         }

  15361.         return this.isFollowRedirects_consegnaContenutiApplicativi_soap;
  15362.     }
  15363.     
  15364.     private Boolean isFollowRedirects_consegnaContenutiApplicativi_rest = null;
  15365.     public boolean isFollowRedirects_consegnaContenutiApplicativi_rest() {  
  15366.         if(this.isFollowRedirects_consegnaContenutiApplicativi_rest==null){
  15367.             try{ 
  15368.                 String name = null;
  15369.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.rest");
  15370.                 if(name!=null){
  15371.                     name = name.trim();
  15372.                     this.isFollowRedirects_consegnaContenutiApplicativi_rest = Boolean.parseBoolean(name);
  15373.                 }else{
  15374.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.rest' non impostata, viene utilizzato il default=false");
  15375.                     this.isFollowRedirects_consegnaContenutiApplicativi_rest = false;
  15376.                 }
  15377.             }catch(java.lang.Exception e) {
  15378.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.rest' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  15379.                 this.isFollowRedirects_consegnaContenutiApplicativi_rest = false;
  15380.             }  
  15381.         }

  15383.         return this.isFollowRedirects_consegnaContenutiApplicativi_rest;
  15384.     }
  15385.         
  15386.     private Integer getFollowRedirectsMaxHop_inoltroBuste = null;
  15387.     public int getFollowRedirectsMaxHop_inoltroBuste() {    
  15388.         if(this.getFollowRedirectsMaxHop_inoltroBuste==null){
  15389.             try{ 
  15390.                 String name = null;
  15391.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.maxHop");
  15392.                 if(name!=null){
  15393.                     name = name.trim();
  15394.                     this.getFollowRedirectsMaxHop_inoltroBuste = Integer.parseInt(name);
  15395.                 }else{
  15396.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.maxHop' non impostata, viene utilizzato il default=5");
  15397.                     this.getFollowRedirectsMaxHop_inoltroBuste = 5;
  15398.                 }
  15399.             }catch(java.lang.Exception e) {
  15400.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.followRedirects.maxHop' non impostata, viene utilizzato il default=5, errore:"+e.getMessage(),e);
  15401.                 this.getFollowRedirectsMaxHop_inoltroBuste = 5;
  15402.             }  
  15403.         }

  15405.         return this.getFollowRedirectsMaxHop_inoltroBuste;
  15406.     }
  15407.     
  15408.     private Integer getFollowRedirectsMaxHop_consegnaContenutiApplicativi = null;
  15409.     public int getFollowRedirectsMaxHop_consegnaContenutiApplicativi() {    
  15410.         if(this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi==null){
  15411.             try{ 
  15412.                 String name = null;
  15413.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.maxHop");
  15414.                 if(name!=null){
  15415.                     name = name.trim();
  15416.                     this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi = Integer.parseInt(name);
  15417.                 }else{
  15418.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.maxHop' non impostata, viene utilizzato il default=5");
  15419.                     this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi = 5;
  15420.                 }
  15421.             }catch(java.lang.Exception e) {
  15422.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.followRedirects.maxHop' non impostata, viene utilizzato il default=5, errore:"+e.getMessage(),e);
  15423.                 this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi = 5;
  15424.             }  
  15425.         }

  15427.         return this.getFollowRedirectsMaxHop_consegnaContenutiApplicativi;
  15428.     }

  15430.     
  15431.     private Boolean checkSoapActionQuotedString_ricezioneContenutiApplicativi = null;
  15432.     public boolean checkSoapActionQuotedString_ricezioneContenutiApplicativi() {    
  15433.         if(this.checkSoapActionQuotedString_ricezioneContenutiApplicativi==null){
  15434.             try{ 
  15435.                 String name = null;
  15436.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.soapAction.checkQuotedString");
  15437.                 if(name!=null){
  15438.                     name = name.trim();
  15439.                     this.checkSoapActionQuotedString_ricezioneContenutiApplicativi = Boolean.parseBoolean(name);
  15440.                 }else{
  15441.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.soapAction.checkQuotedString' non impostata, viene utilizzato il default=false");
  15442.                     this.checkSoapActionQuotedString_ricezioneContenutiApplicativi = false;
  15443.                 }
  15444.             }catch(java.lang.Exception e) {
  15445.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.soapAction.checkQuotedString' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  15446.                 this.checkSoapActionQuotedString_ricezioneContenutiApplicativi = false;
  15447.             }  
  15448.         }

  15450.         return this.checkSoapActionQuotedString_ricezioneContenutiApplicativi;
  15451.     }
  15452.     
  15453.     private Boolean checkSoapActionQuotedString_ricezioneBuste = null;
  15454.     public boolean checkSoapActionQuotedString_ricezioneBuste() {   
  15455.         if(this.checkSoapActionQuotedString_ricezioneBuste==null){
  15456.             try{ 
  15457.                 String name = null;
  15458.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.soapAction.checkQuotedString");
  15459.                 if(name!=null){
  15460.                     name = name.trim();
  15461.                     this.checkSoapActionQuotedString_ricezioneBuste = Boolean.parseBoolean(name);
  15462.                 }else{
  15463.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.soapAction.checkQuotedString' non impostata, viene utilizzato il default=false");
  15464.                     this.checkSoapActionQuotedString_ricezioneBuste = false;
  15465.                 }
  15466.             }catch(java.lang.Exception e) {
  15467.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.soapAction.checkQuotedString' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  15468.                 this.checkSoapActionQuotedString_ricezioneBuste = false;
  15469.             }  
  15470.         }

  15472.         return this.checkSoapActionQuotedString_ricezioneBuste;
  15473.     }
  15474.     
  15475.     private String httpUserAgent = null;
  15476.     public String getHttpUserAgent() {  
  15477.         if(this.httpUserAgent==null){
  15478.             try{ 
  15479.                 String name = null;
  15480.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.http.userAgent");
  15481.                 if(name!=null){
  15482.                     name = name.trim();
  15483.                     this.httpUserAgent = name;
  15484.                 }else{
  15485.                     /**NON EMETTO WARNING: this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.userAgent' non impostata, viene utilizzato il default="+Costanti.OPENSPCOOP_PRODUCT_VERSION);*/
  15486.                     this.httpUserAgent = this.getProductName();
  15487.                 }
  15488.             }catch(java.lang.Exception e) {
  15489.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.userAgent' non impostata, viene utilizzato il default="+this.getProductName()+", errore:"+e.getMessage(),e);
  15490.                 this.httpUserAgent = this.getProductName();
  15491.             }  
  15492.         }

  15494.         return this.httpUserAgent;
  15495.     }
  15496.     
  15497.     private String httpServer = null;
  15498.     public String getHttpServer() { 
  15499.         if(this.httpServer==null){
  15500.             try{ 
  15501.                 String name = null;
  15502.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.http.xPdd");
  15503.                 if(name!=null){
  15504.                     name = name.trim();
  15505.                     this.httpServer = name;
  15506.                 }else{
  15507.                     /**NON EMETTO WARNING: this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.xPdd' non impostata, viene utilizzato il default="+this.getHttpUserAgent());*/
  15508.                     this.httpServer = this.getVersione();
  15509.                 }
  15510.             }catch(java.lang.Exception e) {
  15511.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.xPdd' non impostata, viene utilizzato il default="+this.getVersione()+", errore:"+e.getMessage(),e);
  15512.                 this.httpServer = this.getVersione();
  15513.             }  
  15514.         }

  15516.         return this.httpServer;
  15517.     }
  15518.     
  15519.     private Boolean readHttpXPdDDetails = null;
  15520.     private String httpXPdDDetails = null;
  15521.     public String getHttpXPdDDetails() {    
  15522.         if(this.readHttpXPdDDetails==null){
  15523.             try{ 
  15524.                 String name = null;
  15525.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.http.xDetails");
  15526.                 if(name!=null){
  15527.                     name = name.trim();
  15528.                     this.httpXPdDDetails = name;
  15529.                 }else{
  15530.                     this.httpXPdDDetails = this.getDetails();
  15531.                 }
  15532.             }catch(java.lang.Exception e) {
  15533.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.http.xDetails' non impostata correttamente:"+e.getMessage(),e);
  15534.                 this.httpXPdDDetails = this.getDetails();
  15535.             }  
  15536.         }
  15537.         this.readHttpXPdDDetails = true;

  15539.         return this.httpXPdDDetails;
  15540.     }
  15541.     
  15542.     
  15543.     private Boolean isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = null;
  15544.     public boolean isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi() { 
  15545.         if(this.isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi==null){
  15546.             try{ 
  15547.                 String name = null;
  15548.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.enabled");
  15549.                 if(name!=null){
  15550.                     name = name.trim();
  15551.                     this.isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = Boolean.parseBoolean(name);
  15552.                 }else{
  15553.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true");
  15554.                     this.isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = true;
  15555.                 }
  15556.             }catch(java.lang.Exception e) {
  15557.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15558.                 this.isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = true;
  15559.             }  
  15560.         }

  15562.         return this.isEnabledEncodingRFC2047HeaderValueRicezioneContenutiApplicativi;
  15563.     }
  15564.     
  15565.     private Charset getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = null;
  15566.     public Charset getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi() {    
  15567.         if(this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi==null){
  15568.             try{ 
  15569.                 String name = null;
  15570.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.charset");
  15571.                 if(name!=null){
  15572.                     name = name.trim();
  15573.                     this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = Charset.toEnumConstant(name);
  15574.                     if(this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi==null){
  15575.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15576.                     }
  15577.                 }else{
  15578.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name());
  15579.                     this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = Charset.US_ASCII;
  15580.                 }
  15581.             }catch(java.lang.Exception e) {
  15582.                 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);
  15583.                 this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = Charset.US_ASCII;
  15584.             }  
  15585.         }

  15587.         return this.getCharsetEncodingRFC2047HeaderValueRicezioneContenutiApplicativi;
  15588.     }
  15589.     
  15590.     private RFC2047Encoding getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = null;
  15591.     public RFC2047Encoding getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi() {   
  15592.         if(this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi==null){
  15593.             try{ 
  15594.                 String name = null;
  15595.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.encoding");
  15596.                 if(name!=null){
  15597.                     name = name.trim();
  15598.                     this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = RFC2047Encoding.valueOf(name);
  15599.                     if(this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi==null){
  15600.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15601.                     }
  15602.                 }else{
  15603.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name());
  15604.                     this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = RFC2047Encoding.Q;
  15605.                 }
  15606.             }catch(java.lang.Exception e) {
  15607.                 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);
  15608.                 this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi = RFC2047Encoding.Q;
  15609.             }  
  15610.         }

  15612.         return this.getEncodingRFC2047HeaderValueRicezioneContenutiApplicativi;
  15613.     }
  15614.     
  15615.     private Boolean isEnabledEncodingRFC2047HeaderValueRicezioneBuste = null;
  15616.     public boolean isEnabledEncodingRFC2047HeaderValueRicezioneBuste() {    
  15617.         if(this.isEnabledEncodingRFC2047HeaderValueRicezioneBuste==null){
  15618.             try{ 
  15619.                 String name = null;
  15620.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.enabled");
  15621.                 if(name!=null){
  15622.                     name = name.trim();
  15623.                     this.isEnabledEncodingRFC2047HeaderValueRicezioneBuste = Boolean.parseBoolean(name);
  15624.                 }else{
  15625.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true");
  15626.                     this.isEnabledEncodingRFC2047HeaderValueRicezioneBuste = true;
  15627.                 }
  15628.             }catch(java.lang.Exception e) {
  15629.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15630.                 this.isEnabledEncodingRFC2047HeaderValueRicezioneBuste = true;
  15631.             }  
  15632.         }

  15634.         return this.isEnabledEncodingRFC2047HeaderValueRicezioneBuste;
  15635.     }
  15636.     
  15637.     private Charset getCharsetEncodingRFC2047HeaderValueRicezioneBuste = null;
  15638.     public Charset getCharsetEncodingRFC2047HeaderValueRicezioneBuste() {   
  15639.         if(this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste==null){
  15640.             try{ 
  15641.                 String name = null;
  15642.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.charset");
  15643.                 if(name!=null){
  15644.                     name = name.trim();
  15645.                     this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste = Charset.toEnumConstant(name);
  15646.                     if(this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste==null){
  15647.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15648.                     }
  15649.                 }else{
  15650.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name());
  15651.                     this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste = Charset.US_ASCII;
  15652.                 }
  15653.             }catch(java.lang.Exception e) {
  15654.                 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);
  15655.                 this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste = Charset.US_ASCII;
  15656.             }  
  15657.         }

  15659.         return this.getCharsetEncodingRFC2047HeaderValueRicezioneBuste;
  15660.     }
  15661.     
  15662.     private RFC2047Encoding getEncodingRFC2047HeaderValueRicezioneBuste = null;
  15663.     public RFC2047Encoding getEncodingRFC2047HeaderValueRicezioneBuste() {  
  15664.         if(this.getEncodingRFC2047HeaderValueRicezioneBuste==null){
  15665.             try{ 
  15666.                 String name = null;
  15667.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.encoding");
  15668.                 if(name!=null){
  15669.                     name = name.trim();
  15670.                     this.getEncodingRFC2047HeaderValueRicezioneBuste = RFC2047Encoding.valueOf(name);
  15671.                     if(this.getEncodingRFC2047HeaderValueRicezioneBuste==null){
  15672.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15673.                     }
  15674.                 }else{
  15675.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name());
  15676.                     this.getEncodingRFC2047HeaderValueRicezioneBuste = RFC2047Encoding.Q;
  15677.                 }
  15678.             }catch(java.lang.Exception e) {
  15679.                 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);
  15680.                 this.getEncodingRFC2047HeaderValueRicezioneBuste = RFC2047Encoding.Q;
  15681.             }  
  15682.         }

  15684.         return this.getEncodingRFC2047HeaderValueRicezioneBuste;
  15685.     }
  15686.     
  15687.     private Boolean isEnabledEncodingRFC2047HeaderValueInoltroBuste = null;
  15688.     public boolean isEnabledEncodingRFC2047HeaderValueInoltroBuste() {  
  15689.         if(this.isEnabledEncodingRFC2047HeaderValueInoltroBuste==null){
  15690.             try{ 
  15691.                 String name = null;
  15692.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.enabled");
  15693.                 if(name!=null){
  15694.                     name = name.trim();
  15695.                     this.isEnabledEncodingRFC2047HeaderValueInoltroBuste = Boolean.parseBoolean(name);
  15696.                 }else{
  15697.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true");
  15698.                     this.isEnabledEncodingRFC2047HeaderValueInoltroBuste = true;
  15699.                 }
  15700.             }catch(java.lang.Exception e) {
  15701.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15702.                 this.isEnabledEncodingRFC2047HeaderValueInoltroBuste = true;
  15703.             }  
  15704.         }

  15706.         return this.isEnabledEncodingRFC2047HeaderValueInoltroBuste;
  15707.     }
  15708.     
  15709.     private Charset getCharsetEncodingRFC2047HeaderValueInoltroBuste = null;
  15710.     public Charset getCharsetEncodingRFC2047HeaderValueInoltroBuste() { 
  15711.         if(this.getCharsetEncodingRFC2047HeaderValueInoltroBuste==null){
  15712.             try{ 
  15713.                 String name = null;
  15714.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.charset");
  15715.                 if(name!=null){
  15716.                     name = name.trim();
  15717.                     this.getCharsetEncodingRFC2047HeaderValueInoltroBuste = Charset.toEnumConstant(name);
  15718.                     if(this.getCharsetEncodingRFC2047HeaderValueInoltroBuste==null){
  15719.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15720.                     }
  15721.                 }else{
  15722.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name());
  15723.                     this.getCharsetEncodingRFC2047HeaderValueInoltroBuste = Charset.US_ASCII;
  15724.                 }
  15725.             }catch(java.lang.Exception e) {
  15726.                 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);
  15727.                 this.getCharsetEncodingRFC2047HeaderValueInoltroBuste = Charset.US_ASCII;
  15728.             }  
  15729.         }

  15731.         return this.getCharsetEncodingRFC2047HeaderValueInoltroBuste;
  15732.     }
  15733.     
  15734.     private RFC2047Encoding getEncodingRFC2047HeaderValueInoltroBuste = null;
  15735.     public RFC2047Encoding getEncodingRFC2047HeaderValueInoltroBuste() {    
  15736.         if(this.getEncodingRFC2047HeaderValueInoltroBuste==null){
  15737.             try{ 
  15738.                 String name = null;
  15739.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.encoding");
  15740.                 if(name!=null){
  15741.                     name = name.trim();
  15742.                     this.getEncodingRFC2047HeaderValueInoltroBuste = RFC2047Encoding.valueOf(name);
  15743.                     if(this.getEncodingRFC2047HeaderValueInoltroBuste==null){
  15744.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15745.                     }
  15746.                 }else{
  15747.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name());
  15748.                     this.getEncodingRFC2047HeaderValueInoltroBuste = RFC2047Encoding.Q;
  15749.                 }
  15750.             }catch(java.lang.Exception e) {
  15751.                 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);
  15752.                 this.getEncodingRFC2047HeaderValueInoltroBuste = RFC2047Encoding.Q;
  15753.             }  
  15754.         }

  15756.         return this.getEncodingRFC2047HeaderValueInoltroBuste;
  15757.     }
  15758.     
  15759.     private Boolean isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = null;
  15760.     public boolean isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi() {  
  15761.         if(this.isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi==null){
  15762.             try{ 
  15763.                 String name = null;
  15764.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.enabled");
  15765.                 if(name!=null){
  15766.                     name = name.trim();
  15767.                     this.isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = Boolean.parseBoolean(name);
  15768.                 }else{
  15769.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true");
  15770.                     this.isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = true;
  15771.                 }
  15772.             }catch(java.lang.Exception e) {
  15773.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15774.                 this.isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = true;
  15775.             }  
  15776.         }

  15778.         return this.isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi;
  15779.     }
  15780.     
  15781.     private Charset getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = null;
  15782.     public Charset getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi() { 
  15783.         if(this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi==null){
  15784.             try{ 
  15785.                 String name = null;
  15786.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.charset");
  15787.                 if(name!=null){
  15788.                     name = name.trim();
  15789.                     this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = Charset.toEnumConstant(name);
  15790.                     if(this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi==null){
  15791.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15792.                     }
  15793.                 }else{
  15794.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.charset' non impostata, viene utilizzato il default="+Charset.US_ASCII.name());
  15795.                     this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = Charset.US_ASCII;
  15796.                 }
  15797.             }catch(java.lang.Exception e) {
  15798.                 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);
  15799.                 this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = Charset.US_ASCII;
  15800.             }  
  15801.         }

  15803.         return this.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi;
  15804.     }
  15805.     
  15806.     private RFC2047Encoding getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = null;
  15807.     public RFC2047Encoding getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi() {    
  15808.         if(this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi==null){
  15809.             try{ 
  15810.                 String name = null;
  15811.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.encoding");
  15812.                 if(name!=null){
  15813.                     name = name.trim();
  15814.                     this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = RFC2047Encoding.valueOf(name);
  15815.                     if(this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi==null){
  15816.                         throw new CoreException(VALORE_NON_VALIDO+name);
  15817.                     }
  15818.                 }else{
  15819.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerValue.encodingRFC2047.encoding' non impostata, viene utilizzato il default="+RFC2047Encoding.Q.name());
  15820.                     this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = RFC2047Encoding.Q;
  15821.                 }
  15822.             }catch(java.lang.Exception e) {
  15823.                 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);
  15824.                 this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi = RFC2047Encoding.Q;
  15825.             }  
  15826.         }

  15828.         return this.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi;
  15829.     }
  15830.     

  15832.     private Boolean isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi = null;
  15833.     public boolean isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi() {  
  15834.         if(this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi==null){
  15835.             try{ 
  15836.                 String name = null;
  15837.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerNameValue.validazione.enabled");
  15838.                 if(name!=null){
  15839.                     name = name.trim();
  15840.                     this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi = Boolean.parseBoolean(name);
  15841.                 }else{
  15842.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true");
  15843.                     this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi = true;
  15844.                 }
  15845.             }catch(java.lang.Exception e) {
  15846.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15847.                 this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi = true;
  15848.             }  
  15849.         }

  15851.         return this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneContenutiApplicativi;
  15852.     }
  15853.     
  15854.     private Boolean isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste = null;
  15855.     public boolean isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste() { 
  15856.         if(this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste==null){
  15857.             try{ 
  15858.                 String name = null;
  15859.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.headerNameValue.validazione.enabled");
  15860.                 if(name!=null){
  15861.                     name = name.trim();
  15862.                     this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste = Boolean.parseBoolean(name);
  15863.                 }else{
  15864.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true");
  15865.                     this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste = true;
  15866.                 }
  15867.             }catch(java.lang.Exception e) {
  15868.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15869.                 this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste = true;
  15870.             }  
  15871.         }

  15873.         return this.isEnabledValidazioneRFC2047HeaderNameValueRicezioneBuste;
  15874.     }
  15875.     
  15876.     private Boolean isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste = null;
  15877.     public boolean isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste() {   
  15878.         if(this.isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste==null){
  15879.             try{ 
  15880.                 String name = null;
  15881.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.inoltroBuste.headerNameValue.validazione.enabled");
  15882.                 if(name!=null){
  15883.                     name = name.trim();
  15884.                     this.isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste = Boolean.parseBoolean(name);
  15885.                 }else{
  15886.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true");
  15887.                     this.isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste = true;
  15888.                 }
  15889.             }catch(java.lang.Exception e) {
  15890.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.inoltroBuste.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15891.                 this.isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste = true;
  15892.             }  
  15893.         }

  15895.         return this.isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste;
  15896.     }
  15897.     
  15898.     private Boolean isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi = null;
  15899.     public boolean isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi() {   
  15900.         if(this.isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi==null){
  15901.             try{ 
  15902.                 String name = null;
  15903.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerNameValue.validazione.enabled");
  15904.                 if(name!=null){
  15905.                     name = name.trim();
  15906.                     this.isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi = Boolean.parseBoolean(name);
  15907.                 }else{
  15908.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true");
  15909.                     this.isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi = true;
  15910.                 }
  15911.             }catch(java.lang.Exception e) {
  15912.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.headerNameValue.validazione.enabled' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  15913.                 this.isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi = true;
  15914.             }  
  15915.         }

  15917.         return this.isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi;
  15918.     }
  15919.     
  15920.     private Integer getGestioneCORS_returnCode_ricezioneContenutiApplicativi = null;
  15921.     public int getGestioneCORS_returnCode_ricezioneContenutiApplicativi() { 
  15922.         if(this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi==null){
  15923.             try{ 
  15924.                 String name = null;
  15925.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.cors.returnCode");
  15926.                 if(name!=null){
  15927.                     name = name.trim();
  15928.                     this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi = java.lang.Integer.parseInt(name);
  15929.                 }else{
  15930.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.cors.returnCode' non impostata, viene utilizzato il default="+CostantiPdD.GESTIONE_CORS_RETURN_CODE);
  15931.                     this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi = CostantiPdD.GESTIONE_CORS_RETURN_CODE;
  15932.                 }
  15933.             }catch(java.lang.Exception e) {
  15934.                 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);
  15935.                 this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi = CostantiPdD.GESTIONE_CORS_RETURN_CODE;
  15936.             }    
  15937.         }

  15939.         return this.getGestioneCORS_returnCode_ricezioneContenutiApplicativi;
  15940.     }
  15941.     
  15942.     private Boolean isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi = null;
  15943.     public boolean isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi() { 
  15944.         if(this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi==null){
  15945.             String pName = "org.openspcoop2.pdd.services.ricezioneContenutiApplicativi.cors.resourceHttpMethodQualsiasi";
  15946.             try{ 
  15947.                 String name = null;
  15948.                 name = this.reader.getValueConvertEnvProperties(pName);
  15949.                 if(name!=null){
  15950.                     name = name.trim();
  15951.                     this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi = java.lang.Boolean.valueOf(name);
  15952.                 }else{
  15953.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  15954.                     this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi = false;
  15955.                 }
  15956.             }catch(java.lang.Exception e) {
  15957.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  15958.                 this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi = false;
  15959.             }    
  15960.         }

  15962.         return this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi;
  15963.     }
  15964.     
  15965.     private Integer getGestioneCORS_returnCode_ricezioneBuste = null;
  15966.     public int getGestioneCORS_returnCode_ricezioneBuste() {    
  15967.         if(this.getGestioneCORS_returnCode_ricezioneBuste==null){
  15968.             try{ 
  15969.                 String name = null;
  15970.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.ricezioneBuste.cors.returnCode");
  15971.                 if(name!=null){
  15972.                     name = name.trim();
  15973.                     this.getGestioneCORS_returnCode_ricezioneBuste = java.lang.Integer.parseInt(name);
  15974.                 }else{
  15975.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.ricezioneBuste.cors.returnCode' non impostata, viene utilizzato il default="+CostantiPdD.GESTIONE_CORS_RETURN_CODE);
  15976.                     this.getGestioneCORS_returnCode_ricezioneBuste = CostantiPdD.GESTIONE_CORS_RETURN_CODE;
  15977.                 }
  15978.             }catch(java.lang.Exception e) {
  15979.                 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);
  15980.                 this.getGestioneCORS_returnCode_ricezioneBuste = CostantiPdD.GESTIONE_CORS_RETURN_CODE;
  15981.             }    
  15982.         }

  15984.         return this.getGestioneCORS_returnCode_ricezioneBuste;
  15985.     }
  15986.     
  15987.     private Boolean isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste = null;
  15988.     public boolean isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste() {    
  15989.         if(this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste==null){
  15990.             String pName = "org.openspcoop2.pdd.services.ricezioneBuste.cors.resourceHttpMethodQualsiasi";
  15991.             try{ 
  15992.                 String name = null;
  15993.                 name = this.reader.getValueConvertEnvProperties(pName);
  15994.                 if(name!=null){
  15995.                     name = name.trim();
  15996.                     this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste = java.lang.Boolean.valueOf(name);
  15997.                 }else{
  15998.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  15999.                     this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste = false;
  16000.                 }
  16001.             }catch(java.lang.Exception e) {
  16002.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  16003.                 this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste = false;
  16004.             }    
  16005.         }

  16007.         return this.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste;
  16008.     }
  16009.     
  16010.     
  16011.     private ArchiveType getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType = null;
  16012.     public ArchiveType getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType() {    
  16013.         if(this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType==null){
  16014.             String pName = "org.openspcoop2.pdd.connettori.consegnaContenutiApplicativi.notificaRichiestaRisposta.archiveType";
  16015.             try{ 
  16016.                 String name = null;
  16017.                 name = this.reader.getValueConvertEnvProperties(pName);
  16018.                 if(name!=null){
  16019.                     name = name.trim();
  16020.                     this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType = ArchiveType.valueOf(name.toUpperCase());
  16021.                 }else{
  16022.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ArchiveType.ZIP.toString()));
  16023.                     this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType = ArchiveType.ZIP;
  16024.                 }
  16025.             }catch(java.lang.Exception e) {
  16026.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ArchiveType.ZIP.toString()),e);
  16027.                 this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType = ArchiveType.ZIP;
  16028.             }    
  16029.         }

  16031.         return this.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType;
  16032.     }
  16033.     


  16036.     /* ***************** DATE ************* */
  16037.     /**
  16038.      * Restituisce il tipo di tempo da utilizzare
  16039.      *
  16040.      * @return il tipo di tempo da utilizzare
  16041.      * 
  16042.      */
  16043.     private TipoOraRegistrazione tipoTempo = null;
  16044.     public TipoOraRegistrazione getTipoTempoBusta(String implementazionePdDSoggetto) {
  16045.         
  16046.         // ovverriding per implementazione porta di dominio
  16047.         if(this.pddReader!=null){
  16048.             String tipo = this.pddReader.getBusta_TempoTipo(implementazionePdDSoggetto);
  16049.             if(tipo!=null && ( 
  16050.                     CostantiConfigurazione.TEMPO_TIPO_LOCALE.equalsIgnoreCase(tipo) || 
  16051.                     CostantiConfigurazione.TEMPO_TIPO_SINCRONIZZATO.equalsIgnoreCase(tipo)  ) 
  16052.             ){
  16053.                 if(CostantiConfigurazione.TEMPO_TIPO_LOCALE.equalsIgnoreCase(tipo))
  16054.                     return TipoOraRegistrazione.LOCALE;
  16055.                 else 
  16056.                     return TipoOraRegistrazione.SINCRONIZZATO;
  16057.             }
  16058.         }

  16060.         if(this.tipoTempo==null){
  16061.             try{ 
  16062.                 String name = null;
  16063.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.tempo.tipo");
  16064.                 if(name!=null){
  16065.                     name = name.trim();
  16066.                     if(CostantiConfigurazione.TEMPO_TIPO_LOCALE.equals(name))
  16067.                         this.tipoTempo = TipoOraRegistrazione.LOCALE;
  16068.                     else if(CostantiConfigurazione.TEMPO_TIPO_SINCRONIZZATO.equals(name))
  16069.                         this.tipoTempo = TipoOraRegistrazione.SINCRONIZZATO;
  16070.                     else
  16071.                         throw new CoreException("Tipo "+name+" non conosciuto");
  16072.                 }
  16073.                 else{
  16074.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.tempo.tipo' non impostata, viene utilizzato il default="+CostantiConfigurazione.TEMPO_TIPO_LOCALE);
  16075.                     this.tipoTempo = TipoOraRegistrazione.LOCALE;
  16076.                 }

  16078.             }catch(java.lang.Exception e) {
  16079.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.tempo.tipo' non impostata, viene utilizzato il default="+CostantiConfigurazione.TEMPO_TIPO_LOCALE+", errore:"+e.getMessage(),e);
  16080.                 this.tipoTempo = TipoOraRegistrazione.LOCALE;
  16081.             }    
  16082.         }

  16084.         return this.tipoTempo;
  16085.     }

  16087.     /**
  16088.      * Restituisce il tipo di Date da utilizzare
  16089.      *
  16090.      * @return il tipo di Date da utilizzare
  16091.      * 
  16092.      */
  16093.     private String tipoDateManager = null;
  16094.     public String getTipoDateManager() {    
  16095.         if(this.tipoDateManager==null){
  16096.             try{ 
  16097.                 String name = null;
  16098.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.date.tipo");
  16099.                 if(name!=null)
  16100.                     name = name.trim();
  16101.                 else
  16102.                     throw new CoreException(NON_DEFINITA);
  16103.                 this.tipoDateManager = name;
  16104.             }catch(java.lang.Exception e) {
  16105.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.date.tipo': "+e.getMessage(),e);
  16106.                 this.tipoDateManager = null;
  16107.             }    
  16108.         }

  16110.         return this.tipoDateManager;
  16111.     }
  16112.     
  16113.     private DateEngineType tipoDateTimeFormat = null;
  16114.     public DateEngineType getTipoDateTimeFormat() { 
  16115.         if(this.tipoDateTimeFormat==null){
  16116.             try{ 
  16117.                 String name = null;
  16118.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dateTimeFormat");
  16119.                 if(name!=null)
  16120.                     name = name.trim();
  16121.                 else
  16122.                     throw new CoreException(NON_DEFINITA);
  16123.                 this.tipoDateTimeFormat = DateEngineType.valueOf(name);
  16124.             }catch(java.lang.Exception e) {
  16125.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.dateTimeFormat': "+e.getMessage(),e);
  16126.                 this.tipoDateTimeFormat = null;
  16127.             }    
  16128.         }

  16130.         return this.tipoDateTimeFormat;
  16131.     }

  16133.     /**
  16134.      * Restituisce le proprieta' da utilizzare sul tipo di Date da utilizzare
  16135.      *
  16136.      * @return proprieta' da utilizzare sul tipo di Date da utilizzare
  16137.      * 
  16138.      */
  16139.     private java.util.Properties dateManagerProperties = null;
  16140.     public java.util.Properties getDateManagerProperties() {
  16141.         if(this.dateManagerProperties==null){
  16142.             java.util.Properties prop = new java.util.Properties();
  16143.             try{ 

  16145.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.date.property.");
  16146.                 this.dateManagerProperties = prop;

  16148.             }catch(java.lang.Exception e) {
  16149.                 this.logError("Riscontrato errore durante la lettura delle propriete' 'org.openspcoop2.pdd.date.property.*': "+e.getMessage(),e);
  16150.                 this.dateManagerProperties = null;
  16151.             }    
  16152.         }

  16154.         return this.dateManagerProperties;
  16155.     }








  16164.     /* ************** INTEGRATION MANAGER ****************** */

  16166.     private Boolean isIntegrationManagerEnabled = null;
  16167.     public boolean isIntegrationManagerEnabled() {  
  16168.         if(this.isIntegrationManagerEnabled==null){
  16169.             try{ 
  16170.                 String name = null;
  16171.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.enabled");
  16172.                 if(name==null){
  16173.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrationManager.enabled' non impostata, viene utilizzato il default=false");
  16174.                     name="false";
  16175.                 }
  16176.                 name = name.trim();
  16177.                 this.isIntegrationManagerEnabled = Boolean.parseBoolean(name);
  16178.             } catch(java.lang.Exception e) {
  16179.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrationManager.enabled': "+e.getMessage(),e);
  16180.                 this.isIntegrationManagerEnabled = false;
  16181.             }    
  16182.         }

  16184.         return this.isIntegrationManagerEnabled;
  16185.     }
  16186.     
  16187.     private Boolean isIntegrationManagerIdWithDate = null;
  16188.     public boolean isIntegrationManagerIdWithDate() {   
  16189.         if(this.isIntegrationManagerIdWithDate==null){
  16190.             try{ 
  16191.                 String name = null;
  16192.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.idWithDate");
  16193.                 if(name==null){
  16194.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.integrationManager.idWithDate' non impostata, viene utilizzato il default=false");
  16195.                     name="false";
  16196.                 }
  16197.                 name = name.trim();
  16198.                 this.isIntegrationManagerIdWithDate = Boolean.parseBoolean(name);
  16199.             } catch(java.lang.Exception e) {
  16200.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.integrationManager.idWithDate': "+e.getMessage(),e);
  16201.                 this.isIntegrationManagerIdWithDate = false;
  16202.             }    
  16203.         }

  16205.         return this.isIntegrationManagerIdWithDate;
  16206.     }
  16207.     
  16208.     private Integer getIntegrationManagerIdsLimit = null;
  16209.     private Boolean getIntegrationManagerIdsLimit_read = null;
  16210.     public Integer getIntegrationManagerIdsLimit() {    
  16211.         String pName = "org.openspcoop2.pdd.integrationManager.ids.limit";
  16212.         if(this.getIntegrationManagerIdsLimit_read==null){
  16213.             try{ 
  16214.                 String name = null;
  16215.                 name = this.reader.getValueConvertEnvProperties(pName);
  16216.                 if(name==null){
  16217.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  16218.                     name="false";
  16219.                 }
  16220.                 name = name.trim();
  16221.                 this.getIntegrationManagerIdsLimit = Integer.valueOf(name);
  16222.             } catch(java.lang.Exception e) {
  16223.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  16224.                 this.getIntegrationManagerIdsLimit = null;
  16225.             }   
  16226.             this.getIntegrationManagerIdsLimit_read = true;
  16227.         }

  16229.         return this.getIntegrationManagerIdsLimit;
  16230.     }
  16231.     
  16232.     private Boolean integrationManager_isNomePortaDelegataUrlBasedValue = null;
  16233.     public boolean integrationManager_isNomePortaDelegataUrlBased() {
  16234.         if(this.integrationManager_isNomePortaDelegataUrlBasedValue==null){
  16235.             try{  
  16236.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.service.IntegrationManager.nomePortaDelegataUrlBased"); 

  16238.                 if(value!=null){
  16239.                     value = value.trim();
  16240.                     this.integrationManager_isNomePortaDelegataUrlBasedValue = Boolean.parseBoolean(value);
  16241.                 }else{
  16242.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.service.IntegrationManager.nomePortaDelegataUrlBased' non impostata, viene utilizzato il default=false");
  16243.                     this.integrationManager_isNomePortaDelegataUrlBasedValue = false;
  16244.                 }
  16245.             }catch(java.lang.Exception e) {
  16246.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.service.IntegrationManager.nomePortaDelegataUrlBased' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  16247.                 this.integrationManager_isNomePortaDelegataUrlBasedValue = false;
  16248.             }
  16249.         }

  16251.         return this.integrationManager_isNomePortaDelegataUrlBasedValue;
  16252.     }

  16254.     private Boolean integrationManager_readInformazioniTrasportoValue = null;
  16255.     public boolean integrationManager_readInformazioniTrasporto() {
  16256.         if(this.integrationManager_readInformazioniTrasportoValue==null){
  16257.             try{  
  16258.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.service.IntegrationManager.infoTrasporto"); 

  16260.                 if(value!=null){
  16261.                     value = value.trim();
  16262.                     this.integrationManager_readInformazioniTrasportoValue = Boolean.parseBoolean(value);
  16263.                 }else{
  16264.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.service.IntegrationManager.infoTrasporto' non impostata, viene utilizzato il default=false");
  16265.                     this.integrationManager_readInformazioniTrasportoValue = false;
  16266.                 }
  16267.             }catch(java.lang.Exception e) {
  16268.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.service.IntegrationManager.infoTrasporto' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  16269.                 this.integrationManager_readInformazioniTrasportoValue = false;
  16270.             }
  16271.         }

  16273.         return this.integrationManager_readInformazioniTrasportoValue;
  16274.     }



  16278.     // *** Consegne, gestione runtime ***
  16279.     
  16280.     private Boolean isIntegrationManager_runtime_useRuntimeManager = null;
  16281.     public boolean isIntegrationManager_runtime_useRuntimeManager() {   
  16282.         if(this.isIntegrationManager_runtime_useRuntimeManager==null){
  16283.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.useRuntimeManager";
  16284.             try{ 
  16285.                 String name = null;
  16286.                 name = this.reader.getValueConvertEnvProperties(pName);
  16287.                 if(name==null){
  16288.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  16289.                     name="true";
  16290.                 }
  16291.                 name = name.trim();
  16292.                 this.isIntegrationManager_runtime_useRuntimeManager = Boolean.parseBoolean(name);
  16293.             } catch(java.lang.Exception e) {
  16294.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  16295.                 this.isIntegrationManager_runtime_useRuntimeManager = true;
  16296.             }    
  16297.         }

  16299.         return this.isIntegrationManager_runtime_useRuntimeManager;
  16300.     }
  16301.     
  16302.     private Boolean isIntegrationManager_runtime_useConsegnePreseInCaricoManager = null;
  16303.     public boolean isIntegrationManager_runtime_useConsegnePreseInCaricoManager() { 
  16304.         if(this.isIntegrationManager_runtime_useConsegnePreseInCaricoManager==null){
  16305.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.useConsegnePreseInCaricoManager";
  16306.             try{ 
  16307.                 String name = null;
  16308.                 name = this.reader.getValueConvertEnvProperties(pName);
  16309.                 if(name==null){
  16310.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  16311.                     name="true";
  16312.                 }
  16313.                 name = name.trim();
  16314.                 this.isIntegrationManager_runtime_useConsegnePreseInCaricoManager = Boolean.parseBoolean(name);
  16315.             } catch(java.lang.Exception e) {
  16316.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  16317.                 this.isIntegrationManager_runtime_useConsegnePreseInCaricoManager = true;
  16318.             }    
  16319.         }

  16321.         return this.isIntegrationManager_runtime_useConsegnePreseInCaricoManager;
  16322.     }
  16323.     
  16324.     private String getIntegrationManager_runtime_dataSource = null;
  16325.     public String getIntegrationManager_runtime_dataSource() throws CoreException { 
  16326.         if(this.getIntegrationManager_runtime_dataSource==null){
  16327.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.dataSource";
  16328.             try{ 
  16329.                 String name = null;
  16330.                 name = this.reader.getValueConvertEnvProperties(pName);
  16331.                 if(name==null){
  16332.                     throw new CoreException("Proprieta' non impostata");
  16333.                 }
  16334.                 name = name.trim();
  16335.                 this.getIntegrationManager_runtime_dataSource = name;
  16336.             } catch(java.lang.Exception e) {
  16337.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  16338.                 throw new CoreException(e.getMessage(),e);
  16339.             }    
  16340.         }

  16342.         return this.getIntegrationManager_runtime_dataSource;
  16343.     }
  16344.     
  16345.     private Properties getIntegrationManager_runtime_dataSourceJndiContext = null;
  16346.     public Properties getIntegrationManager_runtime_dataSourceJndiContext() throws CoreException {  
  16347.         if(this.getIntegrationManager_runtime_dataSourceJndiContext==null){
  16348.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.dataSource.property.";
  16349.             try{ 
  16350.                 this.getIntegrationManager_runtime_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
  16351.             } catch(java.lang.Exception e) {
  16352.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  16353.                 throw new CoreException(e.getMessage(),e);
  16354.             }    
  16355.         }

  16357.         return this.getIntegrationManager_runtime_dataSourceJndiContext;
  16358.     }
  16359.     
  16360.     private Boolean isIntegrationManager_runtime_dataSource_useDBUtils = null;
  16361.     public boolean isIntegrationManager_runtime_dataSource_useDBUtils() {   
  16362.         if(this.isIntegrationManager_runtime_dataSource_useDBUtils==null){
  16363.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.runtime.datasource.useDSUtils";
  16364.             try{ 
  16365.                 String name = null;
  16366.                 name = this.reader.getValueConvertEnvProperties(pName);
  16367.                 if(name==null){
  16368.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  16369.                     name="true";
  16370.                 }
  16371.                 name = name.trim();
  16372.                 this.isIntegrationManager_runtime_dataSource_useDBUtils = Boolean.parseBoolean(name);
  16373.             } catch(java.lang.Exception e) {
  16374.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  16375.                 this.isIntegrationManager_runtime_dataSource_useDBUtils = true;
  16376.             }    
  16377.         }

  16379.         return this.isIntegrationManager_runtime_dataSource_useDBUtils;
  16380.     }
  16381.     
  16382.     
  16383.     // *** Consegne, gestione tracce ***
  16384.     
  16385.     private Boolean isIntegrationManager_transazioni_useTransactionManager = null;
  16386.     public boolean isIntegrationManager_transazioni_useTransactionManager() {   
  16387.         if(this.isIntegrationManager_transazioni_useTransactionManager==null){
  16388.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.useTransactionManager";
  16389.             try{ 
  16390.                 String name = null;
  16391.                 name = this.reader.getValueConvertEnvProperties(pName);
  16392.                 if(name==null){
  16393.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  16394.                     name="true";
  16395.                 }
  16396.                 name = name.trim();
  16397.                 this.isIntegrationManager_transazioni_useTransactionManager = Boolean.parseBoolean(name);
  16398.             } catch(java.lang.Exception e) {
  16399.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  16400.                 this.isIntegrationManager_transazioni_useTransactionManager = true;
  16401.             }    
  16402.         }

  16404.         return this.isIntegrationManager_transazioni_useTransactionManager;
  16405.     }
  16406.     
  16407.     private Boolean isIntegrationManager_transazioni_useConsegnePreseInCaricoManager = null;
  16408.     public boolean isIntegrationManager_transazioni_useConsegnePreseInCaricoManager() { 
  16409.         if(this.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager==null){
  16410.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.useConsegnePreseInCaricoManager";
  16411.             try{ 
  16412.                 String name = null;
  16413.                 name = this.reader.getValueConvertEnvProperties(pName);
  16414.                 if(name==null){
  16415.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  16416.                     name="true";
  16417.                 }
  16418.                 name = name.trim();
  16419.                 this.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager = Boolean.parseBoolean(name);
  16420.             } catch(java.lang.Exception e) {
  16421.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  16422.                 this.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager = true;
  16423.             }    
  16424.         }

  16426.         return this.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager;
  16427.     }
  16428.     
  16429.     private String getIntegrationManager_transazioni_dataSource = null;
  16430.     public String getIntegrationManager_transazioni_dataSource() throws CoreException { 
  16431.         if(this.getIntegrationManager_transazioni_dataSource==null){
  16432.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.dataSource";
  16433.             try{ 
  16434.                 String name = null;
  16435.                 name = this.reader.getValueConvertEnvProperties(pName);
  16436.                 if(name==null){
  16437.                     throw new CoreException("Proprieta' non impostata");
  16438.                 }
  16439.                 name = name.trim();
  16440.                 this.getIntegrationManager_transazioni_dataSource = name;
  16441.             } catch(java.lang.Exception e) {
  16442.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  16443.                 throw new CoreException(e.getMessage(),e);
  16444.             }    
  16445.         }

  16447.         return this.getIntegrationManager_transazioni_dataSource;
  16448.     }
  16449.     
  16450.     private Properties getIntegrationManager_transazioni_dataSourceJndiContext = null;
  16451.     public Properties getIntegrationManager_transazioni_dataSourceJndiContext() throws CoreException {  
  16452.         if(this.getIntegrationManager_transazioni_dataSourceJndiContext==null){
  16453.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.dataSource.property.";
  16454.             try{ 
  16455.                 this.getIntegrationManager_transazioni_dataSourceJndiContext = this.reader.readPropertiesConvertEnvProperties(pName);
  16456.             } catch(java.lang.Exception e) {
  16457.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  16458.                 throw new CoreException(e.getMessage(),e);
  16459.             }    
  16460.         }

  16462.         return this.getIntegrationManager_transazioni_dataSourceJndiContext;
  16463.     }
  16464.     
  16465.     private Boolean isIntegrationManager_transazioni_dataSource_useDBUtils = null;
  16466.     public boolean isIntegrationManager_transazioni_dataSource_useDBUtils() {   
  16467.         if(this.isIntegrationManager_transazioni_dataSource_useDBUtils==null){
  16468.             String pName = "org.openspcoop2.pdd.service.IntegrationManager.transazioni.datasource.useDSUtils";
  16469.             try{ 
  16470.                 String name = null;
  16471.                 name = this.reader.getValueConvertEnvProperties(pName);
  16472.                 if(name==null){
  16473.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  16474.                     name="true";
  16475.                 }
  16476.                 name = name.trim();
  16477.                 this.isIntegrationManager_transazioni_dataSource_useDBUtils = Boolean.parseBoolean(name);
  16478.             } catch(java.lang.Exception e) {
  16479.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  16480.                 this.isIntegrationManager_transazioni_dataSource_useDBUtils = true;
  16481.             }    
  16482.         }

  16484.         return this.isIntegrationManager_transazioni_dataSource_useDBUtils;
  16485.     }
  16486.     







  16494.     /* ************** GESTIONE ATTACHMENTS *************** */
  16495.     /**
  16496.      * Restituisce l'indicazione se cancellare l'istruzione <?xml
  16497.      *
  16498.      * @return Restituisce Restituisce l'indicazione se cancellare l'istruzione <?xml
  16499.      * 
  16500.      */
  16501.     private Boolean isDeleteInstructionTargetMachineXml= null;
  16502.     public boolean isDeleteInstructionTargetMachineXml(){
  16503.         if(this.isDeleteInstructionTargetMachineXml==null){
  16504.             try{  
  16505.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.deleteInstructionTargetMachineXml"); 

  16507.                 if(value!=null){
  16508.                     value = value.trim();
  16509.                     this.isDeleteInstructionTargetMachineXml = Boolean.parseBoolean(value);
  16510.                 }else{
  16511.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.deleteInstructionTargetMachineXml' non impostata, viene utilizzato il default=false");
  16512.                     this.isDeleteInstructionTargetMachineXml = false;
  16513.                 }

  16515.             }catch(java.lang.Exception e) {
  16516.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.deleteInstructionTargetMachineXml' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  16517.                 this.isDeleteInstructionTargetMachineXml = false;
  16518.             }
  16519.         }

  16521.         return this.isDeleteInstructionTargetMachineXml;
  16522.     }

  16524.     private Boolean tunnelSOAP_loadMailcap = null;
  16525.     public boolean isTunnelSOAP_loadMailcap() { 
  16526.         if(this.tunnelSOAP_loadMailcap==null){
  16527.             try{ 
  16528.                 String name = null;
  16529.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.mailcap.load");
  16530.                 if(name!=null){
  16531.                     name = name.trim();
  16532.                     this.tunnelSOAP_loadMailcap = Boolean.parseBoolean(name);
  16533.                 }else{
  16534.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mailcap.load' non impostata, viene utilizzato il default="+false);
  16535.                     this.tunnelSOAP_loadMailcap = false;
  16536.                 }
  16537.             }catch(java.lang.Exception e) {
  16538.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mailcap.load' non impostata, viene utilizzato il default="+false+", errore:"+e.getMessage(),e);
  16539.                 this.tunnelSOAP_loadMailcap = false;
  16540.             }    
  16541.         }

  16543.         return this.tunnelSOAP_loadMailcap;
  16544.     }
  16545.     
  16546.     /**
  16547.      * Restituisce il tipo di Date da utilizzare
  16548.      *
  16549.      * @return il tipo di Date da utilizzare
  16550.      * 
  16551.      */
  16552.     private String tunnelSOAPKeyWord_headerTrasporto = null;
  16553.     public String getTunnelSOAPKeyWord_headerTrasporto() {  
  16554.         if(this.tunnelSOAPKeyWord_headerTrasporto==null){
  16555.             try{ 
  16556.                 String name = null;
  16557.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.trasporto");
  16558.                 if(name!=null){
  16559.                     name = name.trim();
  16560.                     this.tunnelSOAPKeyWord_headerTrasporto = name;
  16561.                 }else{
  16562.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.trasporto' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_ATTACHMENT);
  16563.                     this.tunnelSOAPKeyWord_headerTrasporto = CostantiPdD.IMBUSTAMENTO_ATTACHMENT;
  16564.                 }
  16565.             }catch(java.lang.Exception e) {
  16566.                 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);
  16567.                 this.tunnelSOAPKeyWord_headerTrasporto = CostantiPdD.IMBUSTAMENTO_ATTACHMENT;
  16568.             }    
  16569.         }

  16571.         return this.tunnelSOAPKeyWord_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 tunnelSOAPKeyWordMimeType_headerTrasporto = null;
  16581.     public String getTunnelSOAPKeyWordMimeType_headerTrasporto() {  
  16582.         if(this.tunnelSOAPKeyWordMimeType_headerTrasporto==null){
  16583.             try{ 
  16584.                 String name = null;
  16585.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.trasporto");
  16586.                 if(name!=null){
  16587.                     name = name.trim();
  16588.                     this.tunnelSOAPKeyWordMimeType_headerTrasporto = name;
  16589.                 }else{
  16590.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.trasporto' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_MIME_TYPE);
  16591.                     this.tunnelSOAPKeyWordMimeType_headerTrasporto = CostantiPdD.IMBUSTAMENTO_MIME_TYPE;
  16592.                 }
  16593.             }catch(java.lang.Exception e) {
  16594.                 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);
  16595.                 this.tunnelSOAPKeyWordMimeType_headerTrasporto = CostantiPdD.IMBUSTAMENTO_MIME_TYPE;
  16596.             }    
  16597.         }

  16599.         return this.tunnelSOAPKeyWordMimeType_headerTrasporto;
  16600.     }

  16602.     /**
  16603.      * Restituisce il tipo di Date da utilizzare
  16604.      *
  16605.      * @return il tipo di Date da utilizzare
  16606.      * 
  16607.      */
  16608.     private String tunnelSOAPKeyWord_urlBased = null;
  16609.     public String getTunnelSOAPKeyWord_urlBased() { 
  16610.         if(this.tunnelSOAPKeyWord_urlBased==null){
  16611.             try{ 
  16612.                 String name = null;
  16613.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.urlBased");
  16614.                 if(name!=null){
  16615.                     name = name.trim();
  16616.                     this.tunnelSOAPKeyWord_urlBased = name;
  16617.                 }else{
  16618.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.urlBased' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_ATTACHMENT);
  16619.                     this.tunnelSOAPKeyWord_urlBased = CostantiPdD.IMBUSTAMENTO_ATTACHMENT;
  16620.                 }
  16621.             }catch(java.lang.Exception e) {
  16622.                 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);
  16623.                 this.tunnelSOAPKeyWord_urlBased = CostantiPdD.IMBUSTAMENTO_ATTACHMENT;
  16624.             }    
  16625.         }

  16627.         return this.tunnelSOAPKeyWord_urlBased;
  16628.     }

  16630.     /**
  16631.      * Restituisce il tipo di Date da utilizzare
  16632.      *
  16633.      * @return il tipo di Date da utilizzare
  16634.      * 
  16635.      */
  16636.     private String tunnelSOAPKeyWordMimeType_urlBased = null;
  16637.     public String getTunnelSOAPKeyWordMimeType_urlBased() { 
  16638.         if(this.tunnelSOAPKeyWordMimeType_urlBased==null){
  16639.             try{ 
  16640.                 String name = null;
  16641.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.urlBased");
  16642.                 if(name!=null){
  16643.                     name = name.trim();
  16644.                     this.tunnelSOAPKeyWordMimeType_urlBased = name;
  16645.                 }else{
  16646.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.core.soap.tunnelSOAP.mimeType.urlBased' non impostata, viene utilizzato il default="+CostantiPdD.IMBUSTAMENTO_MIME_TYPE);
  16647.                     this.tunnelSOAPKeyWordMimeType_urlBased = CostantiPdD.IMBUSTAMENTO_MIME_TYPE;
  16648.                 }
  16649.             }catch(java.lang.Exception e) {
  16650.                 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);
  16651.                 this.tunnelSOAPKeyWordMimeType_urlBased = CostantiPdD.IMBUSTAMENTO_MIME_TYPE;
  16652.             }    
  16653.         }

  16655.         return this.tunnelSOAPKeyWordMimeType_urlBased;
  16656.     }
  16657.     



  16661.     /* ***************** ASINCRONI ************/
  16662.     /**
  16663.      * Restituisce il Timeout di attesa di una busta di richiesta/ricevutaRichiesta asincrona non completamente processata 
  16664.      *
  16665.      * @return Restituisce il Timeout di attesa di una busta
  16666.      * 
  16667.      */
  16668.     private Long timeoutBustaRispostaAsincrona = null;
  16669.     public long getTimeoutBustaRispostaAsincrona() {    
  16670.         if(this.timeoutBustaRispostaAsincrona == null){
  16671.             try{ 
  16672.                 String name = null;
  16673.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.attesaAttiva");
  16674.                 if(name!=null){
  16675.                     name = name.trim();
  16676.                     this.timeoutBustaRispostaAsincrona = java.lang.Long.parseLong(name) * 1000;
  16677.                 }else{
  16678.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.attesaAttiva' non impostata, viene utilizzato il default="+(CostantiPdD.RISPOSTA_ASINCRONA_ATTESA_ATTIVA/1000));
  16679.                     this.timeoutBustaRispostaAsincrona = CostantiPdD.RISPOSTA_ASINCRONA_ATTESA_ATTIVA;
  16680.                 }
  16681.             }catch(java.lang.Exception e) {
  16682.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.attesaAttiva' non impostata" +
  16683.                         ", viene utilizzato il default="+(CostantiPdD.RISPOSTA_ASINCRONA_ATTESA_ATTIVA/1000)+", errore:"+e.getMessage(),e);
  16684.                 this.timeoutBustaRispostaAsincrona = CostantiPdD.RISPOSTA_ASINCRONA_ATTESA_ATTIVA;
  16685.             }    
  16686.         }

  16688.         return this.timeoutBustaRispostaAsincrona;
  16689.     } 
  16690.     /**
  16691.      * Restituisce la Frequenza di check di attesa di una busta di richiesta/ricevutaRichiesta asincrona non completamente processata 
  16692.      *
  16693.      * @return Restituisce la Frequenza di check di attesa di una busta di richiesta/ricevutaRichiesta asincrona non completamente processata 
  16694.      * 
  16695.      */
  16696.     private Integer checkIntervalBustaRispostaAsincrona = null;
  16697.     public int getCheckIntervalBustaRispostaAsincrona() {   
  16698.         if(this.checkIntervalBustaRispostaAsincrona==null){
  16699.             try{ 
  16700.                 String name = null;
  16701.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.check");
  16702.                 if(name!=null){
  16703.                     name = name.trim();
  16704.                     this.checkIntervalBustaRispostaAsincrona = java.lang.Integer.parseInt(name);
  16705.                 }else{
  16706.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.repository.messaggioAsincronoInProcessamento.check' non impostata, viene utilizzato il default="+CostantiPdD.RISPOSTA_ASINCRONA_CHECK_INTERVAL);
  16707.                     this.checkIntervalBustaRispostaAsincrona = CostantiPdD.RISPOSTA_ASINCRONA_CHECK_INTERVAL;
  16708.                 }
  16709.             }catch(java.lang.Exception e) {
  16710.                 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);
  16711.                 this.checkIntervalBustaRispostaAsincrona = CostantiPdD.RISPOSTA_ASINCRONA_CHECK_INTERVAL;
  16712.             }    
  16713.         }

  16715.         return this.checkIntervalBustaRispostaAsincrona;
  16716.     }




  16721.     /*---------- Cluster ID -------------*/

  16723.     private Boolean isClusterDinamico = null;
  16724.     public boolean isClusterDinamico(){
  16725.         String pName = "org.openspcoop2.pdd.cluster_dinamico.enabled";
  16726.         if(this.isClusterDinamico==null){
  16727.             try{  
  16728.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  16730.                 if(value!=null){
  16731.                     value = value.trim();
  16732.                     this.isClusterDinamico = Boolean.parseBoolean(value);
  16733.                 }else{
  16734.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  16735.                     this.isClusterDinamico = false;
  16736.                 }

  16738.             }catch(java.lang.Exception e) {
  16739.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  16740.                 this.isClusterDinamico = false;
  16741.             }
  16742.         }
  16743.         return this.isClusterDinamico;
  16744.     }
  16745.     
  16746.     private Integer getClusterDinamicoRefreshSecondsInterval = null;
  16747.     public int getClusterDinamicoRefreshSecondsInterval() { 
  16748.         String pName = "org.openspcoop2.pdd.cluster_dinamico.refresh";
  16749.         if(this.getClusterDinamicoRefreshSecondsInterval==null){
  16750.             try{ 
  16751.                 String name = null;
  16752.                 name = this.reader.getValueConvertEnvProperties(pName);
  16753.                 if(name!=null){
  16754.                     name = name.trim();
  16755.                     this.getClusterDinamicoRefreshSecondsInterval = java.lang.Integer.parseInt(name);
  16756.                 }else{
  16757.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.CLUSTER_DINAMICO_REFRESH_SECONDS));
  16758.                     this.getClusterDinamicoRefreshSecondsInterval = CostantiPdD.CLUSTER_DINAMICO_REFRESH_SECONDS;
  16759.                 }
  16760.             }catch(java.lang.Exception e) {
  16761.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.CLUSTER_DINAMICO_REFRESH_SECONDS),e);
  16762.                 this.getClusterDinamicoRefreshSecondsInterval = CostantiPdD.CLUSTER_DINAMICO_REFRESH_SECONDS;
  16763.             }  
  16764.         }

  16766.         return this.getClusterDinamicoRefreshSecondsInterval;
  16767.     }
  16768.     
  16769.     private String cluster_hostname = null;
  16770.     public String getClusterHostname() {
  16771.         if(this.cluster_hostname==null){
  16772.             try{ 
  16773.                 String name = null;
  16774.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cluster_id.hostname");
  16775.                 if(name==null) {
  16776.                     this.cluster_hostname = getClusterId(true);
  16777.                 }
  16778.                 else{
  16779.                     name = name.trim();
  16780.                     this.cluster_hostname = name;
  16781.                 }
  16782.             }catch(java.lang.Exception e) {
  16783.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.cluster_id.hostname': "+e.getMessage(),e);
  16784.                 this.cluster_hostname = null;
  16785.             }  
  16786.         }

  16788.         return this.cluster_hostname;
  16789.     }
  16790.         
  16791.     private String group_id = null;
  16792.     public String getGroupId(boolean rateLimitingGestioneCluster) {
  16793.         String pName = "org.openspcoop2.pdd.group_id";
  16794.         if(this.group_id==null){
  16795.             try{ 
  16796.                 String name = null;
  16797.                 name = this.reader.getValueConvertEnvProperties(pName);
  16798.                 if(name==null) {
  16799.                     // Gestione RateLimiting senza una effettiva attivazione di un cluster dinamico
  16800.                     if(!isClusterDinamico()) {
  16801.                         if(rateLimitingGestioneCluster) {
  16802.                             this.group_id = org.openspcoop2.utils.Costanti.OPENSPCOOP2;
  16803.                         }
  16804.                         else {
  16805.                             throw new CoreException(NON_DEFINITA);
  16806.                         }
  16807.                     }
  16808.                     else {
  16809.                         throw new CoreException(NON_DEFINITA);
  16810.                     }
  16811.                 }
  16812.                 else if(name!=null){
  16813.                     name = name.trim();
  16814.                     this.group_id = name;
  16815.                 }
  16816.             }catch(java.lang.Exception e) {
  16817.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  16818.                 this.group_id = null;
  16819.             }  
  16820.         }

  16822.         return this.group_id;
  16823.     }
  16824.     
  16825.     /**
  16826.      * Restituisce il cluster id del nodo del cluster su cui gira la pdd 
  16827.      *
  16828.      * @return Il cluster id di questo nodo
  16829.      * @added Fabio Tronci (tronci@link.it) 06/06/08 
  16830.      */
  16831.     private String cluster_id = null;
  16832.     public String getClusterId(boolean required) {
  16833.         if(this.cluster_id==null){
  16834.             try{ 
  16835.                 String name = null;
  16836.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cluster_id");
  16837.                 if(name==null && required)
  16838.                     throw new CoreException(NON_DEFINITA);
  16839.                 if(name!=null){
  16840.                     name = name.trim();
  16841.                     this.cluster_id = name;
  16842.                 }
  16843.             }catch(java.lang.Exception e) {
  16844.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.cluster_id': "+e.getMessage(),e);
  16845.                 this.cluster_id = null;
  16846.             }  
  16847.         }

  16849.         return this.cluster_id;
  16850.     }
  16851.     
  16852.     private Boolean isUseHashClusterId = null;
  16853.     public boolean isUseHashClusterId(){
  16854.         String pName = "org.openspcoop2.pdd.cluster_id.hash.enabled";
  16855.         if(this.isUseHashClusterId==null){
  16856.             try{  
  16857.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  16859.                 if(value!=null){
  16860.                     value = value.trim();
  16861.                     this.isUseHashClusterId = Boolean.parseBoolean(value);
  16862.                 }else{
  16863.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  16864.                     this.isUseHashClusterId = false;
  16865.                 }

  16867.             }catch(java.lang.Exception e) {
  16868.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  16869.                 this.isUseHashClusterId = false;
  16870.             }
  16871.         }
  16872.         return this.isUseHashClusterId;
  16873.     }
  16874.     
  16875.     private String cluster_id_preCodificaHash = null;
  16876.     public String getCluster_id_preCodificaHash() {
  16877.         return this.cluster_id_preCodificaHash;
  16878.     }
  16879.     public void updateClusterId() {
  16880.         this.cluster_id_preCodificaHash = this.cluster_id;
  16881.         // calcolo il cluster fornito come hash value
  16882.         this.cluster_id = DynamicClusterManager.hashClusterId(this.cluster_id);
  16883.     }
  16884.     
  16885.     private String cluster_id_numerico =null;
  16886.     private Boolean cluster_id_numerico_read =null;
  16887.     public String getClusterIdNumerico() throws ProtocolException {
  16888.         if(this.cluster_id_numerico_read==null){
  16889.             try{ 
  16890.                 String name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cluster_id.numeric");
  16891.                 if(name!=null){
  16892.                     int numero = Integer.parseInt(name.trim());
  16893.                     if(numero<0 || numero>99){
  16894.                         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";
  16895.                         this.logError(msg);
  16896.                         throw new ProtocolException(msg);
  16897.                     }
  16898.                     this.cluster_id_numerico = name.trim();
  16899.                 }
  16900.                 
  16901.                 this.cluster_id_numerico_read = true;
  16902.                 
  16903.             }catch(java.lang.Exception e) {
  16904.                 String msg = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.cluster_id.numeric': "+e.getMessage();
  16905.                 this.logError(msg,e);
  16906.                 throw new ProtocolException(msg,e);
  16907.             }   
  16908.         }
  16909.         return this.cluster_id_numerico;
  16910.     }
  16911.     
  16912.     private Integer getClusterDinamicoIdNumericoCifre = null;
  16913.     public int getClusterDinamicoIdNumericoCifre(boolean rateLimitingGestioneCluster) { 
  16914.         String pName = "org.openspcoop2.pdd.cluster_id.numeric.dinamico.cifre";
  16915.         if(this.getClusterDinamicoIdNumericoCifre==null){
  16916.             try{ 
  16917.                 String name = null;
  16918.                 name = this.reader.getValueConvertEnvProperties(pName);
  16919.                 if(name!=null){
  16920.                     name = name.trim();
  16921.                     this.getClusterDinamicoIdNumericoCifre = java.lang.Integer.parseInt(name);
  16922.                     if(this.getClusterDinamicoIdNumericoCifre<=0) {
  16923.                         throw new CoreException("Il valore indicato deve essere maggiore di 0");
  16924.                     }
  16925.                 }
  16926.                 else{
  16927.                     // Gestione RateLimiting senza una effettiva attivazione di un cluster dinamico
  16928.                     if(!isClusterDinamico()) {
  16929.                         if(rateLimitingGestioneCluster) {
  16930.                             this.getClusterDinamicoIdNumericoCifre = 2; // per default si registra staticamente fino a 99 nodi
  16931.                         }
  16932.                         else {
  16933.                             throw new CoreException("Non Impostato");
  16934.                         }
  16935.                     }
  16936.                     else {
  16937.                         throw new CoreException("Non Impostato");
  16938.                     }
  16939.                 }
  16940.             }catch(java.lang.Exception e) {
  16941.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  16942.                 this.getClusterDinamicoIdNumericoCifre = -1;
  16943.             }  
  16944.         }

  16946.         return this.getClusterDinamicoIdNumericoCifre;
  16947.     }
  16948.     public boolean isClusterIdNumericoDinamico(boolean rateLimitingGestioneCluster) {
  16949.         return getClusterDinamicoIdNumericoCifre(rateLimitingGestioneCluster)>0;
  16950.     }

  16952.     private Boolean isTimerLockByDatabase = null;
  16953.     public boolean isTimerLockByDatabase(){
  16954.         if(this.isTimerLockByDatabase==null){
  16955.             try{  
  16956.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.lockDatabase"); 

  16958.                 if(value!=null){
  16959.                     value = value.trim();
  16960.                     this.isTimerLockByDatabase = Boolean.parseBoolean(value);
  16961.                 }else{
  16962.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.lockDatabase' non impostata, viene utilizzato il default=true");
  16963.                     this.isTimerLockByDatabase = true;
  16964.                 }

  16966.             }catch(java.lang.Exception e) {
  16967.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.lockDatabase' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  16968.                 this.isTimerLockByDatabase = true;
  16969.             }
  16970.             
  16971.             if(this.isTimerLockByDatabase) {
  16972.                 // Richiede la definizione di un clusterId e di un tipo di database
  16973.                 if(this.getClusterId(false)==null) {
  16974.                     this.isTimerLockByDatabase = false;
  16975.                 }
  16976.                 else if(this.getDatabaseType()==null) {
  16977.                     this.isTimerLockByDatabase = false;
  16978.                 }
  16979.             }
  16980.         }
  16981.         return this.isTimerLockByDatabase;
  16982.     }
  16983.     
  16984.     private Boolean isTimerLockByDatabaseNotifyLogEnabled = null;
  16985.     public boolean isTimerLockByDatabaseNotifyLogEnabled(){
  16986.         if(this.isTimerLockByDatabaseNotifyLogEnabled==null){
  16987.             try{  
  16988.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.timer.lockDatabase.notify.log"); 

  16990.                 if(value!=null){
  16991.                     value = value.trim();
  16992.                     this.isTimerLockByDatabaseNotifyLogEnabled = Boolean.parseBoolean(value);
  16993.                 }else{
  16994.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.lockDatabase.notify.log' non impostata, viene utilizzato il default=true");
  16995.                     this.isTimerLockByDatabaseNotifyLogEnabled = true;
  16996.                 }

  16998.             }catch(java.lang.Exception e) {
  16999.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.timer.lockDatabase.notify.log' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  17000.                 this.isTimerLockByDatabaseNotifyLogEnabled = true;
  17001.             }
  17002.         }
  17003.         return this.isTimerLockByDatabaseNotifyLogEnabled;
  17004.     }
  17005.     
  17006.     private String pddContextSerializer = null;
  17007.     public String getPddContextSerializer() {
  17008.         if(this.pddContextSerializer==null){
  17009.             try{ 
  17010.                 String name = null;
  17011.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.contextSerializer");
  17012.                 if(name!=null){
  17013.                     name = name.trim();
  17014.                     this.pddContextSerializer = name;
  17015.                 }else{
  17016.                     this.pddContextSerializer = CostantiConfigurazione.NONE;
  17017.                 }
  17018.             }catch(java.lang.Exception e) {
  17019.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.contextSerializer': "+e.getMessage(),e);
  17020.                 this.pddContextSerializer = CostantiConfigurazione.NONE;
  17021.             }  
  17022.         }

  17024.         return this.pddContextSerializer;
  17025.     }




  17030.     /*---------- Stateless -------------*/

  17032.     /**
  17033.      * Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo oneway
  17034.      *
  17035.      * @return il Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo oneway
  17036.      * 
  17037.      */
  17038.     private String statelessOneWay = null;
  17039.     public String getStatelessOneWay() {    
  17040.         if(this.statelessOneWay==null){
  17041.             try{ 
  17042.                 String name = null;
  17043.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.default.oneway");
  17044.                 if(name!=null){
  17045.                     name = name.trim();
  17046.                     if( (CostantiConfigurazione.ABILITATO.equals(name)==false) && (CostantiConfigurazione.DISABILITATO.equals(name)==false) ){
  17047.                         throw new CoreException("Valori ammessi sono abilitato/disabilito");
  17048.                     }
  17049.                 }
  17050.                 else{
  17051.                     throw new CoreException(NON_DEFINITA);
  17052.                 }
  17053.                 this.statelessOneWay = name;
  17054.             }catch(java.lang.Exception e) {
  17055.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.default.oneway': "+e.getMessage(),e);
  17056.                 this.statelessOneWay = null;
  17057.             }    
  17058.         }

  17060.         return this.statelessOneWay;
  17061.     }

  17063.     /**
  17064.      * Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo sincrono
  17065.      *
  17066.      * @return il Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo sincrono
  17067.      * 
  17068.      */
  17069.     private String statelessSincrono = null;
  17070.     public String getStatelessSincrono() {
  17071.         if(this.statelessSincrono==null){
  17072.             try{ 
  17073.                 String name = null;
  17074.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.default.sincrono");
  17075.                 if(name!=null){
  17076.                     name = name.trim();
  17077.                     if( (CostantiConfigurazione.ABILITATO.equals(name)==false) && (CostantiConfigurazione.DISABILITATO.equals(name)==false) ){
  17078.                         throw new CoreException("Valori ammessi sono abilitato/disabilito");
  17079.                     }
  17080.                 }
  17081.                 else{
  17082.                     throw new CoreException(NON_DEFINITA);
  17083.                 }
  17084.                 this.statelessSincrono = name;
  17085.             }catch(java.lang.Exception e) {
  17086.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.default.sincrono': "+e.getMessage(),e);
  17087.                 this.statelessSincrono = null;
  17088.             }    
  17089.         }
  17090.         //System.out.println("MODALITA default per sincrono: "+OpenSPCoopProperties.statelessSincrono);
  17091.         return this.statelessSincrono;
  17092.     }

  17094.     /**
  17095.      * Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo asincrono simmetrico e asimmetrico
  17096.      *
  17097.      * @return il Restituisce il comportamento di default (Stateless abilitato/disabilitato) per il profilo asincrono simmetrico e asimmetrico
  17098.      * 
  17099.      */
  17100.     private String statelessAsincrono = null;
  17101.     public String getStatelessAsincroni() { 
  17102.         if(this.statelessAsincrono==null){
  17103.             try{ 
  17104.                 String name = null;
  17105.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.default.asincroni");
  17106.                 if(name!=null){
  17107.                     name = name.trim();
  17108.                     if( (CostantiConfigurazione.ABILITATO.equals(name)==false) && (CostantiConfigurazione.DISABILITATO.equals(name)==false) ){
  17109.                         throw new CoreException("Valori ammessi sono abilitato/disabilito");
  17110.                     }
  17111.                 }
  17112.                 else{
  17113.                     throw new CoreException(NON_DEFINITA);
  17114.                 }
  17115.                 this.statelessAsincrono = name;
  17116.             }catch(java.lang.Exception e) {
  17117.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.default.asincroni': "+e.getMessage(),e);
  17118.                 this.statelessAsincrono = null;
  17119.             }    
  17120.         }
  17121.         //System.out.println("MODALITA default per asincroni: "+OpenSPCoopProperties.statelessAsincrono);
  17122.         return this.statelessAsincrono;
  17123.     }

  17125.     /**
  17126.      * Restituisce l'indicazione se gestire il oneway non stateless nella nuova modalita della versione 1.4 o come la vecchia 1.0
  17127.      *
  17128.      * @return Restituisce l'indicazione se gestire il oneway non stateless nella nuova modalita della versione 1.4 o come la vecchia 1.0
  17129.      * 
  17130.      */
  17131.     private Boolean isGestioneOnewayStateful_1_1= null;
  17132.     public boolean isGestioneOnewayStateful_1_1(){
  17133.         if(this.isGestioneOnewayStateful_1_1==null){
  17134.             try{  
  17135.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateful.oneway"); 

  17137.                 if(value!=null){
  17138.                     value = value.trim();
  17139.                     if( (CostantiConfigurazione.ONEWAY_STATEFUL_1_0.equals(value)==false) && (CostantiConfigurazione.ONEWAY_STATEFUL_1_1.equals(value)==false) ){
  17140.                         throw new CoreException("Valori ammessi sono 1.0/1.1");
  17141.                     }
  17142.                     this.isGestioneOnewayStateful_1_1 = CostantiConfigurazione.ONEWAY_STATEFUL_1_1.equals(value);
  17143.                 }else{
  17144.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.stateful.oneway' non impostata, viene utilizzato il default=true");
  17145.                     this.isGestioneOnewayStateful_1_1 = true;
  17146.                 }

  17148.             }catch(java.lang.Exception e) {
  17149.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.stateful.oneway' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  17150.                 this.isGestioneOnewayStateful_1_1 = true;
  17151.             }
  17152.         }
  17153.         //System.out.println("MODALITA 11 per gestione Oneway; "+OpenSPCoopProperties.isGestioneOnewayStateful_1_1);
  17154.         return this.isGestioneOnewayStateful_1_1;
  17155.     }

  17157.     /**
  17158.      * Restituisce il comportamento per il routing
  17159.      *
  17160.      * @return il Restituisce il comportamento per il routing
  17161.      * 
  17162.      */
  17163.     private String statelessRouting = null;
  17164.     public String getStatelessRouting() {   
  17165.         if(this.statelessRouting==null){
  17166.             try{ 
  17167.                 String name = null;
  17168.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.router");
  17169.                 if(name!=null){
  17170.                     name = name.trim();
  17171.                     if( (CostantiConfigurazione.ABILITATO.equals(name)==false) && (CostantiConfigurazione.DISABILITATO.equals(name)==false) ){
  17172.                         throw new CoreException("Valori ammessi sono abilitato/disabilito");
  17173.                     }
  17174.                 }
  17175.                 else{
  17176.                     throw new CoreException(NON_DEFINITA);
  17177.                 }
  17178.                 this.statelessRouting = name;
  17179.             }catch(java.lang.Exception e) {
  17180.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.router': "+e.getMessage(),e);
  17181.                 this.statelessRouting = null;
  17182.             }    
  17183.         }
  17184.         //System.out.println("MODALITA per routing: "+OpenSPCoopProperties.statelessRouting);
  17185.         return this.statelessRouting;
  17186.     }


  17189.     /**
  17190.      * Restituisce l'indicazione se una gestione stateless deve rinegoziare la connessione
  17191.      *
  17192.      * @return Restituisce l'indicazione se una gestione stateless deve rinegoziare la connessione
  17193.      * 
  17194.      */
  17195.     private Boolean isGestioneStateful_RinegoziamentoConnessione= null;
  17196.     private boolean isRinegoziamentoConnessione(){
  17197.         if(this.isGestioneStateful_RinegoziamentoConnessione==null){
  17198.             try{  
  17199.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.stateless.dataSource.rinegoziamentoConnessione"); 

  17201.                 if(value!=null){
  17202.                     value = value.trim();
  17203.                     if( (CostantiConfigurazione.ABILITATO.equals(value)==false) && (CostantiConfigurazione.DISABILITATO.equals(value)==false) ){
  17204.                         throw new CoreException("Valori ammessi sono abilitato/disabilitato");
  17205.                     }
  17206.                     if( CostantiConfigurazione.DISABILITATO.equals(value) ){
  17207.                         this.isGestioneStateful_RinegoziamentoConnessione = false;
  17208.                     }else{
  17209.                         this.isGestioneStateful_RinegoziamentoConnessione = true;
  17210.                     }
  17211.                 }else{
  17212.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.dataSource.rinegoziamentoConnessione' non impostata, viene utilizzato il default=true");
  17213.                     this.isGestioneStateful_RinegoziamentoConnessione = true;
  17214.                 }

  17216.             }catch(java.lang.Exception e) {
  17217.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.stateless.dataSource.rinegoziamentoConnessione' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  17218.                 this.isGestioneStateful_RinegoziamentoConnessione = true;
  17219.             }
  17220.         }
  17221.         return this.isGestioneStateful_RinegoziamentoConnessione;
  17222.     }
  17223.     
  17224.     public boolean isRinegoziamentoConnessione(ProfiloDiCollaborazione profilo){
  17225.         if(ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(profilo) || ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(profilo))
  17226.             return true;
  17227.         else
  17228.             return this.isRinegoziamentoConnessione();
  17229.     }




  17234.     private Boolean mergeHandlerBuiltInAndHandlerUser = null;
  17235.     public boolean isMergeHandlerBuiltInAndHandlerUser() {  
  17236.         if(this.mergeHandlerBuiltInAndHandlerUser==null){
  17237.             try{ 
  17238.                 String v = null;
  17239.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.merge");
  17240.                 if(v!=null){
  17241.                     v = v.trim();
  17242.                     this.mergeHandlerBuiltInAndHandlerUser = Boolean.parseBoolean(v);
  17243.                 } 
  17244.                 else{
  17245.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.merge' non impostata, viene utilizzato il default="+false);
  17246.                     this.mergeHandlerBuiltInAndHandlerUser = false;
  17247.                 }
  17248.             }catch(java.lang.Exception e) {
  17249.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.merge' non impostata correttamente,  errore:"+e.getMessage(),e);
  17250.             } 
  17251.         }
  17252.         return this.mergeHandlerBuiltInAndHandlerUser;
  17253.     }
  17254.     
  17255.     /*---------- Gestori handler built-in -------------*/
  17256.     
  17257.     private Boolean printInfoHandlerBuiltIn = null;
  17258.     public boolean isPrintInfoHandlerBuiltIn() {    
  17259.         if(this.printInfoHandlerBuiltIn==null){
  17260.             try{ 
  17261.                 String v = null;
  17262.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.printInfo");
  17263.                 if(v!=null){
  17264.                     v = v.trim();
  17265.                     this.printInfoHandlerBuiltIn = Boolean.parseBoolean(v);
  17266.                 } 
  17267.                 else{
  17268.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.built-in.printInfo' non impostata, viene utilizzato il default="+true);
  17269.                     this.printInfoHandlerBuiltIn = true;
  17270.                 }
  17271.             }catch(java.lang.Exception e) {
  17272.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.built-in.printInfo' non impostata correttamente,  errore:"+e.getMessage(),e);
  17273.             } 
  17274.         }
  17275.         return this.printInfoHandlerBuiltIn;
  17276.     }
  17277.     
  17278.     
  17279.     /**
  17280.      * Restituisce l'elenco degli handlers di tipo InitHandlerBuiltIn
  17281.      * 
  17282.      * @return  Restituisce l'elenco degli handlers di tipo InitHandlerBuiltIn
  17283.      */
  17284.     private String[] tipiInitHandlerBuiltIn = null;
  17285.     private boolean tipiInitHandlerBuiltInRead = false;
  17286.     public String[] getInitHandlerBuiltIn() {
  17287.         if(this.tipiInitHandlerBuiltInRead == false){
  17288.             try{ 
  17289.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.init");
  17290.                 if(value!=null){
  17291.                     value = value.trim();
  17292.                     String [] r = value.split(",");
  17293.                     this.tipiInitHandlerBuiltIn = r;
  17294.                 }else{
  17295.                     this.tipiInitHandlerBuiltIn = 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.init': "+e.getMessage(),e);
  17299.                 this.tipiInitHandlerBuiltIn = null;
  17300.             }   
  17301.             this.tipiInitHandlerBuiltInRead = true;
  17302.         }

  17304.         return this.tipiInitHandlerBuiltIn;
  17305.     }
  17306.     
  17307.     /**
  17308.      * Restituisce l'elenco degli handlers di tipo ExitHandlerBuiltIn
  17309.      * 
  17310.      * @return  Restituisce l'elenco degli handlers di tipo ExitHandlerBuiltIn
  17311.      */
  17312.     private String[] tipiExitHandlerBuiltIn = null;
  17313.     private boolean tipiExitHandlerBuiltInRead = false;
  17314.     public String[] getExitHandlerBuiltIn() {
  17315.         if(this.tipiExitHandlerBuiltInRead == false){
  17316.             try{ 
  17317.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.exit");
  17318.                 if(value!=null){
  17319.                     value = value.trim();
  17320.                     String [] r = value.split(",");
  17321.                     this.tipiExitHandlerBuiltIn = r;
  17322.                 }else{
  17323.                     this.tipiExitHandlerBuiltIn = 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.exit': "+e.getMessage(),e);
  17327.                 this.tipiExitHandlerBuiltIn = null;
  17328.             }   
  17329.             this.tipiExitHandlerBuiltInRead = true;
  17330.         }

  17332.         return this.tipiExitHandlerBuiltIn;
  17333.     }
  17334.     
  17335.     /**
  17336.      * Restituisce l'elenco degli handlers di tipo PreInRequestHandlerBuiltIn
  17337.      * 
  17338.      * @return  Restituisce l'elenco degli handlers di tipo PreInRequestHandlerBuiltIn
  17339.      */
  17340.     private String[] tipiPreInRequestHandlerBuiltIn = null;
  17341.     private boolean tipiPreInRequestHandlerBuiltInRead = false;
  17342.     public String[] getPreInRequestHandlerBuiltIn() {
  17343.         if(this.tipiPreInRequestHandlerBuiltInRead == false){
  17344.             try{ 
  17345.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.pre-in-request");
  17346.                 if(value!=null){
  17347.                     value = value.trim();
  17348.                     String [] r = value.split(",");
  17349.                     this.tipiPreInRequestHandlerBuiltIn = r;
  17350.                 }else{
  17351.                     this.tipiPreInRequestHandlerBuiltIn = null;
  17352.                 }
  17353.             }catch(java.lang.Exception e) {
  17354.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.pre-in-request': "+e.getMessage(),e);
  17355.                 this.tipiPreInRequestHandlerBuiltIn = null;
  17356.             }   
  17357.             this.tipiPreInRequestHandlerBuiltInRead = true;
  17358.         }

  17360.         return this.tipiPreInRequestHandlerBuiltIn;
  17361.     }

  17363.     
  17364.     /**
  17365.      * Restituisce l'elenco degli handlers di tipo InRequestHandlerBuiltIn
  17366.      * 
  17367.      * @return  Restituisce l'elenco degli handlers di tipo InRequestHandlerBuiltIn
  17368.      */
  17369.     private String[] tipiInRequestHandlerBuiltIn = null;
  17370.     private boolean tipiInRequestHandlerBuiltInRead = false;
  17371.     public String[] getInRequestHandlerBuiltIn() {
  17372.         if(this.tipiInRequestHandlerBuiltInRead == false){
  17373.             try{ 
  17374.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.in-request");
  17375.                 if(value!=null){
  17376.                     value = value.trim();
  17377.                     String [] r = value.split(",");
  17378.                     this.tipiInRequestHandlerBuiltIn = r;
  17379.                 }else{
  17380.                     this.tipiInRequestHandlerBuiltIn = 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-request': "+e.getMessage(),e);
  17384.                 this.tipiInRequestHandlerBuiltIn = null;
  17385.             }   
  17386.             this.tipiInRequestHandlerBuiltInRead = true;
  17387.         }

  17389.         return this.tipiInRequestHandlerBuiltIn;
  17390.     }
  17391.     
  17392.     /**
  17393.      * Restituisce l'elenco degli handlers di tipo InRequestProtocolHandlerBuiltIn
  17394.      * 
  17395.      * @return  Restituisce l'elenco degli handlers di tipo InRequestProtocolHandlerBuiltIn
  17396.      */
  17397.     private String[] tipiInRequestProtocolHandlerBuiltIn = null;
  17398.     private boolean tipiInRequestProtocolHandlerBuiltInRead = false;
  17399.     public String[] getInRequestProtocolHandlerBuiltIn() {
  17400.         if(this.tipiInRequestProtocolHandlerBuiltInRead == false){
  17401.             try{ 
  17402.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.in-protocol-request");
  17403.                 if(value!=null){
  17404.                     value = value.trim();
  17405.                     String [] r = value.split(",");
  17406.                     this.tipiInRequestProtocolHandlerBuiltIn = r;
  17407.                 }else{
  17408.                     this.tipiInRequestProtocolHandlerBuiltIn = 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.in-protocol-request': "+e.getMessage(),e);
  17412.                 this.tipiInRequestProtocolHandlerBuiltIn = null;
  17413.             }   
  17414.             this.tipiInRequestProtocolHandlerBuiltInRead = true;
  17415.         }

  17417.         return this.tipiInRequestProtocolHandlerBuiltIn;
  17418.     }
  17419.     
  17420.     /**
  17421.      * Restituisce l'elenco degli handlers di tipo OutRequestHandlerBuiltIn
  17422.      * 
  17423.      * @return  Restituisce l'elenco degli handlers di tipo OutRequestHandlerBuiltIn
  17424.      */
  17425.     private String[] tipiOutRequestHandlerBuiltIn = null;
  17426.     private boolean tipiOutRequestHandlerBuiltInRead = false;
  17427.     public String[] getOutRequestHandlerBuiltIn() {
  17428.         if(this.tipiOutRequestHandlerBuiltInRead == false){
  17429.             try{ 
  17430.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.out-request");
  17431.                 if(value!=null){
  17432.                     value = value.trim();
  17433.                     String [] r = value.split(",");
  17434.                     this.tipiOutRequestHandlerBuiltIn = r;
  17435.                 }else{
  17436.                     this.tipiOutRequestHandlerBuiltIn = 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.out-request': "+e.getMessage(),e);
  17440.                 this.tipiOutRequestHandlerBuiltIn = null;
  17441.             }   
  17442.             this.tipiOutRequestHandlerBuiltInRead = true;
  17443.         }

  17445.         return this.tipiOutRequestHandlerBuiltIn;
  17446.     }
  17447.     
  17448.     /**
  17449.      * Restituisce l'elenco degli handlers di tipo PostOutRequestHandlerBuiltIn
  17450.      * 
  17451.      * @return  Restituisce l'elenco degli handlers di tipo PostOutRequestHandlerBuiltIn
  17452.      */
  17453.     private String[] tipiPostOutRequestHandlerBuiltIn = null;
  17454.     private boolean tipiPostOutRequestHandlerBuiltInRead = false;
  17455.     public String[] getPostOutRequestHandlerBuiltIn() {
  17456.         if(this.tipiPostOutRequestHandlerBuiltInRead == false){
  17457.             try{ 
  17458.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.post-out-request");
  17459.                 if(value!=null){
  17460.                     value = value.trim();
  17461.                     String [] r = value.split(",");
  17462.                     this.tipiPostOutRequestHandlerBuiltIn = r;
  17463.                 }else{
  17464.                     this.tipiPostOutRequestHandlerBuiltIn = 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.post-out-request': "+e.getMessage(),e);
  17468.                 this.tipiPostOutRequestHandlerBuiltIn = null;
  17469.             }   
  17470.             this.tipiPostOutRequestHandlerBuiltInRead = true;
  17471.         }

  17473.         return this.tipiPostOutRequestHandlerBuiltIn;
  17474.     }
  17475.     
  17476.     /**
  17477.      * Restituisce l'elenco degli handlers di tipo PreInResponseHandlerBuiltIn
  17478.      * 
  17479.      * @return  Restituisce l'elenco degli handlers di tipo PreInResponseHandlerBuiltIn
  17480.      */
  17481.     private String[] tipiPreInResponseHandlerBuiltIn = null;
  17482.     private boolean tipiPreInResponseHandlerBuiltInRead = false;
  17483.     public String[] getPreInResponseHandlerBuiltIn() {
  17484.         if(this.tipiPreInResponseHandlerBuiltInRead == false){
  17485.             try{ 
  17486.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.pre-in-response");
  17487.                 if(value!=null){
  17488.                     value = value.trim();
  17489.                     String [] r = value.split(",");
  17490.                     this.tipiPreInResponseHandlerBuiltIn = r;
  17491.                 }else{
  17492.                     this.tipiPreInResponseHandlerBuiltIn = 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.pre-in-response': "+e.getMessage(),e);
  17496.                 this.tipiPreInResponseHandlerBuiltIn = null;
  17497.             }   
  17498.             this.tipiPreInResponseHandlerBuiltInRead = true;
  17499.         }

  17501.         return this.tipiPreInResponseHandlerBuiltIn;
  17502.     }
  17503.     
  17504.     /**
  17505.      * Restituisce l'elenco degli handlers di tipo InResponseHandlerBuiltIn
  17506.      * 
  17507.      * @return  Restituisce l'elenco degli handlers di tipo InResponseHandlerBuiltIn
  17508.      */
  17509.     private String[] tipiInResponseHandlerBuiltIn = null;
  17510.     private boolean tipiInResponseHandlerBuiltInRead = false;
  17511.     public String[] getInResponseHandlerBuiltIn() {
  17512.         if(this.tipiInResponseHandlerBuiltInRead == false){
  17513.             try{ 
  17514.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.in-response");
  17515.                 if(value!=null){
  17516.                     value = value.trim();
  17517.                     String [] r = value.split(",");
  17518.                     this.tipiInResponseHandlerBuiltIn = r;
  17519.                 }else{
  17520.                     this.tipiInResponseHandlerBuiltIn = 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.in-response': "+e.getMessage(),e);
  17524.                 this.tipiInResponseHandlerBuiltIn = null;
  17525.             }   
  17526.             this.tipiInResponseHandlerBuiltInRead = true;
  17527.         }

  17529.         return this.tipiInResponseHandlerBuiltIn;
  17530.     }
  17531.     
  17532.     /**
  17533.      * Restituisce l'elenco degli handlers di tipo OutResponseHandlerBuiltIn
  17534.      * 
  17535.      * @return  Restituisce l'elenco degli handlers di tipo OutResponseHandlerBuiltIn
  17536.      */
  17537.     private String[] tipiOutResponseHandlerBuiltIn = null;
  17538.     private boolean tipiOutResponseHandlerBuiltInRead = false;
  17539.     public String[] getOutResponseHandlerBuiltIn() {
  17540.         if(this.tipiOutResponseHandlerBuiltInRead == false){
  17541.             try{ 
  17542.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.out-response");
  17543.                 if(value!=null){
  17544.                     value = value.trim();
  17545.                     String [] r = value.split(",");
  17546.                     this.tipiOutResponseHandlerBuiltIn = r;
  17547.                 }else{
  17548.                     this.tipiOutResponseHandlerBuiltIn = 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.out-response': "+e.getMessage(),e);
  17552.                 this.tipiOutResponseHandlerBuiltIn = null;
  17553.             }   
  17554.             this.tipiOutResponseHandlerBuiltInRead = true;
  17555.         }

  17557.         return this.tipiOutResponseHandlerBuiltIn;
  17558.     }
  17559.     
  17560.     /**
  17561.      * Restituisce l'elenco degli handlers di tipo PostOutResponseHandlerBuiltIn
  17562.      * 
  17563.      * @return  Restituisce l'elenco degli handlers di tipo PostOutResponseHandlerBuiltIn
  17564.      */
  17565.     private String[] tipiPostOutResponseHandlerBuiltIn = null;
  17566.     private boolean tipiPostOutResponseHandlerBuiltInRead = false;
  17567.     public String[] getPostOutResponseHandlerBuiltIn() {
  17568.         if(this.tipiPostOutResponseHandlerBuiltInRead == false){
  17569.             try{ 
  17570.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.built-in.post-out-response");
  17571.                 if(value!=null){
  17572.                     value = value.trim();
  17573.                     String [] r = value.split(",");
  17574.                     this.tipiPostOutResponseHandlerBuiltIn = r;
  17575.                 }else{
  17576.                     this.tipiPostOutResponseHandlerBuiltIn = null;
  17577.                 }
  17578.             }catch(java.lang.Exception e) {
  17579.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.built-in.post-out-response': "+e.getMessage(),e);
  17580.                 this.tipiPostOutResponseHandlerBuiltIn = null;
  17581.             }   
  17582.             this.tipiPostOutResponseHandlerBuiltInRead = true;
  17583.         }

  17585.         return this.tipiPostOutResponseHandlerBuiltIn;
  17586.     }

  17588.     /**
  17589.      * Restituisce l'elenco degli handlers di tipo IntegrationManagerRequestHandlerBuiltIn
  17590.      * 
  17591.      * @return  Restituisce l'elenco degli handlers di tipo IntegrationManagerRequestHandlerBuiltIn
  17592.      */
  17593.     private String[] tipiIntegrationManagerRequestHandlerBuiltIn = null;
  17594.     private boolean tipiIntegrationManagerRequestHandlerBuiltInRead = false;
  17595.     public String[] getIntegrationManagerRequestHandlerBuiltIn() {
  17596.         if(this.tipiIntegrationManagerRequestHandlerBuiltInRead == false){
  17597.             try{ 
  17598.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.handler.built-in.request");
  17599.                 if(value!=null){
  17600.                     value = value.trim();
  17601.                     String [] r = value.split(",");
  17602.                     this.tipiIntegrationManagerRequestHandlerBuiltIn = r;
  17603.                 }else{
  17604.                     this.tipiIntegrationManagerRequestHandlerBuiltIn = 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.request': "+e.getMessage(),e);
  17608.                 this.tipiIntegrationManagerRequestHandlerBuiltIn = null;
  17609.             }   
  17610.             this.tipiIntegrationManagerRequestHandlerBuiltInRead = true;
  17611.         }

  17613.         return this.tipiIntegrationManagerRequestHandlerBuiltIn;
  17614.     }
  17615.     
  17616.     /**
  17617.      * Restituisce l'elenco degli handlers di tipo IntegrationManagerResponseHandlerBuiltIn
  17618.      * 
  17619.      * @return  Restituisce l'elenco degli handlers di tipo IntegrationManagerResponseHandlerBuiltIn
  17620.      */
  17621.     private String[] tipiIntegrationManagerResponseHandlerBuiltIn = null;
  17622.     private boolean tipiIntegrationManagerResponseHandlerBuiltInRead = false;
  17623.     public String[] getIntegrationManagerResponseHandlerBuiltIn() {
  17624.         if(this.tipiIntegrationManagerResponseHandlerBuiltInRead == false){
  17625.             try{ 
  17626.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.handler.built-in.response");
  17627.                 if(value!=null){
  17628.                     value = value.trim();
  17629.                     String [] r = value.split(",");
  17630.                     this.tipiIntegrationManagerResponseHandlerBuiltIn = r;
  17631.                 }else{
  17632.                     this.tipiIntegrationManagerResponseHandlerBuiltIn = null;
  17633.                 }
  17634.             }catch(java.lang.Exception e) {
  17635.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.integrationManager.handler.built-in.response': "+e.getMessage(),e);
  17636.                 this.tipiIntegrationManagerResponseHandlerBuiltIn = null;
  17637.             }   
  17638.             this.tipiIntegrationManagerResponseHandlerBuiltInRead = true;
  17639.         }

  17641.         return this.tipiIntegrationManagerResponseHandlerBuiltIn;
  17642.     }
  17643.     
  17644.     
  17645.     
  17646.     
  17647.     

  17649.     /*---------- Gestori handler -------------*/
  17650.     
  17651.     private Boolean printInfoHandler = null;
  17652.     public boolean isPrintInfoHandler() {   
  17653.         if(this.printInfoHandler==null){
  17654.             try{ 
  17655.                 String v = null;
  17656.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.printInfo");
  17657.                 if(v!=null){
  17658.                     v = v.trim();
  17659.                     this.printInfoHandler = Boolean.parseBoolean(v);
  17660.                 } 
  17661.                 else{
  17662.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.printInfo' non impostata, viene utilizzato il default="+true);
  17663.                     this.printInfoHandler = true;
  17664.                 }
  17665.             }catch(java.lang.Exception e) {
  17666.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.handler.printInfo' non impostata correttamente,  errore:"+e.getMessage(),e);
  17667.             } 
  17668.         }
  17669.         return this.printInfoHandler;
  17670.     }
  17671.     
  17672.     /**
  17673.      * Restituisce l'elenco degli handlers di tipo InitHandler
  17674.      * 
  17675.      * @return  Restituisce l'elenco degli handlers di tipo InitHandler
  17676.      */
  17677.     private String[] tipiInitHandler = null;
  17678.     private boolean tipiInitHandlerRead = false;
  17679.     public String[] getInitHandler() {
  17680.         if(this.tipiInitHandlerRead == false){
  17681.             try{ 
  17682.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.init");
  17683.                 if(value!=null){
  17684.                     value = value.trim();
  17685.                     String [] r = value.split(",");
  17686.                     this.tipiInitHandler = r;
  17687.                 }else{
  17688.                     this.tipiInitHandler = null;
  17689.                 }
  17690.             }catch(java.lang.Exception e) {
  17691.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.init': "+e.getMessage(),e);
  17692.                 this.tipiInitHandler = null;
  17693.             }   
  17694.             this.tipiInitHandlerRead = true;
  17695.         }

  17697.         return this.tipiInitHandler;
  17698.     }
  17699.     
  17700.     /**
  17701.      * Restituisce l'elenco degli handlers di tipo ExitHandler
  17702.      * 
  17703.      * @return  Restituisce l'elenco degli handlers di tipo ExitHandler
  17704.      */
  17705.     private String[] tipiExitHandler = null;
  17706.     private boolean tipiExitHandlerRead = false;
  17707.     public String[] getExitHandler() {
  17708.         if(this.tipiExitHandlerRead == false){
  17709.             try{ 
  17710.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.exit");
  17711.                 if(value!=null){
  17712.                     value = value.trim();
  17713.                     String [] r = value.split(",");
  17714.                     this.tipiExitHandler = r;
  17715.                 }else{
  17716.                     this.tipiExitHandler = null;
  17717.                 }
  17718.             }catch(java.lang.Exception e) {
  17719.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.exit': "+e.getMessage(),e);
  17720.                 this.tipiExitHandler = null;
  17721.             }   
  17722.             this.tipiExitHandlerRead = true;
  17723.         }

  17725.         return this.tipiExitHandler;
  17726.     }
  17727.     
  17728.     /**
  17729.      * Restituisce l'elenco degli handlers di tipo PreInRequestHandler
  17730.      * 
  17731.      * @return  Restituisce l'elenco degli handlers di tipo PreInRequestHandler
  17732.      */
  17733.     private String[] tipiPreInRequestHandler = null;
  17734.     private boolean tipiPreInRequestHandlerRead = false;
  17735.     public String[] getPreInRequestHandler() {
  17736.         if(this.tipiPreInRequestHandlerRead == false){
  17737.             try{ 
  17738.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.pre-in-request");
  17739.                 if(value!=null){
  17740.                     value = value.trim();
  17741.                     String [] r = value.split(",");
  17742.                     this.tipiPreInRequestHandler = r;
  17743.                 }else{
  17744.                     this.tipiPreInRequestHandler = null;
  17745.                 }
  17746.             }catch(java.lang.Exception e) {
  17747.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.pre-in-request': "+e.getMessage(),e);
  17748.                 this.tipiPreInRequestHandler = null;
  17749.             }   
  17750.             this.tipiPreInRequestHandlerRead = true;
  17751.         }

  17753.         return this.tipiPreInRequestHandler;
  17754.     }

  17756.     
  17757.     /**
  17758.      * Restituisce l'elenco degli handlers di tipo InRequestHandler
  17759.      * 
  17760.      * @return  Restituisce l'elenco degli handlers di tipo InRequestHandler
  17761.      */
  17762.     private String[] tipiInRequestHandler = null;
  17763.     private boolean tipiInRequestHandlerRead = false;
  17764.     public String[] getInRequestHandler() {
  17765.         if(this.tipiInRequestHandlerRead == false){
  17766.             try{ 
  17767.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.in-request");
  17768.                 if(value!=null){
  17769.                     value = value.trim();
  17770.                     String [] r = value.split(",");
  17771.                     this.tipiInRequestHandler = r;
  17772.                 }else{
  17773.                     this.tipiInRequestHandler = 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-request': "+e.getMessage(),e);
  17777.                 this.tipiInRequestHandler = null;
  17778.             }   
  17779.             this.tipiInRequestHandlerRead = true;
  17780.         }

  17782.         return this.tipiInRequestHandler;
  17783.     }
  17784.     
  17785.     /**
  17786.      * Restituisce l'elenco degli handlers di tipo InRequestProtocolHandler
  17787.      * 
  17788.      * @return  Restituisce l'elenco degli handlers di tipo InRequestProtocolHandler
  17789.      */
  17790.     private String[] tipiInRequestProtocolHandler = null;
  17791.     private boolean tipiInRequestProtocolHandlerRead = false;
  17792.     public String[] getInRequestProtocolHandler() {
  17793.         if(this.tipiInRequestProtocolHandlerRead == false){
  17794.             try{ 
  17795.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.in-protocol-request");
  17796.                 if(value!=null){
  17797.                     value = value.trim();
  17798.                     String [] r = value.split(",");
  17799.                     this.tipiInRequestProtocolHandler = r;
  17800.                 }else{
  17801.                     this.tipiInRequestProtocolHandler = null;
  17802.                 }
  17803.             }catch(java.lang.Exception e) {
  17804.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.in-protocol-request': "+e.getMessage(),e);
  17805.                 this.tipiInRequestProtocolHandler = null;
  17806.             }   
  17807.             this.tipiInRequestProtocolHandlerRead = true;
  17808.         }

  17810.         return this.tipiInRequestProtocolHandler;
  17811.     }
  17812.     
  17813.     /**
  17814.      * Restituisce l'elenco degli handlers di tipo OutRequestHandler
  17815.      * 
  17816.      * @return  Restituisce l'elenco degli handlers di tipo OutRequestHandler
  17817.      */
  17818.     private String[] tipiOutRequestHandler = null;
  17819.     private boolean tipiOutRequestHandlerRead = false;
  17820.     public String[] getOutRequestHandler() {
  17821.         if(this.tipiOutRequestHandlerRead == false){
  17822.             try{ 
  17823.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.out-request");
  17824.                 if(value!=null){
  17825.                     value = value.trim();
  17826.                     String [] r = value.split(",");
  17827.                     this.tipiOutRequestHandler = r;
  17828.                 }else{
  17829.                     this.tipiOutRequestHandler = null;
  17830.                 }
  17831.             }catch(java.lang.Exception e) {
  17832.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.out-request': "+e.getMessage(),e);
  17833.                 this.tipiOutRequestHandler = null;
  17834.             }   
  17835.             this.tipiOutRequestHandlerRead = true;
  17836.         }

  17838.         return this.tipiOutRequestHandler;
  17839.     }
  17840.     
  17841.     /**
  17842.      * Restituisce l'elenco degli handlers di tipo PostOutRequestHandler
  17843.      * 
  17844.      * @return  Restituisce l'elenco degli handlers di tipo PostOutRequestHandler
  17845.      */
  17846.     private String[] tipiPostOutRequestHandler = null;
  17847.     private boolean tipiPostOutRequestHandlerRead = false;
  17848.     public String[] getPostOutRequestHandler() {
  17849.         if(this.tipiPostOutRequestHandlerRead == false){
  17850.             try{ 
  17851.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.post-out-request");
  17852.                 if(value!=null){
  17853.                     value = value.trim();
  17854.                     String [] r = value.split(",");
  17855.                     this.tipiPostOutRequestHandler = r;
  17856.                 }else{
  17857.                     this.tipiPostOutRequestHandler = null;
  17858.                 }
  17859.             }catch(java.lang.Exception e) {
  17860.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.post-out-request': "+e.getMessage(),e);
  17861.                 this.tipiPostOutRequestHandler = null;
  17862.             }   
  17863.             this.tipiPostOutRequestHandlerRead = true;
  17864.         }

  17866.         return this.tipiPostOutRequestHandler;
  17867.     }
  17868.     
  17869.     /**
  17870.      * Restituisce l'elenco degli handlers di tipo PreInResponseHandler
  17871.      * 
  17872.      * @return  Restituisce l'elenco degli handlers di tipo PreInResponseHandler
  17873.      */
  17874.     private String[] tipiPreInResponseHandler = null;
  17875.     private boolean tipiPreInResponseHandlerRead = false;
  17876.     public String[] getPreInResponseHandler() {
  17877.         if(this.tipiPreInResponseHandlerRead == false){
  17878.             try{ 
  17879.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.pre-in-response");
  17880.                 if(value!=null){
  17881.                     value = value.trim();
  17882.                     String [] r = value.split(",");
  17883.                     this.tipiPreInResponseHandler = r;
  17884.                 }else{
  17885.                     this.tipiPreInResponseHandler = null;
  17886.                 }
  17887.             }catch(java.lang.Exception e) {
  17888.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.pre-in-response': "+e.getMessage(),e);
  17889.                 this.tipiPreInResponseHandler = null;
  17890.             }   
  17891.             this.tipiPreInResponseHandlerRead = true;
  17892.         }

  17894.         return this.tipiPreInResponseHandler;
  17895.     }
  17896.     
  17897.     /**
  17898.      * Restituisce l'elenco degli handlers di tipo InResponseHandler
  17899.      * 
  17900.      * @return  Restituisce l'elenco degli handlers di tipo InResponseHandler
  17901.      */
  17902.     private String[] tipiInResponseHandler = null;
  17903.     private boolean tipiInResponseHandlerRead = false;
  17904.     public String[] getInResponseHandler() {
  17905.         if(this.tipiInResponseHandlerRead == false){
  17906.             try{ 
  17907.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.in-response");
  17908.                 if(value!=null){
  17909.                     value = value.trim();
  17910.                     String [] r = value.split(",");
  17911.                     this.tipiInResponseHandler = r;
  17912.                 }else{
  17913.                     this.tipiInResponseHandler = null;
  17914.                 }
  17915.             }catch(java.lang.Exception e) {
  17916.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.in-response': "+e.getMessage(),e);
  17917.                 this.tipiInResponseHandler = null;
  17918.             }   
  17919.             this.tipiInResponseHandlerRead = true;
  17920.         }

  17922.         return this.tipiInResponseHandler;
  17923.     }
  17924.     
  17925.     /**
  17926.      * Restituisce l'elenco degli handlers di tipo OutResponseHandler
  17927.      * 
  17928.      * @return  Restituisce l'elenco degli handlers di tipo OutResponseHandler
  17929.      */
  17930.     private String[] tipiOutResponseHandler = null;
  17931.     private boolean tipiOutResponseHandlerRead = false;
  17932.     public String[] getOutResponseHandler() {
  17933.         if(this.tipiOutResponseHandlerRead == false){
  17934.             try{ 
  17935.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.out-response");
  17936.                 if(value!=null){
  17937.                     value = value.trim();
  17938.                     String [] r = value.split(",");
  17939.                     this.tipiOutResponseHandler = r;
  17940.                 }else{
  17941.                     this.tipiOutResponseHandler = null;
  17942.                 }
  17943.             }catch(java.lang.Exception e) {
  17944.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.out-response': "+e.getMessage(),e);
  17945.                 this.tipiOutResponseHandler = null;
  17946.             }   
  17947.             this.tipiOutResponseHandlerRead = true;
  17948.         }

  17950.         return this.tipiOutResponseHandler;
  17951.     }
  17952.     
  17953.     /**
  17954.      * Restituisce l'elenco degli handlers di tipo PostOutResponseHandler
  17955.      * 
  17956.      * @return  Restituisce l'elenco degli handlers di tipo PostOutResponseHandler
  17957.      */
  17958.     private String[] tipiPostOutResponseHandler = null;
  17959.     private boolean tipiPostOutResponseHandlerRead = false;
  17960.     public String[] getPostOutResponseHandler() {
  17961.         if(this.tipiPostOutResponseHandlerRead == false){
  17962.             try{ 
  17963.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.handler.post-out-response");
  17964.                 if(value!=null){
  17965.                     value = value.trim();
  17966.                     String [] r = value.split(",");
  17967.                     this.tipiPostOutResponseHandler = r;
  17968.                 }else{
  17969.                     this.tipiPostOutResponseHandler = null;
  17970.                 }
  17971.             }catch(java.lang.Exception e) {
  17972.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.handler.post-out-response': "+e.getMessage(),e);
  17973.                 this.tipiPostOutResponseHandler = null;
  17974.             }   
  17975.             this.tipiPostOutResponseHandlerRead = true;
  17976.         }

  17978.         return this.tipiPostOutResponseHandler;
  17979.     }

  17981.     /**
  17982.      * Restituisce l'elenco degli handlers di tipo IntegrationManagerRequestHandler
  17983.      * 
  17984.      * @return  Restituisce l'elenco degli handlers di tipo IntegrationManagerRequestHandler
  17985.      */
  17986.     private String[] tipiIntegrationManagerRequestHandler = null;
  17987.     private boolean tipiIntegrationManagerRequestHandlerRead = false;
  17988.     public String[] getIntegrationManagerRequestHandler() {
  17989.         if(this.tipiIntegrationManagerRequestHandlerRead == false){
  17990.             try{ 
  17991.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.handler.request");
  17992.                 if(value!=null){
  17993.                     value = value.trim();
  17994.                     String [] r = value.split(",");
  17995.                     this.tipiIntegrationManagerRequestHandler = r;
  17996.                 }else{
  17997.                     this.tipiIntegrationManagerRequestHandler = 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.request': "+e.getMessage(),e);
  18001.                 this.tipiIntegrationManagerRequestHandler = null;
  18002.             }   
  18003.             this.tipiIntegrationManagerRequestHandlerRead = true;
  18004.         }

  18006.         return this.tipiIntegrationManagerRequestHandler;
  18007.     }
  18008.     
  18009.     /**
  18010.      * Restituisce l'elenco degli handlers di tipo IntegrationManagerResponseHandler
  18011.      * 
  18012.      * @return  Restituisce l'elenco degli handlers di tipo IntegrationManagerResponseHandler
  18013.      */
  18014.     private String[] tipiIntegrationManagerResponseHandler = null;
  18015.     private boolean tipiIntegrationManagerResponseHandlerRead = false;
  18016.     public String[] getIntegrationManagerResponseHandler() {
  18017.         if(this.tipiIntegrationManagerResponseHandlerRead == false){
  18018.             try{ 
  18019.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.integrationManager.handler.response");
  18020.                 if(value!=null){
  18021.                     value = value.trim();
  18022.                     String [] r = value.split(",");
  18023.                     this.tipiIntegrationManagerResponseHandler = r;
  18024.                 }else{
  18025.                     this.tipiIntegrationManagerResponseHandler = null;
  18026.                 }
  18027.             }catch(java.lang.Exception e) {
  18028.                 this.logError("Riscontrato errore durante la lettura dei tipi di handler 'org.openspcoop2.pdd.integrationManager.handler.response': "+e.getMessage(),e);
  18029.                 this.tipiIntegrationManagerResponseHandler = null;
  18030.             }   
  18031.             this.tipiIntegrationManagerResponseHandlerRead = true;
  18032.         }

  18034.         return this.tipiIntegrationManagerResponseHandler;
  18035.     }









  18045.     /* ----------- MessageSecurity --------------------- */
  18046.     
  18047.     private Boolean isLoadApacheXMLDSig = null;
  18048.     public boolean isLoadApacheXMLDSig(){

  18050.         String pName = "org.openspcoop2.pdd.security.addApacheXMLDSigProvider";
  18051.         if(this.isLoadApacheXMLDSig==null){
  18052.             try{  
  18053.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18055.                 if (value != null){
  18056.                     value = value.trim();
  18057.                     this.isLoadApacheXMLDSig = Boolean.parseBoolean(value);
  18058.                 }else{
  18059.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  18060.                     this.isLoadApacheXMLDSig = true;
  18061.                 }

  18063.             }catch(java.lang.Exception e) {
  18064.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  18065.                 this.isLoadApacheXMLDSig = true;
  18066.             }
  18067.         }

  18069.         return this.isLoadApacheXMLDSig;
  18070.     }
  18071.     
  18072.     private Boolean isLoadBouncyCastle = null;
  18073.     public boolean isLoadBouncyCastle(){

  18075.         if(this.isLoadBouncyCastle==null){
  18076.             try{  
  18077.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.security.addBouncyCastleProvider"); 

  18079.                 if (value != null){
  18080.                     value = value.trim();
  18081.                     this.isLoadBouncyCastle = Boolean.parseBoolean(value);
  18082.                 }else{
  18083.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.security.addBouncyCastleProvider' non impostata, viene utilizzato il default=true");
  18084.                     this.isLoadBouncyCastle = true;
  18085.                 }

  18087.             }catch(java.lang.Exception e) {
  18088.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.security.addBouncyCastleProvider' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  18089.                 this.isLoadBouncyCastle = true;
  18090.             }
  18091.         }

  18093.         return this.isLoadBouncyCastle;
  18094.     }
  18095.     
  18096.     private Boolean secureRandomBouncyCastle_read = null;
  18097.     private String bouncyCastleSecureRandomAlgo = null;
  18098.     public String getBouncyCastleSecureRandomAlgorithm(){

  18100.         String pName = "org.openspcoop2.pdd.security.bouncyCastleProvider.secureRandomAlgorithm";
  18101.         if(this.secureRandomBouncyCastle_read==null){
  18102.             try{  
  18103.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18105.                 if (value != null){
  18106.                     value = value.trim();
  18107.                     this.bouncyCastleSecureRandomAlgo = value;
  18108.                 }

  18110.             }catch(java.lang.Exception e) {
  18111.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  18112.                 this.bouncyCastleSecureRandomAlgo = null;
  18113.             }
  18114.             
  18115.             this.secureRandomBouncyCastle_read = true;
  18116.         }

  18118.         return this.bouncyCastleSecureRandomAlgo;
  18119.     }
  18120.     
  18121.     private Boolean isUseBouncyCastleProviderForCertificate = null;
  18122.     public boolean isUseBouncyCastleProviderForCertificate(){

  18124.         if(this.isUseBouncyCastleProviderForCertificate==null){
  18125.             String pName = "org.openspcoop2.pdd.security.cert.useBouncyCastleProvider";
  18126.             try{  
  18127.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18129.                 if (value != null){
  18130.                     value = value.trim();
  18131.                     this.isUseBouncyCastleProviderForCertificate = Boolean.parseBoolean(value);
  18132.                 }else{
  18133.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  18134.                     this.isUseBouncyCastleProviderForCertificate = true;
  18135.                 }

  18137.             }catch(java.lang.Exception e) {
  18138.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  18139.                 this.isUseBouncyCastleProviderForCertificate = true;
  18140.             }
  18141.         }

  18143.         return this.isUseBouncyCastleProviderForCertificate;
  18144.     }
  18145.     
  18146.     private Boolean isUseBouncyCastleProviderForMessageDigest = null;
  18147.     public boolean isUseBouncyCastleProviderForMessageDigest(){

  18149.         if(this.isUseBouncyCastleProviderForMessageDigest==null){
  18150.             String pName = "org.openspcoop2.pdd.security.digest.useBouncyCastleProvider";
  18151.             try{  
  18152.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18154.                 if (value != null){
  18155.                     value = value.trim();
  18156.                     this.isUseBouncyCastleProviderForMessageDigest = Boolean.parseBoolean(value);
  18157.                 }else{
  18158.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  18159.                     this.isUseBouncyCastleProviderForMessageDigest = true;
  18160.                 }

  18162.             }catch(java.lang.Exception e) {
  18163.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  18164.                 this.isUseBouncyCastleProviderForMessageDigest = true;
  18165.             }
  18166.         }

  18168.         return this.isUseBouncyCastleProviderForMessageDigest;
  18169.     }
  18170.     
  18171.     private Boolean isUseBouncyCastleProviderForWss4jCryptoMerlin = null;
  18172.     public boolean isUseBouncyCastleProviderForWss4jCryptoMerlin(){

  18174.         if(this.isUseBouncyCastleProviderForWss4jCryptoMerlin==null){
  18175.             String pName = "org.openspcoop2.pdd.security.wss4jCryptoMerlin.useBouncyCastleProvider";
  18176.             try{  
  18177.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18179.                 if (value != null){
  18180.                     value = value.trim();
  18181.                     this.isUseBouncyCastleProviderForWss4jCryptoMerlin = Boolean.parseBoolean(value);
  18182.                 }else{
  18183.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  18184.                     this.isUseBouncyCastleProviderForWss4jCryptoMerlin = true;
  18185.                 }

  18187.             }catch(java.lang.Exception e) {
  18188.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  18189.                 this.isUseBouncyCastleProviderForWss4jCryptoMerlin = true;
  18190.             }
  18191.         }

  18193.         return this.isUseBouncyCastleProviderForWss4jCryptoMerlin;
  18194.     }
  18195.     
  18196.     private Boolean securityEgd_read = null;
  18197.     private String securityEgd = null;
  18198.     public String getSecurityEgd(){

  18200.         String pName = "org.openspcoop2.pdd.security.egd";
  18201.         if(this.securityEgd_read==null){
  18202.             try{  
  18203.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18205.                 if (value != null){
  18206.                     value = value.trim();
  18207.                     this.securityEgd = value;
  18208.                 }

  18210.             }catch(java.lang.Exception e) {
  18211.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  18212.                 this.securityEgd = null;
  18213.             }
  18214.             
  18215.             this.securityEgd_read = true;
  18216.         }

  18218.         return this.securityEgd;
  18219.     }
  18220.     
  18221.     /**
  18222.      * Indicazione se generare un actor di default
  18223.      *   
  18224.      * @return Indicazione se generare un actor di default
  18225.      * 
  18226.      */
  18227.     private Boolean isGenerazioneActorDefault = null;
  18228.     public boolean isGenerazioneActorDefault(String implementazionePdDSoggetto){

  18230.         // ovverriding per implementazione porta di dominio
  18231.         if(this.pddReader!=null){
  18232.             String tipo = this.pddReader.getMessageSecurity_ActorDefaultEnable(implementazionePdDSoggetto);
  18233.             if(tipo!=null && ( 
  18234.                     CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo) || 
  18235.                     CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo)  ) 
  18236.             ){
  18237.                 if(CostantiConfigurazione.TRUE.equalsIgnoreCase(tipo))
  18238.                     return true;
  18239.                 else if(CostantiConfigurazione.FALSE.equalsIgnoreCase(tipo))
  18240.                     return false;
  18241.             }
  18242.         }

  18244.         if(this.isGenerazioneActorDefault==null){
  18245.             try{  
  18246.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.actorDefault.enable"); 

  18248.                 if (value != null){
  18249.                     value = value.trim();
  18250.                     this.isGenerazioneActorDefault = Boolean.parseBoolean(value);
  18251.                 }else{
  18252.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.actorDefault.enable' non impostata, viene utilizzato il default=true");
  18253.                     this.isGenerazioneActorDefault = true;
  18254.                 }

  18256.             }catch(java.lang.Exception e) {
  18257.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.actorDefault.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  18258.                 this.isGenerazioneActorDefault = true;
  18259.             }
  18260.         }

  18262.         return this.isGenerazioneActorDefault;
  18263.     }


  18266.     /**
  18267.      * Actor di default
  18268.      *   
  18269.      * @return actor di default
  18270.      * 
  18271.      */
  18272.     private String actorDefault = null;
  18273.     public String getActorDefault(String implementazionePdDSoggetto){

  18275.         // ovverriding per implementazione porta di dominio
  18276.         if(this.pddReader!=null){
  18277.             String valore = this.pddReader.getMessageSecurity_ActorDefaultValue(implementazionePdDSoggetto);
  18278.             if(valore!=null){
  18279.                 return valore;
  18280.             }
  18281.         }

  18283.         if(this.actorDefault==null){
  18284.             try{  
  18285.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.actorDefault.valore"); 

  18287.                 if (value != null){
  18288.                     value = value.trim();
  18289.                     this.actorDefault = value;
  18290.                 }else{
  18291.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.actorDefault.valore' non impostata, viene utilizzato il default=openspcoop");
  18292.                     this.actorDefault = "openspcoop";
  18293.                 }

  18295.             }catch(java.lang.Exception e) {
  18296.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.actorDefault.valore' non impostata, viene utilizzato il default=openspcoop, errore:"+e.getMessage(),e);
  18297.                 this.actorDefault = "openspcoop";
  18298.             }
  18299.         }

  18301.         return this.actorDefault;
  18302.     }
  18303.     
  18304.     /**
  18305.      * WsuId prefix associato agli id delle reference utilizzate dagli header di MessageSecurity
  18306.      *   
  18307.      * @return prefix
  18308.      * 
  18309.      */
  18310.     private String prefixWsuId = null;
  18311.     public String getPrefixWsuId(){

  18313.         if(this.prefixWsuId==null){
  18314.             try{  
  18315.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.prefixWsuId"); 

  18317.                 if (value != null){
  18318.                     value = value.trim();
  18319.                     this.prefixWsuId = value;
  18320.                 }else{
  18321.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.prefixWsuId' non impostata, viene utilizzato il default di MessageSecurity");
  18322.                     this.prefixWsuId = "";
  18323.                 }

  18325.             }catch(java.lang.Exception e) {
  18326.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.prefixWsuId' non impostata, viene utilizzato il default di MessageSecurity, errore:"+e.getMessage(),e);
  18327.                 this.prefixWsuId = "";
  18328.             }
  18329.         }

  18331.         return this.prefixWsuId;
  18332.     }
  18333.     
  18334.     private Boolean secureRandomWsuId_read = null;
  18335.     private String wsuIdSecureRandomAlgo = null;
  18336.     public String getWsuIdSecureRandomAlgorithm(){

  18338.         String pName = "org.openspcoop2.pdd.messageSecurity.wsuId.secureRandomAlgorithm";
  18339.         if(this.secureRandomWsuId_read==null){
  18340.             try{  
  18341.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18343.                 if (value != null){
  18344.                     value = value.trim();
  18345.                     this.wsuIdSecureRandomAlgo = value;
  18346.                 }

  18348.             }catch(java.lang.Exception e) {
  18349.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  18350.                 this.wsuIdSecureRandomAlgo = null;
  18351.             }
  18352.             
  18353.             this.secureRandomWsuId_read = true;
  18354.         }

  18356.         return this.wsuIdSecureRandomAlgo;
  18357.     }
  18358.     
  18359.     private Boolean removeAllWsuIdRef = null;
  18360.     public boolean isRemoveAllWsuIdRef(){

  18362.         if(this.removeAllWsuIdRef==null){
  18363.             try{  
  18364.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.removeAllWsuIdRef"); 

  18366.                 if (value != null){
  18367.                     value = value.trim();
  18368.                     this.removeAllWsuIdRef = Boolean.parseBoolean(value);
  18369.                 }else{
  18370.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.removeAllWsuIdRef' non impostata, viene utilizzato il default 'false'");
  18371.                     this.removeAllWsuIdRef = false;
  18372.                 }

  18374.             }catch(java.lang.Exception e) {
  18375.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.removeAllWsuIdRef' non impostata, viene utilizzato il default 'false', errore:"+e.getMessage(),e);
  18376.                 this.removeAllWsuIdRef = false;
  18377.             }
  18378.         }

  18380.         return this.removeAllWsuIdRef;
  18381.     }
  18382.     
  18383.     private String externalPWCallback = null;
  18384.     private Boolean externalPWCallbackReaded = null;
  18385.     public String getExternalPWCallbackPropertyFile(){

  18387.         if(this.externalPWCallbackReaded==null){
  18388.             try{  
  18389.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.externalPWCallback.propertiesFile"); 

  18391.                 if (value != null){
  18392.                     value = value.trim();
  18393.                     this.externalPWCallback = value;
  18394.                 }else{
  18395.                     this.logDebug("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.externalPWCallback.propertiesFile' non impostata");
  18396.                     this.externalPWCallback = null;
  18397.                 }
  18398.                 this.externalPWCallbackReaded = true;

  18400.             }catch(java.lang.Exception e) {
  18401.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.externalPWCallback.propertiesFile' non impostata, errore:"+e.getMessage(),e);
  18402.                 this.externalPWCallback = null;
  18403.                 this.externalPWCallbackReaded = true;
  18404.             }
  18405.         }

  18407.         return this.externalPWCallback;
  18408.     }


  18411.     /**
  18412.      * Restituisce l'indicazione se la cache messageSecurity e' abilitata
  18413.      *
  18414.      * @return Restituisce l'indicazione se la cache messageSecurity e' abilitata
  18415.      */
  18416.     private Boolean isAbilitataCacheMessageSecurityKeystore_value = null;
  18417.     public boolean isAbilitataCacheMessageSecurityKeystore() {
  18418.         if(this.isAbilitataCacheMessageSecurityKeystore_value==null){
  18419.             try{  
  18420.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.keystore.cache.enable"); 
  18421.                 if(value!=null){
  18422.                     value = value.trim();
  18423.                     this.isAbilitataCacheMessageSecurityKeystore_value = Boolean.parseBoolean(value);
  18424.                 }else{
  18425.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.keystore.cache.enable' non impostata, viene utilizzato il default=false");
  18426.                     this.isAbilitataCacheMessageSecurityKeystore_value = false;
  18427.                 }
  18428.             }catch(java.lang.Exception e) {
  18429.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.keystore.cache.enable' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  18430.                 this.isAbilitataCacheMessageSecurityKeystore_value = false;
  18431.             }
  18432.         }

  18434.         return this.isAbilitataCacheMessageSecurityKeystore_value;
  18435.     }

  18437.     /**
  18438.      * Restituisce la dimensione della cache messageSecurity 
  18439.      *
  18440.      * @return Restituisce la dimensione della cache messageSecurity 
  18441.      */
  18442.     private Integer dimensioneCacheMessageSecurityKeystore_value = null;
  18443.     public int getDimensioneCacheMessageSecurityKeystore() throws OpenSPCoop2ConfigurationException{    
  18444.         if(this.dimensioneCacheMessageSecurityKeystore_value==null){
  18445.             try{  
  18446.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.keystore.cache.dimensione"); 
  18447.                 if(value!=null){
  18448.                     value = value.trim();
  18449.                     this.dimensioneCacheMessageSecurityKeystore_value = Integer.parseInt(value);
  18450.                 }else{
  18451.                     this.dimensioneCacheMessageSecurityKeystore_value = -1;
  18452.                 }
  18453.             }catch(java.lang.Exception e) {
  18454.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.keystore.cache.dimensione': "+e.getMessage(),e);
  18455.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop  'org.openspcoop2.pdd.messageSecurity.keystore.cache.dimensione'",e);
  18456.             }
  18457.         }

  18459.         return this.dimensioneCacheMessageSecurityKeystore_value;
  18460.     }

  18462.     /**
  18463.      * Restituisce la  itemLifeSecond della cache messageSecurity
  18464.      *
  18465.      * @return Restituisce la itemLifeSecond della cache messageSecurity
  18466.      */
  18467.     private Integer itemLifeSecondCacheMessageSecurityKeystore_value = null;
  18468.     public int getItemLifeSecondCacheMessageSecurityKeystore() throws OpenSPCoop2ConfigurationException{
  18469.         if(this.itemLifeSecondCacheMessageSecurityKeystore_value==null){
  18470.             try{  
  18471.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.keystore.cache.itemLifeSecond"); 
  18472.                 if(value!=null){
  18473.                     value = value.trim();
  18474.                     this.itemLifeSecondCacheMessageSecurityKeystore_value = Integer.parseInt(value);
  18475.                 }else{
  18476.                     this.itemLifeSecondCacheMessageSecurityKeystore_value = -1;
  18477.                 }
  18478.             }catch(java.lang.Exception e) {
  18479.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.keystore.cache.itemLifeSecond': "+e.getMessage(),e);
  18480.                 throw new OpenSPCoop2ConfigurationException("Riscontrato errore durante la lettura della proprieta' di openspcoop  'org.openspcoop2.pdd.messageSecurity.keystore.cache.itemLifeSecond'",e);
  18481.             }
  18482.         }

  18484.         return this.itemLifeSecondCacheMessageSecurityKeystore_value;
  18485.     }
  18486.     
  18487.     
  18488.     
  18489.     
  18490.     
  18491.     
  18492.     /* ********  Gestore Credenziali  ******** */

  18494.     private Boolean getAutenticazioneLockPermitsRead = null;
  18495.     private Integer getAutenticazioneLockPermits = null;
  18496.     public Integer getAutenticazioneLockPermits() {

  18498.         String pName = "org.openspcoop2.pdd.core.autenticazione.lock.permits";
  18499.         if(this.getAutenticazioneLockPermitsRead==null){
  18500.             try{  
  18501.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18503.                 if (value != null){
  18504.                     value = value.trim();
  18505.                     int permits = Integer.parseInt(value); 
  18506.                     if(permits>1) {
  18507.                         // altrimenti è un normale semaphore binario
  18508.                         this.getAutenticazioneLockPermits = permits;
  18509.                     }
  18510.                 }
  18511.                 
  18512.                 
  18513.             }catch(java.lang.Exception e) {
  18514.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  18515.             }
  18516.             
  18517.             this.getAutenticazioneLockPermitsRead = true;
  18518.         }

  18520.         return this.getAutenticazioneLockPermits;
  18521.     }
  18522.     
  18523.     private Map<String, Integer> getTipoAutenticazioneLockPermits = null;
  18524.     public Integer getAutenticazioneLockPermits(String tipoAutenticazione) { 

  18526.         String pName = "org.openspcoop2.pdd.core.autenticazione.lock.permits.";
  18527.         if(this.getTipoAutenticazioneLockPermits==null){
  18528.             
  18529.             this.getTipoAutenticazioneLockPermits = new HashMap<>();
  18530.             
  18531.             try{  
  18532.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);
  18533.                 processAutenticazioneLockPermits(p);
  18534.             }catch(java.lang.Exception e) {
  18535.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  18536.             }
  18537.             
  18538.         }

  18540.         return this.getTipoAutenticazioneLockPermits.get(tipoAutenticazione);
  18541.     }
  18542.     private void processAutenticazioneLockPermits(Properties p) {
  18543.         if(p!=null && !p.isEmpty()) {
  18544.             for (Object oKey : p.keySet()) {
  18545.                 if(oKey!=null) {
  18546.                     String key = (String) oKey;
  18547.                     String value = p.getProperty(key);
  18548.                     processAutenticazioneLockPermits(key, value);
  18549.                 }
  18550.             }
  18551.         }
  18552.     }
  18553.     private void processAutenticazioneLockPermits(String key, String value) {
  18554.         if(value!=null) {
  18555.             int permits = Integer.parseInt(value);
  18556.             if(permits>1) {
  18557.                 // altrimenti è un normale semaphore binario
  18558.                 this.getTipoAutenticazioneLockPermits.put(key, permits);
  18559.             }
  18560.         }
  18561.     }
  18562.     
  18563.     private Boolean isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed = null;
  18564.     public boolean isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed(){

  18566.         if(this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed==null){
  18567.             String pName = "org.openspcoop2.pdd.core.autenticazione.gestioneToken.saveAuthenticationInfo.authenticationFailed";
  18568.             try{  
  18569.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  18571.                 if (value != null){
  18572.                     value = value.trim();
  18573.                     this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed = Boolean.parseBoolean(value);
  18574.                 }else{
  18575.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  18576.                     this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed = true;
  18577.                 }

  18579.             }catch(java.lang.Exception e) {
  18580.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  18581.                 this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed = true;
  18582.             }
  18583.         }

  18585.         return this.isGestioneAutenticazioneSaveTokenAuthenticationInfoAuthenticationFailed;
  18586.     }
  18587.     
  18588.     private CryptConfig getCryptConfigAutenticazioneApplicativi = null;
  18589.     public CryptConfig getCryptConfigAutenticazioneApplicativi() {
  18590.         if(this.getCryptConfigAutenticazioneApplicativi == null){
  18591.             try{  
  18592.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.autenticazione.applicativi.password"); 
  18593.                 if(value!=null){
  18594.                     value = value.trim();
  18595.                     this.getCryptConfigAutenticazioneApplicativi = new CryptConfig(value);
  18596.                 }
  18597.             }catch(java.lang.Exception e) {
  18598.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.core.autenticazione.applicativi.password': "+e.getMessage(),e);
  18599.                 return null;
  18600.             }
  18601.         }

  18603.         return this.getCryptConfigAutenticazioneApplicativi;
  18604.     }
  18605.     
  18606.     private CryptConfig getCryptConfigAutenticazioneSoggetti = null;
  18607.     public CryptConfig getCryptConfigAutenticazioneSoggetti() {
  18608.         if(this.getCryptConfigAutenticazioneSoggetti == null){
  18609.             try{  
  18610.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.core.autenticazione.soggetti.password"); 
  18611.                 if(value!=null){
  18612.                     value = value.trim();
  18613.                     this.getCryptConfigAutenticazioneSoggetti = new CryptConfig(value);
  18614.                 }
  18615.             }catch(java.lang.Exception e) {
  18616.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.core.autenticazione.soggetti.password': "+e.getMessage(),e);
  18617.                 return null;
  18618.             }
  18619.         }

  18621.         return this.getCryptConfigAutenticazioneSoggetti;
  18622.     }

  18624.     private Boolean isAutenticazioneBasicLogPassword = null;
  18625.     public boolean isAutenticazioneBasicLogPassword() {
  18626.         String pName = "org.openspcoop2.pdd.core.autenticazione.basic.invalidCredentials.logPassword";
  18627.         if(this.isAutenticazioneBasicLogPassword == null){
  18628.             try{  
  18629.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18630.                 if(value!=null){
  18631.                     value = value.trim();
  18632.                     this.isAutenticazioneBasicLogPassword = Boolean.valueOf(value);
  18633.                 }
  18634.                 else {
  18635.                     this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=false");
  18636.                     this.isAutenticazioneBasicLogPassword = false;
  18637.                 }
  18638.             }catch(java.lang.Exception e) {
  18639.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=false. Errore: "+e.getMessage(),e);
  18640.                 this.isAutenticazioneBasicLogPassword = false;
  18641.             }
  18642.         }

  18644.         return this.isAutenticazioneBasicLogPassword;
  18645.     }
  18646.     
  18647.     private WWWAuthenticateConfig getRealmAutenticazioneBasicWWWAuthenticateConfig = null;
  18648.     private boolean getRealmAutenticazioneBasicWWWAuthenticateConfig_read = false;
  18649.     public WWWAuthenticateConfig getRealmAutenticazioneBasicWWWAuthenticateConfig() {
  18650.         if(this.getRealmAutenticazioneBasicWWWAuthenticateConfig_read == false){
  18651.             
  18652. //          String pNameAuth = "org.openspcoop2.pdd.core.autenticazione.basic.authType";
  18653. //          String authType = null;
  18654. //          try{  
  18655. //              authType = this.reader.getValue_convertEnvProperties(pNameAuth); 
  18656. //              if(authType!=null){
  18657. //                  authType = authType.trim();
  18658. //              }
  18659. //          }catch(java.lang.Exception e) {
  18660. //              this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameAuth+"': "+e.getMessage(),e);
  18661. //          }
  18662.             String authType = HttpConstants.AUTHENTICATION_BASIC;
  18663.             
  18664.             String pNameRealm = "org.openspcoop2.pdd.core.autenticazione.basic.realm";
  18665.             String realm = null;
  18666.             try {
  18667.                 realm = this.reader.getValueConvertEnvProperties(pNameRealm); 
  18668.                 if(realm!=null){
  18669.                     realm = realm.trim();
  18670.                 }
  18671.             }catch(java.lang.Exception e) {
  18672.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameRealm+"': "+e.getMessage(),e);
  18673.             }
  18674.             
  18675.             if(authType!=null && !"".equals(authType) && realm!=null && !"".equals(realm)) {
  18676.                 this.getRealmAutenticazioneBasicWWWAuthenticateConfig = new WWWAuthenticateConfig();
  18677.                 this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setAuthType(authType);
  18678.                 this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setRealm(realm);
  18679.                 
  18680.                 String pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.basic.error_description.notFound";
  18681.                 String error_description = null;
  18682.                 try {
  18683.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  18684.                     if(error_description!=null){
  18685.                         error_description = error_description.trim();
  18686.                         if(!"".equals(error_description)) {
  18687.                             this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setNotFound_error(WWWAuthenticateErrorCode.invalid_request.name());
  18688.                             this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setNotFound_error_description(error_description);
  18689.                         }
  18690.                     }
  18691.                 }catch(java.lang.Exception e) {
  18692.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  18693.                 }
  18694.                 
  18695.                 pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.basic.error_description.invalid";
  18696.                 error_description = null;
  18697.                 try {
  18698.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  18699.                     if(error_description!=null){
  18700.                         error_description = error_description.trim();
  18701.                         if(!"".equals(error_description)) {
  18702.                             this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setInvalid_error(WWWAuthenticateErrorCode.invalid_request.name());
  18703.                             this.getRealmAutenticazioneBasicWWWAuthenticateConfig.setInvalid_error_description(error_description);
  18704.                         }
  18705.                     }
  18706.                 }catch(java.lang.Exception e) {
  18707.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  18708.                 }
  18709.             }
  18710.             
  18711.             this.getRealmAutenticazioneBasicWWWAuthenticateConfig_read = true;
  18712.         }

  18714.         return this.getRealmAutenticazioneBasicWWWAuthenticateConfig;
  18715.     }
  18716.     
  18717.     private WWWAuthenticateConfig getRealmAutenticazioneApiKeyWWWAuthenticateConfig = null;
  18718.     private boolean getRealmAutenticazioneApiKeyWWWAuthenticateConfig_read = false;
  18719.     public WWWAuthenticateConfig getRealmAutenticazioneApiKeyWWWAuthenticateConfig() {
  18720.         if(this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig_read == false){
  18721.             
  18722.             String pNameAuth = "org.openspcoop2.pdd.core.autenticazione.apiKey.authType";
  18723.             String authType = null;
  18724.             try{  
  18725.                 authType = this.reader.getValueConvertEnvProperties(pNameAuth); 
  18726.                 if(authType!=null){
  18727.                     authType = authType.trim();
  18728.                 }
  18729.             }catch(java.lang.Exception e) {
  18730.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameAuth+"': "+e.getMessage(),e);
  18731.             }
  18732.             
  18733.             String pNameRealm = "org.openspcoop2.pdd.core.autenticazione.apiKey.realm";
  18734.             String realm = null;
  18735.             try {
  18736.                 realm = this.reader.getValueConvertEnvProperties(pNameRealm); 
  18737.                 if(realm!=null){
  18738.                     realm = realm.trim();
  18739.                 }
  18740.             }catch(java.lang.Exception e) {
  18741.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameRealm+"': "+e.getMessage(),e);
  18742.             }
  18743.             
  18744.             if(authType!=null && !"".equals(authType) && realm!=null && !"".equals(realm)) {
  18745.                 this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig = new WWWAuthenticateConfig();
  18746.                 this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setAuthType(authType);
  18747.                 this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setRealm(realm);
  18748.                 
  18749.                 String pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.apiKey.error_description.notFound";
  18750.                 String error_description = null;
  18751.                 try {
  18752.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  18753.                     if(error_description!=null){
  18754.                         error_description = error_description.trim();
  18755.                         if(!"".equals(error_description)) {
  18756.                             this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setNotFound_error(WWWAuthenticateErrorCode.invalid_request.name());
  18757.                             this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setNotFound_error_description(error_description);
  18758.                         }
  18759.                     }
  18760.                 }catch(java.lang.Exception e) {
  18761.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  18762.                 }
  18763.                 
  18764.                 pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.apiKey.error_description.invalid";
  18765.                 error_description = null;
  18766.                 try {
  18767.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  18768.                     if(error_description!=null){
  18769.                         error_description = error_description.trim();
  18770.                         if(!"".equals(error_description)) {
  18771.                             this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setInvalid_error(WWWAuthenticateErrorCode.invalid_request.name());
  18772.                             this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig.setInvalid_error_description(error_description);
  18773.                         }
  18774.                     }
  18775.                 }catch(java.lang.Exception e) {
  18776.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  18777.                 }
  18778.             }
  18779.             
  18780.             this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig_read = true;
  18781.         }

  18783.         return this.getRealmAutenticazioneApiKeyWWWAuthenticateConfig;
  18784.     }
  18785.     
  18786.     private Boolean isAutenticazioneHttpsPortaDelegataValidityCheck = null;
  18787.     public boolean isAutenticazioneHttpsPortaDelegataValidityCheck() {
  18788.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.validityCheck";
  18789.         if(this.isAutenticazioneHttpsPortaDelegataValidityCheck == null){
  18790.             try{  
  18791.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18792.                 if(value!=null){
  18793.                     value = value.trim();
  18794.                     this.isAutenticazioneHttpsPortaDelegataValidityCheck = Boolean.valueOf(value);
  18795.                 }
  18796.                 else {
  18797.                     this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
  18798.                     this.isAutenticazioneHttpsPortaDelegataValidityCheck = true;
  18799.                 }
  18800.             }catch(java.lang.Exception e) {
  18801.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
  18802.                 this.isAutenticazioneHttpsPortaDelegataValidityCheck = true;
  18803.             }
  18804.         }

  18806.         return this.isAutenticazioneHttpsPortaDelegataValidityCheck;
  18807.     }
  18808.     
  18809.     private File getAutenticazioneHttpsPortaDelegataTruststorePath = null;
  18810.     private Boolean getAutenticazioneHttpsPortaDelegataTruststorePath_read = null;
  18811.     public File getAutenticazioneHttpsPortaDelegataTruststorePath() throws CoreException {
  18812.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.path";
  18813.         if(this.getAutenticazioneHttpsPortaDelegataTruststorePath_read == null){
  18814.             try{  
  18815.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18816.                 if(value!=null){
  18817.                     value = value.trim();
  18818.                     this.getAutenticazioneHttpsPortaDelegataTruststorePath = new File(value);
  18819.                     if(this.getAutenticazioneHttpsPortaDelegataTruststorePath.exists()) {
  18820.                         if(!this.getAutenticazioneHttpsPortaDelegataTruststorePath.isFile()) {
  18821.                             throw newCoreExceptionNotFile(this.getAutenticazioneHttpsPortaDelegataTruststorePath, false);
  18822.                         }
  18823.                         if(!this.getAutenticazioneHttpsPortaDelegataTruststorePath.canRead()) {
  18824.                             throw newCoreExceptionCannotRead(this.getAutenticazioneHttpsPortaDelegataTruststorePath,false);
  18825.                         }
  18826.                     }
  18827.                     else {
  18828.                         this.getAutenticazioneHttpsPortaDelegataTruststorePath=null;
  18829.                     }
  18830.                 }
  18831.             }catch(java.lang.Exception e) {
  18832.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18833.             }
  18834.             this.getAutenticazioneHttpsPortaDelegataTruststorePath_read = true;
  18835.         }

  18837.         return this.getAutenticazioneHttpsPortaDelegataTruststorePath;
  18838.     }
  18839.     
  18840.     private String getAutenticazioneHttpsPortaDelegataTruststorePassword = null;
  18841.     private Boolean getAutenticazioneHttpsPortaDelegataTruststorePassword_read = null;
  18842.     public String getAutenticazioneHttpsPortaDelegataTruststorePassword() throws CoreException {
  18843.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.password";
  18844.         if(this.getAutenticazioneHttpsPortaDelegataTruststorePassword_read == null){
  18845.             try{  
  18846.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18847.                 if(value!=null){
  18848.                     value = value.trim();
  18849.                     this.getAutenticazioneHttpsPortaDelegataTruststorePassword = value;
  18850.                 }
  18851.             }catch(java.lang.Exception e) {
  18852.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18853.             }
  18854.             this.getAutenticazioneHttpsPortaDelegataTruststorePassword_read = true;
  18855.         }

  18857.         return this.getAutenticazioneHttpsPortaDelegataTruststorePassword;
  18858.     }
  18859.     
  18860.     private String getAutenticazioneHttpsPortaDelegataTruststoreType = null;
  18861.     public String getAutenticazioneHttpsPortaDelegataTruststoreType() throws CoreException {
  18862.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.type";
  18863.         if(this.getAutenticazioneHttpsPortaDelegataTruststoreType == null){
  18864.             try{  
  18865.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18866.                 if(value!=null){
  18867.                     value = value.trim();
  18868.                     this.getAutenticazioneHttpsPortaDelegataTruststoreType = value;
  18869.                 }
  18870.                 else {
  18871.                     this.getAutenticazioneHttpsPortaDelegataTruststoreType = KeystoreType.JKS.getNome();
  18872.                 }
  18873.             }catch(java.lang.Exception e) {
  18874.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18875.             }
  18876.         }

  18878.         return this.getAutenticazioneHttpsPortaDelegataTruststoreType;
  18879.     }
  18880.     
  18881.     private String getAutenticazioneHttpsPortaDelegataTruststoreCRLs = null;
  18882.     private Boolean getAutenticazioneHttpsPortaDelegataTruststoreCRLs_read = null;
  18883.     public String getAutenticazioneHttpsPortaDelegataTruststoreCRLs() throws CoreException {
  18884.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.crls";
  18885.         if(this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs_read == null){
  18886.             try{  
  18887.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18888.                 if(value!=null){
  18889.                     value = value.trim();
  18890.                     this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs = value;
  18891.                 }
  18892.             }catch(java.lang.Exception e) {
  18893.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18894.             }
  18895.             this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs_read = true;
  18896.         }

  18898.         return this.getAutenticazioneHttpsPortaDelegataTruststoreCRLs;
  18899.     }
  18900.     
  18901.     private String getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy = null;
  18902.     private Boolean getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy_read = null;
  18903.     public String getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy() throws CoreException {
  18904.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneContenutiApplicativi.truststore.ocspPolicy";
  18905.         if(this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy_read == null){
  18906.             try{  
  18907.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18908.                 if(value!=null){
  18909.                     value = value.trim();
  18910.                     this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy = value;
  18911.                 }
  18912.             }catch(java.lang.Exception e) {
  18913.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18914.             }
  18915.             this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy_read = true;
  18916.         }

  18918.         return this.getAutenticazioneHttpsPortaDelegataTruststoreOCSPPolicy;
  18919.     }
  18920.     
  18921.     private Boolean isAutenticazioneHttpsPortaApplicativaValidityCheck = null;
  18922.     public boolean isAutenticazioneHttpsPortaApplicativaValidityCheck() {
  18923.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.validityCheck";
  18924.         if(this.isAutenticazioneHttpsPortaApplicativaValidityCheck == null){
  18925.             try{  
  18926.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18927.                 if(value!=null){
  18928.                     value = value.trim();
  18929.                     this.isAutenticazioneHttpsPortaApplicativaValidityCheck = Boolean.valueOf(value);
  18930.                 }
  18931.                 else {
  18932.                     this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
  18933.                     this.isAutenticazioneHttpsPortaApplicativaValidityCheck = true;
  18934.                 }
  18935.             }catch(java.lang.Exception e) {
  18936.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
  18937.                 this.isAutenticazioneHttpsPortaApplicativaValidityCheck = true;
  18938.             }
  18939.         }

  18941.         return this.isAutenticazioneHttpsPortaApplicativaValidityCheck;
  18942.     }
  18943.     
  18944.     private File getAutenticazioneHttpsPortaApplicativaTruststorePath = null;
  18945.     private Boolean getAutenticazioneHttpsPortaApplicativaTruststorePath_read = null;
  18946.     public File getAutenticazioneHttpsPortaApplicativaTruststorePath() throws CoreException {
  18947.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.path";
  18948.         if(this.getAutenticazioneHttpsPortaApplicativaTruststorePath_read == null){
  18949.             try{  
  18950.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18951.                 if(value!=null){
  18952.                     value = value.trim();
  18953.                     this.getAutenticazioneHttpsPortaApplicativaTruststorePath = new File(value);
  18954.                     if(this.getAutenticazioneHttpsPortaApplicativaTruststorePath.exists()) {
  18955.                         if(!this.getAutenticazioneHttpsPortaApplicativaTruststorePath.isFile()) {
  18956.                             throw newCoreExceptionNotFile(this.getAutenticazioneHttpsPortaApplicativaTruststorePath, false);
  18957.                         }
  18958.                         if(!this.getAutenticazioneHttpsPortaApplicativaTruststorePath.canRead()) {
  18959.                             throw newCoreExceptionCannotRead(this.getAutenticazioneHttpsPortaApplicativaTruststorePath, false);
  18960.                         }
  18961.                     }
  18962.                     else {
  18963.                         this.getAutenticazioneHttpsPortaApplicativaTruststorePath=null;
  18964.                     }
  18965.                 }
  18966.             }catch(java.lang.Exception e) {
  18967.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18968.             }
  18969.             this.getAutenticazioneHttpsPortaApplicativaTruststorePath_read = true;
  18970.         }

  18972.         return this.getAutenticazioneHttpsPortaApplicativaTruststorePath;
  18973.     }
  18974.     
  18975.     private String getAutenticazioneHttpsPortaApplicativaTruststorePassword = null;
  18976.     private Boolean getAutenticazioneHttpsPortaApplicativaTruststorePassword_read = null;
  18977.     public String getAutenticazioneHttpsPortaApplicativaTruststorePassword() throws CoreException {
  18978.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.password";
  18979.         if(this.getAutenticazioneHttpsPortaApplicativaTruststorePassword_read == null){
  18980.             try{  
  18981.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  18982.                 if(value!=null){
  18983.                     value = value.trim();
  18984.                     this.getAutenticazioneHttpsPortaApplicativaTruststorePassword = value;
  18985.                 }
  18986.             }catch(java.lang.Exception e) {
  18987.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  18988.             }
  18989.             this.getAutenticazioneHttpsPortaApplicativaTruststorePassword_read = true;
  18990.         }

  18992.         return this.getAutenticazioneHttpsPortaApplicativaTruststorePassword;
  18993.     }
  18994.     
  18995.     private String getAutenticazioneHttpsPortaApplicativaTruststoreType = null;
  18996.     public String getAutenticazioneHttpsPortaApplicativaTruststoreType() throws CoreException {
  18997.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.type";
  18998.         if(this.getAutenticazioneHttpsPortaApplicativaTruststoreType == null){
  18999.             try{  
  19000.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  19001.                 if(value!=null){
  19002.                     value = value.trim();
  19003.                     this.getAutenticazioneHttpsPortaApplicativaTruststoreType = value;
  19004.                 }
  19005.                 else {
  19006.                     this.getAutenticazioneHttpsPortaApplicativaTruststoreType = KeystoreType.JKS.getNome();
  19007.                 }
  19008.             }catch(java.lang.Exception e) {
  19009.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  19010.             }
  19011.         }

  19013.         return this.getAutenticazioneHttpsPortaApplicativaTruststoreType;
  19014.     }
  19015.     
  19016.     private String getAutenticazioneHttpsPortaApplicativaTruststoreCRLs = null;
  19017.     private Boolean getAutenticazioneHttpsPortaApplicativaTruststoreCRLs_read = null;
  19018.     public String getAutenticazioneHttpsPortaApplicativaTruststoreCRLs() throws CoreException {
  19019.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.crls";
  19020.         if(this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs_read == null){
  19021.             try{  
  19022.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  19023.                 if(value!=null){
  19024.                     value = value.trim();
  19025.                     this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs = value;
  19026.                 }
  19027.             }catch(java.lang.Exception e) {
  19028.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  19029.             }
  19030.             this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs_read = true;
  19031.         }

  19033.         return this.getAutenticazioneHttpsPortaApplicativaTruststoreCRLs;
  19034.     }
  19035.     
  19036.     private String getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy = null;
  19037.     private Boolean getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy_read = null;
  19038.     public String getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy() throws CoreException {
  19039.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.ricezioneBuste.truststore.ocspPolicy";
  19040.         if(this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy_read == null){
  19041.             try{  
  19042.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  19043.                 if(value!=null){
  19044.                     value = value.trim();
  19045.                     this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy = value;
  19046.                 }
  19047.             }catch(java.lang.Exception e) {
  19048.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  19049.             }
  19050.             this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy_read = true;
  19051.         }

  19053.         return this.getAutenticazioneHttpsPortaApplicativaTruststoreOCSPPolicy;
  19054.     }
  19055.     
  19056.     
  19057.     private Boolean isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari = null;
  19058.     public boolean isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari() {
  19059.         String pName = "org.openspcoop2.pdd.core.autenticazione.https.portaDelegata.checkSoggettiProprietari";
  19060.         if(this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari == null){
  19061.             try{  
  19062.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  19063.                 if(value!=null){
  19064.                     value = value.trim();
  19065.                     this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari = Boolean.valueOf(value);
  19066.                 }
  19067.                 else {
  19068.                     this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
  19069.                     this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari = true;
  19070.                 }
  19071.             }catch(java.lang.Exception e) {
  19072.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
  19073.                 this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari = true;
  19074.             }
  19075.         }

  19077.         return this.isAutenticazioneHttpsPortaDelegataCheckSoggettiProprietari;
  19078.     }
  19079.     
  19080.     private WWWAuthenticateConfig getRealmAutenticazioneHttpsWWWAuthenticateConfig = null;
  19081.     private boolean getRealmAutenticazioneHttpsWWWAuthenticateConfig_read = false;
  19082.     public WWWAuthenticateConfig getRealmAutenticazioneHttpsWWWAuthenticateConfig() {
  19083.         if(this.getRealmAutenticazioneHttpsWWWAuthenticateConfig_read == false){
  19084.             
  19085.             String pNameAuth = "org.openspcoop2.pdd.core.autenticazione.https.authType";
  19086.             String authType = null;
  19087.             try{  
  19088.                 authType = this.reader.getValueConvertEnvProperties(pNameAuth); 
  19089.                 if(authType!=null){
  19090.                     authType = authType.trim();
  19091.                 }
  19092.             }catch(java.lang.Exception e) {
  19093.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameAuth+"': "+e.getMessage(),e);
  19094.             }
  19095.             
  19096.             String pNameRealm = "org.openspcoop2.pdd.core.autenticazione.https.realm";
  19097.             String realm = null;
  19098.             try {
  19099.                 realm = this.reader.getValueConvertEnvProperties(pNameRealm); 
  19100.                 if(realm!=null){
  19101.                     realm = realm.trim();
  19102.                 }
  19103.             }catch(java.lang.Exception e) {
  19104.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameRealm+"': "+e.getMessage(),e);
  19105.             }
  19106.             
  19107.             if(authType!=null && !"".equals(authType) && realm!=null && !"".equals(realm)) {
  19108.                 this.getRealmAutenticazioneHttpsWWWAuthenticateConfig = new WWWAuthenticateConfig();
  19109.                 this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setAuthType(authType);
  19110.                 this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setRealm(realm);
  19111.                 
  19112.                 String pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.https.error_description.notFound";
  19113.                 String error_description = null;
  19114.                 try {
  19115.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  19116.                     if(error_description!=null){
  19117.                         error_description = error_description.trim();
  19118.                         if(!"".equals(error_description)) {
  19119.                             this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setNotFound_error(WWWAuthenticateErrorCode.invalid_request.name());
  19120.                             this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setNotFound_error_description(error_description);
  19121.                         }
  19122.                     }
  19123.                 }catch(java.lang.Exception e) {
  19124.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  19125.                 }
  19126.                 
  19127.                 pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.https.error_description.invalid";
  19128.                 error_description = null;
  19129.                 try {
  19130.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  19131.                     if(error_description!=null){
  19132.                         error_description = error_description.trim();
  19133.                         if(!"".equals(error_description)) {
  19134.                             this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setInvalid_error(WWWAuthenticateErrorCode.invalid_request.name());
  19135.                             this.getRealmAutenticazioneHttpsWWWAuthenticateConfig.setInvalid_error_description(error_description);
  19136.                         }
  19137.                     }
  19138.                 }catch(java.lang.Exception e) {
  19139.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  19140.                 }
  19141.             }
  19142.             
  19143.             this.getRealmAutenticazioneHttpsWWWAuthenticateConfig_read = true;
  19144.         }

  19146.         return this.getRealmAutenticazioneHttpsWWWAuthenticateConfig;
  19147.     }
  19148.     
  19149.     private Boolean isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari = null;
  19150.     public boolean isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari() {
  19151.         String pName = "org.openspcoop2.pdd.core.autenticazione.principal.portaDelegata.checkSoggettiProprietari";
  19152.         if(this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari == null){
  19153.             try{  
  19154.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  19155.                 if(value!=null){
  19156.                     value = value.trim();
  19157.                     this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari = Boolean.valueOf(value);
  19158.                 }
  19159.                 else {
  19160.                     this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
  19161.                     this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari = true;
  19162.                 }
  19163.             }catch(java.lang.Exception e) {
  19164.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
  19165.                 this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari = true;
  19166.             }
  19167.         }

  19169.         return this.isAutenticazionePrincipalPortaDelegataCheckSoggettiProprietari;
  19170.     }
  19171.     
  19172.     private Map<TipoAutenticazionePrincipal, WWWAuthenticateConfig> getRealmAutenticazionePrincipalWWWAuthenticateConfig = new HashMap<TipoAutenticazionePrincipal, WWWAuthenticateConfig>();
  19173.     public WWWAuthenticateConfig getRealmAutenticazionePrincipalWWWAuthenticateConfig(TipoAutenticazionePrincipal principal) {
  19174.         if(!this.getRealmAutenticazionePrincipalWWWAuthenticateConfig.containsKey(principal)){
  19175.             
  19176.             String pNameAuth = "org.openspcoop2.pdd.core.autenticazione.principal."+principal.getValue()+".authType";
  19177.             String authType = null;
  19178.             try{  
  19179.                 authType = this.reader.getValueConvertEnvProperties(pNameAuth); 
  19180.                 if(authType!=null){
  19181.                     authType = authType.trim();
  19182.                 }
  19183.             }catch(java.lang.Exception e) {
  19184.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameAuth+"': "+e.getMessage(),e);
  19185.             }
  19186.             
  19187.             String pNameRealm = "org.openspcoop2.pdd.core.autenticazione.principal."+principal.getValue()+".realm";
  19188.             String realm = null;
  19189.             try {
  19190.                 realm = this.reader.getValueConvertEnvProperties(pNameRealm); 
  19191.                 if(realm!=null){
  19192.                     realm = realm.trim();
  19193.                 }
  19194.             }catch(java.lang.Exception e) {
  19195.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameRealm+"': "+e.getMessage(),e);
  19196.             }
  19197.             
  19198.             WWWAuthenticateConfig wwwConfig = null;
  19199.             if(authType!=null && !"".equals(authType) && realm!=null && !"".equals(realm)) {
  19200.                 
  19201.                 wwwConfig = new WWWAuthenticateConfig();
  19202.                 wwwConfig.setAuthType(authType);
  19203.                 wwwConfig.setRealm(realm);
  19204.                 
  19205.                 String pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.principal."+principal.getValue()+".error_description.notFound";
  19206.                 String error_description = null;
  19207.                 try {
  19208.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  19209.                     if(error_description!=null){
  19210.                         error_description = error_description.trim();
  19211.                         if(!"".equals(error_description)) {
  19212.                             wwwConfig.setNotFound_error(WWWAuthenticateErrorCode.invalid_request.name());
  19213.                             wwwConfig.setNotFound_error_description(error_description);
  19214.                         }
  19215.                     }
  19216.                 }catch(java.lang.Exception e) {
  19217.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  19218.                 }
  19219.                 
  19220.                 pNameErrorDescription = "org.openspcoop2.pdd.core.autenticazione.principal."+principal.getValue()+".error_description.invalid";
  19221.                 error_description = null;
  19222.                 try {
  19223.                     error_description = this.reader.getValueConvertEnvProperties(pNameErrorDescription); 
  19224.                     if(error_description!=null){
  19225.                         error_description = error_description.trim();
  19226.                         if(!"".equals(error_description)) {
  19227.                             wwwConfig.setInvalid_error(WWWAuthenticateErrorCode.invalid_request.name());
  19228.                             wwwConfig.setInvalid_error_description(error_description);
  19229.                         }
  19230.                     }
  19231.                 }catch(java.lang.Exception e) {
  19232.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pNameErrorDescription+"': "+e.getMessage(),e);
  19233.                 }
  19234.                 
  19235.             }
  19236.             
  19237.             this.getRealmAutenticazionePrincipalWWWAuthenticateConfig.put(principal, wwwConfig);
  19238.         }

  19240.         return this.getRealmAutenticazionePrincipalWWWAuthenticateConfig.get(principal);
  19241.     }
  19242.     
  19243.     private Boolean isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari = null;
  19244.     public boolean isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari() {
  19245.         String pName = "org.openspcoop2.pdd.core.autenticazione.token.portaDelegata.checkSoggettiProprietari";
  19246.         if(this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari == null){
  19247.             try{  
  19248.                 String value = this.reader.getValueConvertEnvProperties(pName); 
  19249.                 if(value!=null){
  19250.                     value = value.trim();
  19251.                     this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari = Boolean.valueOf(value);
  19252.                 }
  19253.                 else {
  19254.                     this.logError("Proprieta' di openspcoop '"+pName+"' non definita; viene usato il default=true");
  19255.                     this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari = true;
  19256.                 }
  19257.             }catch(java.lang.Exception e) {
  19258.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default=true. Errore: "+e.getMessage(),e);
  19259.                 this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari = true;
  19260.             }
  19261.         }

  19263.         return this.isAutenticazioneTokenPortaDelegataCheckSoggettiProprietari;
  19264.     }
  19265.     
  19266.     /**
  19267.      * Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare lato Porta Delegata
  19268.      * 
  19269.      * @return Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare lato Porta Delegata
  19270.      */
  19271.     private String[] tipoGestoreCredenzialiPD = null;
  19272.     private boolean tipoGestoreCredenzialiPDRead = false;
  19273.     public String[] getTipoGestoreCredenzialiPD() {
  19274.         if(this.tipoGestoreCredenzialiPDRead == false){
  19275.             try{  
  19276.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.pd.gestoriCredenziali"); 
  19277.                 if(value!=null){
  19278.                     value = value.trim();
  19279.                     String [] r = value.split(",");
  19280.                     this.tipoGestoreCredenzialiPD = r;
  19281.                 }
  19282.             }catch(java.lang.Exception e) {
  19283.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.services.pd.gestoriCredenziali': "+e.getMessage(),e);
  19284.                 this.tipoGestoreCredenzialiPD = null;
  19285.             }
  19286.             this.tipoGestoreCredenzialiPDRead = true;
  19287.         }

  19289.         return this.tipoGestoreCredenzialiPD;
  19290.     }
  19291.     
  19292.     /**
  19293.      * Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare lato Porta Applicativa
  19294.      * 
  19295.      * @return Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare lato Porta Applicativa
  19296.      */
  19297.     private String[] tipoGestoreCredenzialiPA = null;
  19298.     private boolean tipoGestoreCredenzialiPARead = false;
  19299.     public String[] getTipoGestoreCredenzialiPA() {
  19300.         if(this.tipoGestoreCredenzialiPARead == false){
  19301.             try{  
  19302.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.pa.gestoriCredenziali"); 
  19303.                 if(value!=null){
  19304.                     value = value.trim();
  19305.                     String [] r = value.split(",");
  19306.                     this.tipoGestoreCredenzialiPA = r;
  19307.                 }
  19308.             }catch(java.lang.Exception e) {
  19309.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.services.pa.gestoriCredenziali': "+e.getMessage(),e);
  19310.                 this.tipoGestoreCredenzialiPA = null;
  19311.             }
  19312.             this.tipoGestoreCredenzialiPARead = true;
  19313.         }

  19315.         return this.tipoGestoreCredenzialiPA;
  19316.     }
  19317.     
  19318.     /**
  19319.      * Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare sul servizio di IntegrationManager
  19320.      * 
  19321.      * @return Restituisce l'elenco dei tipi di gestori di credenziali da utilizzare sul servizio di IntegrationManager
  19322.      */
  19323.     private String[] tipoGestoreCredenzialiIM = null;
  19324.     private boolean tipoGestoreCredenzialiIMRead = false;
  19325.     public String[] getTipoGestoreCredenzialiIM() {
  19326.         if(this.tipoGestoreCredenzialiIMRead == false){
  19327.             try{  
  19328.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.services.integrationManager.gestoriCredenziali"); 
  19329.                 if(value!=null){
  19330.                     value = value.trim();
  19331.                     String [] r = value.split(",");
  19332.                     this.tipoGestoreCredenzialiIM = r;
  19333.                 }
  19334.             }catch(java.lang.Exception e) {
  19335.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.services.integrationManager.gestoriCredenziali': "+e.getMessage(),e);
  19336.                 this.tipoGestoreCredenzialiIM = null;
  19337.             }
  19338.             this.tipoGestoreCredenzialiIMRead = true;
  19339.         }

  19341.         return this.tipoGestoreCredenzialiIM;
  19342.     }
  19343.     
  19344.     
  19345.     
  19346.     
  19347.     
  19348.     




  19353.     /* ----------- Accesso Registro Servizi --------------------- */
  19354.     /**
  19355.      * Indicazione se la porta di dominio deve processare gli accordi di servizio, i servizi e i fruitori ancora in stato di bozza
  19356.      *   
  19357.      * @return Indicazione se la porta di dominio deve processare gli accordi di servizio, i servizi e i fruitori ancora in stato di bozza
  19358.      * 
  19359.      */
  19360.     private Boolean isReadObjectStatoBozza = null;
  19361.     public boolean isReadObjectStatoBozza(){

  19363.         if(this.isReadObjectStatoBozza==null){
  19364.             try{  
  19365.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.registroServizi.readObjectStatoBozza"); 

  19367.                 if (value != null){
  19368.                     value = value.trim();
  19369.                     this.isReadObjectStatoBozza = Boolean.parseBoolean(value);
  19370.                 }else{
  19371.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.registroServizi.readObjectStatoBozza' non impostata, viene utilizzato il default=true");
  19372.                     this.isReadObjectStatoBozza = false;
  19373.                 }

  19375.             }catch(java.lang.Exception e) {
  19376.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.registroServizi.readObjectStatoBozza' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  19377.                 this.isReadObjectStatoBozza = false;
  19378.             }
  19379.         }

  19381.         return this.isReadObjectStatoBozza;
  19382.     }
  19383.     
  19384.     
  19385.     
  19386.     
  19387.     
  19388.     
  19389.     /* ----------- Tracce --------------------- */
  19390.     /**
  19391.      * Indicazione se la porta di dominio deve generare un errore in caso di tracciamento non riuscito
  19392.      *   
  19393.      * @return Indicazione se la porta di dominio deve generare un errore in caso di tracciamento non riuscito
  19394.      * 
  19395.      */
  19396.     private Boolean isTracciaturaFallita_BloccaCooperazioneInCorso = null;
  19397.     public boolean isTracciaturaFallita_BloccaCooperazioneInCorso(){

  19399.         if(this.isTracciaturaFallita_BloccaCooperazioneInCorso==null){
  19400.             try{  
  19401.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.tracciamento.registrazioneFallita.bloccaCooperazioneInCorso"); 

  19403.                 if (value != null){
  19404.                     value = value.trim();
  19405.                     this.isTracciaturaFallita_BloccaCooperazioneInCorso = Boolean.parseBoolean(value);
  19406.                 }else{
  19407.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.tracciamento.registrazioneFallita.bloccaCooperazioneInCorso' non impostata, viene utilizzato il default=true");
  19408.                     this.isTracciaturaFallita_BloccaCooperazioneInCorso = true;
  19409.                 }

  19411.             }catch(java.lang.Exception e) {
  19412.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.tracciamento.registrazioneFallita.bloccaCooperazioneInCorso' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  19413.                 this.isTracciaturaFallita_BloccaCooperazioneInCorso = true;
  19414.             }
  19415.         }

  19417.         return this.isTracciaturaFallita_BloccaCooperazioneInCorso;
  19418.     }
  19419.     /**
  19420.      * 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.
  19421.      *   
  19422.      * @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.
  19423.      * 
  19424.      */
  19425.     private Boolean isTracciaturaFallita_BloccoServiziPdD = null;
  19426.     public boolean isTracciaturaFallita_BloccoServiziPdD(){

  19428.         if(this.isTracciaturaFallita_BloccoServiziPdD==null){
  19429.             try{  
  19430.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.tracciamento.registrazione.bloccoServiziPdD"); 

  19432.                 if (value != null){
  19433.                     value = value.trim();
  19434.                     this.isTracciaturaFallita_BloccoServiziPdD = Boolean.parseBoolean(value);
  19435.                 }else{
  19436.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.tracciamento.registrazione.bloccoServiziPdD' non impostata, viene utilizzato il default=false");
  19437.                     this.isTracciaturaFallita_BloccoServiziPdD = false;
  19438.                 }

  19440.             }catch(java.lang.Exception e) {
  19441.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.tracciamento.registrazione.bloccoServiziPdD' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  19442.                 this.isTracciaturaFallita_BloccoServiziPdD = false;
  19443.             }
  19444.         }

  19446.         return this.isTracciaturaFallita_BloccoServiziPdD;
  19447.     }
  19448.     
  19449.     
  19450.     
  19451.     
  19452.     
  19453.     
  19454.     
  19455.     
  19456.     
  19457.     
  19458.     
  19459.     /* ----------- MsgDiagnostici --------------------- */
  19460.     
  19461.     private Boolean isRegistrazioneDiagnosticaFile_intestazione_formatValues = null;
  19462.     public boolean isRegistrazioneDiagnosticaFile_intestazione_formatValues(){

  19464.         if(this.isRegistrazioneDiagnosticaFile_intestazione_formatValues==null){
  19465.             try{  
  19466.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.msgDiagnostici.file.header.formatValues"); 

  19468.                 if (value != null){
  19469.                     value = value.trim();
  19470.                     this.isRegistrazioneDiagnosticaFile_intestazione_formatValues = Boolean.parseBoolean(value);
  19471.                 }else{
  19472.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.msgDiagnostici.file.header.formatValues' non impostata, viene utilizzato il default=true");
  19473.                     this.isRegistrazioneDiagnosticaFile_intestazione_formatValues = true;
  19474.                 }

  19476.             }catch(java.lang.Exception e) {
  19477.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.msgDiagnostici.file.header.formatValues' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  19478.                 this.isRegistrazioneDiagnosticaFile_intestazione_formatValues = true;
  19479.             }
  19480.         }

  19482.         return this.isRegistrazioneDiagnosticaFile_intestazione_formatValues;
  19483.     }
  19484.     
  19485.     /**
  19486.      * 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.
  19487.      *   
  19488.      * @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.
  19489.      * 
  19490.      */
  19491.     private Boolean isRegistrazioneDiagnosticaFallita_BloccoServiziPdD = null;
  19492.     public boolean isRegistrazioneDiagnosticaFallita_BloccoServiziPdD(){

  19494.         if(this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD==null){
  19495.             try{  
  19496.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.msgDiagnostici.emissioneFallita.bloccoServiziPdD"); 

  19498.                 if (value != null){
  19499.                     value = value.trim();
  19500.                     this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD = Boolean.parseBoolean(value);
  19501.                 }else{
  19502.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.msgDiagnostici.emissioneFallita.bloccoServiziPdD' non impostata, viene utilizzato il default=false");
  19503.                     this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD = false;
  19504.                 }

  19506.             }catch(java.lang.Exception e) {
  19507.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.msgDiagnostici.emissioneFallita.bloccoServiziPdD' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  19508.                 this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD = false;
  19509.             }
  19510.         }

  19512.         return this.isRegistrazioneDiagnosticaFallita_BloccoServiziPdD;
  19513.     }
  19514.     
  19515.     private Boolean isLoggerSaajDisabilitato = null;
  19516.     public boolean isLoggerSaajDisabilitato(){

  19518.         if(this.isLoggerSaajDisabilitato==null){
  19519.             try{  
  19520.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.com.sun.xml.messaging.saaj.disabled"); 

  19522.                 if (value != null){
  19523.                     value = value.trim();
  19524.                     this.isLoggerSaajDisabilitato = Boolean.parseBoolean(value);
  19525.                 }else{
  19526.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.com.sun.xml.messaging.saaj.disabled' non impostata, viene utilizzato il default=true");
  19527.                     this.isLoggerSaajDisabilitato = true;
  19528.                 }

  19530.             }catch(java.lang.Exception e) {
  19531.                 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);
  19532.                 this.isLoggerSaajDisabilitato = true;
  19533.             }
  19534.         }

  19536.         return this.isLoggerSaajDisabilitato;
  19537.     }
  19538.     
  19539.     
  19540.     
  19541.     
  19542.     
  19543.     
  19544.     
  19545.     
  19546.     /* ----------- Dump --------------------- */
  19547.     
  19548.     private String getDumpBufferImpl = null;
  19549.     private Boolean getDumpBufferImplRead = null;
  19550.     public String getDumpBufferImpl() { 
  19551.         if(this.getDumpBufferImplRead==null){
  19552.             String pName = "org.openspcoop2.pdd.logger.dump.buffer.impl";
  19553.             
  19554.             try{ 
  19555.                 String name = null;
  19556.                 name = this.reader.getValueConvertEnvProperties(pName);
  19557.                 if(name!=null){
  19558.                     name = name.trim();
  19559.                     this.getDumpBufferImpl = name;
  19560.                 }
  19561.                 
  19562.                 this.getDumpBufferImplRead = true;
  19563.                 
  19564.             } catch(java.lang.Exception e) {
  19565.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  19566.             }    
  19567.         }

  19569.         return this.getDumpBufferImpl;
  19570.     }
  19571.     
  19572.     /**
  19573.      * Indicazione se la porta di dominio deve registrare tutti gli attachments (in caso di dump abilitato) o solo quelli "visualizzabili"
  19574.      *   
  19575.      * @return Indicazione se la porta di dominio deve registrare tutti gli attachments (in caso di dump abilitato) o solo quelli "visualizzabili"
  19576.      * 
  19577.      */
  19578.     private Boolean isDumpAllAttachments = null;
  19579.     public boolean isDumpAllAttachments(){

  19581.         if(this.isDumpAllAttachments==null){
  19582.             try{  
  19583.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.dump.allAttachments"); 

  19585.                 if (value != null){
  19586.                     value = value.trim();
  19587.                     this.isDumpAllAttachments = Boolean.parseBoolean(value);
  19588.                 }else{
  19589.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.allAttachments' non impostata, viene utilizzato il default=true");
  19590.                     this.isDumpAllAttachments = true;
  19591.                 }

  19593.             }catch(java.lang.Exception e) {
  19594.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.registroServizi.readObjectStatoBozza' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  19595.                 this.isDumpAllAttachments = true;
  19596.             }
  19597.         }

  19599.         return this.isDumpAllAttachments;
  19600.     }
  19601.     
  19602.     /**
  19603.      * 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
  19604.      *   
  19605.      * @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
  19606.      * 
  19607.      */
  19608.     private Boolean isDumpFallitoBloccaCooperazioneInCorso = null;
  19609.     public boolean isDumpFallitoBloccaCooperazioneInCorso(){

  19611.         if(this.isDumpFallitoBloccaCooperazioneInCorso==null){
  19612.             try{  
  19613.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.dump.registrazioneFallita.bloccaCooperazioneInCorso"); 

  19615.                 if (value != null){
  19616.                     value = value.trim();
  19617.                     this.isDumpFallitoBloccaCooperazioneInCorso = Boolean.parseBoolean(value);
  19618.                 }else{
  19619.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.registrazioneFallita.bloccaCooperazioneInCorso' non impostata, viene utilizzato il default=false");
  19620.                     this.isDumpFallitoBloccaCooperazioneInCorso = false;
  19621.                 }

  19623.             }catch(java.lang.Exception e) {
  19624.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.registrazioneFallita.bloccaCooperazioneInCorso' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  19625.                 this.isDumpFallitoBloccaCooperazioneInCorso = false;
  19626.             }
  19627.         }

  19629.         return this.isDumpFallitoBloccaCooperazioneInCorso;
  19630.     }
  19631.     /**
  19632.      * 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.
  19633.      *   
  19634.      * @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.
  19635.      * 
  19636.      */
  19637.     private Boolean isDumpFallitoBloccoServiziPdD = null;
  19638.     public boolean isDumpFallitoBloccoServiziPdD(){

  19640.         if(this.isDumpFallitoBloccoServiziPdD==null){
  19641.             try{  
  19642.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.dump.registrazione.bloccoServiziPdD"); 

  19644.                 if (value != null){
  19645.                     value = value.trim();
  19646.                     this.isDumpFallitoBloccoServiziPdD = Boolean.parseBoolean(value);
  19647.                 }else{
  19648.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.registrazione.bloccoServiziPdD' non impostata, viene utilizzato il default=false");
  19649.                     this.isDumpFallitoBloccoServiziPdD = false;
  19650.                 }

  19652.             }catch(java.lang.Exception e) {
  19653.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dump.registrazione.bloccoServiziPdD' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  19654.                 this.isDumpFallitoBloccoServiziPdD = false;
  19655.             }
  19656.         }

  19658.         return this.isDumpFallitoBloccoServiziPdD;
  19659.     }

  19661.     private List<String> getDumpHeaderWhiteList = null;
  19662.     public List<String> getDumpHeaderWhiteList(){

  19664.         if(this.getDumpHeaderWhiteList==null){
  19665.             String pName = "org.openspcoop2.pdd.logger.dump.header.whiteList";
  19666.             try{
  19667.                 this.getDumpHeaderWhiteList = new ArrayList<>();
  19668.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19669.                 initDumpList(this.getDumpHeaderWhiteList, tmp);
  19670.             }catch(java.lang.Exception e) {
  19671.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19672.             }
  19673.         }

  19675.         return this.getDumpHeaderWhiteList;
  19676.     }
  19677.     
  19678.     private List<String> getDumpHeaderBlackList = null;
  19679.     public List<String> getDumpHeaderBlackList(){

  19681.         if(this.getDumpHeaderBlackList==null){
  19682.             String pName = "org.openspcoop2.pdd.logger.dump.header.blackList";
  19683.             try{
  19684.                 this.getDumpHeaderBlackList = new ArrayList<>();
  19685.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19686.                 initDumpList(this.getDumpHeaderBlackList, tmp);
  19687.             }catch(java.lang.Exception e) {
  19688.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19689.             }
  19690.         }

  19692.         return this.getDumpHeaderBlackList;
  19693.     }
  19694.     
  19695.     private List<String> getDumpHeaderErogazioniWhiteList = null;
  19696.     public List<String> getDumpHeaderErogazioniWhiteList(){

  19698.         if(this.getDumpHeaderErogazioniWhiteList==null){
  19699.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.whiteList";
  19700.             try{
  19701.                 this.getDumpHeaderErogazioniWhiteList = new ArrayList<>();
  19702.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19703.                 initDumpList(this.getDumpHeaderErogazioniWhiteList, tmp);
  19704.             }catch(java.lang.Exception e) {
  19705.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19706.             }
  19707.         }

  19709.         return this.getDumpHeaderErogazioniWhiteList;
  19710.     }
  19711.     
  19712.     private List<String> getDumpHeaderErogazioniBlackList = null;
  19713.     public List<String> getDumpHeaderErogazioniBlackList(){

  19715.         if(this.getDumpHeaderErogazioniBlackList==null){
  19716.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.blackList";
  19717.             try{
  19718.                 this.getDumpHeaderErogazioniBlackList = new ArrayList<>();
  19719.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19720.                 initDumpList(this.getDumpHeaderErogazioniBlackList, tmp);
  19721.             }catch(java.lang.Exception e) {
  19722.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19723.             }
  19724.         }

  19726.         return this.getDumpHeaderErogazioniBlackList;
  19727.     }
  19728.     
  19729.     private List<String> getDumpHeaderFruizioniWhiteList = null;
  19730.     public List<String> getDumpHeaderFruizioniWhiteList(){

  19732.         if(this.getDumpHeaderFruizioniWhiteList==null){
  19733.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.whiteList";
  19734.             try{
  19735.                 this.getDumpHeaderFruizioniWhiteList = new ArrayList<>();
  19736.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19737.                 initDumpList(this.getDumpHeaderFruizioniWhiteList, tmp);
  19738.             }catch(java.lang.Exception e) {
  19739.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19740.             }
  19741.         }

  19743.         return this.getDumpHeaderFruizioniWhiteList;
  19744.     }
  19745.     
  19746.     private List<String> getDumpHeaderFruizioniBlackList = null;
  19747.     public List<String> getDumpHeaderFruizioniBlackList(){

  19749.         if(this.getDumpHeaderFruizioniBlackList==null){
  19750.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.blackList";
  19751.             try{
  19752.                 this.getDumpHeaderFruizioniBlackList = new ArrayList<>();
  19753.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19754.                 initDumpList(this.getDumpHeaderFruizioniBlackList, tmp);
  19755.             }catch(java.lang.Exception e) {
  19756.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19757.             }
  19758.         }

  19760.         return this.getDumpHeaderFruizioniBlackList;
  19761.     }
  19762.     
  19763.     private List<String> getDumpHeaderErogazioniRichiestaIngressoWhiteList = null;
  19764.     public List<String> getDumpHeaderErogazioniRichiestaIngressoWhiteList(){

  19766.         if(this.getDumpHeaderErogazioniRichiestaIngressoWhiteList==null){
  19767.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.richiesta-ingresso.whiteList";
  19768.             try{
  19769.                 this.getDumpHeaderErogazioniRichiestaIngressoWhiteList = new ArrayList<>();
  19770.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19771.                 initDumpList(this.getDumpHeaderErogazioniRichiestaIngressoWhiteList, tmp);
  19772.             }catch(java.lang.Exception e) {
  19773.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19774.             }
  19775.         }

  19777.         return this.getDumpHeaderErogazioniRichiestaIngressoWhiteList;
  19778.     }
  19779.     
  19780.     private List<String> getDumpHeaderErogazioniRichiestaIngressoBlackList = null;
  19781.     public List<String> getDumpHeaderErogazioniRichiestaIngressoBlackList(){

  19783.         if(this.getDumpHeaderErogazioniRichiestaIngressoBlackList==null){
  19784.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.richiesta-ingresso.blackList";
  19785.             try{
  19786.                 this.getDumpHeaderErogazioniRichiestaIngressoBlackList = new ArrayList<>();
  19787.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19788.                 initDumpList(this.getDumpHeaderErogazioniRichiestaIngressoBlackList, tmp);
  19789.             }catch(java.lang.Exception e) {
  19790.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19791.             }
  19792.         }

  19794.         return this.getDumpHeaderErogazioniRichiestaIngressoBlackList;
  19795.     }
  19796.     
  19797.     private List<String> getDumpHeaderErogazioniRichiestaUscitaWhiteList = null;
  19798.     public List<String> getDumpHeaderErogazioniRichiestaUscitaWhiteList(){

  19800.         if(this.getDumpHeaderErogazioniRichiestaUscitaWhiteList==null){
  19801.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.richiesta-uscita.whiteList";
  19802.             try{
  19803.                 this.getDumpHeaderErogazioniRichiestaUscitaWhiteList = new ArrayList<>();
  19804.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19805.                 initDumpList(this.getDumpHeaderErogazioniRichiestaUscitaWhiteList, tmp);
  19806.             }catch(java.lang.Exception e) {
  19807.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19808.             }
  19809.         }

  19811.         return this.getDumpHeaderErogazioniRichiestaUscitaWhiteList;
  19812.     }
  19813.     
  19814.     private List<String> getDumpHeaderErogazioniRichiestaUscitaBlackList = null;
  19815.     public List<String> getDumpHeaderErogazioniRichiestaUscitaBlackList(){

  19817.         if(this.getDumpHeaderErogazioniRichiestaUscitaBlackList==null){
  19818.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.richiesta-uscita.blackList";
  19819.             try{
  19820.                 this.getDumpHeaderErogazioniRichiestaUscitaBlackList = new ArrayList<>();
  19821.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19822.                 initDumpList(this.getDumpHeaderErogazioniRichiestaUscitaBlackList, tmp);
  19823.             }catch(java.lang.Exception e) {
  19824.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19825.             }
  19826.         }

  19828.         return this.getDumpHeaderErogazioniRichiestaUscitaBlackList;
  19829.     }
  19830.     
  19831.     private List<String> getDumpHeaderErogazioniRispostaIngressoWhiteList = null;
  19832.     public List<String> getDumpHeaderErogazioniRispostaIngressoWhiteList(){

  19834.         if(this.getDumpHeaderErogazioniRispostaIngressoWhiteList==null){
  19835.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.risposta-ingresso.whiteList";
  19836.             try{
  19837.                 this.getDumpHeaderErogazioniRispostaIngressoWhiteList = new ArrayList<>();
  19838.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19839.                 initDumpList(this.getDumpHeaderErogazioniRispostaIngressoWhiteList, tmp);
  19840.             }catch(java.lang.Exception e) {
  19841.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19842.             }
  19843.         }

  19845.         return this.getDumpHeaderErogazioniRispostaIngressoWhiteList;
  19846.     }
  19847.     
  19848.     private List<String> getDumpHeaderErogazioniRispostaIngressoBlackList = null;
  19849.     public List<String> getDumpHeaderErogazioniRispostaIngressoBlackList(){

  19851.         if(this.getDumpHeaderErogazioniRispostaIngressoBlackList==null){
  19852.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.risposta-ingresso.blackList";
  19853.             try{
  19854.                 this.getDumpHeaderErogazioniRispostaIngressoBlackList = new ArrayList<>();
  19855.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19856.                 initDumpList(this.getDumpHeaderErogazioniRispostaIngressoBlackList, tmp);
  19857.             }catch(java.lang.Exception e) {
  19858.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19859.             }
  19860.         }

  19862.         return this.getDumpHeaderErogazioniRispostaIngressoBlackList;
  19863.     }
  19864.     
  19865.     private List<String> getDumpHeaderErogazioniRispostaUscitaWhiteList = null;
  19866.     public List<String> getDumpHeaderErogazioniRispostaUscitaWhiteList(){

  19868.         if(this.getDumpHeaderErogazioniRispostaUscitaWhiteList==null){
  19869.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.risposta-uscita.whiteList";
  19870.             try{
  19871.                 this.getDumpHeaderErogazioniRispostaUscitaWhiteList = new ArrayList<>();
  19872.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19873.                 initDumpList(this.getDumpHeaderErogazioniRispostaUscitaWhiteList, tmp);
  19874.             }catch(java.lang.Exception e) {
  19875.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19876.             }
  19877.         }

  19879.         return this.getDumpHeaderErogazioniRispostaUscitaWhiteList;
  19880.     }
  19881.     
  19882.     private List<String> getDumpHeaderErogazioniRispostaUscitaBlackList = null;
  19883.     public List<String> getDumpHeaderErogazioniRispostaUscitaBlackList(){

  19885.         if(this.getDumpHeaderErogazioniRispostaUscitaBlackList==null){
  19886.             String pName = "org.openspcoop2.pdd.logger.dump.header.erogazioni.risposta-uscita.blackList";
  19887.             try{
  19888.                 this.getDumpHeaderErogazioniRispostaUscitaBlackList = new ArrayList<>();
  19889.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19890.                 initDumpList(this.getDumpHeaderErogazioniRispostaUscitaBlackList, tmp);
  19891.             }catch(java.lang.Exception e) {
  19892.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19893.             }
  19894.         }

  19896.         return this.getDumpHeaderErogazioniRispostaUscitaBlackList;
  19897.     }
  19898.     
  19899.     private List<String> getDumpHeaderFruizioniRichiestaIngressoWhiteList = null;
  19900.     public List<String> getDumpHeaderFruizioniRichiestaIngressoWhiteList(){

  19902.         if(this.getDumpHeaderFruizioniRichiestaIngressoWhiteList==null){
  19903.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.richiesta-ingresso.whiteList";
  19904.             try{
  19905.                 this.getDumpHeaderFruizioniRichiestaIngressoWhiteList = new ArrayList<>();
  19906.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19907.                 initDumpList(this.getDumpHeaderFruizioniRichiestaIngressoWhiteList, tmp);
  19908.             }catch(java.lang.Exception e) {
  19909.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19910.             }
  19911.         }

  19913.         return this.getDumpHeaderFruizioniRichiestaIngressoWhiteList;
  19914.     }
  19915.     
  19916.     private List<String> getDumpHeaderFruizioniRichiestaIngressoBlackList = null;
  19917.     public List<String> getDumpHeaderFruizioniRichiestaIngressoBlackList(){

  19919.         if(this.getDumpHeaderFruizioniRichiestaIngressoBlackList==null){
  19920.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.richiesta-ingresso.blackList";
  19921.             try{
  19922.                 this.getDumpHeaderFruizioniRichiestaIngressoBlackList = new ArrayList<>();
  19923.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19924.                 initDumpList(this.getDumpHeaderFruizioniRichiestaIngressoBlackList, tmp);
  19925.             }catch(java.lang.Exception e) {
  19926.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19927.             }
  19928.         }

  19930.         return this.getDumpHeaderFruizioniRichiestaIngressoBlackList;
  19931.     }
  19932.     
  19933.     private List<String> getDumpHeaderFruizioniRichiestaUscitaWhiteList = null;
  19934.     public List<String> getDumpHeaderFruizioniRichiestaUscitaWhiteList(){

  19936.         if(this.getDumpHeaderFruizioniRichiestaUscitaWhiteList==null){
  19937.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.richiesta-uscita.whiteList";
  19938.             try{
  19939.                 this.getDumpHeaderFruizioniRichiestaUscitaWhiteList = new ArrayList<>();
  19940.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19941.                 initDumpList(this.getDumpHeaderFruizioniRichiestaUscitaWhiteList, tmp);
  19942.             }catch(java.lang.Exception e) {
  19943.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19944.             }
  19945.         }

  19947.         return this.getDumpHeaderFruizioniRichiestaUscitaWhiteList;
  19948.     }
  19949.     
  19950.     private List<String> getDumpHeaderFruizioniRichiestaUscitaBlackList = null;
  19951.     public List<String> getDumpHeaderFruizioniRichiestaUscitaBlackList(){

  19953.         if(this.getDumpHeaderFruizioniRichiestaUscitaBlackList==null){
  19954.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.richiesta-uscita.blackList";
  19955.             try{
  19956.                 this.getDumpHeaderFruizioniRichiestaUscitaBlackList = new ArrayList<>();
  19957.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19958.                 initDumpList(this.getDumpHeaderFruizioniRichiestaUscitaBlackList, tmp);
  19959.             }catch(java.lang.Exception e) {
  19960.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19961.             }
  19962.         }

  19964.         return this.getDumpHeaderFruizioniRichiestaUscitaBlackList;
  19965.     }
  19966.     
  19967.     private List<String> getDumpHeaderFruizioniRispostaIngressoWhiteList = null;
  19968.     public List<String> getDumpHeaderFruizioniRispostaIngressoWhiteList(){

  19970.         if(this.getDumpHeaderFruizioniRispostaIngressoWhiteList==null){
  19971.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.risposta-ingresso.whiteList";
  19972.             try{
  19973.                 this.getDumpHeaderFruizioniRispostaIngressoWhiteList = new ArrayList<>();
  19974.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  19975.                 initDumpList(this.getDumpHeaderFruizioniRispostaIngressoWhiteList, tmp);
  19976.             }catch(java.lang.Exception e) {
  19977.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19978.             }
  19979.         }

  19981.         return this.getDumpHeaderFruizioniRispostaIngressoWhiteList;
  19982.     }
  19983.     
  19984.     private List<String> getDumpHeaderFruizioniRispostaIngressoBlackList = null;
  19985.     public List<String> getDumpHeaderFruizioniRispostaIngressoBlackList(){

  19987.         if(this.getDumpHeaderFruizioniRispostaIngressoBlackList==null){
  19988.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.risposta-ingresso.blackList";
  19989.             try{
  19990.                 this.getDumpHeaderFruizioniRispostaIngressoBlackList = new ArrayList<>();
  19991.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  19992.                 initDumpList(this.getDumpHeaderFruizioniRispostaIngressoBlackList, tmp);
  19993.             }catch(java.lang.Exception e) {
  19994.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  19995.             }
  19996.         }

  19998.         return this.getDumpHeaderFruizioniRispostaIngressoBlackList;
  19999.     }
  20000.     
  20001.     private List<String> getDumpHeaderFruizioniRispostaUscitaWhiteList = null;
  20002.     public List<String> getDumpHeaderFruizioniRispostaUscitaWhiteList(){

  20004.         if(this.getDumpHeaderFruizioniRispostaUscitaWhiteList==null){
  20005.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.risposta-uscita.whiteList";
  20006.             try{
  20007.                 this.getDumpHeaderFruizioniRispostaUscitaWhiteList = new ArrayList<>();
  20008.                 String tmp = this.reader.getValueConvertEnvProperties(pName);
  20009.                 initDumpList(this.getDumpHeaderFruizioniRispostaUscitaWhiteList, tmp);
  20010.             }catch(java.lang.Exception e) {
  20011.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  20012.             }
  20013.         }

  20015.         return this.getDumpHeaderFruizioniRispostaUscitaWhiteList;
  20016.     }
  20017.     
  20018.     private List<String> getDumpHeaderFruizioniRispostaUscitaBlackList = null;
  20019.     public List<String> getDumpHeaderFruizioniRispostaUscitaBlackList(){

  20021.         if(this.getDumpHeaderFruizioniRispostaUscitaBlackList==null){
  20022.             String pName = "org.openspcoop2.pdd.logger.dump.header.fruizioni.risposta-uscita.blackList";
  20023.             try{
  20024.                 this.getDumpHeaderFruizioniRispostaUscitaBlackList = new ArrayList<>();
  20025.                 String tmp = this.reader.getValueConvertEnvProperties(pName); 
  20026.                 initDumpList(this.getDumpHeaderFruizioniRispostaUscitaBlackList, tmp);
  20027.             }catch(java.lang.Exception e) {
  20028.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  20029.             }
  20030.         }

  20032.         return this.getDumpHeaderFruizioniRispostaUscitaBlackList;
  20033.     }
  20034.     
  20035.     private void initDumpList(List<String> list, String tmp) {
  20036.         if(tmp!=null && !"".equals(tmp.trim())) {
  20037.             tmp = tmp.trim();
  20038.             if(tmp.contains(",")) {
  20039.                 String [] split = tmp.split(",");
  20040.                 initDumpList(list, split);
  20041.             }
  20042.             else {
  20043.                 list.add(tmp);
  20044.             }
  20045.         }
  20046.     }
  20047.     private void initDumpList(List<String> list, String [] split) {
  20048.         if(split!=null && split.length>0) {
  20049.             for (String s : split) {
  20050.                 if(s!=null) {
  20051.                     s = s.trim();
  20052.                     if(!"".equals(s)) {
  20053.                         list.add(s);
  20054.                     }
  20055.                 }
  20056.             }
  20057.         }
  20058.     }
  20059.     
  20060.     
  20061.     private Boolean isDumpEmitDiagnostic = null;
  20062.     public boolean isDumpEmitDiagnostic(){

  20064.         if(this.isDumpEmitDiagnostic==null){
  20065.             String pName = "org.openspcoop2.pdd.logger.dump.emitDiagnostic";
  20066.             try{  
  20067.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  20069.                 if (value != null){
  20070.                     value = value.trim();
  20071.                     this.isDumpEmitDiagnostic = Boolean.parseBoolean(value);
  20072.                 }else{
  20073.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  20074.                     this.isDumpEmitDiagnostic = true;
  20075.                 }

  20077.             }catch(java.lang.Exception e) {
  20078.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  20079.                 this.isDumpEmitDiagnostic = true;
  20080.             }
  20081.         }

  20083.         return this.isDumpEmitDiagnostic;
  20084.     }
  20085.     
  20086.     
  20087.     /* ----------- Dump (Binario) --------------------- */
  20088.     
  20089.     private Boolean isDumpBinarioRegistrazioneDatabase = null;
  20090.     public boolean isDumpBinarioRegistrazioneDatabase(){

  20092.         if(this.isDumpBinarioRegistrazioneDatabase==null){
  20093.             try{  
  20094.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.logger.dumpBinario.registrazioneDatabase"); 

  20096.                 if (value != null){
  20097.                     value = value.trim();
  20098.                     this.isDumpBinarioRegistrazioneDatabase = Boolean.parseBoolean(value);
  20099.                 }else{
  20100.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dumpBinario.registrazioneDatabase' non impostata, viene utilizzato il default=false");
  20101.                     this.isDumpBinarioRegistrazioneDatabase = false;
  20102.                 }

  20104.             }catch(java.lang.Exception e) {
  20105.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.logger.dumpBinario.registrazioneDatabase' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  20106.                 this.isDumpBinarioRegistrazioneDatabase = false;
  20107.             }
  20108.         }

  20110.         return this.isDumpBinarioRegistrazioneDatabase;
  20111.     }
  20112.     
  20113.     private Integer getDumpBinarioInMemoryThreshold = null;
  20114.     public int getDumpBinarioInMemoryThreshold() {  
  20115.         String pName = "org.openspcoop2.pdd.logger.dumpBinario.inMemory.threshold";
  20116.         if(this.getDumpBinarioInMemoryThreshold==null){
  20117.             try{ 
  20118.                 String name = null;
  20119.                 name = this.reader.getValueConvertEnvProperties(pName);
  20120.                 if(name!=null){
  20121.                     name = name.trim();
  20122.                     this.getDumpBinarioInMemoryThreshold = java.lang.Integer.parseInt(name);
  20123.                 }else{
  20124.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.DUMP_BINARIO_THRESHOLD));
  20125.                     this.getDumpBinarioInMemoryThreshold = CostantiPdD.DUMP_BINARIO_THRESHOLD;
  20126.                 }
  20127.             }catch(java.lang.Exception e) {
  20128.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.DUMP_BINARIO_THRESHOLD),e);
  20129.                 this.getDumpBinarioInMemoryThreshold = CostantiPdD.DUMP_BINARIO_THRESHOLD;
  20130.             }  
  20131.         }

  20133.         return this.getDumpBinarioInMemoryThreshold;
  20134.     }
  20135.     
  20136.     private File getDumpBinarioRepository = null;
  20137.     public File getDumpBinarioRepository() throws CoreException {   
  20138.         String pName = "org.openspcoop2.pdd.logger.dumpBinario.msgRepository";
  20139.         if(this.getDumpBinarioRepository==null){
  20140.             try{ 
  20141.                 String name = null;
  20142.                 name = this.reader.getValueConvertEnvProperties(pName);
  20143.                 if(name==null){
  20144.                     throw new CoreException("Proprieta' non impostata");
  20145.                 }
  20146.                 name = LoggerWrapperFactory.applyClusterIdStrategy(name.trim(), "dumpBinario");
  20147.                 this.getDumpBinarioRepository = new File(name);
  20148.                 checkDumpBinarioRepository();
  20149.             } catch(java.lang.Exception e) {
  20150.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  20151.                 throw new CoreException(e.getMessage(),e);
  20152.             }    
  20153.         }

  20155.         return this.getDumpBinarioRepository;
  20156.     }
  20157.     private void checkDumpBinarioRepository() throws CoreException {
  20158.         if(this.getDumpBinarioRepository.exists()) {
  20159.             if(!this.getDumpBinarioRepository.isDirectory()) {
  20160.                 throw newCoreExceptionNotDir(this.getDumpBinarioRepository,true);
  20161.             }
  20162.             if(!this.getDumpBinarioRepository.canRead()) {
  20163.                 throw newCoreExceptionCannotRead(this.getDumpBinarioRepository, true);
  20164.             }
  20165.             if(!this.getDumpBinarioRepository.canWrite()) {
  20166.                 throw newCoreExceptionCannotWrite(this.getDumpBinarioRepository, true);
  20167.             }
  20168.         }
  20169.         else {
  20170.             // viene creata automaticamente
  20171.         }
  20172.     }
  20173.     
  20174.     
  20175.     
  20176.     
  20177.     /* ----------- Dump (NonRealtime) --------------------- */
  20178.     
  20179.     private Integer getDumpNonRealtimeInMemoryThreshold = null;
  20180.     public int getDumpNonRealtimeInMemoryThreshold() {  
  20181.         if(this.getDumpNonRealtimeInMemoryThreshold==null){
  20182.             try{ 
  20183.                 String name = null;
  20184.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dump.nonRealTime.inMemory.threshold");
  20185.                 if(name!=null){
  20186.                     name = name.trim();
  20187.                     this.getDumpNonRealtimeInMemoryThreshold = java.lang.Integer.parseInt(name);
  20188.                 }else{
  20189.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.inMemory.threshold' non impostata, viene utilizzato il default="+CostantiPdD.DUMP_NON_REALTIME_THRESHOLD);
  20190.                     this.getDumpNonRealtimeInMemoryThreshold = CostantiPdD.DUMP_NON_REALTIME_THRESHOLD;
  20191.                 }
  20192.             }catch(java.lang.Exception e) {
  20193.                 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);
  20194.                 this.getDumpNonRealtimeInMemoryThreshold = CostantiPdD.DUMP_NON_REALTIME_THRESHOLD;
  20195.             }  
  20196.         }

  20198.         return this.getDumpNonRealtimeInMemoryThreshold;
  20199.     }
  20200.     
  20201.     private String getDumpNonRealtimeMode = null;
  20202.     private String getDumpNonRealtimeMode() throws CoreException {  
  20203.         if(this.getDumpNonRealtimeMode==null){
  20204.             try{ 
  20205.                 String name = null;
  20206.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dump.nonRealTime.mode");
  20207.                 if(name!=null){
  20208.                     name = name.trim();
  20209.                     if(!CostantiPdD.DUMP_NON_REALTIME_MODE_DB.equalsIgnoreCase(name) && 
  20210.                             !CostantiPdD.DUMP_NON_REALTIME_MODE_FILE_SYSTEM.equalsIgnoreCase(name) && 
  20211.                             !CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO.equalsIgnoreCase(name) ) {
  20212.                         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+")");
  20213.                     }
  20214.                     this.getDumpNonRealtimeMode = name;
  20215.                 }else{
  20216.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.mode' non impostata, viene utilizzato il default="+CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO);
  20217.                     this.getDumpNonRealtimeMode = CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO;
  20218.                 }
  20219.             }catch(java.lang.Exception e) {
  20220.                 this.logError("Proprieta' di openspcoop ''org.openspcoop2.pdd.dump.nonRealTime.mode' non impostata, errore:"+e.getMessage(),e);
  20221.                 throw new CoreException(e.getMessage(),e);
  20222.             }  
  20223.             
  20224.             checkDumpNonRealtimeMode();
  20225.         }

  20227.         return this.getDumpNonRealtimeMode;
  20228.     }
  20229.     private void checkDumpNonRealtimeMode() throws CoreException {  
  20230.         if(CostantiPdD.DUMP_NON_REALTIME_MODE_AUTO.equalsIgnoreCase(this.getDumpNonRealtimeMode)) {
  20231.             String databaseTypeCheck = this.getDatabaseType();
  20232.             if(databaseTypeCheck==null) {
  20233.                 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'");
  20234.             }
  20235.             if(TipiDatabase.POSTGRESQL.getNome().equalsIgnoreCase(databaseTypeCheck) || TipiDatabase.HSQL.getNome().equalsIgnoreCase(databaseTypeCheck)) {
  20236.                 // 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
  20237.                 this.getDumpNonRealtimeMode = CostantiPdD.DUMP_NON_REALTIME_MODE_FILE_SYSTEM;
  20238.             }
  20239.             else {
  20240.                 this.getDumpNonRealtimeMode = CostantiPdD.DUMP_NON_REALTIME_MODE_DB;
  20241.             }
  20242.         }
  20243.     }
  20244.     
  20245.     public boolean isDumpNonRealtimeDatabaseMode() {
  20246.         return CostantiPdD.DUMP_NON_REALTIME_MODE_DB.equalsIgnoreCase(this.getDumpNonRealtimeMode);
  20247.     }
  20248.     public boolean isDumpNonRealtimeFileSystemMode() {
  20249.         return CostantiPdD.DUMP_NON_REALTIME_MODE_FILE_SYSTEM.equalsIgnoreCase(this.getDumpNonRealtimeMode);
  20250.     }
  20251.     
  20252.     private File getDumpNonRealtimeRepository = null;
  20253.     public File getDumpNonRealtimeRepository() throws CoreException {   
  20254.         if(this.getDumpNonRealtimeRepository==null){
  20255.             try{ 
  20256.                 String name = null;
  20257.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dump.nonRealTime.msgRepository");
  20258.                 if(name==null){
  20259.                     throw new CoreException("Proprieta' non impostata");
  20260.                 }
  20261.                 name = LoggerWrapperFactory.applyClusterIdStrategy(name.trim(), "dumpNonRealTime");
  20262.                 this.getDumpNonRealtimeRepository = new File(name);
  20263.                 checkDumpNonRealtimeRepository();
  20264.             } catch(java.lang.Exception e) {
  20265.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.msgRepository': "+e.getMessage(),e);
  20266.                 throw new CoreException(e.getMessage(),e);
  20267.             }    
  20268.         }

  20270.         return this.getDumpNonRealtimeRepository;
  20271.     }
  20272.     private void checkDumpNonRealtimeRepository() throws CoreException {    
  20273.         if(this.getDumpNonRealtimeRepository.exists()) {
  20274.             if(!this.getDumpNonRealtimeRepository.isDirectory()) {
  20275.                 throw newCoreExceptionNotDir(this.getDumpNonRealtimeRepository,true);
  20276.             }
  20277.             if(!this.getDumpNonRealtimeRepository.canRead()) {
  20278.                 throw newCoreExceptionCannotRead(this.getDumpNonRealtimeRepository, true);
  20279.             }
  20280.             if(!this.getDumpNonRealtimeRepository.canWrite()) {
  20281.                 throw newCoreExceptionCannotWrite(this.getDumpNonRealtimeRepository, true);
  20282.             }
  20283.         }
  20284.         else {
  20285.             // viene creata automaticamente
  20286.         }
  20287.     }
  20288.     
  20289.     private Boolean isDumpNonRealtimeThrowStreamingHandlerException = null;
  20290.     public boolean isDumpNonRealtimeThrowStreamingHandlerException(){

  20292.         if(this.isDumpNonRealtimeThrowStreamingHandlerException==null){
  20293.             try{  
  20294.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.dump.nonRealTime.throwStreamingHandlerException"); 

  20296.                 if (value != null){
  20297.                     value = value.trim();
  20298.                     this.isDumpNonRealtimeThrowStreamingHandlerException = Boolean.parseBoolean(value);
  20299.                 }else{
  20300.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.throwStreamingHandlerException' non impostata, viene utilizzato il default=true");
  20301.                     this.isDumpNonRealtimeThrowStreamingHandlerException = true;
  20302.                 }

  20304.             }catch(java.lang.Exception e) {
  20305.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.dump.nonRealTime.throwStreamingHandlerException' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  20306.                 this.isDumpNonRealtimeThrowStreamingHandlerException = true;
  20307.             }
  20308.         }

  20310.         return this.isDumpNonRealtimeThrowStreamingHandlerException;
  20311.     }
  20312.     
  20313.     
  20314.     
  20315.     
  20316.     
  20317.     /* ------------- ID ---------------------*/
  20318.     /**
  20319.      * Restituisce il tipo di generatore id identificativi unici
  20320.      *
  20321.      * @return il tipo di generatore id identificativi unici
  20322.      * 
  20323.      */
  20324.     private String tipoIDManager = null;
  20325.     public String getTipoIDManager() {  
  20326.         if(this.tipoIDManager==null){
  20327.             try{ 
  20328.                 String name = null;
  20329.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.idGenerator");
  20330.                 if(name!=null){
  20331.                     name = name.trim();
  20332.                     this.tipoIDManager = name;
  20333.                 }else{
  20334.                     this.tipoIDManager = CostantiConfigurazione.NONE;
  20335.                 }
  20336.             }catch(java.lang.Exception e) {
  20337.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.idGenerator': "+e.getMessage(),e);
  20338.                 this.tipoIDManager = CostantiConfigurazione.NONE;
  20339.             }    
  20340.         }

  20342.         return this.tipoIDManager;
  20343.     }
  20344.     
  20345.     private Boolean useIDManagerWithThreadLocal = null;
  20346.     public boolean useIDManagerWithThreadLocal(){

  20348.         String pName = "org.openspcoop2.pdd.idGenerator.useThreadLocal";
  20349.         if(this.useIDManagerWithThreadLocal==null){
  20350.             try{  
  20351.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  20353.                 if (value != null){
  20354.                     value = value.trim();
  20355.                     this.useIDManagerWithThreadLocal = Boolean.parseBoolean(value);
  20356.                 }else{
  20357.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  20358.                     this.useIDManagerWithThreadLocal = false;
  20359.                 }

  20361.             }catch(java.lang.Exception e) {
  20362.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  20363.                 this.useIDManagerWithThreadLocal = false;
  20364.             }
  20365.         }

  20367.         return this.useIDManagerWithThreadLocal;
  20368.     }
  20369.     
  20370.     private Boolean listIDManagerParametersRead = null;
  20371.     private List<String> listIDManagerParameters = null;
  20372.     public List<String> getIDManagerParameters(){

  20374.         String pName = "org.openspcoop2.pdd.idGenerator."+this.getTipoIDManager()+".parameters";
  20375.         if(this.listIDManagerParametersRead==null){
  20376.             try{  
  20377.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  20379.                 initIDManagerParameters(value);

  20381.             }catch(java.lang.Exception e) {
  20382.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  20383.             }
  20384.             this.listIDManagerParametersRead = true;
  20385.         }

  20387.         return this.listIDManagerParameters;
  20388.     }
  20389.     private void initIDManagerParameters(String value){
  20390.         if (value != null){
  20391.             value = value.trim();
  20392.             
  20393.             if(value.contains(",")) {
  20394.                 String [] tmp = value.split(",");
  20395.                 if(tmp!=null && tmp.length>0) {
  20396.                     this.listIDManagerParameters = new ArrayList<>();
  20397.                     for (String v : tmp) {
  20398.                         this.listIDManagerParameters.add(v);
  20399.                     }
  20400.                 }
  20401.             }
  20402.             else {
  20403.                 this.listIDManagerParameters = new ArrayList<>();
  20404.                 this.listIDManagerParameters.add(value);
  20405.             }
  20406.         }
  20407.     }
  20408.     
  20409.     private Integer getIDManagerBufferSize = null;
  20410.     public int getIDManagerBufferSize(){

  20412.         String pName = "org.openspcoop2.pdd.idGenerator.buffer";
  20413.         if(this.getIDManagerBufferSize==null){
  20414.             try{  
  20415.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  20417.                 if (value != null){
  20418.                     value = value.trim();
  20419.                     this.getIDManagerBufferSize = Integer.parseInt(value);
  20420.                 }else{
  20421.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=-1");
  20422.                     this.getIDManagerBufferSize = -1;
  20423.                 }

  20425.             }catch(java.lang.Exception e) {
  20426.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=-1, errore:"+e.getMessage(),e);
  20427.                 this.getIDManagerBufferSize = -1;
  20428.             }
  20429.         }

  20431.         return this.getIDManagerBufferSize;
  20432.     }
  20433.     
  20434.     
  20435.     
  20436.     
  20437.     
  20438.     /* ------------- DEMO Mode ---------------------*/
  20439.     private Boolean generazioneDateCasualiLogAbilitato = null;
  20440.     private Date generazioneDateCasualiLogDataInizioIntervallo = null;
  20441.     private Date generazioneDateCasualiLogDataFineIntervallo = null;
  20442.     public Date getGenerazioneDateCasualiLogDataInizioIntervallo() {
  20443.         return this.generazioneDateCasualiLogDataInizioIntervallo;
  20444.     }
  20445.     public Date getGenerazioneDateCasualiLogDataFineIntervallo() {
  20446.         return this.generazioneDateCasualiLogDataFineIntervallo;
  20447.     }
  20448.     public boolean generazioneDateCasualiLogAbilitato() {   
  20449.         if(this.generazioneDateCasualiLogAbilitato==null){
  20450.             try{ 
  20451.                 String name = null;
  20452.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.generazioneDateCasuali.enabled");
  20453.                 if(name!=null){
  20454.                     name = name.trim();
  20455.                     this.generazioneDateCasualiLogAbilitato = Boolean.parseBoolean(name);
  20456.                     
  20457.                     initDateCasualiLogAbilitato();
  20458.                     
  20459.                 }else{
  20460.                     this.generazioneDateCasualiLogAbilitato = false; //default, anche senza che sia definita la proprieta'
  20461.                 }
  20462.             }catch(java.lang.Exception e) {
  20463.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.generazioneDateCasuali.enabled' non impostata correttamente,  errore:"+e.getMessage(),e);
  20464.                 this.generazioneDateCasualiLogAbilitato = false;
  20465.             }    
  20466.         }

  20468.         return this.generazioneDateCasualiLogAbilitato;
  20469.     }
  20470.     private void initDateCasualiLogAbilitato() throws CoreException, UtilsException, ParseException {   
  20471.         if(this.generazioneDateCasualiLogAbilitato.booleanValue()){
  20472.             
  20473.             if(getTipoIDManager()==null || CostantiConfigurazione.NONE.equals(getTipoIDManager())){
  20474.                 throw new CoreException("Non e' possibile utilizzare la modalita' di generazione casuale delle date, se non si abilita la generazione di un ID");
  20475.             }
  20476.             
  20477.             String inizioIntervallo = this.reader.getValueConvertEnvProperties("org.openspcoop2.generazioneDateCasuali.inizioIntervallo");
  20478.             String fineIntervallo = this.reader.getValueConvertEnvProperties("org.openspcoop2.generazioneDateCasuali.fineIntervallo");
  20479.             SimpleDateFormat sdf = DateUtils.getDefaultDateTimeFormatter("yyyy-MM-dd hh:mm");
  20480.             if(inizioIntervallo==null){
  20481.                 throw new CoreException("Non e' stato definito l'intervallo di inizio per la modalita' di generazione casuale delle date");
  20482.             }
  20483.             else{inizioIntervallo=inizioIntervallo.trim();}
  20484.             this.generazioneDateCasualiLogDataInizioIntervallo = sdf.parse(inizioIntervallo);
  20485.             if(fineIntervallo==null){
  20486.                 throw new CoreException("Non e' stato definito l'intervallo di fine per la modalita' di generazione casuale delle date");
  20487.             }
  20488.             else{fineIntervallo=fineIntervallo.trim();}
  20489.             this.generazioneDateCasualiLogDataFineIntervallo = sdf.parse(fineIntervallo);
  20490.             
  20491.             if(this.generazioneDateCasualiLogDataInizioIntervallo.after(this.generazioneDateCasualiLogDataFineIntervallo)){
  20492.                 throw new CoreException("Non e' stato definito un intervallo di generazione casuale delle date corretto (inizioIntervallo>fineIntervallo)");
  20493.             }
  20494.         }
  20495.     }
  20496.     
  20497.     
  20498.     
  20499.     
  20500.     
  20501.     /* ------------- Factory ---------------------*/
  20502.     
  20503.     private Boolean openspcoop2MessageFactoryRead = null;
  20504.     private String openspcoop2MessageFactory = null;
  20505.     public String getOpenspcoop2MessageFactory() {  
  20506.         if(this.openspcoop2MessageFactoryRead==null){
  20507.             try{ 
  20508.                 String v = null;
  20509.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messagefactory");
  20510.                 if(v!=null){
  20511.                     v = v.trim();
  20512.                     this.openspcoop2MessageFactory = v;
  20513.                 } else{
  20514.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messagefactory' non impostata, viene utilizzato il default="+OpenSPCoop2MessageFactory.messageFactoryImpl);
  20515.                 }
  20516.             }catch(java.lang.Exception e) {
  20517.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messagefactory' non impostata correttamente,  errore:"+e.getMessage(),e);
  20518.             } 
  20519.         }
  20520.         this.openspcoop2MessageFactoryRead = true;
  20521.         return this.openspcoop2MessageFactory;
  20522.     }
  20523.     
  20524.     private Boolean messageSecurityContextRead = null;
  20525.     private String messageSecurityContext = null;
  20526.     public String getMessageSecurityContext() { 
  20527.         if(this.messageSecurityContextRead==null){
  20528.             try{ 
  20529.                 String v = null;
  20530.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.context");
  20531.                 if(v!=null){
  20532.                     v = v.trim();
  20533.                     this.messageSecurityContext = v;
  20534.                 } else{
  20535.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.context' non impostata, viene utilizzato il default="+MessageSecurityFactory.messageSecurityContextImplClass);
  20536.                 }
  20537.             } catch(java.lang.Exception e) {
  20538.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.context' non impostata correttamente,  errore:"+e.getMessage(),e);
  20539.             } 
  20540.         }
  20541.         this.messageSecurityContextRead = true;
  20542.         return this.messageSecurityContext;
  20543.     }
  20544.     
  20545.     private Boolean messageSecurityDigestReaderRead = null;
  20546.     private String messageSecurityDigestReader = null;
  20547.     public String getMessageSecurityDigestReader() {    
  20548.         if(this.messageSecurityDigestReaderRead==null){
  20549.             try{ 
  20550.                 String v = null;
  20551.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.digestReader");
  20552.                 if(v!=null){
  20553.                     v = v.trim();
  20554.                     this.messageSecurityDigestReader = v;
  20555.                 } else{
  20556.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.digestReader' non impostata, viene utilizzato il default="+MessageSecurityFactory.messageSecurityDigestReaderImplClass);
  20557.                 }
  20558.             } catch(java.lang.Exception e) {
  20559.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.digestReader' non impostata correttamente,  errore:"+e.getMessage(),e);
  20560.             } 
  20561.         }
  20562.         this.messageSecurityDigestReaderRead = true;
  20563.         return this.messageSecurityDigestReader;
  20564.     }
  20565.     
  20566.     private Boolean printInfoFactory = null;
  20567.     public boolean isPrintInfoFactory() {   
  20568.         if(this.printInfoFactory==null){
  20569.             try{ 
  20570.                 String v = null;
  20571.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messagefactory.printInfo");
  20572.                 if(v!=null){
  20573.                     v = v.trim();
  20574.                     this.printInfoFactory = Boolean.parseBoolean(v);
  20575.                 } 
  20576.                 else{
  20577.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messagefactory.printInfo' non impostata, viene utilizzato il default="+true);
  20578.                     this.printInfoFactory = true;
  20579.                 }
  20580.             }catch(java.lang.Exception e) {
  20581.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messagefactory.printInfo' non impostata correttamente,  errore:"+e.getMessage(),e);
  20582.             } 
  20583.         }
  20584.         return this.printInfoFactory;
  20585.     }
  20586.         
  20587.     private Boolean printInfoMessageSecurity = null;
  20588.     public boolean isPrintInfoMessageSecurity() {   
  20589.         if(this.printInfoMessageSecurity==null){
  20590.             try{ 
  20591.                 String v = null;
  20592.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.messageSecurity.printInfo");
  20593.                 if(v!=null){
  20594.                     v = v.trim();
  20595.                     this.printInfoMessageSecurity = Boolean.parseBoolean(v);
  20596.                 } 
  20597.                 else{
  20598.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.printInfo' non impostata, viene utilizzato il default="+true);
  20599.                     this.printInfoMessageSecurity = true;
  20600.                 }
  20601.             }catch(java.lang.Exception e) {
  20602.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.messageSecurity.printInfo' non impostata correttamente,  errore:"+e.getMessage(),e);
  20603.             } 
  20604.         }
  20605.         return this.printInfoMessageSecurity;
  20606.     }
  20607.     
  20608.     
  20609.     
  20610.     /* ------------- Utility ---------------------*/
  20611.     
  20612.     private Boolean freeMemoryLog = null;
  20613.     public boolean getFreeMemoryLog() { 
  20614.         if(this.freeMemoryLog==null){
  20615.             try{ 
  20616.                 String v = null;
  20617.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.freememorylog");
  20618.                 if(v!=null){
  20619.                     v = v.trim();
  20620.                     this.freeMemoryLog = Boolean.parseBoolean(v);
  20621.                 } 
  20622.                 else{
  20623.                     this.freeMemoryLog = false;
  20624.                 }
  20625.             }catch(java.lang.Exception e) {
  20626.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.freememorylog' non impostata correttamente. Assumo valore di default 'false'.");
  20627.                 this.freeMemoryLog = false;
  20628.             } 
  20629.         }
  20630.         return this.freeMemoryLog;
  20631.     }
  20632.     
  20633.     
  20634.     
  20635.     
  20636.     
  20637.     
  20638.     /* ------------- Protocol ---------------------*/
  20639.     
  20640.     private String defaultProtocolName = null;      
  20641.     public String getDefaultProtocolName(){
  20642.         if(this.defaultProtocolName==null){
  20643.             try{ 
  20644.                 this.defaultProtocolName = this.reader.getValue("org.openspcoop2.pdd.services.defaultProtocol");
  20645.                 if(this.defaultProtocolName!=null){
  20646.                     this.defaultProtocolName = this.defaultProtocolName.trim();
  20647.                 }
  20648.             } catch(java.lang.Exception e) {
  20649.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.services.defaultProtocol' non impostata correttamente,  errore:"+e.getMessage(),e);
  20650.             } 
  20651.         }
  20652.         return this.defaultProtocolName;
  20653.     }

  20655.     
  20656.         
  20657.     
  20658.     /* ------------- Soggetti Virtuali ---------------------*/
  20659.     
  20660.     private Boolean isSoggettiVirtualiEnabled = null;
  20661.     public boolean isSoggettiVirtualiEnabled() {    
  20662.         if(this.isSoggettiVirtualiEnabled==null){
  20663.             String pName = "org.openspcoop2.pdd.SoggettiVirtuali.enabled";
  20664.             try{ 
  20665.                 String name = null;
  20666.                 name = this.reader.getValueConvertEnvProperties(pName);
  20667.                 if(name==null){
  20668.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  20669.                     name="false";
  20670.                 }
  20671.                 name = name.trim();
  20672.                 this.isSoggettiVirtualiEnabled = Boolean.parseBoolean(name);
  20673.             } catch(java.lang.Exception e) {
  20674.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  20675.                 this.isSoggettiVirtualiEnabled = false;
  20676.             }    
  20677.         }

  20679.         return this.isSoggettiVirtualiEnabled;
  20680.     }
  20681.     
  20682.     
  20683.     /* ------------- Generazione Errore Protocol non supportato ---------------------*/
  20684.     
  20685.     private Boolean isGenerazioneErroreProtocolloNonSupportato = null;
  20686.     public boolean isGenerazioneErroreProtocolloNonSupportato() {   
  20687.         if(this.isGenerazioneErroreProtocolloNonSupportato==null){
  20688.             try{ 
  20689.                 String name = null;
  20690.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.protocolNotSupported.generateErrorMessage");
  20691.                 if(name==null){
  20692.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.protocolNotSupported.generateErrorMessage' non impostata, viene utilizzato il default=false");
  20693.                     name="false";
  20694.                 }
  20695.                 name = name.trim();
  20696.                 this.isGenerazioneErroreProtocolloNonSupportato = Boolean.parseBoolean(name);
  20697.             } catch(java.lang.Exception e) {
  20698.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.protocolNotSupported.generateErrorMessage': "+e.getMessage(),e);
  20699.                 this.isGenerazioneErroreProtocolloNonSupportato = false;
  20700.             }    
  20701.         }

  20703.         return this.isGenerazioneErroreProtocolloNonSupportato;
  20704.     }
  20705.     
  20706.     
  20707.     
  20708.     
  20709.     /* ------------- Generazione Errore HttpMethodUnsupported ---------------------*/
  20710.     
  20711.     private Boolean isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled = null;
  20712.     public boolean isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled() { 
  20713.         if(this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled==null){
  20714.             try{ 
  20715.                 String name = null;
  20716.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pd.httpMethodUnsupported.generateErrorMessage");
  20717.                 if(name==null){
  20718.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pd.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
  20719.                     name="true";
  20720.                 }
  20721.                 name = name.trim();
  20722.                 this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled = Boolean.parseBoolean(name);
  20723.             } catch(java.lang.Exception e) {
  20724.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pd.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
  20725.                 this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled = true;
  20726.             }    
  20727.         }

  20729.         return this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataEnabled;
  20730.     }
  20731.     
  20732.     private Boolean isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled = null;
  20733.     public boolean isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled() { 
  20734.         if(this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled==null){
  20735.             try{ 
  20736.                 String name = null;
  20737.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pdToSoap.httpMethodUnsupported.generateErrorMessage");
  20738.                 if(name==null){
  20739.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pdToSoap.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
  20740.                     name="true";
  20741.                 }
  20742.                 name = name.trim();
  20743.                 this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled = Boolean.parseBoolean(name);
  20744.             } catch(java.lang.Exception e) {
  20745.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pdToSoap.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
  20746.                 this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled = true;
  20747.             }    
  20748.         }

  20750.         return this.isGenerazioneErroreHttpMethodUnsupportedPortaDelegataImbustamentoSOAPEnabled;
  20751.     }
  20752.     
  20753.     private Boolean isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled = null;
  20754.     public boolean isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled() {  
  20755.         if(this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled==null){
  20756.             try{ 
  20757.                 String name = null;
  20758.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pa.httpMethodUnsupported.generateErrorMessage");
  20759.                 if(name==null){
  20760.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pa.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
  20761.                     name="true";
  20762.                 }
  20763.                 name = name.trim();
  20764.                 this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled = Boolean.parseBoolean(name);
  20765.             } catch(java.lang.Exception e) {
  20766.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pa.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
  20767.                 this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled = true;
  20768.             }    
  20769.         }

  20771.         return this.isGenerazioneErroreHttpMethodUnsupportedPortaApplicativaEnabled;
  20772.     }
  20773.     
  20774.     private Boolean isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled = null;
  20775.     public boolean isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled() {    
  20776.         if(this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled==null){
  20777.             try{ 
  20778.                 String name = null;
  20779.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.im.httpMethodUnsupported.generateErrorMessage");
  20780.                 if(name==null){
  20781.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.im.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
  20782.                     name="true";
  20783.                 }
  20784.                 name = name.trim();
  20785.                 this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled = Boolean.parseBoolean(name);
  20786.             } catch(java.lang.Exception e) {
  20787.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.im.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
  20788.                 this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled = true;
  20789.             }    
  20790.         }

  20792.         return this.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled;
  20793.     }
  20794.     
  20795.     private Boolean isGenerazioneErroreHttpMethodUnsupportedCheckEnabled = null;
  20796.     public boolean isGenerazioneErroreHttpMethodUnsupportedCheckEnabled() { 
  20797.         if(this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled==null){
  20798.             try{ 
  20799.                 String name = null;
  20800.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.httpMethodUnsupported.generateErrorMessage");
  20801.                 if(name==null){
  20802.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.check.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
  20803.                     name="true";
  20804.                 }
  20805.                 name = name.trim();
  20806.                 this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled = Boolean.parseBoolean(name);
  20807.             } catch(java.lang.Exception e) {
  20808.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
  20809.                 this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled = true;
  20810.             }    
  20811.         }

  20813.         return this.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled;
  20814.     }
  20815.     
  20816.     private Boolean isGenerazioneErroreHttpMethodUnsupportedProxyEnabled = null;
  20817.     public boolean isGenerazioneErroreHttpMethodUnsupportedProxyEnabled() { 
  20818.         if(this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled==null){
  20819.             try{ 
  20820.                 String name = null;
  20821.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxy.httpMethodUnsupported.generateErrorMessage");
  20822.                 if(name==null){
  20823.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxy.httpMethodUnsupported.generateErrorMessage' non impostata, viene utilizzato il default=true");
  20824.                     name="true";
  20825.                 }
  20826.                 name = name.trim();
  20827.                 this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled = Boolean.parseBoolean(name);
  20828.             } catch(java.lang.Exception e) {
  20829.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxy.httpMethodUnsupported.generateErrorMessage': "+e.getMessage(),e);
  20830.                 this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled = true;
  20831.             }    
  20832.         }

  20834.         return this.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled;
  20835.     }
  20836.     
  20837.     
  20838.     
  20839.     
  20840.     /* ------------- Generazione WSDL ---------------------*/
  20841.     
  20842.     private Boolean isGenerazioneWsdlPortaDelegataEnabled = null;
  20843.     public boolean isGenerazioneWsdlPortaDelegataEnabled() {    
  20844.         if(this.isGenerazioneWsdlPortaDelegataEnabled==null){
  20845.             try{ 
  20846.                 String name = null;
  20847.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pd.generateWsdl");
  20848.                 if(name==null){
  20849.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pd.generateWsdl' non impostata, viene utilizzato il default=false");
  20850.                     name="false";
  20851.                 }
  20852.                 name = name.trim();
  20853.                 this.isGenerazioneWsdlPortaDelegataEnabled = Boolean.parseBoolean(name);
  20854.             } catch(java.lang.Exception e) {
  20855.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pd.generateWsdl': "+e.getMessage(),e);
  20856.                 this.isGenerazioneWsdlPortaDelegataEnabled = false;
  20857.             }    
  20858.         }

  20860.         return this.isGenerazioneWsdlPortaDelegataEnabled;
  20861.     }
  20862.     
  20863.     private Boolean isGenerazioneWsdlPortaApplicativaEnabled = null;
  20864.     public boolean isGenerazioneWsdlPortaApplicativaEnabled() { 
  20865.         if(this.isGenerazioneWsdlPortaApplicativaEnabled==null){
  20866.             try{ 
  20867.                 String name = null;
  20868.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.pa.generateWsdl");
  20869.                 if(name==null){
  20870.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.pa.generateWsdl' non impostata, viene utilizzato il default=false");
  20871.                     name="false";
  20872.                 }
  20873.                 name = name.trim();
  20874.                 this.isGenerazioneWsdlPortaApplicativaEnabled = Boolean.parseBoolean(name);
  20875.             } catch(java.lang.Exception e) {
  20876.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.pa.generateWsdl': "+e.getMessage(),e);
  20877.                 this.isGenerazioneWsdlPortaApplicativaEnabled = false;
  20878.             }    
  20879.         }

  20881.         return this.isGenerazioneWsdlPortaApplicativaEnabled;
  20882.     }
  20883.     
  20884.     private Boolean isGenerazioneWsdlIntegrationManagerEnabled = null;
  20885.     public boolean isGenerazioneWsdlIntegrationManagerEnabled() {   
  20886.         if(this.isGenerazioneWsdlIntegrationManagerEnabled==null){
  20887.             try{ 
  20888.                 String name = null;
  20889.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.im.generateWsdl");
  20890.                 if(name==null){
  20891.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.im.generateWsdl' non impostata, viene utilizzato il default=true");
  20892.                     name="true";
  20893.                 }
  20894.                 name = name.trim();
  20895.                 this.isGenerazioneWsdlIntegrationManagerEnabled = Boolean.parseBoolean(name);
  20896.             } catch(java.lang.Exception e) {
  20897.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.im.generateWsdl': "+e.getMessage(),e);
  20898.                 this.isGenerazioneWsdlIntegrationManagerEnabled = true;
  20899.             }    
  20900.         }

  20902.         return this.isGenerazioneWsdlIntegrationManagerEnabled;
  20903.     }
  20904.     
  20905.     
  20906.     
  20907.     
  20908.     /* ------------- Check Reader Risorse JMX ---------------------*/
  20909.     
  20910.     private Boolean isCheckEnabled = null;
  20911.     public boolean isCheckEnabled() {   
  20912.         if(this.isCheckEnabled==null){
  20913.             try{ 
  20914.                 String name = null;
  20915.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.enabled");
  20916.                 if(name==null){
  20917.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.check.enabled' non impostata, viene utilizzato il default=true");
  20918.                     name="true";
  20919.                 }
  20920.                 name = name.trim();
  20921.                 this.isCheckEnabled = Boolean.parseBoolean(name);
  20922.             } catch(java.lang.Exception e) {
  20923.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.enabled': "+e.getMessage(),e);
  20924.                 this.isCheckEnabled = true;
  20925.             }    
  20926.         }

  20928.         return this.isCheckEnabled;
  20929.     }
  20930.     
  20931.     private Boolean isCheckHealthCheckApiRestEnabled = null;
  20932.     public boolean isCheckHealthCheckApiRestEnabled() { 
  20933.         if(this.isCheckHealthCheckApiRestEnabled==null){
  20934.             String pName = "org.openspcoop2.pdd.check.healthCheck.apiRest.enabled";
  20935.             try{ 
  20936.                 String name = null;
  20937.                 name = this.reader.getValueConvertEnvProperties(pName);
  20938.                 if(name==null){
  20939.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  20940.                     name="false";
  20941.                 }
  20942.                 name = name.trim();
  20943.                 this.isCheckHealthCheckApiRestEnabled = Boolean.parseBoolean(name);
  20944.             } catch(java.lang.Exception e) {
  20945.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  20946.                 this.isCheckHealthCheckApiRestEnabled = false;
  20947.             }    
  20948.         }

  20950.         return this.isCheckHealthCheckApiRestEnabled;
  20951.     }
  20952.     
  20953.     private String getCheckHealthCheckApiRestEndpoint = null;
  20954.     public String getCheckHealthCheckApiRestEndpoint() {    
  20955.         if(this.getCheckHealthCheckApiRestEndpoint==null){
  20956.             String pName = "org.openspcoop2.pdd.check.healthCheck.apiRest.endpoint";
  20957.             try{ 
  20958.                 String name = null;
  20959.                 name = this.reader.getValueConvertEnvProperties(pName);
  20960.                 if(name==null){
  20961.                     throw new CoreException("Non definita");
  20962.                 }
  20963.                 name = name.trim();
  20964.                 this.getCheckHealthCheckApiRestEndpoint = name;
  20965.             } catch(java.lang.Exception e) {
  20966.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  20967.                 this.getCheckHealthCheckApiRestEndpoint = null;
  20968.             }    
  20969.         }

  20971.         return this.getCheckHealthCheckApiRestEndpoint;
  20972.     }
  20973.     
  20974.     private Boolean isCheckHealthCheckApiSoapEnabled = null;
  20975.     public boolean isCheckHealthCheckApiSoapEnabled() { 
  20976.         if(this.isCheckHealthCheckApiSoapEnabled==null){
  20977.             String pName = "org.openspcoop2.pdd.check.healthCheck.apiSoap.enabled";
  20978.             try{ 
  20979.                 String name = null;
  20980.                 name = this.reader.getValueConvertEnvProperties(pName);
  20981.                 if(name==null){
  20982.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  20983.                     name="false";
  20984.                 }
  20985.                 name = name.trim();
  20986.                 this.isCheckHealthCheckApiSoapEnabled = Boolean.parseBoolean(name);
  20987.             } catch(java.lang.Exception e) {
  20988.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  20989.                 this.isCheckHealthCheckApiSoapEnabled = false;
  20990.             }    
  20991.         }

  20993.         return this.isCheckHealthCheckApiSoapEnabled;
  20994.     }
  20995.     
  20996.     private String getCheckHealthCheckApiSoapEndpoint = null;
  20997.     public String getCheckHealthCheckApiSoapEndpoint() {    
  20998.         if(this.getCheckHealthCheckApiSoapEndpoint==null){
  20999.             String pName = "org.openspcoop2.pdd.check.healthCheck.apiSoap.endpoint";
  21000.             try{ 
  21001.                 String name = null;
  21002.                 name = this.reader.getValueConvertEnvProperties(pName);
  21003.                 if(name==null){
  21004.                     throw new CoreException("Non definita");
  21005.                 }
  21006.                 name = name.trim();
  21007.                 this.getCheckHealthCheckApiSoapEndpoint = name;
  21008.             } catch(java.lang.Exception e) {
  21009.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21010.                 this.getCheckHealthCheckApiSoapEndpoint = null;
  21011.             }    
  21012.         }

  21014.         return this.getCheckHealthCheckApiSoapEndpoint;
  21015.     }
  21016.     
  21017.     private Boolean isCheckHealthCheckStatsEnabled = null;
  21018.     public boolean isCheckHealthCheckStatsEnabled() {   
  21019.         if(this.isCheckHealthCheckStatsEnabled==null){
  21020.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.enabled";
  21021.             try{ 
  21022.                 String name = null;
  21023.                 name = this.reader.getValueConvertEnvProperties(pName);
  21024.                 if(name==null){
  21025.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  21026.                     name="false";
  21027.                 }
  21028.                 name = name.trim();
  21029.                 this.isCheckHealthCheckStatsEnabled = Boolean.parseBoolean(name);
  21030.             } catch(java.lang.Exception e) {
  21031.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21032.                 this.isCheckHealthCheckStatsEnabled = false;
  21033.             }    
  21034.         }

  21036.         return this.isCheckHealthCheckStatsEnabled;
  21037.     }
  21038.     
  21039.     private Boolean isCheckHealthCheckStatsHourlyEnabled = null;
  21040.     public boolean isCheckHealthCheckStatsHourlyEnabled() { 
  21041.         if(this.isCheckHealthCheckStatsHourlyEnabled==null){
  21042.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloOrario.verifica";
  21043.             try{ 
  21044.                 String name = null;
  21045.                 name = this.reader.getValueConvertEnvProperties(pName);
  21046.                 if(name==null){
  21047.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  21048.                     name="false";
  21049.                 }
  21050.                 name = name.trim();
  21051.                 this.isCheckHealthCheckStatsHourlyEnabled = Boolean.parseBoolean(name);
  21052.             } catch(java.lang.Exception e) {
  21053.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21054.                 this.isCheckHealthCheckStatsHourlyEnabled = false;
  21055.             }    
  21056.         }

  21058.         return this.isCheckHealthCheckStatsHourlyEnabled;
  21059.     }
  21060.     
  21061.     private Integer getCheckHealthCheckStatsHourlyThreshold = null;
  21062.     public int getCheckHealthCheckStatsHourlyThreshold() {  
  21063.         if(this.getCheckHealthCheckStatsHourlyThreshold==null){
  21064.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloOrario.soglia";
  21065.             try{ 
  21066.                 String name = null;
  21067.                 name = this.reader.getValueConvertEnvProperties(pName);
  21068.                 if(name==null){
  21069.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, 1));
  21070.                     name="1";
  21071.                 }
  21072.                 name = name.trim();
  21073.                 this.getCheckHealthCheckStatsHourlyThreshold = Integer.valueOf(name);
  21074.             } catch(java.lang.Exception e) {
  21075.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21076.                 this.getCheckHealthCheckStatsHourlyThreshold = -1;
  21077.             }    
  21078.         }

  21080.         return this.getCheckHealthCheckStatsHourlyThreshold;
  21081.     }
  21082.     
  21083.         
  21084.     private Boolean isCheckHealthCheckStatsDailyEnabled = null;
  21085.     public boolean isCheckHealthCheckStatsDailyEnabled() {  
  21086.         if(this.isCheckHealthCheckStatsDailyEnabled==null){
  21087.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloGiornaliero.verifica";
  21088.             try{ 
  21089.                 String name = null;
  21090.                 name = this.reader.getValueConvertEnvProperties(pName);
  21091.                 if(name==null){
  21092.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  21093.                     name="false";
  21094.                 }
  21095.                 name = name.trim();
  21096.                 this.isCheckHealthCheckStatsDailyEnabled = Boolean.parseBoolean(name);
  21097.             } catch(java.lang.Exception e) {
  21098.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21099.                 this.isCheckHealthCheckStatsDailyEnabled = false;
  21100.             }    
  21101.         }

  21103.         return this.isCheckHealthCheckStatsDailyEnabled;
  21104.     }
  21105.     
  21106.     private Integer getCheckHealthCheckStatsDailyThreshold = null;
  21107.     public int getCheckHealthCheckStatsDailyThreshold() {   
  21108.         if(this.getCheckHealthCheckStatsDailyThreshold==null){
  21109.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloGiornaliero.soglia";
  21110.             try{ 
  21111.                 String name = null;
  21112.                 name = this.reader.getValueConvertEnvProperties(pName);
  21113.                 if(name==null){
  21114.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, 1));
  21115.                     name="1";
  21116.                 }
  21117.                 name = name.trim();
  21118.                 this.getCheckHealthCheckStatsDailyThreshold = Integer.valueOf(name);
  21119.             } catch(java.lang.Exception e) {
  21120.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21121.                 this.getCheckHealthCheckStatsDailyThreshold = -1;
  21122.             }    
  21123.         }

  21125.         return this.getCheckHealthCheckStatsDailyThreshold;
  21126.     }
  21127.     
  21128.     private Boolean isCheckHealthCheckStatsWeeklyEnabled = null;
  21129.     public boolean isCheckHealthCheckStatsWeeklyEnabled() { 
  21130.         if(this.isCheckHealthCheckStatsWeeklyEnabled==null){
  21131.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloSettimanale.verifica";
  21132.             try{ 
  21133.                 String name = null;
  21134.                 name = this.reader.getValueConvertEnvProperties(pName);
  21135.                 if(name==null){
  21136.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  21137.                     name="false";
  21138.                 }
  21139.                 name = name.trim();
  21140.                 this.isCheckHealthCheckStatsWeeklyEnabled = Boolean.parseBoolean(name);
  21141.             } catch(java.lang.Exception e) {
  21142.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21143.                 this.isCheckHealthCheckStatsWeeklyEnabled = false;
  21144.             }    
  21145.         }

  21147.         return this.isCheckHealthCheckStatsWeeklyEnabled;
  21148.     }
  21149.     
  21150.     private Integer getCheckHealthCheckStatsWeeklyThreshold = null;
  21151.     public int getCheckHealthCheckStatsWeeklyThreshold() {  
  21152.         if(this.getCheckHealthCheckStatsWeeklyThreshold==null){
  21153.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloSettimanale.soglia";
  21154.             try{ 
  21155.                 String name = null;
  21156.                 name = this.reader.getValueConvertEnvProperties(pName);
  21157.                 if(name==null){
  21158.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, 1));
  21159.                     name="1";
  21160.                 }
  21161.                 name = name.trim();
  21162.                 this.getCheckHealthCheckStatsWeeklyThreshold = Integer.valueOf(name);
  21163.             } catch(java.lang.Exception e) {
  21164.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21165.                 this.getCheckHealthCheckStatsWeeklyThreshold = -1;
  21166.             }    
  21167.         }

  21169.         return this.getCheckHealthCheckStatsWeeklyThreshold;
  21170.     }
  21171.     

  21173.     
  21174.     private Boolean isCheckHealthCheckStatsMonthlyEnabled = null;
  21175.     public boolean isCheckHealthCheckStatsMonthlyEnabled() {    
  21176.         if(this.isCheckHealthCheckStatsMonthlyEnabled==null){
  21177.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloMensile.verifica";
  21178.             try{ 
  21179.                 String name = null;
  21180.                 name = this.reader.getValueConvertEnvProperties(pName);
  21181.                 if(name==null){
  21182.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  21183.                     name="false";
  21184.                 }
  21185.                 name = name.trim();
  21186.                 this.isCheckHealthCheckStatsMonthlyEnabled = Boolean.parseBoolean(name);
  21187.             } catch(java.lang.Exception e) {
  21188.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21189.                 this.isCheckHealthCheckStatsMonthlyEnabled = false;
  21190.             }    
  21191.         }

  21193.         return this.isCheckHealthCheckStatsMonthlyEnabled;
  21194.     }
  21195.     
  21196.     private Integer getCheckHealthCheckStatsMonthlyThreshold = null;
  21197.     public int getCheckHealthCheckStatsMonthlyThreshold() { 
  21198.         if(this.getCheckHealthCheckStatsMonthlyThreshold==null){
  21199.             String pName = "org.openspcoop2.pdd.check.healthCheck.reportStatistici.intervalloMensile.soglia";
  21200.             try{ 
  21201.                 String name = null;
  21202.                 name = this.reader.getValueConvertEnvProperties(pName);
  21203.                 if(name==null){
  21204.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, 1));
  21205.                     name="1";
  21206.                 }
  21207.                 name = name.trim();
  21208.                 this.getCheckHealthCheckStatsMonthlyThreshold = Integer.valueOf(name);
  21209.             } catch(java.lang.Exception e) {
  21210.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21211.                 this.getCheckHealthCheckStatsMonthlyThreshold = -1;
  21212.             }    
  21213.         }

  21215.         return this.getCheckHealthCheckStatsMonthlyThreshold;
  21216.     }
  21217.     
  21218.     private Boolean isCheckReadJMXResourcesEnabled = null;
  21219.     public boolean isCheckReadJMXResourcesEnabled() {   
  21220.         if(this.isCheckReadJMXResourcesEnabled==null){
  21221.             try{ 
  21222.                 String name = null;
  21223.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.readJMXResources.enabled");
  21224.                 if(name==null){
  21225.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.check.readJMXResources.enabled' non impostata, viene utilizzato il default=false");
  21226.                     name="false";
  21227.                 }
  21228.                 name = name.trim();
  21229.                 this.isCheckReadJMXResourcesEnabled = Boolean.parseBoolean(name);
  21230.             } catch(java.lang.Exception e) {
  21231.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.readJMXResources.enabled': "+e.getMessage(),e);
  21232.                 this.isCheckReadJMXResourcesEnabled = false;
  21233.             }    
  21234.         }

  21236.         return this.isCheckReadJMXResourcesEnabled;
  21237.     }
  21238.     
  21239.     private String getCheckReadJMXResourcesUsername = null;
  21240.     private Boolean getCheckReadJMXResourcesUsernameRead = null;
  21241.     public String getCheckReadJMXResourcesUsername() {  
  21242.         if(this.getCheckReadJMXResourcesUsernameRead==null){
  21243.             try{ 
  21244.                 String name = null;
  21245.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.readJMXResources.username");
  21246.                 if(name!=null){
  21247.                     name = name.trim();
  21248.                 }
  21249.                 this.getCheckReadJMXResourcesUsernameRead = true;
  21250.                 this.getCheckReadJMXResourcesUsername = name;
  21251.             } catch(java.lang.Exception e) {
  21252.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.readJMXResources.username': "+e.getMessage(),e);
  21253.             }    
  21254.         }
  21255.         return this.getCheckReadJMXResourcesUsername;
  21256.     }
  21257.     
  21258.     private String getCheckReadJMXResourcesPassword = null;
  21259.     private Boolean getCheckReadJMXResourcesPasswordRead = null;
  21260.     public String getCheckReadJMXResourcesPassword() {  
  21261.         if(this.getCheckReadJMXResourcesPasswordRead==null){
  21262.             try{ 
  21263.                 String name = null;
  21264.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.check.readJMXResources.password");
  21265.                 if(name!=null){
  21266.                     name = name.trim();
  21267.                 }
  21268.                 this.getCheckReadJMXResourcesPasswordRead = true;
  21269.                 this.getCheckReadJMXResourcesPassword = name;
  21270.             } catch(java.lang.Exception e) {
  21271.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.check.readJMXResources.password': "+e.getMessage(),e);
  21272.             }    
  21273.         }
  21274.         return this.getCheckReadJMXResourcesPassword;
  21275.     }
  21276.     
  21277.     
  21278.     private Boolean isProxyReadJMXResourcesEnabled = null;
  21279.     public boolean isProxyReadJMXResourcesEnabled() {   
  21280.         if(this.isProxyReadJMXResourcesEnabled==null){
  21281.             try{ 
  21282.                 String name = null;
  21283.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.enabled");
  21284.                 if(name==null){
  21285.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.enabled' non impostata, viene utilizzato il default=false");
  21286.                     name="false";
  21287.                 }
  21288.                 name = name.trim();
  21289.                 this.isProxyReadJMXResourcesEnabled = Boolean.parseBoolean(name);
  21290.             } catch(java.lang.Exception e) {
  21291.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.enabled': "+e.getMessage(),e);
  21292.                 this.isProxyReadJMXResourcesEnabled = false;
  21293.             }    
  21294.         }

  21296.         return this.isProxyReadJMXResourcesEnabled;
  21297.     }
  21298.     
  21299.     private Boolean isProxyReadJMXResourcesAsyncProcessByTimer = null;
  21300.     public boolean isProxyReadJMXResourcesAsyncProcessByTimer() {   
  21301.         if(this.isProxyReadJMXResourcesAsyncProcessByTimer==null){
  21302.             try{ 
  21303.                 String name = null;
  21304.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate");
  21305.                 if(name==null){
  21306.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate' non impostata, viene utilizzato il default=false");
  21307.                     name="false";
  21308.                 }
  21309.                 name = name.trim();
  21310.                 this.isProxyReadJMXResourcesAsyncProcessByTimer = Boolean.parseBoolean(name);
  21311.             } catch(java.lang.Exception e) {
  21312.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate': "+e.getMessage(),e);
  21313.                 this.isProxyReadJMXResourcesAsyncProcessByTimer = false;
  21314.             }    
  21315.         }

  21317.         return this.isProxyReadJMXResourcesAsyncProcessByTimer;
  21318.     }
  21319.     
  21320.     private String getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass = null;
  21321.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClassRead = null;
  21322.     public String getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass() {   
  21323.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClassRead==null){
  21324.             try{ 
  21325.                 String name = null;
  21326.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.serviceClass");
  21327.                 if(name!=null){
  21328.                     name = name.trim();
  21329.                 }
  21330.                 this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClassRead = true;
  21331.                 this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass = name;
  21332.             } catch(java.lang.Exception e) {
  21333.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.serviceClass': "+e.getMessage(),e);
  21334.             }    
  21335.         }
  21336.         return this.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass;
  21337.     }
  21338.     
  21339.     private Boolean isProxyReadJMXResourcesAsyncProcessByTimerDebug = null;
  21340.     public boolean isProxyReadJMXResourcesAsyncProcessByTimerDebug() {  
  21341.         if(this.isProxyReadJMXResourcesAsyncProcessByTimerDebug==null){
  21342.             String pName = "org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.debug";
  21343.             try{ 
  21344.                 String name = null;
  21345.                 name = this.reader.getValueConvertEnvProperties(pName);
  21346.                 if(name==null){
  21347.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  21348.                     name="true";
  21349.                 }
  21350.                 name = name.trim();
  21351.                 this.isProxyReadJMXResourcesAsyncProcessByTimerDebug = Boolean.parseBoolean(name);
  21352.             } catch(java.lang.Exception e) {
  21353.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  21354.                 this.isProxyReadJMXResourcesAsyncProcessByTimerDebug = true;
  21355.             }    
  21356.         }

  21358.         return this.isProxyReadJMXResourcesAsyncProcessByTimerDebug;
  21359.     }
  21360.     
  21361.     private String getProxyReadJMXResourcesAsyncProcessByTimerHostname = null;
  21362.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerHostnameRead = null;
  21363.     public String getProxyReadJMXResourcesAsyncProcessByTimerHostname() {   
  21364.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerHostnameRead==null){
  21365.             try{ 
  21366.                 String name = null;
  21367.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.hostname");
  21368.                 if(name!=null){
  21369.                     name = name.trim();
  21370.                 }
  21371.                 this.getProxyReadJMXResourcesAsyncProcessByTimerHostnameRead = true;
  21372.                 this.getProxyReadJMXResourcesAsyncProcessByTimerHostname = name;
  21373.             } catch(java.lang.Exception e) {
  21374.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.hostname': "+e.getMessage(),e);
  21375.             }    
  21376.         }
  21377.         return this.getProxyReadJMXResourcesAsyncProcessByTimerHostname;
  21378.     }
  21379.     
  21380.     private String getProxyReadJMXResourcesAsyncProcessByTimerSchema = null;
  21381.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerSchemaRead = null;
  21382.     public String getProxyReadJMXResourcesAsyncProcessByTimerSchema() { 
  21383.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerSchemaRead==null){
  21384.             try{ 
  21385.                 String name = null;
  21386.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.schema");
  21387.                 if(name!=null){
  21388.                     name = name.trim();
  21389.                 }
  21390.                 this.getProxyReadJMXResourcesAsyncProcessByTimerSchemaRead = true;
  21391.                 this.getProxyReadJMXResourcesAsyncProcessByTimerSchema = name;
  21392.             } catch(java.lang.Exception e) {
  21393.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.schema': "+e.getMessage(),e);
  21394.             }    
  21395.         }
  21396.         return this.getProxyReadJMXResourcesAsyncProcessByTimerSchema;
  21397.     }
  21398.     
  21399.     private Integer getProxyReadJMXResourcesAsyncProcessByTimerPort = null;
  21400.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerPortRead = null;
  21401.     public Integer getProxyReadJMXResourcesAsyncProcessByTimerPort() {  
  21402.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerPortRead==null){
  21403.             try{ 
  21404.                 String name = null;
  21405.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.port");
  21406.                 if(name!=null){
  21407.                     name = name.trim();
  21408.                     this.getProxyReadJMXResourcesAsyncProcessByTimerPort = Integer.valueOf(name);
  21409.                 }
  21410.                 this.getProxyReadJMXResourcesAsyncProcessByTimerPortRead = true;
  21411.             } catch(java.lang.Exception e) {
  21412.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.port': "+e.getMessage(),e);
  21413.             }    
  21414.         }
  21415.         return this.getProxyReadJMXResourcesAsyncProcessByTimerPort;
  21416.     }
  21417.     
  21418.     private Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval = null;
  21419.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerCheckIntervalRead = null;
  21420.     public Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval() { 
  21421.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerCheckIntervalRead==null){
  21422.             try{ 
  21423.                 String name = null;
  21424.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.checkInterval");
  21425.                 if(name!=null){
  21426.                     name = name.trim();
  21427.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval = Integer.valueOf(name);
  21428.                 }
  21429.                 else {
  21430.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.checkInterval' non impostata, viene utilizzato il default=60");
  21431.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval = 60;
  21432.                 }
  21433.             } catch(java.lang.Exception e) {
  21434.                 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);
  21435.                 this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval = 60;
  21436.             }
  21437.             this.getProxyReadJMXResourcesAsyncProcessByTimerCheckIntervalRead = true;
  21438.         }
  21439.         return this.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval;
  21440.     }
  21441.     
  21442.     private Integer getProxyReadJMXResourcesAsyncProcessByTimerLimit = null;
  21443.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerLimitRead = null;
  21444.     public Integer getProxyReadJMXResourcesAsyncProcessByTimerLimit() { 
  21445.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerLimitRead==null){
  21446.             try{ 
  21447.                 String name = null;
  21448.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.limit");
  21449.                 if(name!=null){
  21450.                     name = name.trim();
  21451.                     this.getProxyReadJMXResourcesAsyncProcessByTimerLimit = Integer.valueOf(name);
  21452.                 }
  21453.                 else {
  21454.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.limit' non impostata, viene utilizzato il default=100");
  21455.                     this.getProxyReadJMXResourcesAsyncProcessByTimerLimit = 100;
  21456.                 }
  21457.             } catch(java.lang.Exception e) {
  21458.                 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);
  21459.                 this.getProxyReadJMXResourcesAsyncProcessByTimerLimit = 100;
  21460.             }
  21461.             this.getProxyReadJMXResourcesAsyncProcessByTimerLimitRead = true;
  21462.         }
  21463.         return this.getProxyReadJMXResourcesAsyncProcessByTimerLimit;
  21464.     }
  21465.     
  21466.     private Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval = null;
  21467.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordIntervalRead = null;
  21468.     public Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval() {    
  21469.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordIntervalRead==null){
  21470.             try{ 
  21471.                 String name = null;
  21472.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.checkInterval");
  21473.                 if(name!=null){
  21474.                     name = name.trim();
  21475.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval = Integer.valueOf(name);
  21476.                 }
  21477.                 else {
  21478.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.checkInterval' non impostata, viene utilizzato il default=3600");
  21479.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval = 3600;
  21480.                 }
  21481.             } catch(java.lang.Exception e) {
  21482.                 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);
  21483.                 this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval = 3600;
  21484.             }
  21485.             this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordIntervalRead = true;
  21486.         }
  21487.         return this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval;
  21488.     }
  21489.     
  21490.     private Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes = null;
  21491.     private Boolean getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutesRead = null;
  21492.     public Integer getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes() {  
  21493.         if(this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutesRead==null){
  21494.             try{ 
  21495.                 String name = null;
  21496.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.olderThanMinutes");
  21497.                 if(name!=null){
  21498.                     name = name.trim();
  21499.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes = Integer.valueOf(name);
  21500.                 }
  21501.                 else {
  21502.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.asyncUpdate.historyCleaning.olderThanMinutes' non impostata, viene utilizzato il default=60");
  21503.                     this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes = 60;
  21504.                 }
  21505.             } catch(java.lang.Exception e) {
  21506.                 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);
  21507.                 this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes = 60;
  21508.             }
  21509.             this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutesRead = true;
  21510.         }
  21511.         return this.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordDeleteOlderThanMinutes;
  21512.     }
  21513.     
  21514.     private String getProxyReadJMXResourcesSchema = null;
  21515.     private Boolean getProxyReadJMXResourcesSchemaRead = null;
  21516.     public String getProxyReadJMXResourcesSchema() {    
  21517.         if(this.getProxyReadJMXResourcesSchemaRead==null){
  21518.             try{ 
  21519.                 String name = null;
  21520.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.schema");
  21521.                 if(name!=null){
  21522.                     name = name.trim();
  21523.                 }
  21524.                 this.getProxyReadJMXResourcesSchemaRead = true;
  21525.                 this.getProxyReadJMXResourcesSchema = name;
  21526.             } catch(java.lang.Exception e) {
  21527.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.schema': "+e.getMessage(),e);
  21528.             }    
  21529.         }
  21530.         return this.getProxyReadJMXResourcesSchema;
  21531.     }
  21532.     
  21533.     private Integer getProxyReadJMXResourcesPort = null;
  21534.     private Boolean getProxyReadJMXResourcesPortRead = null;
  21535.     public Integer getProxyReadJMXResourcesPort() { 
  21536.         if(this.getProxyReadJMXResourcesPortRead==null){
  21537.             try{ 
  21538.                 String name = null;
  21539.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.port");
  21540.                 if(name!=null){
  21541.                     name = name.trim();
  21542.                     this.getProxyReadJMXResourcesPort = Integer.valueOf(name);
  21543.                 }
  21544.                 this.getProxyReadJMXResourcesPortRead = true;
  21545.             } catch(java.lang.Exception e) {
  21546.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.port': "+e.getMessage(),e);
  21547.             }    
  21548.         }
  21549.         return this.getProxyReadJMXResourcesPort;
  21550.     }
  21551.     
  21552.     // utile per debug: invoco tutte le volte
  21553.     public Integer getProxyReadJMXResourcesPort(String hostname) {  
  21554.         try{ 
  21555.             String name = null;
  21556.             name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.port."+hostname);
  21557.             if(name!=null){
  21558.                 name = name.trim();
  21559.                 return Integer.valueOf(name);
  21560.             }
  21561.         } catch(java.lang.Exception e) {
  21562.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.port."+hostname+"': "+e.getMessage(),e);
  21563.         }    
  21564.         return null;
  21565.     }
  21566.     
  21567.     private String getProxyReadJMXResourcesUsername = null;
  21568.     private Boolean getProxyReadJMXResourcesUsernameRead = null;
  21569.     public String getProxyReadJMXResourcesUsername() {  
  21570.         if(this.getProxyReadJMXResourcesUsernameRead==null){
  21571.             try{ 
  21572.                 String name = null;
  21573.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.username");
  21574.                 if(name!=null){
  21575.                     name = name.trim();
  21576.                 }
  21577.                 this.getProxyReadJMXResourcesUsernameRead = true;
  21578.                 this.getProxyReadJMXResourcesUsername = name;
  21579.             } catch(java.lang.Exception e) {
  21580.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.username': "+e.getMessage(),e);
  21581.             }    
  21582.         }
  21583.         return this.getProxyReadJMXResourcesUsername;
  21584.     }
  21585.     
  21586.     private String getProxyReadJMXResourcesPassword = null;
  21587.     private Boolean getProxyReadJMXResourcesPasswordRead = null;
  21588.     public String getProxyReadJMXResourcesPassword() {  
  21589.         if(this.getProxyReadJMXResourcesPasswordRead==null){
  21590.             try{ 
  21591.                 String name = null;
  21592.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.password");
  21593.                 if(name!=null){
  21594.                     name = name.trim();
  21595.                 }
  21596.                 this.getProxyReadJMXResourcesPasswordRead = true;
  21597.                 this.getProxyReadJMXResourcesPassword = name;
  21598.             } catch(java.lang.Exception e) {
  21599.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.password': "+e.getMessage(),e);
  21600.             }    
  21601.         }
  21602.         return this.getProxyReadJMXResourcesPassword;
  21603.     }
  21604.     
  21605.     private Boolean isProxyReadJMXResourcesHttpsEnabled = null;
  21606.     public boolean isProxyReadJMXResourcesHttpsEnabled() {  
  21607.         if(this.isProxyReadJMXResourcesHttpsEnabled==null){
  21608.             String pName = "org.openspcoop2.pdd.proxyJMXResources.https";
  21609.             try{ 
  21610.                 String name = null;
  21611.                 name = this.reader.getValueConvertEnvProperties(pName);
  21612.                 if(name==null){
  21613.                     this.logDebug(getMessaggioProprietaNonImpostata(pName, false));
  21614.                     name="false";
  21615.                 }
  21616.                 name = name.trim();
  21617.                 this.isProxyReadJMXResourcesHttpsEnabled = Boolean.parseBoolean(name);
  21618.             } catch(java.lang.Exception e) {
  21619.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21620.                 this.isProxyReadJMXResourcesHttpsEnabled = false;
  21621.             }    
  21622.         }

  21624.         return this.isProxyReadJMXResourcesHttpsEnabled;
  21625.     }
  21626.     
  21627.     private Boolean isProxyReadJMXResourcesHttpsEnabledVerificaHostName = null;
  21628.     public boolean isProxyReadJMXResourcesHttpsEnabledVerificaHostName() {  
  21629.         if(this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName==null){
  21630.             String pName = "org.openspcoop2.pdd.proxyJMXResources.https.verificaHostName";
  21631.             try{ 
  21632.                 String name = null;
  21633.                 name = this.reader.getValueConvertEnvProperties(pName);
  21634.                 if(name==null){
  21635.                     this.logDebug(getMessaggioProprietaNonImpostata(pName, true));
  21636.                     name="true";
  21637.                 }
  21638.                 name = name.trim();
  21639.                 this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName = Boolean.parseBoolean(name);
  21640.             } catch(java.lang.Exception e) {
  21641.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21642.                 this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName = true;
  21643.             }    
  21644.         }

  21646.         return this.isProxyReadJMXResourcesHttpsEnabledVerificaHostName;
  21647.     }
  21648.     
  21649.     private Boolean isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer = null;
  21650.     public boolean isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer() {  
  21651.         if(this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer==null){
  21652.             String pName = "org.openspcoop2.pdd.proxyJMXResources.https.autenticazioneServer";
  21653.             try{ 
  21654.                 String name = null;
  21655.                 name = this.reader.getValueConvertEnvProperties(pName);
  21656.                 if(name==null){
  21657.                     this.logDebug(getMessaggioProprietaNonImpostata(pName, true));
  21658.                     name="true";
  21659.                 }
  21660.                 name = name.trim();
  21661.                 this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer = Boolean.parseBoolean(name);
  21662.             } catch(java.lang.Exception e) {
  21663.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21664.                 this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer = true;
  21665.             }    
  21666.         }

  21668.         return this.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer;
  21669.     }
  21670.     
  21671.     private String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath = null;
  21672.     private Boolean getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePathRead = null;
  21673.     public String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath() {    
  21674.         if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePathRead==null){
  21675.             String pName = "org.openspcoop2.pdd.proxyJMXResources.https.autenticazioneServer.truststorePath";
  21676.             try{ 
  21677.                 String name = null;
  21678.                 name = this.reader.getValueConvertEnvProperties(pName);
  21679.                 if(name!=null){
  21680.                     name = name.trim();
  21681.                 }
  21682.                 else {
  21683.                     throw new CoreException(NON_DEFINITA);
  21684.                 }
  21685.                 this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePathRead = true;
  21686.                 this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath = name;
  21687.             } catch(java.lang.Exception e) {
  21688.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21689.             }    
  21690.         }
  21691.         return this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath;
  21692.     }
  21693.     
  21694.     private String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType = null;
  21695.     private Boolean getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreTypeRead = null;
  21696.     public String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType() {    
  21697.         if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreTypeRead==null){
  21698.             String pName = "org.openspcoop2.pdd.proxyJMXResources.https.autenticazioneServer.truststoreType";
  21699.             try{ 
  21700.                 String name = null;
  21701.                 name = this.reader.getValueConvertEnvProperties(pName);
  21702.                 if(name!=null){
  21703.                     name = name.trim();
  21704.                 }
  21705.                 else {
  21706.                     throw new CoreException(NON_DEFINITA);
  21707.                 }
  21708.                 this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreTypeRead = true;
  21709.                 this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType = name;
  21710.             } catch(java.lang.Exception e) {
  21711.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21712.             }    
  21713.         }
  21714.         return this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType;
  21715.     }
  21716.     
  21717.     private String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword = null;
  21718.     private Boolean getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePasswordRead = null;
  21719.     public String getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword() {    
  21720.         if(this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePasswordRead==null){
  21721.             String pName = "org.openspcoop2.pdd.proxyJMXResources.https.autenticazioneServer.truststorePassword";
  21722.             try{ 
  21723.                 String name = null;
  21724.                 name = this.reader.getValueConvertEnvProperties(pName);
  21725.                 if(name!=null){
  21726.                     name = name.trim();
  21727.                 }
  21728.                 else {
  21729.                     throw new CoreException(NON_DEFINITA);
  21730.                 }
  21731.                 this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePasswordRead = true;
  21732.                 this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword = name;
  21733.             } catch(java.lang.Exception e) {
  21734.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21735.             }    
  21736.         }
  21737.         return this.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword;
  21738.     }
  21739.     
  21740.     private Integer getProxyReadJMXResourcesConnectionTimeout = null;
  21741.     public Integer getProxyReadJMXResourcesConnectionTimeout() {    
  21742.         if(this.getProxyReadJMXResourcesConnectionTimeout==null){
  21743.             try{ 
  21744.                 String name = null;
  21745.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.connection.timeout");
  21746.                 if(name!=null){
  21747.                     name = name.trim();
  21748.                 }
  21749.                 else {
  21750.                     throw new CoreException("non esistente");
  21751.                 }
  21752.                 this.getProxyReadJMXResourcesConnectionTimeout = Integer.valueOf(name);
  21753.             } catch(java.lang.Exception e) {
  21754.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.connection.timeout': "+e.getMessage(),e);
  21755.             }    
  21756.         }
  21757.         return this.getProxyReadJMXResourcesConnectionTimeout;
  21758.     }
  21759.     
  21760.     private Integer getProxyReadJMXResourcesReadTimeout = null;
  21761.     public Integer getProxyReadJMXResourcesReadTimeout() {  
  21762.         if(this.getProxyReadJMXResourcesReadTimeout==null){
  21763.             try{ 
  21764.                 String name = null;
  21765.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.proxyJMXResources.readConnection.timeout");
  21766.                 if(name!=null){
  21767.                     name = name.trim();
  21768.                 }
  21769.                 else {
  21770.                     throw new CoreException("non esistente");
  21771.                 }
  21772.                 this.getProxyReadJMXResourcesReadTimeout = Integer.valueOf(name);
  21773.             } catch(java.lang.Exception e) {
  21774.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.proxyJMXResources.readConnection.timeout': "+e.getMessage(),e);
  21775.             }    
  21776.         }
  21777.         return this.getProxyReadJMXResourcesReadTimeout;
  21778.     }
  21779.     
  21780.     

  21782.     
  21783.     /* -------------Datasource Wrapped  ---------------------*/
  21784.     
  21785.     private Boolean isDSOp2UtilsEnabled = null;
  21786.     public boolean isDSOp2UtilsEnabled() {  
  21787.         if(this.isDSOp2UtilsEnabled==null){
  21788.             try{ 
  21789.                 String name = null;
  21790.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.datasource.useDSUtils");
  21791.                 if(name==null){
  21792.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.datasource.useDSUtils' non impostata, viene utilizzato il default=false");
  21793.                     name="false";
  21794.                 }
  21795.                 name = name.trim();
  21796.                 this.isDSOp2UtilsEnabled = Boolean.parseBoolean(name);
  21797.             } catch(java.lang.Exception e) {
  21798.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.datasource.useDSUtils': "+e.getMessage(),e);
  21799.                 this.isDSOp2UtilsEnabled = false;
  21800.             }    
  21801.         }

  21803.         return this.isDSOp2UtilsEnabled;
  21804.     }
  21805.     
  21806.     
  21807.     
  21808.     /* ------------- Datasource check in getConnection event  ---------------------*/
  21809.     
  21810.     private Boolean isDataSourceGetConnectionCheckAutoCommitDisabled = null;
  21811.     public boolean isDataSourceGetConnectionCheckAutoCommitDisabled() { 
  21812.         String pName = "org.openspcoop2.pdd.datasource.getConnection.checkAutoCommitDisabled";
  21813.         if(this.isDataSourceGetConnectionCheckAutoCommitDisabled==null){
  21814.             try{ 
  21815.                 String name = null;
  21816.                 name = this.reader.getValueConvertEnvProperties(pName);
  21817.                 if(name==null){
  21818.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  21819.                     name="true";
  21820.                 }
  21821.                 name = name.trim();
  21822.                 this.isDataSourceGetConnectionCheckAutoCommitDisabled = Boolean.parseBoolean(name);
  21823.             } catch(java.lang.Exception e) {
  21824.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21825.                 this.isDataSourceGetConnectionCheckAutoCommitDisabled = true;
  21826.             }    
  21827.         }

  21829.         return this.isDataSourceGetConnectionCheckAutoCommitDisabled;
  21830.     }
  21831.     
  21832.     private Boolean isDataSourceGetConnectionCheckTransactionIsolationLevel = null;
  21833.     public boolean isDataSourceGetConnectionCheckTransactionIsolationLevel() {  
  21834.         String pName = "org.openspcoop2.pdd.datasource.getConnection.checkTransactionIsolationLevel";
  21835.         if(this.isDataSourceGetConnectionCheckTransactionIsolationLevel==null){
  21836.             try{ 
  21837.                 String name = null;
  21838.                 name = this.reader.getValueConvertEnvProperties(pName);
  21839.                 if(name==null){
  21840.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  21841.                     name="true";
  21842.                 }
  21843.                 name = name.trim();
  21844.                 this.isDataSourceGetConnectionCheckTransactionIsolationLevel = Boolean.parseBoolean(name);
  21845.             } catch(java.lang.Exception e) {
  21846.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21847.                 this.isDataSourceGetConnectionCheckTransactionIsolationLevel = true;
  21848.             }    
  21849.         }

  21851.         return this.isDataSourceGetConnectionCheckTransactionIsolationLevel;
  21852.     }
  21853.     
  21854.     private Integer getDataSourceGetConnectionCheckTransactionIsolationLevelExpected = null;
  21855.     public int getDataSourceGetConnectionCheckTransactionIsolationLevelExpected() { 
  21856.         String pName = "org.openspcoop2.pdd.datasource.getConnection.checkTransactionIsolationLevel.expected";
  21857.         if(this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected==null){
  21858.             try{ 
  21859.                 String name = null;
  21860.                 name = this.reader.getValueConvertEnvProperties(pName);
  21861.                 if(name==null){
  21862.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,Connection.TRANSACTION_READ_COMMITTED));
  21863.                     name=Connection.TRANSACTION_READ_COMMITTED+"";
  21864.                 }
  21865.                 name = name.trim();
  21866.                 this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected = Integer.valueOf(name);
  21867.             } catch(java.lang.Exception e) {
  21868.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  21869.                 this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected = Connection.TRANSACTION_READ_COMMITTED;
  21870.             }    
  21871.         }

  21873.         return this.getDataSourceGetConnectionCheckTransactionIsolationLevelExpected;
  21874.     }
  21875.     

  21877.     
  21878.     
  21879.     /* ------------- NotifierInputStream  ---------------------*/
  21880.     
  21881.     private Boolean isNotifierInputStreamEnabled = null;
  21882.     public boolean isNotifierInputStreamEnabled(){

  21884.         if(this.isNotifierInputStreamEnabled==null){
  21885.             try{  
  21886.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.notifierInputStream.enabled"); 

  21888.                 if (value != null){
  21889.                     value = value.trim();
  21890.                     this.isNotifierInputStreamEnabled = Boolean.parseBoolean(value);
  21891.                 }else{
  21892.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.notifierInputStream.enabled' non impostata, viene utilizzato il default=false");
  21893.                     this.isNotifierInputStreamEnabled = false;
  21894.                 }

  21896.             }catch(java.lang.Exception e) {
  21897.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.notifierInputStream.enabled' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  21898.                 this.isNotifierInputStreamEnabled = false;
  21899.             }
  21900.         }

  21902.         return this.isNotifierInputStreamEnabled;
  21903.     }
  21904.     
  21905.     private String notifierInputStreamCallback = null;      
  21906.     private Boolean notifierInputStreamCallbackRead = null;     
  21907.     public String getNotifierInputStreamCallback() throws CoreException{
  21908.         if(this.notifierInputStreamCallbackRead==null){
  21909.             try{ 
  21910.                 this.notifierInputStreamCallback = this.reader.getValue("org.openspcoop2.pdd.notifierInputStream.tipo");
  21911.                 if(this.notifierInputStreamCallback!=null){
  21912.                     this.notifierInputStreamCallback = this.notifierInputStreamCallback.trim();
  21913.                 }
  21914.                 this.notifierInputStreamCallbackRead = true;
  21915.             } catch(java.lang.Exception e) {
  21916.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.notifierInputStream.tipo' non impostata correttamente,  errore:"+e.getMessage(),e);
  21917.                 throw new CoreException("Proprieta' di openspcoop 'org.openspcoop2.pdd.notifierInputStream.tipo' non impostata correttamente,  errore:"+e.getMessage(),e);
  21918.             } 
  21919.         }
  21920.         return this.notifierInputStreamCallback;
  21921.     }
  21922.     
  21923.     
  21924.     /* ------------- PipeUnblockedVersion  ---------------------*/
  21925.     
  21926.     private String pipedUnblockedStreamClassName = null;        
  21927.     private Boolean pipedUnblockedStreamClassNameRead = null;       
  21928.     public String getPipedUnblockedStreamClassName() throws CoreException{
  21929.         if(this.pipedUnblockedStreamClassNameRead==null){
  21930.             String pName = "org.openspcoop2.pdd.pipedUnblockedStream.className";
  21931.             try{ 
  21932.                 this.pipedUnblockedStreamClassName = this.reader.getValue(pName);
  21933.                 if(this.pipedUnblockedStreamClassName!=null){
  21934.                     this.pipedUnblockedStreamClassName = this.pipedUnblockedStreamClassName.trim();
  21935.                 }
  21936.                 this.pipedUnblockedStreamClassNameRead = true;
  21937.             } catch(java.lang.Exception e) {
  21938.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  21939.                 throw new CoreException("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  21940.             } 
  21941.         }
  21942.         return this.pipedUnblockedStreamClassName;
  21943.     }
  21944.     
  21945.     
  21946.     
  21947.     
  21948.     /* ------------- FORMURLEncoder  ---------------------*/
  21949.     
  21950.     private Boolean isFormUrlEncodedFilterEnabled = null;
  21951.     public boolean isFormUrlEncodedFilterEnabled(){

  21953.         if(this.isFormUrlEncodedFilterEnabled==null){
  21954.             try{  
  21955.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.formUrlEncodedFilter.enabled"); 

  21957.                 if (value != null){
  21958.                     value = value.trim();
  21959.                     this.isFormUrlEncodedFilterEnabled = Boolean.parseBoolean(value);
  21960.                 }else{
  21961.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.formUrlEncodedFilter.enabled' non impostata, viene utilizzato il default=false");
  21962.                     this.isFormUrlEncodedFilterEnabled = false;
  21963.                 }

  21965.             }catch(java.lang.Exception e) {
  21966.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.formUrlEncodedFilter.enabled' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  21967.                 this.isFormUrlEncodedFilterEnabled = false;
  21968.             }
  21969.         }

  21971.         return this.isFormUrlEncodedFilterEnabled;
  21972.     }
  21973.     
  21974.     
  21975.     
  21976.     /* ------------- FORMURLEncoder  ---------------------*/
  21977.     
  21978.     private Boolean isWildflyUndertowClientCertificateFilterEnabled = null;
  21979.     public boolean isWildflyUndertowClientCertificateFilterEnabled(){

  21981.         String pName = "org.openspcoop2.pdd.wildflyUndertowClientCertificateFilter.enabled";
  21982.         if(this.isWildflyUndertowClientCertificateFilterEnabled==null){
  21983.             try{  
  21984.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  21986.                 if (value != null){
  21987.                     value = value.trim();
  21988.                     this.isWildflyUndertowClientCertificateFilterEnabled = Boolean.parseBoolean(value);
  21989.                 }else{
  21990.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  21991.                     this.isWildflyUndertowClientCertificateFilterEnabled = false;
  21992.                 }

  21994.             }catch(java.lang.Exception e) {
  21995.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  21996.                 this.isWildflyUndertowClientCertificateFilterEnabled = false;
  21997.             }
  21998.         }

  22000.         return this.isWildflyUndertowClientCertificateFilterEnabled;
  22001.     }
  22002.     
  22003.     
  22004.     
  22005.     
  22006.     /* ------------- SEMAPHORE  ---------------------*/
  22007.     
  22008.     private Long getSemaphoreTimeoutMS = null;
  22009.     public long getSemaphoreTimeoutMS(){

  22011.         String pName = "org.openspcoop2.pdd.semaphore.timeoutMS";
  22012.         if(this.getSemaphoreTimeoutMS==null){
  22013.             try{  
  22014.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22016.                 if (value != null){
  22017.                     value = value.trim();
  22018.                     this.getSemaphoreTimeoutMS = Long.parseLong(value);
  22019.                 }else{
  22020.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+Semaphore.DEFAULT_LOCK_ACQUISITION_TIMEOUT_MS);
  22021.                     this.getSemaphoreTimeoutMS = Semaphore.DEFAULT_LOCK_ACQUISITION_TIMEOUT_MS;
  22022.                 }

  22024.             }catch(java.lang.Exception e) {
  22025.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+Semaphore.DEFAULT_LOCK_ACQUISITION_TIMEOUT_MS+", errore:"+e.getMessage(),e);
  22026.                 this.getSemaphoreTimeoutMS = Semaphore.DEFAULT_LOCK_ACQUISITION_TIMEOUT_MS;
  22027.             }
  22028.         }

  22030.         return this.getSemaphoreTimeoutMS;
  22031.     }
  22032.     
  22033.     private Long getSemaphoreHoldTimeoutMS = null;
  22034.     public long getSemaphoreHoldTimeoutMS(){

  22036.         String pName = "org.openspcoop2.pdd.semaphore.hold.timeoutMS";
  22037.         if(this.getSemaphoreHoldTimeoutMS==null){
  22038.             try{  
  22039.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22041.                 if (value != null){
  22042.                     value = value.trim();
  22043.                     this.getSemaphoreHoldTimeoutMS = Long.parseLong(value);
  22044.                 }else{
  22045.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+Semaphore.DEFAULT_LOCK_HOLD_TIMEOUT_MS);
  22046.                     this.getSemaphoreHoldTimeoutMS = Semaphore.DEFAULT_LOCK_HOLD_TIMEOUT_MS;
  22047.                 }

  22049.             }catch(java.lang.Exception e) {
  22050.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+Semaphore.DEFAULT_LOCK_HOLD_TIMEOUT_MS+", errore:"+e.getMessage(),e);
  22051.                 this.getSemaphoreHoldTimeoutMS = Semaphore.DEFAULT_LOCK_HOLD_TIMEOUT_MS;
  22052.             }
  22053.         }

  22055.         return this.getSemaphoreHoldTimeoutMS;
  22056.     }
  22057.     
  22058.     private Boolean isSemaphoreDebug = null;
  22059.     public boolean isSemaphoreDebug(){

  22061.         String pName = "org.openspcoop2.pdd.semaphore.debug";
  22062.         if(this.isSemaphoreDebug==null){
  22063.             try{  
  22064.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22066.                 if (value != null){
  22067.                     value = value.trim();
  22068.                     this.isSemaphoreDebug = Boolean.parseBoolean(value);
  22069.                 }else{
  22070.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  22071.                     this.isSemaphoreDebug = false;
  22072.                 }

  22074.             }catch(java.lang.Exception e) {
  22075.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  22076.                 this.isSemaphoreDebug = false;
  22077.             }
  22078.         }

  22080.         return this.isSemaphoreDebug;
  22081.     }
  22082.     
  22083.     private SemaphoreType getSemaphoreType = null;
  22084.     public SemaphoreType getSemaphoreType(){

  22086.         String pName = "org.openspcoop2.pdd.semaphore.type";
  22087.         if(this.getSemaphoreType==null){
  22088.             
  22089.             SemaphoreType defaultV = SemaphoreType.Semaphore;
  22090.             
  22091.             try{  
  22092.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22094.                 if (value != null){
  22095.                     value = value.trim();
  22096.                     this.getSemaphoreType = SemaphoreType.valueOf(value);
  22097.                 }else{
  22098.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultV.toString()));
  22099.                     this.getSemaphoreType = defaultV;
  22100.                 }

  22102.             }catch(java.lang.Exception e) {
  22103.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,defaultV.toString()),e);
  22104.                 this.getSemaphoreType = defaultV;
  22105.             }
  22106.         }

  22108.         return this.getSemaphoreType;
  22109.     }
  22110.     
  22111.     private Boolean isSemaphoreFair = null;
  22112.     public boolean isSemaphoreFair(){

  22114.         String pName = "org.openspcoop2.pdd.semaphore.fair";
  22115.         if(this.isSemaphoreFair==null){
  22116.             try{  
  22117.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22119.                 if (value != null){
  22120.                     value = value.trim();
  22121.                     this.isSemaphoreFair = Boolean.parseBoolean(value);
  22122.                 }else{
  22123.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  22124.                     this.isSemaphoreFair = true;
  22125.                 }

  22127.             }catch(java.lang.Exception e) {
  22128.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  22129.                 this.isSemaphoreFair = true;
  22130.             }
  22131.         }

  22133.         return this.isSemaphoreFair;
  22134.     }
  22135.     
  22136.     
  22137.         
  22138.     /* ------------- JMINIX Console  ---------------------*/
  22139.     
  22140.     private Integer portJminixConsole = null;
  22141.     private Boolean portJminixConsoleReaded = null;
  22142.     public Integer getPortJminixConsole() { 
  22143.         if(this.portJminixConsoleReaded==null){
  22144.             try{ 
  22145.                 String p = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.jminix.port");
  22146.                 if(p!=null){
  22147.                     p = p.trim();
  22148.                     this.portJminixConsole = Integer.parseInt(p);
  22149.                 }
  22150.                 this.portJminixConsoleReaded = true;
  22151.             } catch(java.lang.Exception e) {
  22152.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.jminix.port': "+e.getMessage(),e);
  22153.                 this.portJminixConsoleReaded = true;
  22154.             }    
  22155.         }

  22157.         return this.portJminixConsole;
  22158.     }
  22159.     
  22160.     
  22161.     
  22162.     

  22164.     /* ------------- Custom Function ---------------------*/
  22165.     
  22166.     private Boolean isEnabledFunctionPD = null;
  22167.     public boolean isEnabledFunctionPD() {  
  22168.         if(this.isEnabledFunctionPD==null){
  22169.             try{ 
  22170.                 String name = null;
  22171.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.function.pd.enabled");
  22172.                 if(name==null){
  22173.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.function.pd.enabled' non impostata, viene utilizzato il default=false");
  22174.                     name="true";
  22175.                 }
  22176.                 name = name.trim();
  22177.                 this.isEnabledFunctionPD = Boolean.parseBoolean(name);
  22178.             } catch(java.lang.Exception e) {
  22179.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.function.pd.enabled': "+e.getMessage(),e);
  22180.                 this.isEnabledFunctionPD = false;
  22181.             }    
  22182.         }

  22184.         return this.isEnabledFunctionPD;
  22185.     }
  22186.     
  22187.     private Boolean isEnabledFunctionPDtoSOAP = null;
  22188.     public boolean isEnabledFunctionPDtoSOAP() {    
  22189.         if(this.isEnabledFunctionPDtoSOAP==null){
  22190.             try{ 
  22191.                 String name = null;
  22192.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.function.pdToSoap.enabled");
  22193.                 if(name==null){
  22194.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.function.pdToSoap.enabled' non impostata, viene utilizzato il default=false");
  22195.                     name="true";
  22196.                 }
  22197.                 name = name.trim();
  22198.                 this.isEnabledFunctionPDtoSOAP = Boolean.parseBoolean(name);
  22199.             } catch(java.lang.Exception e) {
  22200.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.function.pdToSoap.enabled': "+e.getMessage(),e);
  22201.                 this.isEnabledFunctionPDtoSOAP = false;
  22202.             }    
  22203.         }

  22205.         return this.isEnabledFunctionPDtoSOAP;
  22206.     }
  22207.     
  22208.     private Boolean isEnabledFunctionPA = null;
  22209.     public boolean isEnabledFunctionPA() {  
  22210.         if(this.isEnabledFunctionPA==null){
  22211.             try{ 
  22212.                 String name = null;
  22213.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.function.pa.enabled");
  22214.                 if(name==null){
  22215.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.function.pa.enabled' non impostata, viene utilizzato il default=false");
  22216.                     name="true";
  22217.                 }
  22218.                 name = name.trim();
  22219.                 this.isEnabledFunctionPA = Boolean.parseBoolean(name);
  22220.             } catch(java.lang.Exception e) {
  22221.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.function.pa.enabled': "+e.getMessage(),e);
  22222.                 this.isEnabledFunctionPA = false;
  22223.             }    
  22224.         }

  22226.         return this.isEnabledFunctionPA;
  22227.     }
  22228.     
  22229.     
  22230.     private FunctionContextsCustom customContexts = null;
  22231.     public FunctionContextsCustom getCustomContexts() throws UtilsException {   
  22232.         if(this.customContexts==null){
  22233.             try{ 
  22234.                 Properties p = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.function.custom.");
  22235.                 if(p!=null && p.size()>0) {
  22236.                     Enumeration<Object> en = p.keys();
  22237.                     while (en.hasMoreElements()) {
  22238.                         Object object = (Object) en.nextElement();
  22239.                         if(object instanceof String) {
  22240.                             String s = (String) object;
  22241.                             if(s.endsWith(".context")) {
  22242.                                 String alias = s.substring(0,s.indexOf(".context"));
  22243.                                 
  22244.                                 String context = p.getProperty(s);
  22245.                                 if(context==null || "".equals(context.trim())) {
  22246.                                     throw new CoreException("Context not defined for alias '"+alias+"'");
  22247.                                 }
  22248.                                 context = context.trim();
  22249.                                 
  22250.                                 String service = p.getProperty(alias+".service");
  22251.                                 boolean serviceFound = false;
  22252.                                 FunctionContextCustom customWithoutSubContext = null;
  22253.                                 IDService idServiceCustomWithoutSubContext = null;
  22254.                                 if(service!=null && !"".equals(service.trim())) {
  22255.                                     idServiceCustomWithoutSubContext = IDService.toEnumConstant(service);
  22256.                                     if(idServiceCustomWithoutSubContext==null) {
  22257.                                         throw new CoreException("Value '"+service+"' unsupported for service in alias '"+alias+"'");
  22258.                                     }
  22259.                                     customWithoutSubContext = new FunctionContextCustom(context, idServiceCustomWithoutSubContext);
  22260.                                     serviceFound = true;
  22261.                                     // lo registro dopo gli eventuali subcontext
  22262.                                 }

  22264.                                 Properties pSubContext = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.function.custom."+alias+".subcontext.");
  22265.                                 if(pSubContext==null || pSubContext.size()<=0) {
  22266.                                     if(!serviceFound) {
  22267.                                         throw new CoreException("Service and SubContext undefined for alias '"+alias+"'");
  22268.                                     }
  22269.                                 }
  22270.                                 else {
  22271.                                     HashMap<String,IDService> subcontextMap = new HashMap<String,IDService>();
  22272.                                     Enumeration<Object> enSubContext = pSubContext.keys();
  22273.                                     while (enSubContext.hasMoreElements()) {
  22274.                                         Object objectSubContext = (Object) enSubContext.nextElement();
  22275.                                         if(objectSubContext instanceof String) {
  22276.                                             String subContextKey = (String) objectSubContext;
  22277.                                             if(subContextKey.endsWith(".url")) {
  22278.                                                 String aliasSubContext = subContextKey.substring(0,subContextKey.indexOf(".url"));
  22279.                                                 
  22280.                                                 String subContext = pSubContext.getProperty(subContextKey);
  22281.                                                 if(subContext==null || "".equals(subContext.trim())) {
  22282.                                                     throw new CoreException("Url not defined for alias '"+alias+"', subcontext '"+aliasSubContext+"'");
  22283.                                                 }
  22284.                                                 subContext = subContext.trim();
  22285.                                                 
  22286.                                                 String serviceSubContext = pSubContext.getProperty(aliasSubContext+".service");
  22287.                                                 if(serviceSubContext!=null && !"".equals(serviceSubContext.trim())) {
  22288.                                                     IDService idService = IDService.toEnumConstant(serviceSubContext);
  22289.                                                     if(idService==null) {
  22290.                                                         throw new CoreException("Value '"+serviceSubContext+"' unsupported for service in alias '"+alias+"', subcontext '"+aliasSubContext+"'");
  22291.                                                     }
  22292.                                                     subcontextMap.put(subContext, idService);   
  22293.                                                 }
  22294.                                                 else {
  22295.                                                     throw new CoreException("Service not defined for alias '"+alias+"', subcontext '"+aliasSubContext+"'");
  22296.                                                 }
  22297.                                             }
  22298.                                         }
  22299.                                     }
  22300.                                     if(subcontextMap.size()<=0) {
  22301.                                         if(!serviceFound) {
  22302.                                             throw new CoreException("SubContext undefined (wrong configuration) for alias '"+alias+"'");
  22303.                                         }
  22304.                                     }
  22305.                                     else {
  22306.                                         FunctionContextCustom custom = new FunctionContextCustom(context, subcontextMap);
  22307.                                         if(this.customContexts==null) {
  22308.                                             this.customContexts = new FunctionContextsCustom();
  22309.                                         }
  22310.                                         this.customContexts.getContexts().add(custom);
  22311.                                         Iterator<String> itS = subcontextMap.keySet().iterator();
  22312.                                         while (itS.hasNext()) {
  22313.                                             String subContext = (String) itS.next();
  22314.                                             this.logInfo("Registrato context '"+context+"', subcontext '"+subContext+"',  per service '"+subcontextMap.get(subContext)+"'");        
  22315.                                         }
  22316.                                     }
  22317.                                 }
  22318.                                 
  22319.                                 if(customWithoutSubContext!=null) {
  22320.                                     if(this.customContexts==null) {
  22321.                                         this.customContexts = new FunctionContextsCustom();
  22322.                                     }
  22323.                                     this.customContexts.getContexts().add(customWithoutSubContext);
  22324.                                     this.logInfo("Registrato context '"+context+"' per service '"+idServiceCustomWithoutSubContext+"'");
  22325.                                 }
  22326.                             }
  22327.                         }
  22328.                     }
  22329.                 }
  22330.                 
  22331.             } catch(java.lang.Exception e) {
  22332.                 this.logError("Riscontrato errore durante la lettura dei custom contexts: "+e.getMessage(),e);
  22333.                 throw new UtilsException("Riscontrato errore durante la lettura dei custom contexts: "+e.getMessage(),e);
  22334.             }    
  22335.         }

  22337.         return this.customContexts;
  22338.     }
  22339.     
  22340.     
  22341.     
  22342.     
  22343.     /* ------------- Custom Container ---------------------*/
  22344.     
  22345.     private Boolean realContainerCustomRead = null;
  22346.     private String realContainerCustom = null;
  22347.     public String getRealContainerCustom() {    
  22348.         if(this.realContainerCustomRead==null){
  22349.             try{ 
  22350.                 String v = null;
  22351.                 v = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.realmContainer.custom");
  22352.                 if(v!=null){
  22353.                     v = v.trim();
  22354.                     this.realContainerCustom = v;
  22355.                 } 
  22356.             } catch(java.lang.Exception e) {
  22357.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.realmContainer.custom' non impostata correttamente,  errore:"+e.getMessage(),e);
  22358.             } 
  22359.         }
  22360.         this.realContainerCustomRead = true;
  22361.         return this.realContainerCustom;
  22362.     }
  22363.     
  22364.     
  22365.     /* ------------- govway_configurazioneSistema ---------------------*/
  22366.     
  22367.     private Boolean isConfigurazioneSistema_javaProperties_showPassword = null;
  22368.     public boolean isConfigurazioneSistema_javaProperties_showPassword(){

  22370.         String pName = "org.openspcoop2.pdd.configurazioneSistema.javaProperties.showPassword";
  22371.         if(this.isConfigurazioneSistema_javaProperties_showPassword==null){
  22372.             try{  
  22373.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22375.                 if (value != null){
  22376.                     value = value.trim();
  22377.                     this.isConfigurazioneSistema_javaProperties_showPassword = Boolean.parseBoolean(value);
  22378.                 }else{
  22379.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  22380.                     this.isConfigurazioneSistema_javaProperties_showPassword = false;
  22381.                 }

  22383.             }catch(java.lang.Exception e) {
  22384.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  22385.                 this.isConfigurazioneSistema_javaProperties_showPassword = false;
  22386.             }
  22387.         }

  22389.         return this.isConfigurazioneSistema_javaProperties_showPassword;
  22390.     }
  22391.     
  22392.     
  22393.     /* ------------- govway startup ---------------------*/
  22394.     
  22395.     private Integer getStartupRichiesteIngressoTimeout = null;
  22396.     public int getStartupRichiesteIngressoTimeoutSecondi() {    
  22397.         if(this.getStartupRichiesteIngressoTimeout==null){
  22398.             String pName = "org.openspcoop2.pdd.startup.richiesteIngresso.timeout";
  22399.             try{ 
  22400.                 String name = null;
  22401.                 name = this.reader.getValueConvertEnvProperties(pName);

  22403.                 if(name!=null){
  22404.                     name = name.trim();
  22405.                     this.getStartupRichiesteIngressoTimeout = java.lang.Integer.parseInt(name);
  22406.                 }else{
  22407.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS));
  22408.                     this.getStartupRichiesteIngressoTimeout = CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS;
  22409.                 }
  22410.             }catch(java.lang.Exception e) {
  22411.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS),e);
  22412.                 this.getStartupRichiesteIngressoTimeout = CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS;
  22413.             }
  22414.         }

  22416.         return this.getStartupRichiesteIngressoTimeout;
  22417.     }
  22418.     private Integer getStartupRichiesteIngressoCheck = null;
  22419.     public int getStartupRichiesteIngressoCheckMs() {   
  22420.         if(this.getStartupRichiesteIngressoCheck==null){
  22421.             String pName = "org.openspcoop2.pdd.startup.richiesteIngresso.check";
  22422.             try{ 
  22423.                 String name = null;
  22424.                 name = this.reader.getValueConvertEnvProperties(pName);

  22426.                 if(name!=null){
  22427.                     name = name.trim();
  22428.                     this.getStartupRichiesteIngressoCheck = java.lang.Integer.parseInt(name);
  22429.                 }else{
  22430.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS));
  22431.                     this.getStartupRichiesteIngressoCheck = CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS;
  22432.                 }
  22433.             }catch(java.lang.Exception e) {
  22434.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS),e);
  22435.                 this.getStartupRichiesteIngressoCheck = CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS;
  22436.             }
  22437.         }

  22439.         return this.getStartupRichiesteIngressoCheck;
  22440.     }
  22441.     
  22442.     private Integer getStartupLockMaxLife = null;
  22443.     public int getStartupLockMaxLife() {    
  22444.         if(this.getStartupLockMaxLife==null){
  22445.             try{ 
  22446.                 String name = null;
  22447.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.startup.lock.maxLife");

  22449.                 if(name!=null){
  22450.                     name = name.trim();
  22451.                     this.getStartupLockMaxLife = java.lang.Integer.parseInt(name);
  22452.                 }else{
  22453.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
  22454.                     this.getStartupLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  22455.                 }
  22456.             }catch(java.lang.Exception e) {
  22457.                 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);
  22458.                 this.getStartupLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  22459.             }
  22460.             if(this.getStartupLockMaxLife!=null && this.getStartupLockMaxLife>0) {
  22461.                 // trasformo in millisecondi l'informazione fornita in secondi
  22462.                 this.getStartupLockMaxLife = this.getStartupLockMaxLife *1000;
  22463.             }
  22464.         }

  22466.         if(this.getStartupLockMaxLife!=null) {
  22467.             return this.getStartupLockMaxLife.intValue();
  22468.         }
  22469.         return -1;
  22470.     }
  22471.     
  22472.     private Integer getStartupLockIdleTime = null;
  22473.     public int getStartupLockIdleTime() {   
  22474.         if(this.getStartupLockIdleTime==null){
  22475.             try{ 
  22476.                 String name = null;
  22477.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.startup.lock.idleTime");

  22479.                 if(name!=null){
  22480.                     name = name.trim();
  22481.                     this.getStartupLockIdleTime = java.lang.Integer.parseInt(name);
  22482.                 }else{
  22483.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.startup.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  22484.                     this.getStartupLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  22485.                 }
  22486.             }catch(java.lang.Exception e) {
  22487.                 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);
  22488.                 this.getStartupLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  22489.             }
  22490.             if(this.getStartupLockIdleTime!=null && this.getStartupLockIdleTime>0) {
  22491.                 // trasformo in millisecondi l'informazione fornita in secondi
  22492.                 this.getStartupLockIdleTime = this.getStartupLockIdleTime *1000;
  22493.             }
  22494.         }

  22496.         if(this.getStartupLockIdleTime!=null) {
  22497.             return this.getStartupLockIdleTime.intValue();
  22498.         }
  22499.         return -1;
  22500.     }
  22501.     
  22502.     private Long getStartupGetLockAttesaAttiva = null;
  22503.     public long getStartupGetLockAttesaAttiva() {   
  22504.         if(this.getStartupGetLockAttesaAttiva==null){
  22505.             String pName = "org.openspcoop2.pdd.startup.lock.attesaAttiva";
  22506.             try{ 
  22507.                 String name = null;
  22508.                 name = this.reader.getValueConvertEnvProperties(pName);

  22510.                 if(name!=null){
  22511.                     name = name.trim();
  22512.                     long time = java.lang.Long.parseLong(name);
  22513.                     this.getStartupGetLockAttesaAttiva = time*1000;
  22514.                 }else{
  22515.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
  22516.                     this.getStartupGetLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
  22517.                 }

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

  22525.         return this.getStartupGetLockAttesaAttiva;
  22526.     }

  22528.     private Integer getStartupGetLockCheckInterval = null;
  22529.     public int getStartupGetLockCheckInterval() {   
  22530.         if(this.getStartupGetLockCheckInterval==null){
  22531.             String pName = "org.openspcoop2.pdd.startup.lock.check";
  22532.             try{ 
  22533.                 String name = null;
  22534.                 name = this.reader.getValueConvertEnvProperties(pName);

  22536.                 if(name!=null){
  22537.                     name = name.trim();
  22538.                     int time = java.lang.Integer.parseInt(name);
  22539.                     this.getStartupGetLockCheckInterval = time;
  22540.                 }else{
  22541.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  22542.                     this.getStartupGetLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  22543.                 }
  22544.             }catch(java.lang.Exception e) {
  22545.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  22546.                 this.getStartupGetLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  22547.             }  
  22548.         }

  22550.         return this.getStartupGetLockCheckInterval;
  22551.     }
  22552.     
  22553.     
  22554.     /* ------------- ExtendedInfo ---------------------*/
  22555.     
  22556.     private String extendedInfoConfigurazione = null;       
  22557.     private Boolean extendedInfoConfigurazioneRead = null;      
  22558.     public String getExtendedInfoConfigurazione() throws CoreException{
  22559.         if(this.extendedInfoConfigurazioneRead==null){
  22560.             String pName = "org.openspcoop2.pdd.config.extendedInfo.configurazione";
  22561.             try{ 
  22562.                 this.extendedInfoConfigurazione = this.reader.getValue(pName);
  22563.                 if(this.extendedInfoConfigurazione!=null){
  22564.                     this.extendedInfoConfigurazione = this.extendedInfoConfigurazione.trim();
  22565.                     this.extendedInfoConfigurazioneRead = true;
  22566.                 }
  22567.             } catch(java.lang.Exception e) {
  22568.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  22569.                 throw new CoreException("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  22570.             } 
  22571.         }
  22572.         return this.extendedInfoConfigurazione;
  22573.     }
  22574.     
  22575.     private String extendedInfoPortaDelegata = null;        
  22576.     private Boolean extendedInfoPortaDelegataRead = null;       
  22577.     public String getExtendedInfoPortaDelegata() throws CoreException{
  22578.         if(this.extendedInfoPortaDelegataRead==null){
  22579.             String pName = "org.openspcoop2.pdd.config.extendedInfo.portaDelegata";
  22580.             try{ 
  22581.                 this.extendedInfoPortaDelegata = this.reader.getValue(pName);
  22582.                 if(this.extendedInfoPortaDelegata!=null){
  22583.                     this.extendedInfoPortaDelegata = this.extendedInfoPortaDelegata.trim();
  22584.                     this.extendedInfoPortaDelegataRead = true;
  22585.                 }
  22586.             } catch(java.lang.Exception e) {
  22587.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  22588.                 throw new CoreException("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  22589.             } 
  22590.         }
  22591.         return this.extendedInfoPortaDelegata;
  22592.     }
  22593.     
  22594.     private String extendedInfoPortaApplicativa = null;     
  22595.     private Boolean extendedInfoPortaApplicativaRead = null;        
  22596.     public String getExtendedInfoPortaApplicativa() throws CoreException{
  22597.         if(this.extendedInfoPortaApplicativaRead==null){
  22598.             String pName = "org.openspcoop2.pdd.config.extendedInfo.portaApplicativa";
  22599.             try{ 
  22600.                 this.extendedInfoPortaApplicativa = this.reader.getValue(pName);
  22601.                 if(this.extendedInfoPortaApplicativa!=null){
  22602.                     this.extendedInfoPortaApplicativa = this.extendedInfoPortaApplicativa.trim();
  22603.                     this.extendedInfoPortaApplicativaRead = true;
  22604.                 }
  22605.             } catch(java.lang.Exception e) {
  22606.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  22607.                 throw new CoreException("Proprieta' di openspcoop '"+pName+"' non impostata correttamente,  errore:"+e.getMessage(),e);
  22608.             } 
  22609.         }
  22610.         return this.extendedInfoPortaApplicativa;
  22611.     }
  22612.     
  22613.     
  22614.     
  22615.     
  22616.     
  22617.     
  22618.     
  22619.     /* ------------- Validazione Contenuti Applicativi ---------------------*/
  22620.     
  22621.     private Boolean isValidazioneContenutiApplicativiDebug = null;
  22622.     public boolean isValidazioneContenutiApplicativiDebug(){

  22624.         if(this.isValidazioneContenutiApplicativiDebug==null){
  22625.             try{  
  22626.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.debug"); 

  22628.                 if (value != null){
  22629.                     value = value.trim();
  22630.                     this.isValidazioneContenutiApplicativiDebug = Boolean.parseBoolean(value);
  22631.                 }else{
  22632.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.debug' non impostata, viene utilizzato il default=false");
  22633.                     this.isValidazioneContenutiApplicativiDebug = false;
  22634.                 }

  22636.             }catch(java.lang.Exception e) {
  22637.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.debug' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  22638.                 this.isValidazioneContenutiApplicativiDebug = false;
  22639.             }
  22640.         }

  22642.         return this.isValidazioneContenutiApplicativiDebug;
  22643.     }
  22644.     
  22645.     private Boolean isValidazioneContenutiApplicativiBufferContentRead = null;
  22646.     public boolean isValidazioneContenutiApplicativiBufferContentRead(){

  22648.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.buffer";
  22649.         if(this.isValidazioneContenutiApplicativiBufferContentRead==null){
  22650.             try{  
  22651.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22653.                 if (value != null){
  22654.                     value = value.trim();
  22655.                     this.isValidazioneContenutiApplicativiBufferContentRead = Boolean.parseBoolean(value);
  22656.                 }else{
  22657.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  22658.                     this.isValidazioneContenutiApplicativiBufferContentRead = true;
  22659.                 }

  22661.             }catch(java.lang.Exception e) {
  22662.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  22663.                 this.isValidazioneContenutiApplicativiBufferContentRead = true;
  22664.             }
  22665.         }

  22667.         return this.isValidazioneContenutiApplicativiBufferContentRead;
  22668.     }
  22669.     
  22670.     private Boolean isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection = null;
  22671.     public boolean isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection(){

  22673.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.xsd.buildSchemaSuccess.serializeXSDCollection";
  22674.         if(this.isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection==null){
  22675.             try{  
  22676.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22678.                 if (value != null){
  22679.                     value = value.trim();
  22680.                     this.isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection = Boolean.parseBoolean(value);
  22681.                 }else{
  22682.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  22683.                     this.isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection = false;
  22684.                 }

  22686.             }catch(java.lang.Exception e) {
  22687.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  22688.                 this.isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection = false;
  22689.             }
  22690.         }

  22692.         return this.isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection;
  22693.     }
  22694.     
  22695.     private Boolean isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection = null;
  22696.     public boolean isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection(){

  22698.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.xsd.buildSchemaError.serializeXSDCollection";
  22699.         if(this.isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection==null){
  22700.             try{  
  22701.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22703.                 if (value != null){
  22704.                     value = value.trim();
  22705.                     this.isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection = Boolean.parseBoolean(value);
  22706.                 }else{
  22707.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  22708.                     this.isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection = true;
  22709.                 }

  22711.             }catch(java.lang.Exception e) {
  22712.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  22713.                 this.isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection = true;
  22714.             }
  22715.         }

  22717.         return this.isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection;
  22718.     }
  22719.     
  22720.     private File getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir = null;
  22721.     private Boolean getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDirRead = null;
  22722.     public File getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir() throws CoreException{

  22724.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.xsd.buildSchema.serializeXSDCollection.dir";
  22725.         if(this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDirRead==null){
  22726.             try{  
  22727.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22729.                 if (value != null){
  22730.                     value = value.trim();
  22731.                     value = LoggerWrapperFactory.applyClusterIdStrategy(value, "xsdCollection");
  22732.                     this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir = new File(value);
  22733.                     checkValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir();
  22734.                 }

  22736.             }catch(java.lang.Exception e) {
  22737.                 this.logError("Riscontrato errore per la directory che deve collezionare gli xsd schema ("+pName+"): "+e.getMessage(),e);
  22738.                 throw new CoreException(e.getMessage(),e);
  22739.             }
  22740.             
  22741.             this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDirRead = true;
  22742.         }

  22744.         return this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir;
  22745.     }
  22746.     private void checkValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir() throws CoreException, UtilsException {   
  22747.         if(this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir.exists()) {
  22748.             if(!this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir.isDirectory()) {
  22749.                 throw newCoreExceptionNotDir(this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir,true);
  22750.             }
  22751.             if(!this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir.canRead()) {
  22752.                 throw newCoreExceptionCannotRead(this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir, true);
  22753.             }
  22754.             if(!this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir.canWrite()) {
  22755.                 throw newCoreExceptionCannotWrite(this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir, true);
  22756.             }
  22757.         }
  22758.         else {
  22759.             FileSystemMkdirConfig configMkdir = new FileSystemMkdirConfig();
  22760.             configMkdir.setCheckCanWrite(true);
  22761.             configMkdir.setCheckCanRead(true);
  22762.             configMkdir.setCheckCanExecute(false);
  22763.             configMkdir.setCrateParentIfNotExists(true);
  22764.             FileSystemUtilities.mkdir(this.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir, configMkdir);
  22765.         }
  22766.     }
  22767.     
  22768.     
  22769.     
  22770.     
  22771.         
  22772.     private Boolean isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione = null;
  22773.     public boolean isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione(){

  22775.         if(this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione==null){
  22776.             try{  
  22777.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.gestione"); 

  22779.                 if (value != null){
  22780.                     value = value.trim();
  22781.                     this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione = Boolean.parseBoolean(value);
  22782.                 }else{
  22783.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.gestione' non impostata, viene utilizzato il default=true");
  22784.                     this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione = true;
  22785.                 }

  22787.             }catch(java.lang.Exception e) {
  22788.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.gestione' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  22789.                 this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione = true;
  22790.             }
  22791.         }

  22793.         return this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione;
  22794.     }
  22795.     
  22796.     private Boolean isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione = null;
  22797.     public boolean isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione(){

  22799.         if(this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione==null){
  22800.             try{  
  22801.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.ripulituraDopoValidazione"); 

  22803.                 if (value != null){
  22804.                     value = value.trim();
  22805.                     this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione = Boolean.parseBoolean(value);
  22806.                 }else{
  22807.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.ripulituraDopoValidazione' non impostata, viene utilizzato il default=true");
  22808.                     this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione = true;
  22809.                 }

  22811.             }catch(java.lang.Exception e) {
  22812.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.rpcLiteral.xsiType.ripulituraDopoValidazione' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  22813.                 this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione = true;
  22814.             }
  22815.         }

  22817.         return this.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione;
  22818.     }
  22819.     
  22820.     private Boolean isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists = null;
  22821.     public boolean isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists(){

  22823.         if(this.isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists==null){
  22824.             String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.rpc.addNamespaceXSITypeIfNotExists";
  22825.             try{  
  22826.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22828.                 if (value != null){
  22829.                     value = value.trim();
  22830.                     this.isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists = Boolean.parseBoolean(value);
  22831.                 }else{
  22832.                     this.logWarn(this.getMessaggioProprietaNonImpostata(pName, true));
  22833.                     this.isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists = true;
  22834.                 }

  22836.             }catch(java.lang.Exception e) {
  22837.                 this.logWarn(this.getMessaggioProprietaNonImpostata(pName, e, true),e);
  22838.                 this.isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists = true;
  22839.             }
  22840.         }

  22842.         return this.isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists;
  22843.     }
  22844.     
  22845.     private Boolean isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists = null;
  22846.     public boolean isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists(){

  22848.         if(this.isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists==null){
  22849.             String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.document.addNamespaceXSITypeIfNotExists";
  22850.             try{  
  22851.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22853.                 if (value != null){
  22854.                     value = value.trim();
  22855.                     this.isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists = Boolean.parseBoolean(value);
  22856.                 }else{
  22857.                     this.logWarn(this.getMessaggioProprietaNonImpostata(pName, false));
  22858.                     this.isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists = true;
  22859.                 }

  22861.             }catch(java.lang.Exception e) {
  22862.                 this.logWarn(this.getMessaggioProprietaNonImpostata(pName, e, false),e);
  22863.                 this.isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists = true;
  22864.             }
  22865.         }

  22867.         return this.isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists;
  22868.     }
  22869.     
  22870.     private Boolean isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists = null;
  22871.     public boolean isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists(){

  22873.         if(this.isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists==null){
  22874.             String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.xsd.addNamespaceXSITypeIfNotExists";
  22875.             try{  
  22876.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22878.                 if (value != null){
  22879.                     value = value.trim();
  22880.                     this.isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists = Boolean.parseBoolean(value);
  22881.                 }else{
  22882.                     this.logWarn(this.getMessaggioProprietaNonImpostata(pName, false));
  22883.                     this.isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists = true;
  22884.                 }

  22886.             }catch(java.lang.Exception e) {
  22887.                 this.logWarn(this.getMessaggioProprietaNonImpostata(pName, e, false),e);
  22888.                 this.isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists = true;
  22889.             }
  22890.         }

  22892.         return this.isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists;
  22893.     }
  22894.     
  22895.     private Boolean isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified = null;
  22896.     public boolean isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified(){

  22898.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.rpc.rootElement.unqualified.accept";
  22899.         if(this.isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified==null){
  22900.             try{  
  22901.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  22903.                 if (value != null){
  22904.                     value = value.trim();
  22905.                     this.isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified = Boolean.parseBoolean(value);
  22906.                 }else{
  22907.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  22908.                     this.isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified = true;
  22909.                 }

  22911.             }catch(java.lang.Exception e) {
  22912.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  22913.                 this.isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified = true;
  22914.             }
  22915.         }

  22917.         return this.isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified;
  22918.     }
  22919.     
  22920.     private Boolean isValidazioneContenutiApplicativiCheckSoapAction = null;
  22921.     public boolean isValidazioneContenutiApplicativiCheckSoapAction(){

  22923.         if(this.isValidazioneContenutiApplicativiCheckSoapAction==null){
  22924.             try{  
  22925.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.soapAction.check"); 

  22927.                 if (value != null){
  22928.                     value = value.trim();
  22929.                     this.isValidazioneContenutiApplicativiCheckSoapAction = Boolean.parseBoolean(value);
  22930.                 }else{
  22931.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.soapAction.check' non impostata, viene utilizzato il default=true");
  22932.                     this.isValidazioneContenutiApplicativiCheckSoapAction = true;
  22933.                 }

  22935.             }catch(java.lang.Exception e) {
  22936.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.soapAction.check' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  22937.                 this.isValidazioneContenutiApplicativiCheckSoapAction = true;
  22938.             }
  22939.         }

  22941.         return this.isValidazioneContenutiApplicativiCheckSoapAction;
  22942.     }
  22943.     
  22944.     private ADDITIONAL getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties = null;
  22945.     public ADDITIONAL getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties(){

  22947.         if(this.getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties==null){
  22948.             try{  
  22949.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.json.additionalProperties"); 

  22951.                 if (value != null){
  22952.                     value = value.trim();
  22953.                     this.getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties = ADDITIONAL.valueOf(value);
  22954.                 }else{
  22955.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.json.additionalProperties' non impostata, viene utilizzato il default");
  22956.                     this.getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties = ADDITIONAL.DEFAULT;
  22957.                 }

  22959.             }catch(java.lang.Exception e) {
  22960.                 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);
  22961.                 this.getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties = ADDITIONAL.DEFAULT;
  22962.             }
  22963.         }

  22965.         return this.getValidazioneContenutiApplicativiJsonPolicyAdditionalProperties;
  22966.     }
  22967.     
  22968.     
  22969.     private ApiName getValidazioneContenutiApplicativiOpenApiJsonValidator = null;
  22970.     public ApiName getValidazioneContenutiApplicativiOpenApiJsonValidator(){

  22972.         if(this.getValidazioneContenutiApplicativiOpenApiJsonValidator==null){
  22973.             try{  
  22974.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.json.validator"); 

  22976.                 if (value != null){
  22977.                     value = value.trim();
  22978.                     this.getValidazioneContenutiApplicativiOpenApiJsonValidator = ApiName.valueOf(value);
  22979.                 }else{
  22980.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.json.validator' non impostata, viene utilizzato il default "+ApiName.NETWORK_NT);
  22981.                     this.getValidazioneContenutiApplicativiOpenApiJsonValidator = ApiName.NETWORK_NT;
  22982.                 }

  22984.             }catch(java.lang.Exception e) {
  22985.                 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);
  22986.                 this.getValidazioneContenutiApplicativiOpenApiJsonValidator = ApiName.NETWORK_NT;
  22987.             }
  22988.         }

  22990.         return this.getValidazioneContenutiApplicativiOpenApiJsonValidator;
  22991.     }
  22992.     
  22993.     private OpenAPILibrary getValidazioneContenutiApplicativiOpenApiLibrary = null;
  22994.     public OpenAPILibrary getValidazioneContenutiApplicativiOpenApiLibrary(){

  22996.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.library";
  22997.         OpenAPILibrary defaultValue = OpenAPILibrary.openapi4j;
  22998.         
  22999.         if(this.getValidazioneContenutiApplicativiOpenApiLibrary==null){
  23000.             try{  
  23001.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23003.                 if (value != null){
  23004.                     value = value.trim();
  23005.                     this.getValidazioneContenutiApplicativiOpenApiLibrary = OpenAPILibrary.valueOf(value);
  23006.                 }else{
  23007.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue.toString()));
  23008.                     this.getValidazioneContenutiApplicativiOpenApiLibrary = defaultValue;
  23009.                 }

  23011.             }catch(java.lang.Exception e) {
  23012.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, defaultValue.toString()),e);
  23013.                 this.getValidazioneContenutiApplicativiOpenApiLibrary = defaultValue;
  23014.             }
  23015.         }

  23017.         return this.getValidazioneContenutiApplicativiOpenApiLibrary;
  23018.     }

  23020.     private Boolean isValidazioneContenutiApplicativiOpenApiMergeAPISpec = null;
  23021.     public boolean isValidazioneContenutiApplicativiOpenApiMergeAPISpec(){

  23023.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.mergeAPISpec";
  23024.         
  23025.         if(this.isValidazioneContenutiApplicativiOpenApiMergeAPISpec==null){
  23026.             try{  
  23027.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23029.                 if (value != null){
  23030.                     value = value.trim();
  23031.                     this.isValidazioneContenutiApplicativiOpenApiMergeAPISpec = Boolean.parseBoolean(value);
  23032.                 }else{
  23033.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23034.                     this.isValidazioneContenutiApplicativiOpenApiMergeAPISpec = false;
  23035.                 }

  23037.             }catch(java.lang.Exception e) {
  23038.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23039.                 this.isValidazioneContenutiApplicativiOpenApiMergeAPISpec = false;
  23040.             }
  23041.         }

  23043.         return this.isValidazioneContenutiApplicativiOpenApiMergeAPISpec;
  23044.     }
  23045.     
  23046.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateAPISpec = null;
  23047.     public boolean isValidazioneContenutiApplicativiOpenApiValidateAPISpec(){

  23049.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateAPISpec";
  23050.         
  23051.         if(this.isValidazioneContenutiApplicativiOpenApiValidateAPISpec==null){
  23052.             try{  
  23053.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23055.                 if (value != null){
  23056.                     value = value.trim();
  23057.                     this.isValidazioneContenutiApplicativiOpenApiValidateAPISpec = Boolean.parseBoolean(value);
  23058.                 }else{
  23059.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23060.                     this.isValidazioneContenutiApplicativiOpenApiValidateAPISpec = true;
  23061.                 }

  23063.             }catch(java.lang.Exception e) {
  23064.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23065.                 this.isValidazioneContenutiApplicativiOpenApiValidateAPISpec = true;
  23066.             }
  23067.         }

  23069.         return this.isValidazioneContenutiApplicativiOpenApiValidateAPISpec;
  23070.     }
  23071.     
  23072.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateRequestPath = null;
  23073.     public boolean isValidazioneContenutiApplicativiOpenApiValidateRequestPath(){

  23075.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestPath";
  23076.         
  23077.         if(this.isValidazioneContenutiApplicativiOpenApiValidateRequestPath==null){
  23078.             try{  
  23079.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23081.                 if (value != null){
  23082.                     value = value.trim();
  23083.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestPath = Boolean.parseBoolean(value);
  23084.                 }else{
  23085.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23086.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestPath = true;
  23087.                 }

  23089.             }catch(java.lang.Exception e) {
  23090.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23091.                 this.isValidazioneContenutiApplicativiOpenApiValidateRequestPath = true;
  23092.             }
  23093.         }

  23095.         return this.isValidazioneContenutiApplicativiOpenApiValidateRequestPath;
  23096.     }
  23097.     
  23098.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateRequestQuery = null;
  23099.     public boolean isValidazioneContenutiApplicativiOpenApiValidateRequestQuery(){

  23101.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestQuery";
  23102.         
  23103.         if(this.isValidazioneContenutiApplicativiOpenApiValidateRequestQuery==null){
  23104.             try{  
  23105.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23107.                 if (value != null){
  23108.                     value = value.trim();
  23109.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestQuery = Boolean.parseBoolean(value);
  23110.                 }else{
  23111.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23112.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestQuery = true;
  23113.                 }

  23115.             }catch(java.lang.Exception e) {
  23116.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23117.                 this.isValidazioneContenutiApplicativiOpenApiValidateRequestQuery = true;
  23118.             }
  23119.         }

  23121.         return this.isValidazioneContenutiApplicativiOpenApiValidateRequestQuery;
  23122.     }
  23123.     
  23124.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam = null;
  23125.     public boolean isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam(){

  23127.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestUnexpectedQueryParam";
  23128.         
  23129.         if(this.isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam==null){
  23130.             try{  
  23131.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23133.                 if (value != null){
  23134.                     value = value.trim();
  23135.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam = Boolean.parseBoolean(value);
  23136.                 }else{
  23137.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23138.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam = false;
  23139.                 }

  23141.             }catch(java.lang.Exception e) {
  23142.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23143.                 this.isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam = false;
  23144.             }
  23145.         }

  23147.         return this.isValidazioneContenutiApplicativiOpenApiValidateRequestUnexpectedQueryParam;
  23148.     }
  23149.     
  23150.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders = null;
  23151.     public boolean isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders(){

  23153.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestHeaders";
  23154.         
  23155.         if(this.isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders==null){
  23156.             try{  
  23157.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23159.                 if (value != null){
  23160.                     value = value.trim();
  23161.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders = Boolean.parseBoolean(value);
  23162.                 }else{
  23163.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23164.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders = true;
  23165.                 }

  23167.             }catch(java.lang.Exception e) {
  23168.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23169.                 this.isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders = true;
  23170.             }
  23171.         }

  23173.         return this.isValidazioneContenutiApplicativiOpenApiValidateRequestHeaders;
  23174.     }
  23175.     
  23176.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateRequestCookie = null;
  23177.     public boolean isValidazioneContenutiApplicativiOpenApiValidateRequestCookie(){

  23179.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestCookie";
  23180.         
  23181.         if(this.isValidazioneContenutiApplicativiOpenApiValidateRequestCookie==null){
  23182.             try{  
  23183.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23185.                 if (value != null){
  23186.                     value = value.trim();
  23187.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestCookie = Boolean.parseBoolean(value);
  23188.                 }else{
  23189.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23190.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestCookie = true;
  23191.                 }

  23193.             }catch(java.lang.Exception e) {
  23194.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23195.                 this.isValidazioneContenutiApplicativiOpenApiValidateRequestCookie = true;
  23196.             }
  23197.         }

  23199.         return this.isValidazioneContenutiApplicativiOpenApiValidateRequestCookie;
  23200.     }
  23201.     
  23202.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateRequestBody = null;
  23203.     public boolean isValidazioneContenutiApplicativiOpenApiValidateRequestBody(){

  23205.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateRequestBody";
  23206.         
  23207.         if(this.isValidazioneContenutiApplicativiOpenApiValidateRequestBody==null){
  23208.             try{  
  23209.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23211.                 if (value != null){
  23212.                     value = value.trim();
  23213.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestBody = Boolean.parseBoolean(value);
  23214.                 }else{
  23215.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23216.                     this.isValidazioneContenutiApplicativiOpenApiValidateRequestBody = true;
  23217.                 }

  23219.             }catch(java.lang.Exception e) {
  23220.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23221.                 this.isValidazioneContenutiApplicativiOpenApiValidateRequestBody = true;
  23222.             }
  23223.         }

  23225.         return this.isValidazioneContenutiApplicativiOpenApiValidateRequestBody;
  23226.     }
  23227.     
  23228.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders = null;
  23229.     public boolean isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders(){

  23231.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateResponseHeaders";
  23232.         
  23233.         if(this.isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders==null){
  23234.             try{  
  23235.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23237.                 if (value != null){
  23238.                     value = value.trim();
  23239.                     this.isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders = Boolean.parseBoolean(value);
  23240.                 }else{
  23241.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23242.                     this.isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders = true;
  23243.                 }

  23245.             }catch(java.lang.Exception e) {
  23246.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23247.                 this.isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders = true;
  23248.             }
  23249.         }

  23251.         return this.isValidazioneContenutiApplicativiOpenApiValidateResponseHeaders;
  23252.     }
  23253.     
  23254.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateResponseBody = null;
  23255.     public boolean isValidazioneContenutiApplicativiOpenApiValidateResponseBody(){

  23257.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateResponseBody";
  23258.         
  23259.         if(this.isValidazioneContenutiApplicativiOpenApiValidateResponseBody==null){
  23260.             try{  
  23261.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23263.                 if (value != null){
  23264.                     value = value.trim();
  23265.                     this.isValidazioneContenutiApplicativiOpenApiValidateResponseBody = Boolean.parseBoolean(value);
  23266.                 }else{
  23267.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23268.                     this.isValidazioneContenutiApplicativiOpenApiValidateResponseBody = true;
  23269.                 }

  23271.             }catch(java.lang.Exception e) {
  23272.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23273.                 this.isValidazioneContenutiApplicativiOpenApiValidateResponseBody = true;
  23274.             }
  23275.         }

  23277.         return this.isValidazioneContenutiApplicativiOpenApiValidateResponseBody;
  23278.     }
  23279.     
  23280.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson = null;
  23281.     public boolean isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson(){

  23283.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateWildcardSubtypeAsJson";
  23284.         
  23285.         if(this.isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson==null){
  23286.             try{  
  23287.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23289.                 if (value != null){
  23290.                     value = value.trim();
  23291.                     this.isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson = Boolean.parseBoolean(value);
  23292.                 }else{
  23293.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23294.                     this.isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson = true;
  23295.                 }

  23297.             }catch(java.lang.Exception e) {
  23298.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23299.                 this.isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson = true;
  23300.             }
  23301.         }

  23303.         return this.isValidazioneContenutiApplicativiOpenApiValidateWildcardSubtypeAsJson;
  23304.     }
  23305.     
  23306.     private Boolean isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization = null;
  23307.     public boolean isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization(){

  23309.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.validateMultipartOptimization";
  23310.         
  23311.         if(this.isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization==null){
  23312.             try{  
  23313.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23315.                 if (value != null){
  23316.                     value = value.trim();
  23317.                     this.isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization = Boolean.parseBoolean(value);
  23318.                 }else{
  23319.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23320.                     this.isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization = false;
  23321.                 }

  23323.             }catch(java.lang.Exception e) {
  23324.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23325.                 this.isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization = false;
  23326.             }
  23327.         }

  23329.         return this.isValidazioneContenutiApplicativiOpenApiValidateMultipartOptimization;
  23330.     }
  23331.     
  23332.     private Boolean isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse = null;
  23333.     public boolean isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse(){

  23335.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.swaggerRequestValidator.injectingAdditionalPropertiesFalse";
  23336.         
  23337.         if(this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse==null){
  23338.             try{  
  23339.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23341.                 if (value != null){
  23342.                     value = value.trim();
  23343.                     this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse = Boolean.parseBoolean(value);
  23344.                 }else{
  23345.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23346.                     this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse = false;
  23347.                 }

  23349.             }catch(java.lang.Exception e) {
  23350.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23351.                 this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse = false;
  23352.             }
  23353.         }

  23355.         return this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorInjectingAdditionalPropertiesFalse;
  23356.     }
  23357.     
  23358.     private Boolean isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec = null;
  23359.     public boolean isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec(){

  23361.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.swaggerRequestValidator.resolveFullyApiSpec";
  23362.         
  23363.         if(this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec==null){
  23364.             try{  
  23365.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23367.                 if (value != null){
  23368.                     value = value.trim();
  23369.                     this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec = Boolean.parseBoolean(value);
  23370.                 }else{
  23371.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23372.                     this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec = false;
  23373.                 }

  23375.             }catch(java.lang.Exception e) {
  23376.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23377.                 this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec = false;
  23378.             }
  23379.         }

  23381.         return this.isValidazioneContenutiApplicativiOpenApiSwaggerRequestValidatorResolveFullyApiSpec;
  23382.     }
  23383.     
  23384.     private Boolean isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values = null;
  23385.     public boolean isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values(){

  23387.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.openapi4j.validateBase64Values";
  23388.         
  23389.         if(this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values==null){
  23390.             try{  
  23391.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23393.                 if (value != null){
  23394.                     value = value.trim();
  23395.                     this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values = Boolean.parseBoolean(value);
  23396.                 }else{
  23397.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23398.                     this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values = false;
  23399.                 }

  23401.             }catch(java.lang.Exception e) {
  23402.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23403.                 this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values = false;
  23404.             }
  23405.         }

  23407.         return this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values;
  23408.     }
  23409.     
  23410.     private Boolean isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl = null;
  23411.     public boolean isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl(){

  23413.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.openapi4j.validateUriReferenceAsUrl";
  23414.         
  23415.         if(this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl==null){
  23416.             try{  
  23417.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23419.                 if (value != null){
  23420.                     value = value.trim();
  23421.                     this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl = Boolean.parseBoolean(value);
  23422.                 }else{
  23423.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23424.                     this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl = false;
  23425.                 }

  23427.             }catch(java.lang.Exception e) {
  23428.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23429.                 this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl = false;
  23430.             }
  23431.         }

  23433.         return this.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl;
  23434.     }
  23435.     
  23436.     private Boolean isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ = null;
  23437.     public boolean isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ(){

  23439.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.dateTimeAllowLowerCaseTZ";
  23440.         
  23441.         if(this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ==null){
  23442.             try{  
  23443.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23445.                 if (value != null){
  23446.                     value = value.trim();
  23447.                     this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ = Boolean.parseBoolean(value);
  23448.                 }else{
  23449.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23450.                     this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ = false;
  23451.                 }

  23453.             }catch(java.lang.Exception e) {
  23454.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23455.                 this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ = false;
  23456.             }
  23457.         }

  23459.         return this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ;
  23460.     }
  23461.     
  23462.     private Boolean isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator = null;
  23463.     public boolean isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator(){

  23465.         String pName = "org.openspcoop2.pdd.validazioneContenutiApplicativi.openApi.dateTimeAllowSpaceSeparator";
  23466.         
  23467.         if(this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator==null){
  23468.             try{  
  23469.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23471.                 if (value != null){
  23472.                     value = value.trim();
  23473.                     this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator = Boolean.parseBoolean(value);
  23474.                 }else{
  23475.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23476.                     this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator = false;
  23477.                 }

  23479.             }catch(java.lang.Exception e) {
  23480.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23481.                 this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator = false;
  23482.             }
  23483.         }

  23485.         return this.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator;
  23486.     }
  23487.     
  23488.     
  23489.     
  23490.     /* ------------- XML ---------------------*/
  23491.     
  23492.     private Boolean isXmlFactoryDTDsEnabled = null;
  23493.     public boolean isXmlFactoryDTDsEnabled(){

  23495.         String pName = "org.openspcoop2.pdd.xmlFactory.DTDs.enabled";
  23496.         
  23497.         if(this.isXmlFactoryDTDsEnabled==null){
  23498.             try{  
  23499.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23501.                 if (value != null){
  23502.                     value = value.trim();
  23503.                     this.isXmlFactoryDTDsEnabled = Boolean.parseBoolean(value);
  23504.                 }else{
  23505.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23506.                     this.isXmlFactoryDTDsEnabled = false;
  23507.                 }

  23509.             }catch(java.lang.Exception e) {
  23510.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23511.                 this.isXmlFactoryDTDsEnabled = false;
  23512.             }
  23513.         }

  23515.         return this.isXmlFactoryDTDsEnabled;
  23516.     }
  23517.     
  23518.     private Boolean isXsltProcessAsDOMSource = null;
  23519.     public boolean isXsltProcessAsDOMSource(){

  23521.         String pName = "org.openspcoop2.pdd.xslt.processAsDOMSource";
  23522.         
  23523.         if(this.isXsltProcessAsDOMSource==null){
  23524.             try{  
  23525.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23527.                 if (value != null){
  23528.                     value = value.trim();
  23529.                     this.isXsltProcessAsDOMSource = Boolean.parseBoolean(value);
  23530.                 }else{
  23531.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23532.                     this.isXsltProcessAsDOMSource = true;
  23533.                 }

  23535.             }catch(java.lang.Exception e) {
  23536.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23537.                 this.isXsltProcessAsDOMSource = true;
  23538.             }
  23539.         }

  23541.         return this.isXsltProcessAsDOMSource;
  23542.     }
  23543.     
  23544.     
  23545.     /* ------------- YAML ---------------------*/
  23546.     
  23547.     private Properties yamlSnakeLimits = null;
  23548.     private Boolean yamlSnakeLimits_read = null;
  23549.     public Properties getYamlSnakeLimits(){

  23551.         String pName = "org.openspcoop2.pdd.yaml.snakeLimits";
  23552.         
  23553.         if(this.yamlSnakeLimits_read==null){
  23554.             try{  
  23555.                 String file = this.reader.getValueConvertEnvProperties(pName); 
  23556.                 if(file!=null && StringUtils.isNotEmpty(file)) {
  23557.                     File f = new File(file);
  23558.                     if(f.exists()) {
  23559.                         if(!f.isFile()) {
  23560.                             throw new CoreException("Il file indicato '"+f.getAbsolutePath()+"' non è un file");
  23561.                         }
  23562.                         if(!f.canRead()) {
  23563.                             throw new CoreException("Il file indicato '"+f.getAbsolutePath()+"' non è accessibile in lettura");
  23564.                         }
  23565.                         try(InputStream is = new FileInputStream(f)){
  23566.                             Properties p = new Properties();
  23567.                             p.load(is);
  23568.                             if (p != null && !p.isEmpty()){
  23569.                                 this.yamlSnakeLimits = p;
  23570.                             }
  23571.                         }
  23572.                     }
  23573.                 }
  23574.                 
  23575.             }catch(java.lang.Exception e) {
  23576.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostate, errore:"+e.getMessage(),e);
  23577.             }
  23578.             this.yamlSnakeLimits_read=true;
  23579.         }

  23581.         return this.yamlSnakeLimits;
  23582.     }
  23583.     
  23584.     
  23585.     /* ------------- XPath e JSON Path ---------------------*/
  23586.     
  23587.     private Boolean isJsonPathCacheEnabled = null;
  23588.     public boolean isJsonPathCacheEnabled(){

  23590.         String pName = "org.openspcoop2.pdd.jsonPath.cache.enabled";
  23591.         
  23592.         if(this.isJsonPathCacheEnabled==null){
  23593.             try{  
  23594.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23596.                 if (value != null){
  23597.                     value = value.trim();
  23598.                     this.isJsonPathCacheEnabled = Boolean.parseBoolean(value);
  23599.                 }else{
  23600.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23601.                     this.isJsonPathCacheEnabled = false;
  23602.                 }

  23604.             }catch(java.lang.Exception e) {
  23605.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23606.                 this.isJsonPathCacheEnabled = false;
  23607.             }
  23608.         }

  23610.         return this.isJsonPathCacheEnabled;
  23611.     }
  23612.     
  23613.     private Boolean isReadByPathBufferEnabled = null;
  23614.     public boolean isReadByPathBufferEnabled(){

  23616.         String pName = "org.openspcoop2.pdd.readByPath.buffer";
  23617.         
  23618.         if(this.isReadByPathBufferEnabled==null){
  23619.             try{  
  23620.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23622.                 if (value != null){
  23623.                     value = value.trim();
  23624.                     this.isReadByPathBufferEnabled = Boolean.parseBoolean(value);
  23625.                 }else{
  23626.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23627.                     this.isReadByPathBufferEnabled = true;
  23628.                 }

  23630.             }catch(java.lang.Exception e) {
  23631.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23632.                 this.isReadByPathBufferEnabled = true;
  23633.             }
  23634.         }

  23636.         return this.isReadByPathBufferEnabled;
  23637.     }
  23638.     
  23639.     
  23640.     
  23641.     /* ------------- Caching Response ---------------------*/
  23642.     
  23643.     private String getCachingResponseDigestAlgorithm = null;
  23644.     public String getCachingResponseDigestAlgorithm(){

  23646.         if(this.getCachingResponseDigestAlgorithm==null){
  23647.             try{  
  23648.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cachingResponse.digestAlgorithm"); 

  23650.                 if (value != null){
  23651.                     value = value.trim();
  23652.                     MessageDigest.getInstance(value); // valida
  23653.                     this.getCachingResponseDigestAlgorithm = value;
  23654.                 }else{
  23655.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.cachingResponse.digestAlgorithm' non impostata, viene utilizzato il default="+CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST_DEFAULT_ALGORITHM);
  23656.                     this.getCachingResponseDigestAlgorithm = CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST_DEFAULT_ALGORITHM;
  23657.                 }

  23659.             }catch(java.lang.Exception e) {
  23660.                 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);
  23661.                 this.getCachingResponseDigestAlgorithm = CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST_DEFAULT_ALGORITHM;
  23662.             }
  23663.         }

  23665.         return this.getCachingResponseDigestAlgorithm;
  23666.     }
  23667.     
  23668.     private Boolean getCachingResponseHeaderCacheKey_read = null;
  23669.     private String getCachingResponseHeaderCacheKey = null;
  23670.     public String getCachingResponseHeaderCacheKey(){

  23672.         if(this.getCachingResponseHeaderCacheKey_read==null){
  23673.             try{  
  23674.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.cachingResponse.header.cacheKey"); 

  23676.                 if (value != null){
  23677.                     value = value.trim();
  23678.                     this.getCachingResponseHeaderCacheKey = value;
  23679.                 }

  23681.                 this.getCachingResponseHeaderCacheKey_read = true;
  23682.                 
  23683.             }catch(java.lang.Exception e) {
  23684.                 this.logError("Proprieta' di openspcoop 'org.openspcoop2.pdd.cachingResponse.header.cacheKey', errore:"+e.getMessage(),e);
  23685.                 
  23686.             }
  23687.         }

  23689.         return this.getCachingResponseHeaderCacheKey;
  23690.     }
  23691.     
  23692.     
  23693.     
  23694.     /* ------------- Gestione Token ---------------------*/
  23695.     
  23696.     private Boolean isGestioneTokenDynamicDiscoveryDebug = null;
  23697.     public boolean isGestioneTokenDynamicDiscoveryDebug(){

  23699.         String pName = "org.openspcoop2.pdd.gestioneToken.dynamicDiscovery.debug";
  23700.         if(this.isGestioneTokenDynamicDiscoveryDebug==null){
  23701.             try{  
  23702.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23704.                 if (value != null){
  23705.                     value = value.trim();
  23706.                     this.isGestioneTokenDynamicDiscoveryDebug = Boolean.parseBoolean(value);
  23707.                 }else{
  23708.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23709.                     this.isGestioneTokenDynamicDiscoveryDebug = false;
  23710.                 }

  23712.             }catch(java.lang.Exception e) {
  23713.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23714.                 this.isGestioneTokenDynamicDiscoveryDebug = false;
  23715.             }
  23716.         }

  23718.         return this.isGestioneTokenDynamicDiscoveryDebug;
  23719.     }
  23720.     
  23721.     private Boolean isGestioneTokenIntrospectionDebug = null;
  23722.     public boolean isGestioneTokenIntrospectionDebug(){

  23724.         String pName = "org.openspcoop2.pdd.gestioneToken.introspection.debug";
  23725.         if(this.isGestioneTokenIntrospectionDebug==null){
  23726.             try{  
  23727.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23729.                 if (value != null){
  23730.                     value = value.trim();
  23731.                     this.isGestioneTokenIntrospectionDebug = Boolean.parseBoolean(value);
  23732.                 }else{
  23733.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23734.                     this.isGestioneTokenIntrospectionDebug = false;
  23735.                 }

  23737.             }catch(java.lang.Exception e) {
  23738.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23739.                 this.isGestioneTokenIntrospectionDebug = false;
  23740.             }
  23741.         }

  23743.         return this.isGestioneTokenIntrospectionDebug;
  23744.     }
  23745.     
  23746.     private Boolean isGestioneTokenUserInfoDebug = null;
  23747.     public boolean isGestioneTokenUserInfoDebug(){

  23749.         String pName = "org.openspcoop2.pdd.gestioneToken.userInfo.debug";
  23750.         if(this.isGestioneTokenUserInfoDebug==null){
  23751.             try{  
  23752.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23754.                 if (value != null){
  23755.                     value = value.trim();
  23756.                     this.isGestioneTokenUserInfoDebug = Boolean.parseBoolean(value);
  23757.                 }else{
  23758.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23759.                     this.isGestioneTokenUserInfoDebug = false;
  23760.                 }

  23762.             }catch(java.lang.Exception e) {
  23763.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23764.                 this.isGestioneTokenUserInfoDebug = false;
  23765.             }
  23766.         }

  23768.         return this.isGestioneTokenUserInfoDebug;
  23769.     }
  23770.     
  23771.     private Boolean getGestioneTokenDynamicDiscoveryLockPermitsRead = null;
  23772.     private Integer getGestioneTokenDynamicDiscoveryLockPermits = null;
  23773.     public Integer getGestioneTokenDynamicDiscoveryLockPermits() {

  23775.         String pName = "org.openspcoop2.pdd.gestioneToken.dynamicDiscovery.lock.permits";
  23776.         if(this.getGestioneTokenDynamicDiscoveryLockPermitsRead==null){
  23777.             try{  
  23778.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23780.                 if (value != null){
  23781.                     value = value.trim();
  23782.                     int permits = Integer.parseInt(value); 
  23783.                     if(permits>1) {
  23784.                         // altrimenti è un normale semaphore binario
  23785.                         this.getGestioneTokenDynamicDiscoveryLockPermits = permits;
  23786.                     }
  23787.                 }
  23788.                 
  23789.                 
  23790.             }catch(java.lang.Exception e) {
  23791.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  23792.             }
  23793.             
  23794.             this.getGestioneTokenDynamicDiscoveryLockPermitsRead = true;
  23795.         }

  23797.         return this.getGestioneTokenDynamicDiscoveryLockPermits;
  23798.     }
  23799.     
  23800.     private Boolean getGestioneTokenValidazioneJWTLockPermitsRead = null;
  23801.     private Integer getGestioneTokenValidazioneJWTLockPermits = null;
  23802.     public Integer getGestioneTokenValidazioneJWTLockPermits() {

  23804.         String pName = "org.openspcoop2.pdd.gestioneToken.validazioneJWT.lock.permits";
  23805.         if(this.getGestioneTokenValidazioneJWTLockPermitsRead==null){
  23806.             try{  
  23807.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23809.                 if (value != null){
  23810.                     value = value.trim();
  23811.                     int permits = Integer.parseInt(value); 
  23812.                     if(permits>1) {
  23813.                         // altrimenti è un normale semaphore binario
  23814.                         this.getGestioneTokenValidazioneJWTLockPermits = permits;
  23815.                     }
  23816.                 }
  23817.                 
  23818.                 
  23819.             }catch(java.lang.Exception e) {
  23820.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  23821.             }
  23822.             
  23823.             this.getGestioneTokenValidazioneJWTLockPermitsRead = true;
  23824.         }

  23826.         return this.getGestioneTokenValidazioneJWTLockPermits;
  23827.     }
  23828.     
  23829.     private Boolean getGestioneTokenIntrospectionLockPermitsRead = null;
  23830.     private Integer getGestioneTokenIntrospectionLockPermits = null;
  23831.     public Integer getGestioneTokenIntrospectionLockPermits() {

  23833.         String pName = "org.openspcoop2.pdd.gestioneToken.introspection.lock.permits";
  23834.         if(this.getGestioneTokenIntrospectionLockPermitsRead==null){
  23835.             try{  
  23836.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23838.                 if (value != null){
  23839.                     value = value.trim();
  23840.                     int permits = Integer.parseInt(value); 
  23841.                     if(permits>1) {
  23842.                         // altrimenti è un normale semaphore binario
  23843.                         this.getGestioneTokenIntrospectionLockPermits = permits;
  23844.                     }
  23845.                 }
  23846.                 
  23847.                 
  23848.             }catch(java.lang.Exception e) {
  23849.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  23850.             }
  23851.             
  23852.             this.getGestioneTokenIntrospectionLockPermitsRead = true;
  23853.         }

  23855.         return this.getGestioneTokenIntrospectionLockPermits;
  23856.     }
  23857.     
  23858.     private Boolean getGestioneTokenUserInfoLockPermitsRead = null;
  23859.     private Integer getGestioneTokenUserInfoLockPermits = null;
  23860.     public Integer getGestioneTokenUserInfoLockPermits() {

  23862.         String pName = "org.openspcoop2.pdd.gestioneToken.userInfo.lock.permits";
  23863.         if(this.getGestioneTokenUserInfoLockPermitsRead==null){
  23864.             try{  
  23865.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23867.                 if (value != null){
  23868.                     value = value.trim();
  23869.                     int permits = Integer.parseInt(value); 
  23870.                     if(permits>1) {
  23871.                         // altrimenti è un normale semaphore binario
  23872.                         this.getGestioneTokenUserInfoLockPermits = permits;
  23873.                     }
  23874.                 }
  23875.                 
  23876.                 
  23877.             }catch(java.lang.Exception e) {
  23878.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  23879.             }
  23880.             
  23881.             this.getGestioneTokenUserInfoLockPermitsRead = true;
  23882.         }

  23884.         return this.getGestioneTokenUserInfoLockPermits;
  23885.     }
  23886.     
  23887.     private Boolean isGestioneTokenDynamicDiscoveryKeyCacheUseToken = null;
  23888.     public boolean isGestioneTokenDynamicDiscoveryKeyCacheUseToken(){

  23890.         String pName = "org.openspcoop2.pdd.gestioneToken.dynamicDiscovery.keyCache.useToken";
  23891.         if(this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken==null){
  23892.             try{  
  23893.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23895.                 if (value != null){
  23896.                     value = value.trim();
  23897.                     this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken = Boolean.parseBoolean(value);
  23898.                 }else{
  23899.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23900.                     this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken = false;
  23901.                 }

  23903.             }catch(java.lang.Exception e) {
  23904.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23905.                 this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken = false;
  23906.             }
  23907.         }

  23909.         return this.isGestioneTokenDynamicDiscoveryKeyCacheUseToken;
  23910.     }
  23911.     
  23912.     private Boolean isGestioneTokenDynamicDiscoveryUseCacheConfig = null;
  23913.     public boolean isGestioneTokenDynamicDiscoveryUseCacheConfig(){

  23915.         String pName = "org.openspcoop2.pdd.gestioneToken.dynamicDiscovery.useCacheConfig";
  23916.         if(this.isGestioneTokenDynamicDiscoveryUseCacheConfig==null){
  23917.             try{  
  23918.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23920.                 if (value != null){
  23921.                     value = value.trim();
  23922.                     this.isGestioneTokenDynamicDiscoveryUseCacheConfig = Boolean.parseBoolean(value);
  23923.                 }else{
  23924.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  23925.                     this.isGestioneTokenDynamicDiscoveryUseCacheConfig = true;
  23926.                 }

  23928.             }catch(java.lang.Exception e) {
  23929.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  23930.                 this.isGestioneTokenDynamicDiscoveryUseCacheConfig = true;
  23931.             }
  23932.         }

  23934.         return this.isGestioneTokenDynamicDiscoveryUseCacheConfig;
  23935.     }
  23936.         
  23937.     private Boolean isGestioneTokenIatRequired = null;
  23938.     public boolean isGestioneTokenIatRequired() {

  23940.         String pName = "org.openspcoop2.pdd.gestioneToken.iat.required";
  23941.         if(this.isGestioneTokenIatRequired==null){
  23942.             try{  
  23943.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23945.                 if (value != null){
  23946.                     value = value.trim();
  23947.                     this.isGestioneTokenIatRequired = Boolean.parseBoolean(value);
  23948.                 }else{
  23949.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23950.                     this.isGestioneTokenIatRequired = false;
  23951.                 }
  23952.             }catch(java.lang.Exception e) {
  23953.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23954.                 this.isGestioneTokenIatRequired = false;
  23955.             }
  23956.         }
  23957.         
  23958.         return this.isGestioneTokenIatRequired;
  23959.     }
  23960.     
  23961.     private static final String GESTIONE_TOKEN_FRUIZIONI = "fruizioni";
  23962.     private static final String GESTIONE_TOKEN_EROGAZIONI = "erogazioni";
  23963.     private static final String GESTIONE_TOKEN_SUFFIX_REQUIRED = ".required";
  23964.     
  23965.     private Map<String,BooleanNullable> isGestioneTokenIatRequirePddRuolodMap = new HashMap<>();
  23966.     public BooleanNullable isGestioneTokenIatRequired(boolean portaDelegata) {

  23968.         String keyRuolo =  portaDelegata ? GESTIONE_TOKEN_FRUIZIONI : GESTIONE_TOKEN_EROGAZIONI;
  23969.         String pName = "org.openspcoop2.pdd.gestioneToken.iat."+keyRuolo+GESTIONE_TOKEN_SUFFIX_REQUIRED;
  23970.         if(!this.isGestioneTokenIatRequirePddRuolodMap.containsKey(keyRuolo)){
  23971.             try{  
  23972.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  23974.                 if (value != null){
  23975.                     value = value.trim();
  23976.                     boolean v = Boolean.parseBoolean(value);
  23977.                     this.isGestioneTokenIatRequirePddRuolodMap.put(keyRuolo, v ? BooleanNullable.TRUE() : BooleanNullable.FALSE());
  23978.                 }else{
  23979.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  23980.                     this.isGestioneTokenIatRequirePddRuolodMap.put(keyRuolo, BooleanNullable.NULL());
  23981.                 }
  23982.             }catch(java.lang.Exception e) {
  23983.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  23984.                 this.isGestioneTokenIatRequirePddRuolodMap.put(keyRuolo, BooleanNullable.NULL());
  23985.             }
  23986.         }
  23987.         
  23988.         return this.isGestioneTokenIatRequirePddRuolodMap.get(keyRuolo);
  23989.     }
  23990.     
  23991.     private Map<String,BooleanNullable> isGestioneTokenIatRequirePddRuoloProtocolloMap = new HashMap<>();
  23992.     public BooleanNullable isGestioneTokenIatRequired(boolean portaDelegata, String protocollo) {

  23994.         String keyRuolo =  portaDelegata ? GESTIONE_TOKEN_FRUIZIONI : GESTIONE_TOKEN_EROGAZIONI;
  23995.         keyRuolo+="."+protocollo;
  23996.         String pName = "org.openspcoop2.pdd.gestioneToken.iat."+keyRuolo+GESTIONE_TOKEN_SUFFIX_REQUIRED;
  23997.         if(!this.isGestioneTokenIatRequirePddRuoloProtocolloMap.containsKey(keyRuolo)){
  23998.             try{  
  23999.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24001.                 if (value != null){
  24002.                     value = value.trim();
  24003.                     boolean v = Boolean.parseBoolean(value);
  24004.                     this.isGestioneTokenIatRequirePddRuoloProtocolloMap.put(keyRuolo, v ? BooleanNullable.TRUE() : BooleanNullable.FALSE());
  24005.                 }else{
  24006.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24007.                     this.isGestioneTokenIatRequirePddRuoloProtocolloMap.put(keyRuolo, BooleanNullable.NULL());
  24008.                 }
  24009.             }catch(java.lang.Exception e) {
  24010.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24011.                 this.isGestioneTokenIatRequirePddRuoloProtocolloMap.put(keyRuolo, BooleanNullable.NULL());
  24012.             }
  24013.         }
  24014.         
  24015.         return this.isGestioneTokenIatRequirePddRuoloProtocolloMap.get(keyRuolo);
  24016.     }
  24017.     public BooleanNullable isGestioneTokenIatPdndRequired() {
  24018.         return isGestioneTokenIatRequired(false, "pdnd");
  24019.     }
  24020.     
  24021.     private Boolean getGestioneTokenIatTimeCheckMillisecondsRead = null;
  24022.     private Long getGestioneTokenIatTimeCheckMilliseconds = null;
  24023.     public Long getGestioneTokenIatTimeCheckMilliseconds() throws CoreException{

  24025.         String pName = "org.openspcoop2.pdd.gestioneToken.iat";
  24026.         if(this.getGestioneTokenIatTimeCheckMillisecondsRead==null){
  24027.             try{  
  24028.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24030.                 if (value != null){
  24031.                     value = value.trim();
  24032.                     long minuti = Long.parseLong(value); // minuti
  24033.                     this.getGestioneTokenIatTimeCheckMilliseconds = minuti * 60l * 1000l;
  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.getGestioneTokenIatTimeCheckMillisecondsRead = true;
  24041.         }

  24043.         return this.getGestioneTokenIatTimeCheckMilliseconds;
  24044.     }
  24045.     
  24046.     private Boolean getGestioneTokenIatTimeCheckFutureToleranceMillisecondsRead = null;
  24047.     private Long getGestioneTokenIatTimeCheckFutureToleranceMilliseconds = null;
  24048.     public Long getGestioneTokenIatTimeCheckFutureToleranceMilliseconds() throws CoreException{

  24050.         String pName = "org.openspcoop2.pdd.gestioneToken.iat.future.toleranceMilliseconds";
  24051.         if(this.getGestioneTokenIatTimeCheckFutureToleranceMillisecondsRead==null){
  24052.             try{  
  24053.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24055.                 if (value != null){
  24056.                     value = value.trim();
  24057.                     this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds = Long.parseLong(value); // gia' millisecondi
  24058.                     if(this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds<=0) {
  24059.                         // disabilito il controllo
  24060.                         this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds=null;
  24061.                     }
  24062.                 }
  24063.             }catch(java.lang.Exception e) {
  24064.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  24065.                 throw new CoreException(e.getMessage(),e);
  24066.             }
  24067.             
  24068.             this.getGestioneTokenIatTimeCheckFutureToleranceMillisecondsRead = true;
  24069.         }

  24071.         return this.getGestioneTokenIatTimeCheckFutureToleranceMilliseconds;
  24072.     }
  24073.     
  24074.     private Boolean isGestioneTokenExpRequired = null;
  24075.     public boolean isGestioneTokenExpRequired() {

  24077.         String pName = "org.openspcoop2.pdd.gestioneToken.exp.required";
  24078.         if(this.isGestioneTokenExpRequired==null){
  24079.             try{  
  24080.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24082.                 if (value != null){
  24083.                     value = value.trim();
  24084.                     this.isGestioneTokenExpRequired = Boolean.parseBoolean(value);
  24085.                 }else{
  24086.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24087.                     this.isGestioneTokenExpRequired = false;
  24088.                 }
  24089.             }catch(java.lang.Exception e) {
  24090.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24091.                 this.isGestioneTokenExpRequired = false;
  24092.             }
  24093.         }
  24094.         
  24095.         return this.isGestioneTokenExpRequired;
  24096.     }
  24097.     
  24098.     private Map<String,BooleanNullable> isGestioneTokenExpRequirePddRuolodMap = new HashMap<>();
  24099.     public BooleanNullable isGestioneTokenExpRequired(boolean portaDelegata) {

  24101.         String keyRuolo =  portaDelegata ? GESTIONE_TOKEN_FRUIZIONI : GESTIONE_TOKEN_EROGAZIONI;
  24102.         String pName = "org.openspcoop2.pdd.gestioneToken.exp."+keyRuolo+GESTIONE_TOKEN_SUFFIX_REQUIRED;
  24103.         if(!this.isGestioneTokenExpRequirePddRuolodMap.containsKey(keyRuolo)){
  24104.             try{  
  24105.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24107.                 if (value != null){
  24108.                     value = value.trim();
  24109.                     boolean v = Boolean.parseBoolean(value);
  24110.                     this.isGestioneTokenExpRequirePddRuolodMap.put(keyRuolo, v ? BooleanNullable.TRUE() : BooleanNullable.FALSE());
  24111.                 }else{
  24112.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24113.                     this.isGestioneTokenExpRequirePddRuolodMap.put(keyRuolo, BooleanNullable.NULL());
  24114.                 }
  24115.             }catch(java.lang.Exception e) {
  24116.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24117.                 this.isGestioneTokenExpRequirePddRuolodMap.put(keyRuolo, BooleanNullable.NULL());
  24118.             }
  24119.         }
  24120.         
  24121.         return this.isGestioneTokenExpRequirePddRuolodMap.get(keyRuolo);
  24122.     }
  24123.     
  24124.     private Map<String,BooleanNullable> isGestioneTokenExpRequirePddRuoloProtocolloMap = new HashMap<>();
  24125.     public BooleanNullable isGestioneTokenExpRequired(boolean portaDelegata, String protocollo) {

  24127.         String keyRuolo =  portaDelegata ? GESTIONE_TOKEN_FRUIZIONI : GESTIONE_TOKEN_EROGAZIONI;
  24128.         keyRuolo+="."+protocollo;
  24129.         String pName = "org.openspcoop2.pdd.gestioneToken.exp."+keyRuolo+GESTIONE_TOKEN_SUFFIX_REQUIRED;
  24130.         if(!this.isGestioneTokenExpRequirePddRuoloProtocolloMap.containsKey(keyRuolo)){
  24131.             try{  
  24132.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24134.                 if (value != null){
  24135.                     value = value.trim();
  24136.                     boolean v = Boolean.parseBoolean(value);
  24137.                     this.isGestioneTokenExpRequirePddRuoloProtocolloMap.put(keyRuolo, v ? BooleanNullable.TRUE() : BooleanNullable.FALSE());
  24138.                 }else{
  24139.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24140.                     this.isGestioneTokenExpRequirePddRuoloProtocolloMap.put(keyRuolo, BooleanNullable.NULL());
  24141.                 }
  24142.             }catch(java.lang.Exception e) {
  24143.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24144.                 this.isGestioneTokenExpRequirePddRuoloProtocolloMap.put(keyRuolo, BooleanNullable.NULL());
  24145.             }
  24146.         }
  24147.         
  24148.         return this.isGestioneTokenExpRequirePddRuoloProtocolloMap.get(keyRuolo);
  24149.     }
  24150.     public BooleanNullable isGestioneTokenExpPdndRequired() {
  24151.         return isGestioneTokenExpRequired(false, "pdnd");
  24152.     }
  24153.     
  24154.     private Boolean isGestioneTokenExpTimeCheck = null;
  24155.     public boolean isGestioneTokenExpTimeCheck(){

  24157.         if(this.isGestioneTokenExpTimeCheck==null){
  24158.             String pName = "org.openspcoop2.pdd.gestioneToken.exp.checkEnabled";
  24159.             try{  
  24160.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24162.                 if (value != null){
  24163.                     value = value.trim();
  24164.                     this.isGestioneTokenExpTimeCheck = Boolean.parseBoolean(value);
  24165.                 }else{
  24166.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  24167.                     this.isGestioneTokenExpTimeCheck = true;
  24168.                 }

  24170.             }catch(java.lang.Exception e) {
  24171.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  24172.                 this.isGestioneTokenExpTimeCheck = true;
  24173.             }
  24174.         }

  24176.         return this.isGestioneTokenExpTimeCheck;
  24177.     }
  24178.     
  24179.     private Boolean getGestioneTokenExpTimeCheckToleranceMillisecondsRead = null;
  24180.     private Long getGestioneTokenExpTimeCheckToleranceMilliseconds = null;
  24181.     public Long getGestioneTokenExpTimeCheckToleranceMilliseconds() throws CoreException{

  24183.         String pName = "org.openspcoop2.pdd.gestioneToken.exp.toleranceMilliseconds";
  24184.         if(this.getGestioneTokenExpTimeCheckToleranceMillisecondsRead==null){
  24185.             try{  
  24186.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24188.                 if (value != null){
  24189.                     value = value.trim();
  24190.                     this.getGestioneTokenExpTimeCheckToleranceMilliseconds = Long.parseLong(value); // gia' millisecondi
  24191.                     if(this.getGestioneTokenExpTimeCheckToleranceMilliseconds<=0) {
  24192.                         // disabilito il controllo
  24193.                         this.getGestioneTokenExpTimeCheckToleranceMilliseconds=null;
  24194.                     }
  24195.                 }
  24196.             }catch(java.lang.Exception e) {
  24197.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  24198.                 throw new CoreException(e.getMessage(),e);
  24199.             }
  24200.             
  24201.             this.getGestioneTokenExpTimeCheckToleranceMillisecondsRead = true;
  24202.         }

  24204.         return this.getGestioneTokenExpTimeCheckToleranceMilliseconds;
  24205.     }
  24206.     
  24207.     private Boolean isGestioneTokenNbfRequired = null;
  24208.     public boolean isGestioneTokenNbfRequired() {

  24210.         String pName = "org.openspcoop2.pdd.gestioneToken.nbf.required";
  24211.         if(this.isGestioneTokenNbfRequired==null){
  24212.             try{  
  24213.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24215.                 if (value != null){
  24216.                     value = value.trim();
  24217.                     this.isGestioneTokenNbfRequired = Boolean.parseBoolean(value);
  24218.                 }else{
  24219.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24220.                     this.isGestioneTokenNbfRequired = false;
  24221.                 }
  24222.             }catch(java.lang.Exception e) {
  24223.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24224.                 this.isGestioneTokenNbfRequired = false;
  24225.             }
  24226.         }
  24227.         
  24228.         return this.isGestioneTokenNbfRequired;
  24229.     }
  24230.     
  24231.     private Map<String,BooleanNullable> isGestioneTokenNbfRequirePddRuolodMap = new HashMap<>();
  24232.     public BooleanNullable isGestioneTokenNbfRequired(boolean portaDelegata) {

  24234.         String keyRuolo =  portaDelegata ? GESTIONE_TOKEN_FRUIZIONI : GESTIONE_TOKEN_EROGAZIONI;
  24235.         String pName = "org.openspcoop2.pdd.gestioneToken.nbf."+keyRuolo+GESTIONE_TOKEN_SUFFIX_REQUIRED;
  24236.         if(!this.isGestioneTokenNbfRequirePddRuolodMap.containsKey(keyRuolo)){
  24237.             try{  
  24238.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24240.                 if (value != null){
  24241.                     value = value.trim();
  24242.                     boolean v = Boolean.parseBoolean(value);
  24243.                     this.isGestioneTokenNbfRequirePddRuolodMap.put(keyRuolo, v ? BooleanNullable.TRUE() : BooleanNullable.FALSE());
  24244.                 }else{
  24245.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24246.                     this.isGestioneTokenNbfRequirePddRuolodMap.put(keyRuolo, BooleanNullable.NULL());
  24247.                 }
  24248.             }catch(java.lang.Exception e) {
  24249.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24250.                 this.isGestioneTokenNbfRequirePddRuolodMap.put(keyRuolo, BooleanNullable.NULL());
  24251.             }
  24252.         }
  24253.         
  24254.         return this.isGestioneTokenNbfRequirePddRuolodMap.get(keyRuolo);
  24255.     }
  24256.     
  24257.     private Map<String,BooleanNullable> isGestioneTokenNbfRequirePddRuoloProtocolloMap = new HashMap<>();
  24258.     public BooleanNullable isGestioneTokenNbfRequired(boolean portaDelegata, String protocollo) {

  24260.         String keyRuolo =  portaDelegata ? GESTIONE_TOKEN_FRUIZIONI : GESTIONE_TOKEN_EROGAZIONI;
  24261.         keyRuolo+="."+protocollo;
  24262.         String pName = "org.openspcoop2.pdd.gestioneToken.nbf."+keyRuolo+GESTIONE_TOKEN_SUFFIX_REQUIRED;
  24263.         if(!this.isGestioneTokenNbfRequirePddRuoloProtocolloMap.containsKey(keyRuolo)){
  24264.             try{  
  24265.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24267.                 if (value != null){
  24268.                     value = value.trim();
  24269.                     boolean v = Boolean.parseBoolean(value);
  24270.                     this.isGestioneTokenNbfRequirePddRuoloProtocolloMap.put(keyRuolo, v ? BooleanNullable.TRUE() : BooleanNullable.FALSE());
  24271.                 }else{
  24272.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24273.                     this.isGestioneTokenNbfRequirePddRuoloProtocolloMap.put(keyRuolo, BooleanNullable.NULL());
  24274.                 }
  24275.             }catch(java.lang.Exception e) {
  24276.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24277.                 this.isGestioneTokenNbfRequirePddRuoloProtocolloMap.put(keyRuolo, BooleanNullable.NULL());
  24278.             }
  24279.         }
  24280.         
  24281.         return this.isGestioneTokenNbfRequirePddRuoloProtocolloMap.get(keyRuolo);
  24282.     }
  24283.     public BooleanNullable isGestioneTokenNbfPdndRequired() {
  24284.         return isGestioneTokenNbfRequired(false, "pdnd");
  24285.     }
  24286.     
  24287.     private Boolean getGestioneTokenNbfTimeCheckToleranceMillisecondsRead = null;
  24288.     private Long getGestioneTokenNbfTimeCheckToleranceMilliseconds = null;
  24289.     public Long getGestioneTokenNbfTimeCheckToleranceMilliseconds() throws CoreException{

  24291.         String pName = "org.openspcoop2.pdd.gestioneToken.nbf.toleranceMilliseconds";
  24292.         if(this.getGestioneTokenNbfTimeCheckToleranceMillisecondsRead==null){
  24293.             try{  
  24294.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24296.                 if (value != null){
  24297.                     value = value.trim();
  24298.                     this.getGestioneTokenNbfTimeCheckToleranceMilliseconds = Long.parseLong(value); // gia' millisecondi
  24299.                     if(this.getGestioneTokenNbfTimeCheckToleranceMilliseconds<=0) {
  24300.                         // disabilito il controllo
  24301.                         this.getGestioneTokenNbfTimeCheckToleranceMilliseconds=null;
  24302.                     }
  24303.                 }
  24304.             }catch(java.lang.Exception e) {
  24305.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  24306.                 throw new CoreException(e.getMessage(),e);
  24307.             }
  24308.             
  24309.             this.getGestioneTokenNbfTimeCheckToleranceMillisecondsRead = true;
  24310.         }

  24312.         return this.getGestioneTokenNbfTimeCheckToleranceMilliseconds;
  24313.     }
  24314.     
  24315.     private CertificateValidityCheck getGestioneTokenValidityCheck = null;
  24316.     public CertificateValidityCheck getGestioneTokenValidityCheck(){

  24318.         String pName = "org.openspcoop2.pdd.gestioneToken.validityCheck";
  24319.         if(this.getGestioneTokenValidityCheck==null){
  24320.             try{  
  24321.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24323.                 if (value != null){
  24324.                     value = value.trim();
  24325.                     this.getGestioneTokenValidityCheck = CertificateValidityCheck.parseCertificateValidityCheck(value);
  24326.                     if(this.getGestioneTokenValidityCheck==null) {
  24327.                         throw new CoreException("Opzione '"+value+"' sconosciuta");
  24328.                     }
  24329.                 }else{
  24330.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  24331.                     this.getGestioneTokenValidityCheck = CertificateValidityCheck.ENABLED;
  24332.                 }

  24334.             }catch(java.lang.Exception e) {
  24335.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  24336.                 this.getGestioneTokenValidityCheck = CertificateValidityCheck.ENABLED;
  24337.             }
  24338.         }

  24340.         return this.getGestioneTokenValidityCheck;
  24341.     }
  24342.     
  24343.     private Boolean isGestioneTokenSaveSourceTokenInfo = null;
  24344.     public boolean isGestioneTokenSaveSourceTokenInfo(){

  24346.         if(this.isGestioneTokenSaveSourceTokenInfo==null){
  24347.             try{  
  24348.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.saveSourceTokenInfo"); 

  24350.                 if (value != null){
  24351.                     value = value.trim();
  24352.                     this.isGestioneTokenSaveSourceTokenInfo = Boolean.parseBoolean(value);
  24353.                 }else{
  24354.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.saveSourceTokenInfo' non impostata, viene utilizzato il default=false");
  24355.                     this.isGestioneTokenSaveSourceTokenInfo = false;
  24356.                 }

  24358.             }catch(java.lang.Exception e) {
  24359.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.saveSourceTokenInfo' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  24360.                 this.isGestioneTokenSaveSourceTokenInfo = false;
  24361.             }
  24362.         }

  24364.         return this.isGestioneTokenSaveSourceTokenInfo;
  24365.     }
  24366.     
  24367.     private Boolean isGestioneTokenSaveTokenInfoValidationFailed = null;
  24368.     public boolean isGestioneTokenSaveTokenInfoValidationFailed(){

  24370.         if(this.isGestioneTokenSaveTokenInfoValidationFailed==null){
  24371.             String pName = "org.openspcoop2.pdd.gestioneToken.saveTokenInfo.validationFailed";
  24372.             try{  
  24373.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24375.                 if (value != null){
  24376.                     value = value.trim();
  24377.                     this.isGestioneTokenSaveTokenInfoValidationFailed = Boolean.parseBoolean(value);
  24378.                 }else{
  24379.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  24380.                     this.isGestioneTokenSaveTokenInfoValidationFailed = false;
  24381.                 }

  24383.             }catch(java.lang.Exception e) {
  24384.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  24385.                 this.isGestioneTokenSaveTokenInfoValidationFailed = false;
  24386.             }
  24387.         }

  24389.         return this.isGestioneTokenSaveTokenInfoValidationFailed;
  24390.     }
  24391.     
  24392.     private Boolean isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature = null;
  24393.     public boolean isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature(){

  24395.         if(this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature==null){
  24396.             String pName = "org.openspcoop2.pdd.gestioneToken.saveTokenInfo.validationFailed.excludeJwtSignature";
  24397.             try{  
  24398.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24400.                 if (value != null){
  24401.                     value = value.trim();
  24402.                     this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature = Boolean.parseBoolean(value);
  24403.                 }else{
  24404.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  24405.                     this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature = true;
  24406.                 }

  24408.             }catch(java.lang.Exception e) {
  24409.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  24410.                 this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature = true;
  24411.             }
  24412.         }

  24414.         return this.isGestioneTokenSaveTokenInfoValidationFailedExcludeJwtSignature;
  24415.     }
  24416.     
  24417.     private Boolean isGestioneTokenSaveTokenAuthenticationInfoValidationFailed = null;
  24418.     public boolean isGestioneTokenSaveTokenAuthenticationInfoValidationFailed(){

  24420.         if(this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed==null){
  24421.             String pName = "org.openspcoop2.pdd.gestioneToken.saveTokenAuthenticationInfo.validationFailed";
  24422.             try{  
  24423.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24425.                 if (value != null){
  24426.                     value = value.trim();
  24427.                     this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed = Boolean.parseBoolean(value);
  24428.                 }else{
  24429.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  24430.                     this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed = true;
  24431.                 }

  24433.             }catch(java.lang.Exception e) {
  24434.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  24435.                 this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed = true;
  24436.             }
  24437.         }

  24439.         return this.isGestioneTokenSaveTokenAuthenticationInfoValidationFailed;
  24440.     }
  24441.     
  24442.     private Boolean isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed = null;
  24443.     public boolean isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed(){

  24445.         if(this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed==null){
  24446.             String pName = "org.openspcoop2.pdd.gestioneToken.saveTokenAuthenticationInfo.authenticationFailed";
  24447.             try{  
  24448.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  24450.                 if (value != null){
  24451.                     value = value.trim();
  24452.                     this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed = Boolean.parseBoolean(value);
  24453.                 }else{
  24454.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  24455.                     this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed = true;
  24456.                 }

  24458.             }catch(java.lang.Exception e) {
  24459.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  24460.                 this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed = true;
  24461.             }
  24462.         }

  24464.         return this.isGestioneTokenSaveTokenAuthenticationInfoAuthenticationFailed;
  24465.     }
  24466.     
  24467.     private Boolean getGestioneTokenFormatDateRead = null;
  24468.     private String getGestioneTokenFormatDate = null;
  24469.     public String getGestioneTokenFormatDate() throws CoreException{

  24471.         if(this.getGestioneTokenFormatDateRead==null){
  24472.             try{  
  24473.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.date.format"); 

  24475.                 if (value != null){
  24476.                     value = value.trim();
  24477.                     this.getGestioneTokenFormatDate = value;
  24478.                 }

  24480.             }catch(java.lang.Exception e) {
  24481.                 String msg = "Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.date.format' non impostata, errore:"+e.getMessage();
  24482.                 this.logError(msg,e);
  24483.                 throw new CoreException(msg);
  24484.             }
  24485.             
  24486.             this.getGestioneTokenFormatDateRead = true;
  24487.         }

  24489.         return this.getGestioneTokenFormatDate;
  24490.     }
  24491.     
  24492.     private String getGestioneTokenHeaderTrasportoJSON = null;
  24493.     public String getGestioneTokenHeaderTrasportoJSON() throws CoreException{

  24495.         if(this.getGestioneTokenHeaderTrasportoJSON==null){
  24496.             try{  
  24497.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.jsonHeader"); 

  24499.                 if (value != null){
  24500.                     value = value.trim();
  24501.                     this.getGestioneTokenHeaderTrasportoJSON = value;
  24502.                 }else{
  24503.                     throw new CoreException("Non impostata");
  24504.                 }

  24506.             }catch(java.lang.Exception e) {
  24507.                 String msg = "Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.jsonHeader' non impostata, errore:"+e.getMessage();
  24508.                 this.logError(msg,e);
  24509.                 throw new CoreException(msg);
  24510.             }
  24511.         }

  24513.         return this.getGestioneTokenHeaderTrasportoJSON;
  24514.     }
  24515.     
  24516.     private String getGestioneTokenHeaderTrasportoJWT = null;
  24517.     public String getGestioneTokenHeaderTrasportoJWT() throws CoreException{

  24519.         if(this.getGestioneTokenHeaderTrasportoJWT==null){
  24520.             try{  
  24521.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.jwsHeader"); 

  24523.                 if (value != null){
  24524.                     value = value.trim();
  24525.                     this.getGestioneTokenHeaderTrasportoJWT = value;
  24526.                 }else{
  24527.                     throw new CoreException("Non impostata");
  24528.                 }

  24530.             }catch(java.lang.Exception e) {
  24531.                 String msg = "Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.jwsHeader' non impostata, errore:"+e.getMessage();
  24532.                 this.logError(msg,e);
  24533.                 throw new CoreException(msg);
  24534.             }
  24535.         }

  24537.         return this.getGestioneTokenHeaderTrasportoJWT;
  24538.     }

  24540.     /**
  24541.      * Restituisce le proprieta' che identificano gli header di integrazione in caso di 'trasporto' 
  24542.      *
  24543.      * @return Restituisce le proprieta' che identificano gli header di integrazione in caso di 'trasporto'
  24544.      *  
  24545.      */
  24546.     private Map<String, String> keyValueGestioneTokenHeaderIntegrazioneTrasporto = null;
  24547.     public Map<String, String> getKeyValueGestioneTokenHeaderIntegrazioneTrasporto() {  
  24548.         if(this.keyValueGestioneTokenHeaderIntegrazioneTrasporto==null){

  24550.             try{ 

  24552.                 this.keyValueGestioneTokenHeaderIntegrazioneTrasporto = this.reader.readPropertiesAsHashMapConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.keyword.");
  24553.                 
  24554.             }catch(java.lang.Exception e) {
  24555.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.keyword.*': "+e.getMessage(),e);
  24556.                 this.keyValueGestioneTokenHeaderIntegrazioneTrasporto = null;
  24557.             }    
  24558.         }

  24560.         return this.keyValueGestioneTokenHeaderIntegrazioneTrasporto;
  24561.     }
  24562.     
  24563.     private Map<String, Boolean> keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD = null;
  24564.     public Map<String, Boolean> getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto() throws CoreException { 
  24565.         if(this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD==null){

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

  24570.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled.");
  24571.                 this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD = new HashMap<>();
  24572.                 Iterator<?> it = prop.keySet().iterator();
  24573.                 while (it.hasNext()) {
  24574.                     Object object = it.next();
  24575.                     if(object instanceof String) {
  24576.                         String key = (String) object;
  24577.                         String value = prop.getProperty(key);
  24578.                         processKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(key, value);
  24579.                     }
  24580.                 }
  24581.                 
  24582.             }catch(java.lang.Exception e) {
  24583.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pd.set.enabled.*': "+e.getMessage(),e);
  24584.                 throw new CoreException(e.getMessage(),e);
  24585.             }    
  24586.         }

  24588.         return this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD;
  24589.     }
  24590.     private void processKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String key, String value) throws CoreException {
  24591.         try {
  24592.             boolean b = Boolean.parseBoolean(value);
  24593.             this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD.put(key, b);
  24594.         }catch(Exception e) {
  24595.             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);
  24596.         }
  24597.     }

  24599.     
  24600.     private Map<String, Boolean> keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA = null;
  24601.     public Map<String, Boolean> getKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto() throws CoreException { 
  24602.         if(this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA==null){

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

  24607.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled.");
  24608.                 this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA = new HashMap<>();
  24609.                 Iterator<?> it = prop.keySet().iterator();
  24610.                 while (it.hasNext()) {
  24611.                     Object object = it.next();
  24612.                     if(object instanceof String) {
  24613.                         String key = (String) object;
  24614.                         String value = prop.getProperty(key);
  24615.                         processKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(key, value);
  24616.                     }
  24617.                 }
  24618.                 
  24619.             }catch(java.lang.Exception e) {
  24620.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.pa.set.enabled.*': "+e.getMessage(),e);
  24621.                 throw new CoreException(e.getMessage(),e);
  24622.             }    
  24623.         }

  24625.         return this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA;
  24626.     }
  24627.     private void processKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String key, String value) throws CoreException {
  24628.         try {
  24629.             boolean b = Boolean.parseBoolean(value);
  24630.             this.keyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA.put(key, b);
  24631.         }catch(Exception e) {
  24632.             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);
  24633.         }
  24634.     }
  24635.     
  24636.     private Map<String, Boolean> keyValueGestioneTokenHeaderIntegrazioneJsonSetPD = null;
  24637.     public Map<String, Boolean> getKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson() throws CoreException {  
  24638.         if(this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPD==null){

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

  24643.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled.");
  24644.                 this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPD = new HashMap<>();
  24645.                 Iterator<?> it = prop.keySet().iterator();
  24646.                 while (it.hasNext()) {
  24647.                     Object object = it.next();
  24648.                     if(object instanceof String) {
  24649.                         String key = (String) object;
  24650.                         String value = prop.getProperty(key);
  24651.                         processKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(key, value);
  24652.                     }
  24653.                 }
  24654.                 
  24655.             }catch(java.lang.Exception e) {
  24656.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.json.pd.set.enabled.*': "+e.getMessage(),e);
  24657.                 throw new CoreException(e.getMessage(),e);
  24658.             }    
  24659.         }

  24661.         return this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPD;
  24662.     }
  24663.     private void processKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(String key, String value) throws CoreException {
  24664.         try {
  24665.             boolean b = Boolean.parseBoolean(value);
  24666.             this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPD.put(key, b);
  24667.         }catch(Exception e) {
  24668.             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);
  24669.         }
  24670.     }

  24672.     
  24673.     private Map<String, Boolean> keyValueGestioneTokenHeaderIntegrazioneJsonSetPA = null;
  24674.     public Map<String, Boolean> getKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson() throws CoreException {  
  24675.         if(this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPA==null){

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

  24680.                 prop = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled.");
  24681.                 this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPA = new HashMap<>();
  24682.                 Iterator<?> it = prop.keySet().iterator();
  24683.                 while (it.hasNext()) {
  24684.                     Object object = it.next();
  24685.                     if(object instanceof String) {
  24686.                         String key = (String) object;
  24687.                         String value = prop.getProperty(key);
  24688.                         processKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(key, value);
  24689.                     }
  24690.                 }
  24691.                 
  24692.             }catch(java.lang.Exception e) {
  24693.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.json.pa.set.enabled.*': "+e.getMessage(),e);
  24694.                 throw new CoreException(e.getMessage(),e);
  24695.             }    
  24696.         }

  24698.         return this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPA;
  24699.     }
  24700.     private void processKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(String key, String value) throws CoreException {
  24701.         try {
  24702.             boolean b = Boolean.parseBoolean(value);
  24703.             this.keyValueGestioneTokenHeaderIntegrazioneJsonSetPA.put(key, b);
  24704.         }catch(Exception e) {
  24705.             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);
  24706.         }
  24707.     }
  24708.     
  24709.     private static final String PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX = "org.openspcoop2.pdd.gestioneToken.forward.custom.";
  24710.     
  24711.     private List<String> getCustomClaimsKeysGestioneTokenForward = null;
  24712.     public List<String> getCustomClaimsKeysGestioneTokenForward() throws CoreException {    
  24713.         if(this.getCustomClaimsKeysGestioneTokenForward==null){

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

  24718.                 this.getCustomClaimsKeysGestioneTokenForward= new ArrayList<>();
  24719.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  24720.                 if(prop!=null && !prop.isEmpty()) {
  24721.                     Enumeration<?> en = prop.keys();
  24722.                     while (en.hasMoreElements()) {
  24723.                         String key = (String) en.nextElement();
  24724.                         processCustomClaimsKeysGestioneTokenForward(key);
  24725.                     }
  24726.                 }
  24727.                 
  24728.             }catch(java.lang.Exception e) {
  24729.                 this.logError("Riscontrato errore durante la lettura delle proprieta' 'org.openspcoop2.pdd.gestioneToken.forward.custom.CLAIM_NAME.name': "+e.getMessage(),e);
  24730.                 throw new CoreException(e.getMessage(),e);
  24731.             }    
  24732.         }

  24734.         return this.getCustomClaimsKeysGestioneTokenForward;
  24735.     }
  24736.     private void processCustomClaimsKeysGestioneTokenForward(String key) {
  24737.         if(key.contains(".")) {
  24738.             String keySub = key.substring(key.indexOf(".")+1); 
  24739.             if("name".equals(keySub)) {
  24740.                 String tmp = key.substring(0, key.indexOf("."));
  24741.                 if(tmp!=null) {
  24742.                     this.getCustomClaimsKeysGestioneTokenForward.add(tmp.trim());
  24743.                 }
  24744.             }
  24745.         }
  24746.     }
  24747.     
  24748.     private Character gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator = null;
  24749.     public Character getGestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator(){

  24751.         if(this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator==null){
  24752.             try{  
  24753.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.audience.separator"); 

  24755.                 if (value != null){
  24756.                     value = value.trim();
  24757.                     if(value.length()<1 || value.length()>1) {
  24758.                         throw new CoreException(ATTESO_UN_CARATTERE_TROVATI+value.length());
  24759.                     }
  24760.                     this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator = value.charAt(0);
  24761.                 }else{
  24762.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.audience.separator' non impostata, viene utilizzato il default=,");
  24763.                     this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator = ',';
  24764.                 }

  24766.             }catch(java.lang.Exception e) {
  24767.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.audience.separator' non impostata, viene utilizzato il default=, ; errore:"+e.getMessage(),e);
  24768.                 this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator = ',';
  24769.             }
  24770.         }

  24772.         return this.gestioneTokenHeaderIntegrazioneTrasportoAudienceSeparator;
  24773.     }
  24774.     
  24775.     private Character gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator = null;
  24776.     public Character getGestioneTokenHeaderIntegrazioneTrasportoScopeSeparator(){

  24778.         if(this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator==null){
  24779.             try{  
  24780.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.scopes.separator"); 

  24782.                 if (value != null){
  24783.                     value = value.trim();
  24784.                     if(value.length()<1 || value.length()>1) {
  24785.                         throw new CoreException(ATTESO_UN_CARATTERE_TROVATI+value.length());
  24786.                     }
  24787.                     this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator = value.charAt(0);
  24788.                 }else{
  24789.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.scopes.separator' non impostata, viene utilizzato il default=,");
  24790.                     this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator = ',';
  24791.                 }

  24793.             }catch(java.lang.Exception e) {
  24794.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.scopes.separator' non impostata, viene utilizzato il default=, ; errore:"+e.getMessage(),e);
  24795.                 this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator = ',';
  24796.             }
  24797.         }

  24799.         return this.gestioneTokenHeaderIntegrazioneTrasportoScopeSeparator;
  24800.     }
  24801.     
  24802.     private Character gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator = null;
  24803.     public Character getGestioneTokenHeaderIntegrazioneTrasportoRoleSeparator(){

  24805.         if(this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator==null){
  24806.             try{  
  24807.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.gestioneToken.forward.trasporto.roles.separator"); 

  24809.                 if (value != null){
  24810.                     value = value.trim();
  24811.                     if(value.length()<1 || value.length()>1) {
  24812.                         throw new CoreException(ATTESO_UN_CARATTERE_TROVATI+value.length());
  24813.                     }
  24814.                     this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator = value.charAt(0);
  24815.                 }else{
  24816.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.roles.separator' non impostata, viene utilizzato il default=,");
  24817.                     this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator = ',';
  24818.                 }

  24820.             }catch(java.lang.Exception e) {
  24821.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.gestioneToken.forward.trasporto.roles.separator' non impostata, viene utilizzato il default=, ; errore:"+e.getMessage(),e);
  24822.                 this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator = ',';
  24823.             }
  24824.         }

  24826.         return this.gestioneTokenHeaderIntegrazioneTrasportoRoleSeparator;
  24827.     }
  24828.     
  24829.     private Map<String, String> getCustomClaimsNameGestioneTokenHeaderIntegrazione = null;
  24830.     public String getCustomClaimsNameGestioneTokenHeaderIntegrazione(String claimName) throws CoreException {   
  24831.         if(this.getCustomClaimsNameGestioneTokenHeaderIntegrazione==null){

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

  24836.                 this.getCustomClaimsNameGestioneTokenHeaderIntegrazione = new HashMap<>();
  24837.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  24838.                 if(prop!=null && !prop.isEmpty()) {
  24839.                     Enumeration<?> en = prop.keys();
  24840.                     while (en.hasMoreElements()) {
  24841.                         String key = (String) en.nextElement();
  24842.                         processCustomClaimsNameGestioneTokenHeaderIntegrazioneEngine(key, prop);
  24843.                     }
  24844.                 }
  24845.                 
  24846.             }catch(java.lang.Exception e) {
  24847.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".trasporto.name': "+e.getMessage(),e);
  24848.                 throw new CoreException(e.getMessage(),e);
  24849.             }    
  24850.         }

  24852.         return this.getCustomClaimsNameGestioneTokenHeaderIntegrazione.get(claimName);
  24853.     }
  24854.     private void processCustomClaimsNameGestioneTokenHeaderIntegrazioneEngine(String key, java.util.Properties prop) throws CoreException { 
  24855.         if(key.contains(".")) {
  24856.             String keySub = key.substring(key.indexOf(".")+1); 
  24857.             if("name".equals(keySub)) {
  24858.                 String tmp = prop.getProperty(key);
  24859.                 if(tmp!=null) {
  24860.                     String claimNameTmp = key.substring(0, key.indexOf("."));
  24861.                     this.getCustomClaimsNameGestioneTokenHeaderIntegrazione.put(claimNameTmp, tmp.trim());
  24862.                 }
  24863.                 else {
  24864.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  24865.                 }
  24866.             }
  24867.         }
  24868.     }
  24869.     
  24870.     private Map<String, String> getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto = null;
  24871.     public String getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto(String claimName) throws CoreException {    
  24872.         if(this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto==null){

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

  24877.                 this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto = new HashMap<>();
  24878.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  24879.                 if(prop!=null && !prop.isEmpty()) {
  24880.                     Enumeration<?> en = prop.keys();
  24881.                     while (en.hasMoreElements()) {
  24882.                         String key = (String) en.nextElement();
  24883.                         processCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto(key, prop);
  24884.                     }
  24885.                 }
  24886.                 
  24887.             }catch(java.lang.Exception e) {
  24888.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".trasporto.name': "+e.getMessage(),e);
  24889.                 throw new CoreException(e.getMessage(),e);
  24890.             }    
  24891.         }

  24893.         return this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto.get(claimName);
  24894.     }
  24895.     private void processCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto(String key, java.util.Properties prop) throws CoreException {    
  24896.         if(key.contains(".")) {
  24897.             String keySub = key.substring(key.indexOf(".")+1); 
  24898.             if("trasporto.name".equals(keySub)) {
  24899.                 String tmp = prop.getProperty(key);
  24900.                 if(tmp!=null) {
  24901.                     String claimNameTmp = key.substring(0, key.indexOf("."));
  24902.                     this.getCustomClaimsHeaderNameGestioneTokenHeaderIntegrazioneTrasporto.put(claimNameTmp, tmp.trim());
  24903.                 }
  24904.                 else {
  24905.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  24906.                 }
  24907.             }
  24908.         }
  24909.     }
  24910.     
  24911.     private Map<String, Boolean> getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD = null;
  24912.     public Boolean getCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String claimName) throws CoreException {  
  24913.         if(this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD==null){

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

  24918.                 this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD = new HashMap<>();
  24919.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  24920.                 if(prop!=null && !prop.isEmpty()) {
  24921.                     Enumeration<?> en = prop.keys();
  24922.                     while (en.hasMoreElements()) {
  24923.                         String key = (String) en.nextElement();
  24924.                         processCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(key, prop);
  24925.                     }
  24926.                 }
  24927.                 
  24928.             }catch(java.lang.Exception e) {
  24929.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".trasporto.pd.set.enabled': "+e.getMessage(),e);
  24930.                 throw new CoreException(e.getMessage(),e);
  24931.             }    
  24932.         }

  24934.         return this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD.get(claimName);
  24935.     }
  24936.     private void processCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String key, java.util.Properties prop) throws CoreException {   
  24937.         if(key.contains(".")) {
  24938.             String keySub = key.substring(key.indexOf(".")+1); 
  24939.             if("trasporto.pd.set.enabled".equals(keySub)) {
  24940.                 String tmp = prop.getProperty(key);
  24941.                 if(tmp!=null) {
  24942.                     try {
  24943.                         boolean b = Boolean.parseBoolean(tmp.trim());
  24944.                         String claimNameTmp = key.substring(0, key.indexOf("."));
  24945.                         this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPD.put(claimNameTmp, b);
  24946.                     }catch(Exception e) {
  24947.                         throw new CoreException("Rilevato errore durante il parsing della property '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+key+"' (atteso: true/false): "+e.getMessage(),e);
  24948.                     }
  24949.                 }
  24950.                 else {
  24951.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  24952.                 }
  24953.             }
  24954.         }
  24955.     }

  24957.     
  24958.     private Map<String, Boolean> getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA = null;
  24959.     public Boolean getCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String claimName) throws CoreException {  
  24960.         if(this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA==null){

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

  24965.                 this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA = new HashMap<>();
  24966.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  24967.                 if(prop!=null && !prop.isEmpty()) {
  24968.                     Enumeration<?> en = prop.keys();
  24969.                     while (en.hasMoreElements()) {
  24970.                         String key = (String) en.nextElement();
  24971.                         processCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(key, prop);
  24972.                     }
  24973.                 }
  24974.                 
  24975.             }catch(java.lang.Exception e) {
  24976.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".trasporto.pa.set.enabled': "+e.getMessage(),e);
  24977.                 throw new CoreException(e.getMessage(),e);
  24978.             }    
  24979.         }

  24981.         return this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA.get(claimName);
  24982.     }
  24983.     private void processCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneTrasporto(String key, java.util.Properties prop) throws CoreException {   
  24984.         if(key.contains(".")) {
  24985.             String keySub = key.substring(key.indexOf(".")+1); 
  24986.             if("trasporto.pa.set.enabled".equals(keySub)) {
  24987.                 String tmp = prop.getProperty(key);
  24988.                 if(tmp!=null) {
  24989.                     try {
  24990.                         boolean b = Boolean.parseBoolean(tmp.trim());
  24991.                         String claimNameTmp = key.substring(0, key.indexOf("."));
  24992.                         this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneTrasportoSetPA.put(claimNameTmp, b);
  24993.                     }catch(Exception e) {
  24994.                         throw new CoreException("Rilevato errore durante il parsing della property '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+key+"' (atteso: true/false): "+e.getMessage(),e);
  24995.                     }
  24996.                 }
  24997.                 else {
  24998.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  24999.                 }
  25000.             }
  25001.         }
  25002.     }
  25003.     
  25004.     private Map<String, String> getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson = null;
  25005.     public String getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson(String claimName) throws CoreException {   
  25006.         if(this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson==null){

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

  25011.                 this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson = new HashMap<>();
  25012.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  25013.                 if(prop!=null && !prop.isEmpty()) {
  25014.                     Enumeration<?> en = prop.keys();
  25015.                     while (en.hasMoreElements()) {
  25016.                         String key = (String) en.nextElement();
  25017.                         processCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson(key, prop);
  25018.                     }
  25019.                 }
  25020.                 
  25021.             }catch(java.lang.Exception e) {
  25022.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".json.name': "+e.getMessage(),e);
  25023.                 throw new CoreException(e.getMessage(),e);
  25024.             }    
  25025.         }

  25027.         return this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson.get(claimName);
  25028.     }
  25029.     private void processCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson(String key, java.util.Properties prop) throws CoreException {   
  25030.         if(key.contains(".")) {
  25031.             String keySub = key.substring(key.indexOf(".")+1); 
  25032.             if("json.name".equals(keySub)) {
  25033.                 String tmp = prop.getProperty(key);
  25034.                 if(tmp!=null) {
  25035.                     String claimNameTmp = key.substring(0, key.indexOf("."));
  25036.                     this.getCustomClaimsJsonPropertyNameGestioneTokenHeaderIntegrazioneJson.put(claimNameTmp, tmp.trim());
  25037.                 }
  25038.                 else {
  25039.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  25040.                 }
  25041.             }
  25042.         }
  25043.     }
  25044.     
  25045.     private Map<String, Boolean> getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD = null;
  25046.     public Boolean getCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(String claimName) throws CoreException {   
  25047.         if(this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD==null){

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

  25052.                 this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD = new HashMap<>();
  25053.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  25054.                 if(prop!=null && !prop.isEmpty()) {
  25055.                     Enumeration<?> en = prop.keys();
  25056.                     while (en.hasMoreElements()) {
  25057.                         String key = (String) en.nextElement();
  25058.                         processCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(key, prop);
  25059.                     }
  25060.                 }
  25061.                 
  25062.             }catch(java.lang.Exception e) {
  25063.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".json.pd.set.enabled': "+e.getMessage(),e);
  25064.                 throw new CoreException(e.getMessage(),e);
  25065.             }    
  25066.         }

  25068.         return this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD.get(claimName);
  25069.     }
  25070.     private void processCustomClaimsKeyPDSetEnabledGestioneTokenHeaderIntegrazioneJson(String key, java.util.Properties prop) throws CoreException {    
  25071.         if(key.contains(".")) {
  25072.             String keySub = key.substring(key.indexOf(".")+1); 
  25073.             if("json.pd.set.enabled".equals(keySub)) {
  25074.                 String tmp = prop.getProperty(key);
  25075.                 if(tmp!=null) {
  25076.                     try {
  25077.                         boolean b = Boolean.parseBoolean(tmp.trim());
  25078.                         String claimNameTmp = key.substring(0, key.indexOf("."));
  25079.                         this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPD.put(claimNameTmp, b);
  25080.                     }catch(Exception e) {
  25081.                         throw new CoreException("Rilevato errore durante il parsing della property '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+key+"' (atteso: true/false): "+e.getMessage(),e);
  25082.                     }
  25083.                 }
  25084.                 else {
  25085.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  25086.                 }
  25087.             }
  25088.         }
  25089.     }

  25091.     
  25092.     private Map<String, Boolean> getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA = null;
  25093.     public Boolean getCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(String claimName) throws CoreException {   
  25094.         if(this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA==null){

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

  25099.                 this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA = new HashMap<>();
  25100.                 prop = this.reader.readPropertiesConvertEnvProperties(PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX);
  25101.                 if(prop!=null && !prop.isEmpty()) {
  25102.                     Enumeration<?> en = prop.keys();
  25103.                     while (en.hasMoreElements()) {
  25104.                         String key = (String) en.nextElement();
  25105.                         processCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(key, prop);
  25106.                     }
  25107.                 }
  25108.                 
  25109.             }catch(java.lang.Exception e) {
  25110.                 this.logError("Riscontrato errore durante la lettura delle proprieta' '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+claimName+".json.pa.set.enabled': "+e.getMessage(),e);
  25111.                 throw new CoreException(e.getMessage(),e);
  25112.             }    
  25113.         }

  25115.         return this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA.get(claimName);
  25116.     }
  25117.     private void processCustomClaimsKeyPASetEnabledGestioneTokenHeaderIntegrazioneJson(String key, java.util.Properties prop) throws CoreException {    
  25118.         if(key.contains(".")) {
  25119.             String keySub = key.substring(key.indexOf(".")+1); 
  25120.             if("json.pa.set.enabled".equals(keySub)) {
  25121.                 String tmp = prop.getProperty(key);
  25122.                 if(tmp!=null) {
  25123.                     try {
  25124.                         boolean b = Boolean.parseBoolean(tmp.trim());
  25125.                         String claimNameTmp = key.substring(0, key.indexOf("."));
  25126.                         this.getCustomClaimsKeyValueGestioneTokenHeaderIntegrazioneJsonSetPA.put(claimNameTmp, b);
  25127.                     }catch(Exception e) {
  25128.                         throw new CoreException("Rilevato errore durante il parsing della property '"+PDD_GESTIONE_TOKEN_FORWARD_CUSTOM_PREFIX+key+"' (atteso: true/false): "+e.getMessage(),e);
  25129.                     }
  25130.                 }
  25131.                 else {
  25132.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  25133.                 }
  25134.             }
  25135.         }
  25136.     }
  25137.     
  25138.     
  25139.     
  25140.     /* ------------- Gestione Retrieve Token ---------------------*/
  25141.     
  25142.     private Boolean isGestioneRetrieveTokenDebug = null;
  25143.     private Boolean isGestioneRetrieveTokenDebugRead = null;
  25144.     public Boolean getGestioneRetrieveTokenDebug(){

  25146.         String pName = "org.openspcoop2.pdd.retrieveToken.debug";
  25147.         if(this.isGestioneRetrieveTokenDebugRead==null){
  25148.             try{  
  25149.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25151.                 if (value != null){
  25152.                     value = value.trim();
  25153.                     this.isGestioneRetrieveTokenDebug = Boolean.parseBoolean(value);
  25154.                 }
  25155.                 
  25156.                 this.isGestioneRetrieveTokenDebugRead=true;

  25158.             }catch(java.lang.Exception e) {
  25159.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default='Utilizzo dell'impostazione del connettore', errore:"+e.getMessage(),e);
  25160.                 this.isGestioneRetrieveTokenDebug = false;
  25161.             }
  25162.         }

  25164.         return this.isGestioneRetrieveTokenDebug;
  25165.     }
  25166.     
  25167.     private Boolean getGestioneRetrieveTokenLockPermitsRead = null;
  25168.     private Integer getGestioneRetrieveTokenLockPermits = null;
  25169.     public Integer getGestioneRetrieveTokenLockPermits() {

  25171.         String pName = "org.openspcoop2.pdd.retrieveToken.lock.permits";
  25172.         if(this.getGestioneRetrieveTokenLockPermitsRead==null){
  25173.             try{  
  25174.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25176.                 if (value != null){
  25177.                     value = value.trim();
  25178.                     int permits = Integer.parseInt(value); 
  25179.                     if(permits>1) {
  25180.                         // altrimenti è un normale semaphore binario
  25181.                         this.getGestioneRetrieveTokenLockPermits = permits;
  25182.                     }
  25183.                 }
  25184.                 
  25185.                 
  25186.             }catch(java.lang.Exception e) {
  25187.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  25188.             }
  25189.             
  25190.             this.getGestioneRetrieveTokenLockPermitsRead = true;
  25191.         }

  25193.         return this.getGestioneRetrieveTokenLockPermits;
  25194.     }
  25195.     
  25196.     private Integer isGestioneRetrieveTokenRefreshTokenBeforeExpirePercent = null;
  25197.     private Boolean isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentRead = null;
  25198.     private String isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentPName = "org.openspcoop2.pdd.retrieveToken.refreshTokenBeforeExpire.percent";
  25199.     public Integer getGestioneRetrieveTokenRefreshTokenBeforeExpirePercent(){

  25201.         if(this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentRead==null){
  25202.             try{  
  25203.                 String value = this.reader.getValueConvertEnvProperties(this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentPName); 

  25205.                 if (value != null){
  25206.                     value = value.trim();
  25207.                     this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercent = Integer.parseInt(value);
  25208.                 }
  25209.                 
  25210.                 this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentRead=true;

  25212.             }catch(java.lang.Exception e) {
  25213.                 this.logError("Proprieta' di openspcoop '"+this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentPName+"' non impostata, errore:"+e.getMessage(),e);
  25214.                 this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercent = null;
  25215.             }
  25216.         }

  25218.         return this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercent;
  25219.     }
  25220.     
  25221.     private Integer isGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds = null;
  25222.     private Boolean isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsRead = null;
  25223.     private String isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsPName = "org.openspcoop2.pdd.retrieveToken.refreshTokenBeforeExpire.seconds";
  25224.     public Integer getGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds(){

  25226.         if(this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsRead==null){
  25227.             try{  
  25228.                 String value = this.reader.getValueConvertEnvProperties(this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsPName); 

  25230.                 if (value != null){
  25231.                     value = value.trim();
  25232.                     this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds = Integer.parseInt(value);
  25233.                 }
  25234.                 
  25235.                 this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsRead=true;

  25237.             }catch(java.lang.Exception e) {
  25238.                 this.logError("Proprieta' di openspcoop '"+this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsPName+"' non impostata, errore:"+e.getMessage(),e);
  25239.                 this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds = null;
  25240.             }
  25241.         }

  25243.         return this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds;
  25244.     }
  25245.     
  25246.     private boolean validateGestioneRetrieveTokenRefreshTokenBeforeExpire() {
  25247.         Integer percent = getGestioneRetrieveTokenRefreshTokenBeforeExpirePercent();
  25248.         Integer seconds = getGestioneRetrieveTokenRefreshTokenBeforeExpireSeconds();
  25249.         boolean percentDefined = percent !=null && percent>0;
  25250.         boolean secondsDefined = seconds!=null && seconds>0;
  25251.         /**
  25252.          *Fix: lascio la possibilità di usare il token fino alla scadenza prossima se non vengono definite nessuna delle due proprietà
  25253.         if(!percentDefined && !secondsDefined) {
  25254.             this.logError("Almeno una proprietà tra le seguenti deve essere definita: '"+isGestioneRetrieveToken_refreshTokenBeforeExpire_percent_pName+"' o '"+isGestioneRetrieveToken_refreshTokenBeforeExpire_seconds_pName+"'");
  25255.             return false;
  25256.         }*/
  25257.         if(percentDefined && secondsDefined) {
  25258.             this.logError("Non è possibile definire contemporaneamente entrambe le seguenti proprietà: '"+this.isGestioneRetrieveTokenRefreshTokenBeforeExpirePercentPName+"' o '"+this.isGestioneRetrieveTokenRefreshTokenBeforeExpireSecondsPName+"'");
  25259.             return false;
  25260.         }
  25261.         return true;
  25262.     }
  25263.     
  25264.     private Boolean isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials = null;
  25265.     public boolean isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials(){

  25267.         String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.clientCredentials";
  25268.         if(this.isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials==null){
  25269.             try{  
  25270.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25272.                 if (value != null){
  25273.                     value = value.trim();
  25274.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials = Boolean.parseBoolean(value);
  25275.                 }else{
  25276.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25277.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials = false;
  25278.                 }

  25280.             }catch(java.lang.Exception e) {
  25281.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25282.                 this.isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials = false;
  25283.             }
  25284.         }

  25286.         return this.isGestioneRetrieveTokenRefreshTokenGrantTypeClientCredentials;
  25287.     }
  25288.     
  25289.     private Boolean isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword = null;
  25290.     public boolean isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword(){

  25292.         String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.usernamePassword";
  25293.         if(this.isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword==null){
  25294.             try{  
  25295.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25297.                 if (value != null){
  25298.                     value = value.trim();
  25299.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword = Boolean.parseBoolean(value);
  25300.                 }else{
  25301.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25302.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword = false;
  25303.                 }

  25305.             }catch(java.lang.Exception e) {
  25306.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25307.                 this.isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword = false;
  25308.             }
  25309.         }

  25311.         return this.isGestioneRetrieveTokenRefreshTokenGrantTypeUsernamePassword;
  25312.     }
  25313.     
  25314.     private Boolean isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509 = null;
  25315.     public boolean isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509(){

  25317.         String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.rfc7523_x509";
  25318.         if(this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509==null){
  25319.             try{  
  25320.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25322.                 if (value != null){
  25323.                     value = value.trim();
  25324.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509 = Boolean.parseBoolean(value);
  25325.                 }else{
  25326.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25327.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509 = false;
  25328.                 }

  25330.             }catch(java.lang.Exception e) {
  25331.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25332.                 this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509 = false;
  25333.             }
  25334.         }

  25336.         return this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523x509;
  25337.     }
  25338.     
  25339.     private Boolean isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret = null;
  25340.     public boolean isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret(){

  25342.         String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.rfc7523_clientSecret";
  25343.         if(this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret==null){
  25344.             try{  
  25345.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25347.                 if (value != null){
  25348.                     value = value.trim();
  25349.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret = Boolean.parseBoolean(value);
  25350.                 }else{
  25351.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25352.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret = false;
  25353.                 }

  25355.             }catch(java.lang.Exception e) {
  25356.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25357.                 this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret = false;
  25358.             }
  25359.         }

  25361.         return this.isGestioneRetrieveTokenRefreshTokenGrantTypeRfc7523ClientSecret;
  25362.     }
  25363.     
  25364.     private Boolean isGestioneRetrieveTokenRefreshTokenGrantTypeCustom = null;
  25365.     public boolean isGestioneRetrieveTokenRefreshTokenGrantTypeCustom(){

  25367.         String pName = "org.openspcoop2.pdd.retrieveToken.refreshToken.grantType.custom";
  25368.         if(this.isGestioneRetrieveTokenRefreshTokenGrantTypeCustom==null){
  25369.             try{  
  25370.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25372.                 if (value != null){
  25373.                     value = value.trim();
  25374.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeCustom = Boolean.parseBoolean(value);
  25375.                 }else{
  25376.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25377.                     this.isGestioneRetrieveTokenRefreshTokenGrantTypeCustom = false;
  25378.                 }

  25380.             }catch(java.lang.Exception e) {
  25381.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25382.                 this.isGestioneRetrieveTokenRefreshTokenGrantTypeCustom = false;
  25383.             }
  25384.         }

  25386.         return this.isGestioneRetrieveTokenRefreshTokenGrantTypeCustom;
  25387.     }
  25388.     
  25389.     private Boolean isGestioneRetrieveTokenSaveAsTokenInfo = null;
  25390.     public boolean isGestioneRetrieveTokenSaveAsTokenInfo(){

  25392.         String pName = "org.openspcoop2.pdd.retrieveToken.saveAsTokenInfo";
  25393.         if(this.isGestioneRetrieveTokenSaveAsTokenInfo==null){
  25394.             try{  
  25395.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25397.                 if (value != null){
  25398.                     value = value.trim();
  25399.                     this.isGestioneRetrieveTokenSaveAsTokenInfo = Boolean.parseBoolean(value);
  25400.                 }else{
  25401.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25402.                     this.isGestioneRetrieveTokenSaveAsTokenInfo = true;
  25403.                 }

  25405.             }catch(java.lang.Exception e) {
  25406.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25407.                 this.isGestioneRetrieveTokenSaveAsTokenInfo = true;
  25408.             }
  25409.         }

  25411.         return this.isGestioneRetrieveTokenSaveAsTokenInfo;
  25412.     }
  25413.     
  25414.     private Boolean isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature = null;
  25415.     public boolean isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature(){

  25417.         String pName = "org.openspcoop2.pdd.retrieveToken.saveAsTokenInfo.excludeJwtSignature";
  25418.         if(this.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature==null){
  25419.             try{  
  25420.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25422.                 if (value != null){
  25423.                     value = value.trim();
  25424.                     this.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature = Boolean.parseBoolean(value);
  25425.                 }else{
  25426.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25427.                     this.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature = true;
  25428.                 }

  25430.             }catch(java.lang.Exception e) {
  25431.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25432.                 this.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature = true;
  25433.             }
  25434.         }

  25436.         return this.isGestioneRetrieveTokenSaveAsTokenInfoExcludeJwtSignature;
  25437.     }
  25438.     
  25439.     private Boolean isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest = null;
  25440.     public boolean isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest(){

  25442.         String pName = "org.openspcoop2.pdd.retrieveToken.saveAsTokenInfo.saveSourceRequest";
  25443.         if(this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest==null){
  25444.             try{  
  25445.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25447.                 if (value != null){
  25448.                     value = value.trim();
  25449.                     this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest = Boolean.parseBoolean(value);
  25450.                 }else{
  25451.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25452.                     this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest = true;
  25453.                 }

  25455.             }catch(java.lang.Exception e) {
  25456.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25457.                 this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest = true;
  25458.             }
  25459.         }

  25461.         return this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequest;
  25462.     }
  25463.     
  25464.     private Boolean isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate = null;
  25465.     public boolean isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate(){

  25467.         String pName = "org.openspcoop2.pdd.retrieveToken.saveAsTokenInfo.saveSourceRequest.date";
  25468.         if(this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate==null){
  25469.             try{  
  25470.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25472.                 if (value != null){
  25473.                     value = value.trim();
  25474.                     this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate = Boolean.parseBoolean(value);
  25475.                 }else{
  25476.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25477.                     this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate = true;
  25478.                 }

  25480.             }catch(java.lang.Exception e) {
  25481.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25482.                 this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate = true;
  25483.             }
  25484.         }

  25486.         return this.isGestioneRetrieveTokenSaveAsTokenInfoSaveSourceRequestDate;
  25487.     }
  25488.     
  25489.     private Boolean isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate = null;
  25490.     public boolean isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate(){

  25492.         String pName = "org.openspcoop2.pdd.retrieveToken.grantType_rfc7523.saveClientAssertionJWTInfo.transazioniRegistrazioneInformazioniNormalizzate";
  25493.         if(this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate==null){
  25494.             try{  
  25495.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25497.                 if (value != null){
  25498.                     value = value.trim();
  25499.                     this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate = Boolean.parseBoolean(value);
  25500.                 }else{
  25501.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25502.                     this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate = false;
  25503.                 }

  25505.             }catch(java.lang.Exception e) {
  25506.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25507.                 this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate = false;
  25508.             }
  25509.         }

  25511.         return this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoTransazioniRegistrazioneInformazioniNormalizzate;
  25512.     }
  25513.     
  25514.     private Boolean isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature = null;
  25515.     public boolean isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature(){

  25517.         String pName = "org.openspcoop2.pdd.retrieveToken.grantType_rfc7523.saveClientAssertionJWTInfo.excludeJwtSignature";
  25518.         if(this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature==null){
  25519.             try{  
  25520.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25522.                 if (value != null){
  25523.                     value = value.trim();
  25524.                     this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature = Boolean.parseBoolean(value);
  25525.                 }else{
  25526.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25527.                     this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature = true;
  25528.                 }

  25530.             }catch(java.lang.Exception e) {
  25531.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25532.                 this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature = true;
  25533.             }
  25534.         }

  25536.         return this.isGestioneRetrieveTokenGrantTypeRfc7523SaveClientAssertionJWTInfoExcludeJwtSignature;
  25537.     }
  25538.     
  25539.     private Boolean isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed = null;
  25540.     public boolean isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed(){

  25542.         String pName = "org.openspcoop2.pdd.retrieveToken.saveTokenInfo.retrieveFailed";
  25543.         if(this.isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed==null){
  25544.             try{  
  25545.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25547.                 if (value != null){
  25548.                     value = value.trim();
  25549.                     this.isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed = Boolean.parseBoolean(value);
  25550.                 }else{
  25551.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25552.                     this.isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed = false;
  25553.                 }

  25555.             }catch(java.lang.Exception e) {
  25556.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25557.                 this.isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed = false;
  25558.             }
  25559.         }

  25561.         return this.isGestioneRetrieveTokenSaveTokenInfoRetrieveFailed;
  25562.     }

  25564.     private Map<String, Boolean> gestioneRetrieveTokenCacheKey = null;
  25565.     private void initGestioneRetrieveTokenCacheKey() throws CoreException {
  25566.         Properties p = null;
  25567.         try {
  25568.             p = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.retrieveToken.cacheKey.");
  25569.         }catch(Exception e) {
  25570.             throw new CoreException(e.getMessage(),e);
  25571.         }
  25572.         if(p!=null) {
  25573.             this.gestioneRetrieveTokenCacheKey = new HashMap<>();
  25574.             for (Object oKey : p.keySet()) {
  25575.                 if(oKey instanceof String) {
  25576.                     String key = (String) oKey;
  25577.                     String v = p.getProperty(key);
  25578.                     if(v!=null) {
  25579.                         boolean b = Boolean.parseBoolean(v.trim());
  25580.                         this.gestioneRetrieveTokenCacheKey.put(key,b);
  25581.                     }
  25582.                 }
  25583.             }
  25584.         }
  25585.     }
  25586.     public boolean isGestioneRetrieveTokenCacheKey(String tipo) {
  25587.         if(this.gestioneRetrieveTokenCacheKey!=null && !this.gestioneRetrieveTokenCacheKey.isEmpty() && this.gestioneRetrieveTokenCacheKey.containsKey(tipo)) {
  25588.             return this.gestioneRetrieveTokenCacheKey.get(tipo);
  25589.         }
  25590.         
  25591.         // logica di default
  25592.         return !(
  25593.                 CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_IDENTIFIER.equals(tipo)
  25594.                 || 
  25595.                 CostantiPdD.HEADER_INTEGRAZIONE_TOKEN_SESSION_INFO.equals(tipo)
  25596.                 );
  25597.     }
  25598.     
  25599.     private static final String PDND_PATTERN_MATCH_DEFAULT = "^https://auth.*\\.interop\\.pagopa\\.it/token\\.oauth2$";
  25600.     private static final String PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY = "org.openspcoop2.pdd.retrieveToken.";
  25601.     private Map<String,String> getGestioneRetrieveTokenPdndUrlPatternMatch = new HashMap<>();
  25602.     public String getGestioneRetrieveTokenPdndUrlPatternMatch(String protocollo){

  25604.         if(protocollo==null) {
  25605.             protocollo = Costanti.MODIPA_PROTOCOL_NAME; // default
  25606.         }
  25607.         
  25608.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+".pdnd.url.pattern";
  25609.         if(!this.getGestioneRetrieveTokenPdndUrlPatternMatch.containsKey(protocollo)){
  25610.             try{  
  25611.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25613.                 if (value != null){
  25614.                     value = value.trim();
  25615.                     this.getGestioneRetrieveTokenPdndUrlPatternMatch.put(protocollo, value);
  25616.                 }else{
  25617.                     // dovrebbe venire chiamato solo per ModI
  25618.                     if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo)) {
  25619.                         this.logWarn(getMessaggioProprietaNonImpostata(pName, PDND_PATTERN_MATCH_DEFAULT));
  25620.                     }
  25621.                     this.getGestioneRetrieveTokenPdndUrlPatternMatch.put(protocollo, PDND_PATTERN_MATCH_DEFAULT);
  25622.                 }

  25624.             }catch(java.lang.Exception e) {
  25625.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, PDND_PATTERN_MATCH_DEFAULT),e);
  25626.                 this.getGestioneRetrieveTokenPdndUrlPatternMatch.put(protocollo, PDND_PATTERN_MATCH_DEFAULT);
  25627.             }
  25628.         }

  25630.         return this.getGestioneRetrieveTokenPdndUrlPatternMatch.get(protocollo);
  25631.     }
  25632.     
  25633.     private Map<String,Boolean> isGestioneRetrieveTokenPdndPayloadClientId = new HashMap<>();
  25634.     private boolean isGestioneRetrieveTokenPdndPayloadClientId(String protocollo){

  25636.         if(protocollo==null) {
  25637.             protocollo = Costanti.MODIPA_PROTOCOL_NAME; // default
  25638.         }
  25639.         
  25640.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+".pdnd.payload.clientId";
  25641.         if(!this.isGestioneRetrieveTokenPdndPayloadClientId.containsKey(protocollo)){
  25642.             try{  
  25643.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25645.                 if (value != null){
  25646.                     value = value.trim();
  25647.                     this.isGestioneRetrieveTokenPdndPayloadClientId.put(protocollo, Boolean.parseBoolean(value));
  25648.                 }else{
  25649.                     // dovrebbe venire chiamato solo per ModI
  25650.                     if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo)) {
  25651.                         this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25652.                     }
  25653.                     this.isGestioneRetrieveTokenPdndPayloadClientId.put(protocollo, false);
  25654.                 }

  25656.             }catch(java.lang.Exception e) {
  25657.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25658.                 this.isGestioneRetrieveTokenPdndPayloadClientId.put(protocollo, false);
  25659.             }
  25660.         }

  25662.         return this.isGestioneRetrieveTokenPdndPayloadClientId.get(protocollo);
  25663.     }
  25664.     
  25665.     private Map<String,Boolean> isGestioneRetrieveTokenPdndPayloadClientIdMapSoggetto = new HashMap<>();
  25666.     public boolean isGestioneRetrieveTokenPdndPayloadClientId(String protocollo, String soggettoFruitore){

  25668.         if(soggettoFruitore==null) {
  25669.             return isGestioneRetrieveTokenPdndPayloadClientId(protocollo);
  25670.         }
  25671.         
  25672.         String key = protocollo+"_"+soggettoFruitore;
  25673.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+"."+soggettoFruitore+".pdnd.payload.clientId";
  25674.         if(!this.isGestioneRetrieveTokenPdndPayloadClientIdMapSoggetto.containsKey(key)){
  25675.             try{  
  25676.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25678.                 if (value != null){
  25679.                     value = value.trim();
  25680.                     this.isGestioneRetrieveTokenPdndPayloadClientIdMapSoggetto.put(key, Boolean.parseBoolean(value));
  25681.                 }else{
  25682.                     return isGestioneRetrieveTokenPdndPayloadClientId(protocollo);
  25683.                 }

  25685.             }catch(java.lang.Exception e) {
  25686.                 this.logError("isGestioneRetrieveTokenPdndPayloadClientId failed: "+e.getMessage(), e);
  25687.                 return isGestioneRetrieveTokenPdndPayloadClientId(protocollo);
  25688.             }
  25689.         }

  25691.         return this.isGestioneRetrieveTokenPdndPayloadClientIdMapSoggetto.get(key);
  25692.     }
  25693.     
  25694.     private Map<String,Boolean> isGestioneRetrieveTokenPdndPayloadNbf = new HashMap<>();
  25695.     private boolean isGestioneRetrieveTokenPdndPayloadNbf(String protocollo){

  25697.         if(protocollo==null) {
  25698.             protocollo = Costanti.MODIPA_PROTOCOL_NAME; // default
  25699.         }
  25700.         
  25701.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+".pdnd.payload.nbf";
  25702.         if(!this.isGestioneRetrieveTokenPdndPayloadNbf.containsKey(protocollo)){
  25703.             try{  
  25704.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25706.                 if (value != null){
  25707.                     value = value.trim();
  25708.                     this.isGestioneRetrieveTokenPdndPayloadNbf.put(protocollo, Boolean.parseBoolean(value));
  25709.                 }else{
  25710.                     // dovrebbe venire chiamato solo per ModI
  25711.                     if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo)) {
  25712.                         this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25713.                     }
  25714.                     this.isGestioneRetrieveTokenPdndPayloadNbf.put(protocollo, false);
  25715.                 }

  25717.             }catch(java.lang.Exception e) {
  25718.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25719.                 this.isGestioneRetrieveTokenPdndPayloadNbf.put(protocollo, false);
  25720.             }
  25721.         }

  25723.         return this.isGestioneRetrieveTokenPdndPayloadNbf.get(protocollo);
  25724.     }
  25725.     
  25726.     private Map<String,Boolean> isGestioneRetrieveTokenPdndPayloadNbfMapSoggetto = new HashMap<>();
  25727.     public boolean isGestioneRetrieveTokenPdndPayloadNbf(String protocollo, String soggettoFruitore){

  25729.         if(soggettoFruitore==null) {
  25730.             return isGestioneRetrieveTokenPdndPayloadNbf(protocollo);
  25731.         }
  25732.         
  25733.         String key = protocollo+"_"+soggettoFruitore;
  25734.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+"."+soggettoFruitore+".pdnd.payload.nbf";
  25735.         if(!this.isGestioneRetrieveTokenPdndPayloadNbfMapSoggetto.containsKey(key)){
  25736.             try{  
  25737.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25739.                 if (value != null){
  25740.                     value = value.trim();
  25741.                     this.isGestioneRetrieveTokenPdndPayloadNbfMapSoggetto.put(key, Boolean.parseBoolean(value));
  25742.                 }else{
  25743.                     return isGestioneRetrieveTokenPdndPayloadNbf(protocollo);
  25744.                 }

  25746.             }catch(java.lang.Exception e) {
  25747.                 this.logError("isGestioneRetrieveTokenPdndPayloadNbf failed: "+e.getMessage(), e);
  25748.                 return isGestioneRetrieveTokenPdndPayloadNbf(protocollo);
  25749.             }
  25750.         }

  25752.         return this.isGestioneRetrieveTokenPdndPayloadNbfMapSoggetto.get(key);
  25753.     }
  25754.     
  25755.     
  25756.     private Map<String,Boolean> isGestioneRetrieveTokenPdndDatiRichiestaForceClientId = new HashMap<>();
  25757.     private boolean isGestioneRetrieveTokenPdndDatiRichiestaForceClientId(String protocollo){

  25759.         if(protocollo==null) {
  25760.             protocollo = Costanti.MODIPA_PROTOCOL_NAME; // default
  25761.         }
  25762.         
  25763.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+".pdnd.datiRichiesta.forceClientId";
  25764.         if(!this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientId.containsKey(protocollo)){
  25765.             try{  
  25766.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25768.                 if (value != null){
  25769.                     value = value.trim();
  25770.                     this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientId.put(protocollo, Boolean.parseBoolean(value));
  25771.                 }else{
  25772.                     // dovrebbe venire chiamato solo per ModI
  25773.                     if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocollo)) {
  25774.                         this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25775.                     }
  25776.                     this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientId.put(protocollo, true);
  25777.                 }

  25779.             }catch(java.lang.Exception e) {
  25780.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25781.                 this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientId.put(protocollo, true);
  25782.             }
  25783.         }

  25785.         return this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientId.get(protocollo);
  25786.     }
  25787.     
  25788.     private Map<String,Boolean> isGestioneRetrieveTokenPdndDatiRichiestaForceClientIdMapSoggetto = new HashMap<>();
  25789.     public boolean isGestioneRetrieveTokenPdndDatiRichiestaForceClientId(String protocollo, String soggettoFruitore){

  25791.         if(soggettoFruitore==null) {
  25792.             return isGestioneRetrieveTokenPdndDatiRichiestaForceClientId(protocollo);
  25793.         }
  25794.         
  25795.         String key = protocollo+"_"+soggettoFruitore;
  25796.         String pName = PDD_RETRIEVE_TOKEN_PREFIX_PROPERTY+protocollo+"."+soggettoFruitore+".pdnd.datiRichiesta.forceClientId";
  25797.         if(!this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientIdMapSoggetto.containsKey(key)){
  25798.             try{  
  25799.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25801.                 if (value != null){
  25802.                     value = value.trim();
  25803.                     this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientIdMapSoggetto.put(key, Boolean.parseBoolean(value));
  25804.                 }else{
  25805.                     return isGestioneRetrieveTokenPdndDatiRichiestaForceClientId(protocollo);
  25806.                 }

  25808.             }catch(java.lang.Exception e) {
  25809.                 this.logError("isGestioneRetrieveTokenPdndDatiRichiestaForceClientId failed: "+e.getMessage(), e);
  25810.                 return isGestioneRetrieveTokenPdndDatiRichiestaForceClientId(protocollo);
  25811.             }
  25812.         }

  25814.         return this.isGestioneRetrieveTokenPdndDatiRichiestaForceClientIdMapSoggetto.get(key);
  25815.     }
  25816.     
  25817.     
  25818.     
  25819.     
  25820.     /* ------------- Gestione Attribute Authority ---------------------*/
  25821.     
  25822.     private Boolean isGestioneAttributeAuthorityDebug = null;
  25823.     public boolean isGestioneAttributeAuthorityDebug(){

  25825.         String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.debug";
  25826.         if(this.isGestioneAttributeAuthorityDebug==null){
  25827.             try{  
  25828.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25830.                 if (value != null){
  25831.                     value = value.trim();
  25832.                     this.isGestioneAttributeAuthorityDebug = Boolean.parseBoolean(value);
  25833.                 }else{
  25834.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25835.                     this.isGestioneAttributeAuthorityDebug = false;
  25836.                 }

  25838.             }catch(java.lang.Exception e) {
  25839.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25840.                 this.isGestioneAttributeAuthorityDebug = false;
  25841.             }
  25842.         }

  25844.         return this.isGestioneAttributeAuthorityDebug;
  25845.     }
  25846.     
  25847.     private Boolean getGestioneAttributeAuthorityLockPermitsRead = null;
  25848.     private Integer getGestioneAttributeAuthorityLockPermits = null;
  25849.     public Integer getGestioneAttributeAuthorityLockPermits() {

  25851.         String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.lock.permits";
  25852.         if(this.getGestioneAttributeAuthorityLockPermitsRead==null){
  25853.             try{  
  25854.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25856.                 if (value != null){
  25857.                     value = value.trim();
  25858.                     int permits = Integer.parseInt(value); 
  25859.                     if(permits>1) {
  25860.                         // altrimenti è un normale semaphore binario
  25861.                         this.getGestioneAttributeAuthorityLockPermits = permits;
  25862.                     }
  25863.                 }
  25864.                 
  25865.                 
  25866.             }catch(java.lang.Exception e) {
  25867.                 this.logError("Proprieta' di openspcoop '"+pName+"' non impostata, errore:"+e.getMessage(),e);
  25868.             }
  25869.             
  25870.             this.getGestioneAttributeAuthorityLockPermitsRead = true;
  25871.         }

  25873.         return this.getGestioneAttributeAuthorityLockPermits;
  25874.     }
  25875.     
  25876.     private Boolean isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo = null;
  25877.     public boolean isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo(){

  25879.         String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.saveSourceAttributeResponseInfo";
  25880.         if(this.isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo==null){
  25881.             try{  
  25882.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25884.                 if (value != null){
  25885.                     value = value.trim();
  25886.                     this.isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo = Boolean.parseBoolean(value);
  25887.                 }else{
  25888.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25889.                     this.isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo = false;
  25890.                 }

  25892.             }catch(java.lang.Exception e) {
  25893.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25894.                 this.isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo = false;
  25895.             }
  25896.         }

  25898.         return this.isGestioneAttributeAuthoritySaveSourceAttributeResponseInfo;
  25899.     }
  25900.     
  25901.     private Boolean isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate = null;
  25902.     public boolean isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate(){

  25904.         String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.transazioniRegistrazioneAttributiInformazioniNormalizzate";
  25905.         if(this.isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate==null){
  25906.             try{  
  25907.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25909.                 if (value != null){
  25910.                     value = value.trim();
  25911.                     this.isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate = Boolean.parseBoolean(value);
  25912.                 }else{
  25913.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  25914.                     this.isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate = false;
  25915.                 }

  25917.             }catch(java.lang.Exception e) {
  25918.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  25919.                 this.isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate = false;
  25920.             }
  25921.         }

  25923.         return this.isGestioneAttributeAuthorityTransazioniRegistrazioneAttributiInformazioniNormalizzate;
  25924.     }
  25925.     
  25926.     private CertificateValidityCheck getGestioneAttributeAuthorityValidityCheck = null;
  25927.     public CertificateValidityCheck getGestioneAttributeAuthorityValidityCheck(){

  25929.         String pName = "org.openspcoop2.pdd.gestioneAttributeAuthority.validityCheck";
  25930.         if(this.getGestioneAttributeAuthorityValidityCheck==null){
  25931.             try{  
  25932.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  25934.                 if (value != null){
  25935.                     value = value.trim();
  25936.                     this.getGestioneAttributeAuthorityValidityCheck = CertificateValidityCheck.parseCertificateValidityCheck(value);
  25937.                     if(this.getGestioneAttributeAuthorityValidityCheck==null) {
  25938.                         throw new CoreException("Opzione '"+value+"' sconosciuta");
  25939.                     }
  25940.                 }else{
  25941.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  25942.                     this.getGestioneAttributeAuthorityValidityCheck = CertificateValidityCheck.ENABLED;
  25943.                 }

  25945.             }catch(java.lang.Exception e) {
  25946.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  25947.                 this.getGestioneAttributeAuthorityValidityCheck = CertificateValidityCheck.ENABLED;
  25948.             }
  25949.         }

  25951.         return this.getGestioneAttributeAuthorityValidityCheck;
  25952.     }
  25953.     
  25954.     
  25955.     
  25956.     
  25957.     
  25958.     
  25959.     /* ------------- JMX Statistiche ---------------------*/
  25960.     
  25961.     private Boolean isStatisticheViaJmx = null;
  25962.     public boolean isStatisticheViaJmx(){

  25964.         if(this.isStatisticheViaJmx==null){
  25965.             try{  
  25966.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.jmx.statistiche"); 

  25968.                 if (value != null){
  25969.                     value = value.trim();
  25970.                     this.isStatisticheViaJmx = Boolean.parseBoolean(value);
  25971.                 }else{
  25972.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jmx.statistiche' non impostata, viene utilizzato il default=false");
  25973.                     this.isStatisticheViaJmx = false;
  25974.                 }

  25976.             }catch(java.lang.Exception e) {
  25977.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.jmx.statistiche' non impostata, viene utilizzato il default=false, errore:"+e.getMessage(),e);
  25978.                 this.isStatisticheViaJmx = false;
  25979.             }
  25980.         }

  25982.         return this.isStatisticheViaJmx;
  25983.     }
  25984.     
  25985.     
  25986.     
  25987.     /* ------------- REST / SOAP Trasporto Utils ---------------------*/
  25988.     
  25989.     private void _list_add(List<MapKey<String>> tmp, List<MapKey<String>> addList) {
  25990.         if(tmp!=null && tmp.size()>0) {
  25991.             for (MapKey<String> hdr : tmp) {
  25992.                 if(addList.contains(hdr)==false) {
  25993.                     addList.add(hdr);
  25994.                 }
  25995.             }
  25996.         }
  25997.     }
  25998.     
  25999.     /* ------------- Forward Proxy ---------------------*/
  26000.     
  26001.     private Boolean isForwardProxyEnable = null;
  26002.     public boolean isForwardProxyEnable(){

  26004.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.enable";
  26005.         if(this.isForwardProxyEnable==null){
  26006.             try{  
  26007.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26009.                 if (value != null){
  26010.                     value = value.trim();
  26011.                     this.isForwardProxyEnable = Boolean.parseBoolean(value);
  26012.                 }else{
  26013.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  26014.                     this.isForwardProxyEnable = false;
  26015.                 }

  26017.             }catch(java.lang.Exception e) {
  26018.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  26019.                 this.isForwardProxyEnable = false;
  26020.             }
  26021.         }

  26023.         return this.isForwardProxyEnable;
  26024.     }
  26025.     
  26026.     
  26027.     private Boolean isForwardProxyHeaderEnable = null;
  26028.     private boolean isForwardProxyHeaderEnable(){

  26030.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.header.enable";
  26031.         if(this.isForwardProxyHeaderEnable==null){
  26032.             try{  
  26033.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26035.                 if (value != null){
  26036.                     value = value.trim();
  26037.                     this.isForwardProxyHeaderEnable = Boolean.parseBoolean(value);
  26038.                 }else{
  26039.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  26040.                     this.isForwardProxyHeaderEnable = false;
  26041.                 }

  26043.             }catch(java.lang.Exception e) {
  26044.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  26045.                 this.isForwardProxyHeaderEnable = false;
  26046.             }
  26047.         }

  26049.         return this.isForwardProxyHeaderEnable;
  26050.     }
  26051.     
  26052.     private String getForwardProxyHeaderName = null;
  26053.     private String getForwardProxyHeaderName(){

  26055.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.header.nome";
  26056.         if(this.getForwardProxyHeaderName==null){
  26057.             try{  
  26058.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26060.                 if (value != null){
  26061.                     value = value.trim();
  26062.                     this.getForwardProxyHeaderName = value;
  26063.                 }else{
  26064.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER));
  26065.                     this.getForwardProxyHeaderName = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER;
  26066.                 }

  26068.             }catch(java.lang.Exception e) {
  26069.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER),e);
  26070.                 this.getForwardProxyHeaderName = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER;
  26071.             }
  26072.         }

  26074.         return this.getForwardProxyHeaderName;
  26075.     }
  26076.     
  26077.     private Boolean isForwardProxyHeaderBase64 = null;
  26078.     private boolean isForwardProxyHeaderBase64(){

  26080.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.header.base64";
  26081.         if(this.isForwardProxyHeaderBase64==null){
  26082.             try{  
  26083.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26085.                 if (value != null){
  26086.                     value = value.trim();
  26087.                     this.isForwardProxyHeaderBase64 = Boolean.parseBoolean(value);
  26088.                 }else{
  26089.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64));
  26090.                     this.isForwardProxyHeaderBase64 = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64;
  26091.                 }

  26093.             }catch(java.lang.Exception e) {
  26094.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64),e);
  26095.                 this.isForwardProxyHeaderBase64 = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64;
  26096.             }
  26097.         }

  26099.         return this.isForwardProxyHeaderBase64;
  26100.     }
  26101.     
  26102.     
  26103.     private Boolean isForwardProxyQueryParameterEnable = null;
  26104.     private boolean isForwardProxyQueryParameterEnable(){

  26106.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.urlParameter.enable";
  26107.         if(this.isForwardProxyQueryParameterEnable==null){
  26108.             try{  
  26109.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26111.                 if (value != null){
  26112.                     value = value.trim();
  26113.                     this.isForwardProxyQueryParameterEnable = Boolean.parseBoolean(value);
  26114.                 }else{
  26115.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  26116.                     this.isForwardProxyQueryParameterEnable = false;
  26117.                 }

  26119.             }catch(java.lang.Exception e) {
  26120.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  26121.                 this.isForwardProxyQueryParameterEnable = false;
  26122.             }
  26123.         }

  26125.         return this.isForwardProxyQueryParameterEnable;
  26126.     }
  26127.     
  26128.     private String getForwardProxyQueryParameterName = null;
  26129.     private String getForwardProxyQueryParameterName(){

  26131.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.urlParameter.nome";
  26132.         if(this.getForwardProxyQueryParameterName==null){
  26133.             try{  
  26134.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26136.                 if (value != null){
  26137.                     value = value.trim();
  26138.                     this.getForwardProxyQueryParameterName = value;
  26139.                 }else{
  26140.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER));
  26141.                     this.getForwardProxyQueryParameterName = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER;
  26142.                 }

  26144.             }catch(java.lang.Exception e) {
  26145.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER),e);
  26146.                 this.getForwardProxyQueryParameterName = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER;
  26147.             }
  26148.         }

  26150.         return this.getForwardProxyQueryParameterName;
  26151.     }
  26152.     
  26153.     private Boolean isForwardProxyQueryParameterBase64 = null;
  26154.     private boolean isForwardProxyQueryParameterBase64(){

  26156.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.urlParameter.base64";
  26157.         if(this.isForwardProxyQueryParameterBase64==null){
  26158.             try{  
  26159.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26161.                 if (value != null){
  26162.                     value = value.trim();
  26163.                     this.isForwardProxyQueryParameterBase64 = Boolean.parseBoolean(value);
  26164.                 }else{
  26165.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64));
  26166.                     this.isForwardProxyQueryParameterBase64 = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64;
  26167.                 }

  26169.             }catch(java.lang.Exception e) {
  26170.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64),e);
  26171.                 this.isForwardProxyQueryParameterBase64 = ForwardProxy.DEFAULT_GOVWAY_PROXY_HEADER_BASE64;
  26172.             }
  26173.         }

  26175.         return this.isForwardProxyQueryParameterBase64;
  26176.     }
  26177.     
  26178.     private Boolean isForwardProxyTokenDynamicDiscoveryEnabled = null;
  26179.     private boolean isForwardProxyTokenDynamicDiscoveryEnabled(){

  26181.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenDynamicDiscovery.enable";
  26182.         if(this.isForwardProxyTokenDynamicDiscoveryEnabled==null){
  26183.             try{  
  26184.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26186.                 if (value != null){
  26187.                     value = value.trim();
  26188.                     this.isForwardProxyTokenDynamicDiscoveryEnabled = Boolean.parseBoolean(value);
  26189.                 }else{
  26190.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_DYNAMIC_DISCOVERY));
  26191.                     this.isForwardProxyTokenDynamicDiscoveryEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_DYNAMIC_DISCOVERY;
  26192.                 }

  26194.             }catch(java.lang.Exception e) {
  26195.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_DYNAMIC_DISCOVERY),e);
  26196.                 this.isForwardProxyTokenDynamicDiscoveryEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_DYNAMIC_DISCOVERY;
  26197.             }
  26198.         }

  26200.         return this.isForwardProxyTokenDynamicDiscoveryEnabled;
  26201.     }
  26202.     
  26203.     private Boolean isForwardProxyTokenValidazioneJwtEnabled = null;
  26204.     private boolean isForwardProxyTokenValidazioneJwtEnabled(){

  26206.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenJwtValidation.enable";
  26207.         if(this.isForwardProxyTokenValidazioneJwtEnabled==null){
  26208.             try{  
  26209.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26211.                 if (value != null){
  26212.                     value = value.trim();
  26213.                     this.isForwardProxyTokenValidazioneJwtEnabled = Boolean.parseBoolean(value);
  26214.                 }else{
  26215.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_VALIDAZIONE_JWT));
  26216.                     this.isForwardProxyTokenValidazioneJwtEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_VALIDAZIONE_JWT;
  26217.                 }

  26219.             }catch(java.lang.Exception e) {
  26220.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_VALIDAZIONE_JWT),e);
  26221.                 this.isForwardProxyTokenValidazioneJwtEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_VALIDAZIONE_JWT;
  26222.             }
  26223.         }

  26225.         return this.isForwardProxyTokenValidazioneJwtEnabled;
  26226.     }
  26227.     
  26228.     private Boolean isForwardProxyTokenIntrospectionEnabled = null;
  26229.     private boolean isForwardProxyTokenIntrospectionEnabled(){

  26231.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenIntrospection.enable";
  26232.         if(this.isForwardProxyTokenIntrospectionEnabled==null){
  26233.             try{  
  26234.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26236.                 if (value != null){
  26237.                     value = value.trim();
  26238.                     this.isForwardProxyTokenIntrospectionEnabled = Boolean.parseBoolean(value);
  26239.                 }else{
  26240.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_INTROSPECTION));
  26241.                     this.isForwardProxyTokenIntrospectionEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_INTROSPECTION;
  26242.                 }

  26244.             }catch(java.lang.Exception e) {
  26245.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_INTROSPECTION),e);
  26246.                 this.isForwardProxyTokenIntrospectionEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_INTROSPECTION;
  26247.             }
  26248.         }

  26250.         return this.isForwardProxyTokenIntrospectionEnabled;
  26251.     }
  26252.     
  26253.     private Boolean isForwardProxyTokenUserInfoEnabled = null;
  26254.     private boolean isForwardProxyTokenUserInfoEnabled(){

  26256.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenUserInfo.enable";
  26257.         if(this.isForwardProxyTokenUserInfoEnabled==null){
  26258.             try{  
  26259.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26261.                 if (value != null){
  26262.                     value = value.trim();
  26263.                     this.isForwardProxyTokenUserInfoEnabled = Boolean.parseBoolean(value);
  26264.                 }else{
  26265.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_USERINFO));
  26266.                     this.isForwardProxyTokenUserInfoEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_USERINFO;
  26267.                 }

  26269.             }catch(java.lang.Exception e) {
  26270.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_USERINFO),e);
  26271.                 this.isForwardProxyTokenUserInfoEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_USERINFO;
  26272.             }
  26273.         }

  26275.         return this.isForwardProxyTokenUserInfoEnabled;
  26276.     }
  26277.     
  26278.     private Boolean isForwardProxyTokenRetrieveEnabled = null;
  26279.     private boolean isForwardProxyTokenRetrieveEnabled(){

  26281.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.tokenRetrieve.enable";
  26282.         if(this.isForwardProxyTokenRetrieveEnabled==null){
  26283.             try{  
  26284.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26286.                 if (value != null){
  26287.                     value = value.trim();
  26288.                     this.isForwardProxyTokenRetrieveEnabled = Boolean.parseBoolean(value);
  26289.                 }else{
  26290.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_RETRIEVE));
  26291.                     this.isForwardProxyTokenRetrieveEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_RETRIEVE;
  26292.                 }

  26294.             }catch(java.lang.Exception e) {
  26295.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_RETRIEVE),e);
  26296.                 this.isForwardProxyTokenRetrieveEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_TOKEN_RETRIEVE;
  26297.             }
  26298.         }

  26300.         return this.isForwardProxyTokenRetrieveEnabled;
  26301.     }
  26302.     
  26303.     private Boolean isForwardProxyAttributeAuthorityEnabled = null;
  26304.     private boolean isForwardProxyAttributeAuthorityEnabled(){

  26306.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.attributeAuthority.enable";
  26307.         if(this.isForwardProxyAttributeAuthorityEnabled==null){
  26308.             try{  
  26309.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26311.                 if (value != null){
  26312.                     value = value.trim();
  26313.                     this.isForwardProxyAttributeAuthorityEnabled = Boolean.parseBoolean(value);
  26314.                 }else{
  26315.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY));
  26316.                     this.isForwardProxyAttributeAuthorityEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY;
  26317.                 }

  26319.             }catch(java.lang.Exception e) {
  26320.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY),e);
  26321.                 this.isForwardProxyAttributeAuthorityEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY;
  26322.             }
  26323.         }

  26325.         return this.isForwardProxyAttributeAuthorityEnabled;
  26326.     }
  26327.     
  26328.     private Boolean isForwardProxyAttributeAuthorityResponseJwtValidationEnabled = null;
  26329.     private boolean isForwardProxyAttributeAuthorityResponseJwtValidationEnabled(){

  26331.         String pName = "org.openspcoop2.pdd.connettori.govwayProxy.attributeAuthority.responseJwtValidation.enable";
  26332.         if(this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled==null){
  26333.             try{  
  26334.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26336.                 if (value != null){
  26337.                     value = value.trim();
  26338.                     this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled = Boolean.parseBoolean(value);
  26339.                 }else{
  26340.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY_RESPONSE_JWT_VALIDATION));
  26341.                     this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY_RESPONSE_JWT_VALIDATION;
  26342.                 }

  26344.             }catch(java.lang.Exception e) {
  26345.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY_RESPONSE_JWT_VALIDATION),e);
  26346.                 this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled = ForwardProxy.DEFAULT_GOVWAY_PROXY_ATTRIBUTE_AUTHORITY_RESPONSE_JWT_VALIDATION;
  26347.             }
  26348.         }

  26350.         return this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled;
  26351.     }
  26352.     
  26353.     public ForwardProxyConfigurazione getForwardProxyConfigurazioneDefault() {
  26354.         ForwardProxyConfigurazione config = new ForwardProxyConfigurazione();
  26355.         if(this.isForwardProxyHeaderEnable()) {
  26356.             config.setHeader(this.getForwardProxyHeaderName());
  26357.             config.setHeaderBase64(this.isForwardProxyHeaderBase64());
  26358.         }
  26359.         if(this.isForwardProxyQueryParameterEnable()) {
  26360.             config.setQuery(this.getForwardProxyQueryParameterName());
  26361.             config.setQueryBase64(this.isForwardProxyQueryParameterBase64());
  26362.         }
  26363.         return config;
  26364.     }
  26365.     
  26366.     public ForwardProxyConfigurazioneToken getForwardProxyConfigurazioneTokenDefault() {
  26367.         ForwardProxyConfigurazioneToken config = new ForwardProxyConfigurazioneToken();
  26368.         config.setTokenDynamicDiscoveryEnabled(this.isForwardProxyTokenDynamicDiscoveryEnabled());
  26369.         config.setTokenJwtValidationEnabled(this.isForwardProxyTokenValidazioneJwtEnabled());
  26370.         config.setTokenIntrospectionEnabled(this.isForwardProxyTokenIntrospectionEnabled());
  26371.         config.setTokenUserInfoEnabled(this.isForwardProxyTokenUserInfoEnabled());
  26372.         config.setTokenRetrieveEnabled(this.isForwardProxyTokenRetrieveEnabled());
  26373.         config.setAttributeAuthorityEnabled(this.isForwardProxyAttributeAuthorityEnabled());
  26374.         config.setAttributeAuthorityResponseJwtValidationEnabled(this.isForwardProxyAttributeAuthorityResponseJwtValidationEnabled());
  26375.         return config;
  26376.     }

  26378.     
  26379.     
  26380.     
  26381.     
  26382.     
  26383.     
  26384.     /* ------------- Trasformazioni ---------------------*/
  26385.     
  26386.     private Boolean isTrasformazioni_readCharsetFromContentType = null;
  26387.     public boolean isTrasformazioni_readCharsetFromContentType(){

  26389.         String pName = "org.openspcoop2.pdd.trasformazioni.readCharsetFromContentType.enable";
  26390.         if(this.isTrasformazioni_readCharsetFromContentType==null){
  26391.             try{  
  26392.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  26394.                 if (value != null){
  26395.                     value = value.trim();
  26396.                     this.isTrasformazioni_readCharsetFromContentType = Boolean.parseBoolean(value);
  26397.                 }else{
  26398.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  26399.                     this.isTrasformazioni_readCharsetFromContentType = false;
  26400.                 }

  26402.             }catch(java.lang.Exception e) {
  26403.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  26404.                 this.isTrasformazioni_readCharsetFromContentType = false;
  26405.             }
  26406.         }

  26408.         return this.isTrasformazioni_readCharsetFromContentType;
  26409.     }
  26410.     
  26411.     private Map<String, String> getTrasformazioni_backwardCompatibility = null;
  26412.     private Boolean getTrasformazioni_backwardCompatibility_read = null;
  26413.     public Map<String, String> getTrasformazioni_backwardCompatibility(){

  26415.         String pName = "org.openspcoop2.pdd.trasformazioni.backwardCompatibility.";
  26416.         if(this.getTrasformazioni_backwardCompatibility_read==null){
  26417.             try{  
  26418.                 Properties p = this.reader.readPropertiesConvertEnvProperties(pName);

  26420.                 if (p != null && !p.isEmpty()){
  26421.                     Enumeration<?> keys = p.keys();
  26422.                     if(keys!=null) {
  26423.                         while (keys.hasMoreElements()) {
  26424.                             Object object = (Object) keys.nextElement();
  26425.                             if(object!=null && object instanceof String) {
  26426.                                 String key = (String) object;
  26427.                                 String value = p.getProperty(key);
  26428.                                 if(value!=null) {
  26429.                                     key = key.trim();
  26430.                                     value = value.trim();
  26431.                                     if(StringUtils.isNotEmpty(key) && StringUtils.isNotEmpty(value)) {
  26432.                                         if(this.getTrasformazioni_backwardCompatibility==null) {
  26433.                                             this.getTrasformazioni_backwardCompatibility=new HashMap<>();
  26434.                                         }
  26435.                                         this.getTrasformazioni_backwardCompatibility.put(key, value); // old, new
  26436.                                     }
  26437.                                 }
  26438.                             }
  26439.                         }
  26440.                     }
  26441.                 }

  26443.             }catch(java.lang.Exception e) {
  26444.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  26445.                 this.isTrasformazioni_readCharsetFromContentType = false;
  26446.             }
  26447.             
  26448.             this.getTrasformazioni_backwardCompatibility_read = true;
  26449.         }

  26451.         return this.getTrasformazioni_backwardCompatibility;
  26452.     }
  26453.     
  26454.     
  26455.     
  26456.     
  26457.     
  26458.     
  26459.     /* ------------- SOAP (Trasporto - URLParameters) ---------------------*/
  26460.     
  26461.     private Boolean isSOAPServicesUrlParametersForward = null;
  26462.     private boolean isSOAPServicesUrlParametersForward(){

  26464.         if(this.isSOAPServicesUrlParametersForward==null){
  26465.             try{  
  26466.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.urlParameters.forward.enable"); 

  26468.                 if (value != null){
  26469.                     value = value.trim();
  26470.                     this.isSOAPServicesUrlParametersForward = Boolean.parseBoolean(value);
  26471.                 }else{
  26472.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.forward.enable' non impostata, viene utilizzato il default=true");
  26473.                     this.isSOAPServicesUrlParametersForward = true;
  26474.                 }

  26476.             }catch(java.lang.Exception e) {
  26477.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.forward.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  26478.                 this.isSOAPServicesUrlParametersForward = true;
  26479.             }
  26480.         }

  26482.         return this.isSOAPServicesUrlParametersForward;
  26483.     }
  26484.     
  26485.     private Boolean getSOAPServicesBlackListInternalUrlParametersRead = null;
  26486.     private List<MapKey<String>> getSOAPServicesBlackListInternalUrlParametersList = null;
  26487.     private List<MapKey<String>> getSOAPServicesBlackListInternalUrlParameters() {  
  26488.         if(this.getSOAPServicesBlackListInternalUrlParametersRead==null){
  26489.             try{ 
  26490.                 this.getSOAPServicesBlackListInternalUrlParametersList = new ArrayList<>();
  26491.                 String name = null;
  26492.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.urlParameters.blackList.internal");
  26493.                 if(name!=null){
  26494.                     name = name.trim();
  26495.                     String [] split = name.split(",");
  26496.                     if(split!=null){
  26497.                         for (int i = 0; i < split.length; i++) {
  26498.                             this.getSOAPServicesBlackListInternalUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26499.                         }
  26500.                     }
  26501.                 }
  26502.                 this.getSOAPServicesBlackListInternalUrlParametersRead = true;
  26503.             } catch(java.lang.Exception e) {
  26504.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.blackList.internal': "+e.getMessage(),e);
  26505.             }    
  26506.         }
  26507.         
  26508.         return this.getSOAPServicesBlackListInternalUrlParametersList;
  26509.     }
  26510.     
  26511.     private Boolean getSOAPServicesBlackListUrlParametersRead = null;
  26512.     private List<MapKey<String>> getSOAPServicesBlackListUrlParametersList = null;
  26513.     private List<MapKey<String>> getSOAPServicesBlackListUrlParameters() {  
  26514.         if(this.getSOAPServicesBlackListUrlParametersRead==null){
  26515.             try{ 
  26516.                 this.getSOAPServicesBlackListUrlParametersList = new ArrayList<>();
  26517.                 String name = null;
  26518.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.urlParameters.blackList");
  26519.                 if(name!=null){
  26520.                     name = name.trim();
  26521.                     String [] split = name.split(",");
  26522.                     if(split!=null){
  26523.                         for (int i = 0; i < split.length; i++) {
  26524.                             this.getSOAPServicesBlackListUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26525.                         }
  26526.                     }
  26527.                 }
  26528.                 this.getSOAPServicesBlackListUrlParametersRead = true;
  26529.             } catch(java.lang.Exception e) {
  26530.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.blackList': "+e.getMessage(),e);
  26531.             }    
  26532.         }
  26533.         
  26534.         return this.getSOAPServicesBlackListUrlParametersList;
  26535.     }
  26536.     
  26537.     private Boolean getSOAPServicesWhiteListUrlParametersRead = null;
  26538.     private List<MapKey<String>> getSOAPServicesWhiteListUrlParametersList = null;
  26539.     private List<MapKey<String>> getSOAPServicesWhiteListUrlParameters() {  
  26540.         if(this.getSOAPServicesWhiteListUrlParametersRead==null){
  26541.             try{ 
  26542.                 this.getSOAPServicesWhiteListUrlParametersList = new ArrayList<>();
  26543.                 String name = null;
  26544.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.urlParameters.whiteList");
  26545.                 if(name!=null){
  26546.                     name = name.trim();
  26547.                     String [] split = name.split(",");
  26548.                     if(split!=null){
  26549.                         for (int i = 0; i < split.length; i++) {
  26550.                             this.getSOAPServicesWhiteListUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26551.                         }
  26552.                     }
  26553.                 }
  26554.                 this.getSOAPServicesWhiteListUrlParametersRead = true;
  26555.             } catch(java.lang.Exception e) {
  26556.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.urlParameters.whiteList': "+e.getMessage(),e);
  26557.             }    
  26558.         }
  26559.         
  26560.         return this.getSOAPServicesWhiteListUrlParametersList;
  26561.     }
  26562.     
  26563.     private List<String> _getSOAPServicesBlackListUrlParameters() { 
  26564.         
  26565.         List<MapKey<String>> blackList = new ArrayList<>();
  26566.         List<MapKey<String>> tmp = this.getSOAPServicesBlackListInternalUrlParameters();
  26567.         this._list_add(tmp, blackList);
  26568.         tmp = this.getSOAPServicesBlackListUrlParameters();
  26569.         this._list_add(tmp, blackList);
  26570.         
  26571.         List<String> l = new ArrayList<>();
  26572.         if(!blackList.isEmpty()) {
  26573.             for (MapKey<String> key : blackList) {
  26574.                 l.add(key.getValue());
  26575.             }
  26576.         }
  26577.         return l;
  26578.     }
  26579.     private List<String> _getSOAPServicesWhiteListUrlParameters() { 
  26580.         
  26581.         List<MapKey<String>> whiteList = new ArrayList<>();
  26582.         List<MapKey<String>> tmp = this.getSOAPServicesWhiteListUrlParameters();
  26583.         this._list_add(tmp, whiteList);
  26584.         
  26585.         List<String> l = new ArrayList<>();
  26586.         if(!whiteList.isEmpty()) {
  26587.             for (MapKey<String> key : whiteList) {
  26588.                 l.add(key.getValue());
  26589.             }
  26590.         }
  26591.         return l;
  26592.     }
  26593.     public ForwardConfig getSOAPServicesUrlParametersForwardConfig() {
  26594.         ForwardConfig f = new ForwardConfig();
  26595.         f.setForwardEnable(this.isSOAPServicesUrlParametersForward());
  26596.         f.setBlackList(_getSOAPServicesBlackListUrlParameters());
  26597.         f.setWhiteList(_getSOAPServicesWhiteListUrlParameters());
  26598.         return f;
  26599.     }
  26600.     
  26601.     
  26602.     
  26603.     
  26604.     /* ------------- SOAP (Trasporto - Headers) ---------------------*/
  26605.     
  26606.     private Boolean isSOAPServicesHeadersForward = null;
  26607.     private boolean isSOAPServicesHeadersForward(){

  26609.         if(this.isSOAPServicesHeadersForward==null){
  26610.             try{  
  26611.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.forward.enable"); 

  26613.                 if (value != null){
  26614.                     value = value.trim();
  26615.                     this.isSOAPServicesHeadersForward = Boolean.parseBoolean(value);
  26616.                 }else{
  26617.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.forward.enable' non impostata, viene utilizzato il default=true");
  26618.                     this.isSOAPServicesHeadersForward = true;
  26619.                 }

  26621.             }catch(java.lang.Exception e) {
  26622.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.forward.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  26623.                 this.isSOAPServicesHeadersForward = true;
  26624.             }
  26625.         }

  26627.         return this.isSOAPServicesHeadersForward;
  26628.     }
  26629.     
  26630.     private Boolean getSOAPServicesBlackListBothInternalHeadersRead = null;
  26631.     private List<MapKey<String>> getSOAPServicesBlackListBothInternalHeadersList = null;
  26632.     private List<MapKey<String>> getSOAPServicesBlackListBothInternalHeaders() {    
  26633.         if(this.getSOAPServicesBlackListBothInternalHeadersRead==null){
  26634.             try{ 
  26635.                 this.getSOAPServicesBlackListBothInternalHeadersList = new ArrayList<>();
  26636.                 String name = null;
  26637.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.internal.both");
  26638.                 if(name!=null){
  26639.                     name = name.trim();
  26640.                     String [] split = name.split(",");
  26641.                     if(split!=null){
  26642.                         for (int i = 0; i < split.length; i++) {
  26643.                             this.getSOAPServicesBlackListBothInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26644.                         }
  26645.                     }
  26646.                 }
  26647.                 this.getSOAPServicesBlackListBothInternalHeadersRead = true;
  26648.             } catch(java.lang.Exception e) {
  26649.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.internal.both': "+e.getMessage(),e);
  26650.             }    
  26651.         }
  26652.         
  26653.         return this.getSOAPServicesBlackListBothInternalHeadersList;
  26654.     }
  26655.     
  26656.     private Boolean getSOAPServicesBlackListRequestInternalHeadersRead = null;
  26657.     private List<MapKey<String>> getSOAPServicesBlackListRequestInternalHeadersList = null;
  26658.     private List<MapKey<String>> getSOAPServicesBlackListRequestInternalHeaders() { 
  26659.         if(this.getSOAPServicesBlackListRequestInternalHeadersRead==null){
  26660.             try{ 
  26661.                 this.getSOAPServicesBlackListRequestInternalHeadersList = new ArrayList<>();
  26662.                 String name = null;
  26663.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.internal.request");
  26664.                 if(name!=null){
  26665.                     name = name.trim();
  26666.                     String [] split = name.split(",");
  26667.                     if(split!=null){
  26668.                         for (int i = 0; i < split.length; i++) {
  26669.                             this.getSOAPServicesBlackListRequestInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26670.                         }
  26671.                     }
  26672.                 }
  26673.                 this.getSOAPServicesBlackListRequestInternalHeadersRead = true;
  26674.             } catch(java.lang.Exception e) {
  26675.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.internal.request': "+e.getMessage(),e);
  26676.             }    
  26677.         }
  26678.         
  26679.         return this.getSOAPServicesBlackListRequestInternalHeadersList;
  26680.     }
  26681.     
  26682.     private Boolean getSOAPServicesBlackListResponseInternalHeadersRead = null;
  26683.     private List<MapKey<String>> getSOAPServicesBlackListResponseInternalHeadersList = null;
  26684.     private List<MapKey<String>> getSOAPServicesBlackListResponseInternalHeaders() {    
  26685.         if(this.getSOAPServicesBlackListResponseInternalHeadersRead==null){
  26686.             try{ 
  26687.                 this.getSOAPServicesBlackListResponseInternalHeadersList = new ArrayList<>();
  26688.                 String name = null;
  26689.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.internal.response");
  26690.                 if(name!=null){
  26691.                     name = name.trim();
  26692.                     String [] split = name.split(",");
  26693.                     if(split!=null){
  26694.                         for (int i = 0; i < split.length; i++) {
  26695.                             this.getSOAPServicesBlackListResponseInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26696.                         }
  26697.                     }
  26698.                 }
  26699.                 this.getSOAPServicesBlackListResponseInternalHeadersRead = true;
  26700.             } catch(java.lang.Exception e) {
  26701.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.internal.response': "+e.getMessage(),e);
  26702.             }    
  26703.         }
  26704.         
  26705.         return this.getSOAPServicesBlackListResponseInternalHeadersList;
  26706.     }
  26707.     
  26708.     private Boolean getSOAPServicesBlackListBothHeadersRead = null;
  26709.     private List<MapKey<String>> getSOAPServicesBlackListBothHeadersList = null;
  26710.     private List<MapKey<String>> getSOAPServicesBlackListBothHeaders() {    
  26711.         if(this.getSOAPServicesBlackListBothHeadersRead==null){
  26712.             try{ 
  26713.                 this.getSOAPServicesBlackListBothHeadersList = new ArrayList<>();
  26714.                 String name = null;
  26715.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.both");
  26716.                 if(name!=null){
  26717.                     name = name.trim();
  26718.                     String [] split = name.split(",");
  26719.                     if(split!=null){
  26720.                         for (int i = 0; i < split.length; i++) {
  26721.                             this.getSOAPServicesBlackListBothHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26722.                         }
  26723.                     }
  26724.                 }
  26725.                 this.getSOAPServicesBlackListBothHeadersRead = true;
  26726.             } catch(java.lang.Exception e) {
  26727.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.both': "+e.getMessage(),e);
  26728.             }    
  26729.         }
  26730.         
  26731.         return this.getSOAPServicesBlackListBothHeadersList;
  26732.     }
  26733.     
  26734.     private Boolean getSOAPServicesBlackListRequestHeadersRead = null;
  26735.     private List<MapKey<String>> getSOAPServicesBlackListRequestHeadersList = null;
  26736.     private List<MapKey<String>> getSOAPServicesBlackListRequestHeaders() { 
  26737.         if(this.getSOAPServicesBlackListRequestHeadersRead==null){
  26738.             try{ 
  26739.                 this.getSOAPServicesBlackListRequestHeadersList = new ArrayList<>();
  26740.                 String name = null;
  26741.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.request");
  26742.                 if(name!=null){
  26743.                     name = name.trim();
  26744.                     String [] split = name.split(",");
  26745.                     if(split!=null){
  26746.                         for (int i = 0; i < split.length; i++) {
  26747.                             this.getSOAPServicesBlackListRequestHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26748.                         }
  26749.                     }
  26750.                 }
  26751.                 this.getSOAPServicesBlackListRequestHeadersRead = true;
  26752.             } catch(java.lang.Exception e) {
  26753.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.request': "+e.getMessage(),e);
  26754.             }    
  26755.         }
  26756.         
  26757.         return this.getSOAPServicesBlackListRequestHeadersList;
  26758.     }
  26759.     
  26760.     private Boolean getSOAPServicesBlackListResponseHeadersRead = null;
  26761.     private List<MapKey<String>> getSOAPServicesBlackListResponseHeadersList = null;
  26762.     private List<MapKey<String>> getSOAPServicesBlackListResponseHeaders() {    
  26763.         if(this.getSOAPServicesBlackListResponseHeadersRead==null){
  26764.             try{ 
  26765.                 this.getSOAPServicesBlackListResponseHeadersList = new ArrayList<>();
  26766.                 String name = null;
  26767.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.blackList.response");
  26768.                 if(name!=null){
  26769.                     name = name.trim();
  26770.                     String [] split = name.split(",");
  26771.                     if(split!=null){
  26772.                         for (int i = 0; i < split.length; i++) {
  26773.                             this.getSOAPServicesBlackListResponseHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26774.                         }
  26775.                     }
  26776.                 }
  26777.                 this.getSOAPServicesBlackListResponseHeadersRead = true;
  26778.             } catch(java.lang.Exception e) {
  26779.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.blackList.response': "+e.getMessage(),e);
  26780.             }    
  26781.         }
  26782.         
  26783.         return this.getSOAPServicesBlackListResponseHeadersList;
  26784.     }
  26785.     
  26786.     private Boolean getSOAPServicesWhiteListBothHeadersRead = null;
  26787.     private List<MapKey<String>> getSOAPServicesWhiteListBothHeadersList = null;
  26788.     private List<MapKey<String>> getSOAPServicesWhiteListBothHeaders() {    
  26789.         if(this.getSOAPServicesWhiteListBothHeadersRead==null){
  26790.             try{ 
  26791.                 this.getSOAPServicesWhiteListBothHeadersList = new ArrayList<>();
  26792.                 String name = null;
  26793.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.whiteList.both");
  26794.                 if(name!=null){
  26795.                     name = name.trim();
  26796.                     String [] split = name.split(",");
  26797.                     if(split!=null){
  26798.                         for (int i = 0; i < split.length; i++) {
  26799.                             this.getSOAPServicesWhiteListBothHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26800.                         }
  26801.                     }
  26802.                 }
  26803.                 this.getSOAPServicesWhiteListBothHeadersRead = true;
  26804.             } catch(java.lang.Exception e) {
  26805.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.whiteList.both': "+e.getMessage(),e);
  26806.             }    
  26807.         }
  26808.         
  26809.         return this.getSOAPServicesWhiteListBothHeadersList;
  26810.     }
  26811.     
  26812.     private Boolean getSOAPServicesWhiteListRequestHeadersRead = null;
  26813.     private List<MapKey<String>> getSOAPServicesWhiteListRequestHeadersList = null;
  26814.     private List<MapKey<String>> getSOAPServicesWhiteListRequestHeaders() { 
  26815.         if(this.getSOAPServicesWhiteListRequestHeadersRead==null){
  26816.             try{ 
  26817.                 this.getSOAPServicesWhiteListRequestHeadersList = new ArrayList<>();
  26818.                 String name = null;
  26819.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.whiteList.request");
  26820.                 if(name!=null){
  26821.                     name = name.trim();
  26822.                     String [] split = name.split(",");
  26823.                     if(split!=null){
  26824.                         for (int i = 0; i < split.length; i++) {
  26825.                             this.getSOAPServicesWhiteListRequestHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26826.                         }
  26827.                     }
  26828.                 }
  26829.                 this.getSOAPServicesWhiteListRequestHeadersRead = true;
  26830.             } catch(java.lang.Exception e) {
  26831.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.whiteList.request': "+e.getMessage(),e);
  26832.             }    
  26833.         }
  26834.         
  26835.         return this.getSOAPServicesWhiteListRequestHeadersList;
  26836.     }
  26837.     
  26838.     private Boolean getSOAPServicesWhiteListResponseHeadersRead = null;
  26839.     private List<MapKey<String>> getSOAPServicesWhiteListResponseHeadersList = null;
  26840.     private List<MapKey<String>> getSOAPServicesWhiteListResponseHeaders() {    
  26841.         if(this.getSOAPServicesWhiteListResponseHeadersRead==null){
  26842.             try{ 
  26843.                 this.getSOAPServicesWhiteListResponseHeadersList = new ArrayList<>();
  26844.                 String name = null;
  26845.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.headers.whiteList.response");
  26846.                 if(name!=null){
  26847.                     name = name.trim();
  26848.                     String [] split = name.split(",");
  26849.                     if(split!=null){
  26850.                         for (int i = 0; i < split.length; i++) {
  26851.                             this.getSOAPServicesWhiteListResponseHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  26852.                         }
  26853.                     }
  26854.                 }
  26855.                 this.getSOAPServicesWhiteListResponseHeadersRead = true;
  26856.             } catch(java.lang.Exception e) {
  26857.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.headers.whiteList.response': "+e.getMessage(),e);
  26858.             }    
  26859.         }
  26860.         
  26861.         return this.getSOAPServicesWhiteListResponseHeadersList;
  26862.     }
  26863.     
  26864.     private List<String> getSOAPServicesBlackListHeaders(boolean request) { 
  26865.         
  26866.         List<MapKey<String>> blackList = new ArrayList<>();
  26867.         List<MapKey<String>> tmp = this.getSOAPServicesBlackListBothInternalHeaders();
  26868.         this._list_add(tmp, blackList);
  26869.         tmp = this.getSOAPServicesBlackListBothHeaders();
  26870.         this._list_add(tmp, blackList);
  26871.         
  26872.         if(request) {
  26873.             tmp = this.getSOAPServicesBlackListRequestInternalHeaders();
  26874.             this._list_add(tmp, blackList);
  26875.             tmp = this.getSOAPServicesBlackListRequestHeaders();
  26876.             this._list_add(tmp, blackList);
  26877.         }
  26878.         else {
  26879.             tmp = this.getSOAPServicesBlackListResponseInternalHeaders();
  26880.             this._list_add(tmp, blackList);
  26881.             tmp = this.getSOAPServicesBlackListResponseHeaders();
  26882.             this._list_add(tmp, blackList);
  26883.         }
  26884.         
  26885.         List<String> l = new ArrayList<>();
  26886.         if(!blackList.isEmpty()) {
  26887.             for (MapKey<String> key : blackList) {
  26888.                 l.add(key.getValue());
  26889.             }
  26890.         }
  26891.         return l;
  26892.     }
  26893.     private List<String> getSOAPServicesWhiteListHeaders(boolean request) { 
  26894.         
  26895.         List<MapKey<String>> whiteList = new ArrayList<>();
  26896.         List<MapKey<String>> tmp = this.getSOAPServicesWhiteListBothHeaders();
  26897.         this._list_add(tmp, whiteList);
  26898.         if(request) {
  26899.             tmp = this.getSOAPServicesWhiteListRequestHeaders();
  26900.             this._list_add(tmp, whiteList);
  26901.         }
  26902.         else {
  26903.             tmp = this.getSOAPServicesWhiteListResponseHeaders();
  26904.             this._list_add(tmp, whiteList);
  26905.         }
  26906.         
  26907.         List<String> l = new ArrayList<>();
  26908.         if(!whiteList.isEmpty()) {
  26909.             for (MapKey<String> key : whiteList) {
  26910.                 l.add(key.getValue());
  26911.             }
  26912.         }
  26913.         return l;
  26914.     }
  26915.     public ForwardConfig getSOAPServicesHeadersForwardConfig(boolean request) {
  26916.         ForwardConfig f = new ForwardConfig();
  26917.         f.setForwardEnable(this.isSOAPServicesHeadersForward());
  26918.         f.setBlackList(getSOAPServicesBlackListHeaders(request));
  26919.         f.setWhiteList(getSOAPServicesWhiteListHeaders(request));
  26920.         return f;
  26921.     }

  26923.     
  26924.     /* ------------- SOAP (Trasporto - Headers - Proxy Pass Reverse) ---------------------*/
  26925.     
  26926.     // Location
  26927.     
  26928.     private Boolean isSOAPServices_inoltroBuste_proxyPassReverse = null;
  26929.     public boolean isSOAPServices_inoltroBuste_proxyPassReverse() { 
  26930.         if(this.isSOAPServices_inoltroBuste_proxyPassReverse==null){
  26931.             try{ 
  26932.                 String name = null;
  26933.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse");
  26934.                 if(name==null){
  26935.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse' non impostata, viene utilizzato il default=false");
  26936.                     name="false";
  26937.                 }
  26938.                 name = name.trim();
  26939.                 this.isSOAPServices_inoltroBuste_proxyPassReverse = Boolean.parseBoolean(name);
  26940.             } catch(java.lang.Exception e) {
  26941.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse': "+e.getMessage(),e);
  26942.                 this.isSOAPServices_inoltroBuste_proxyPassReverse = false;
  26943.             }    
  26944.         }

  26946.         return this.isSOAPServices_inoltroBuste_proxyPassReverse;
  26947.     }
  26948.     
  26949.     private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse = null;
  26950.     public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse() { 
  26951.         if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse==null){
  26952.             try{ 
  26953.                 String name = null;
  26954.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse");
  26955.                 if(name==null){
  26956.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse' non impostata, viene utilizzato il default=false");
  26957.                     name="false";
  26958.                 }
  26959.                 name = name.trim();
  26960.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse = Boolean.parseBoolean(name);
  26961.             } catch(java.lang.Exception e) {
  26962.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse': "+e.getMessage(),e);
  26963.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse = false;
  26964.             }    
  26965.         }

  26967.         return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse;
  26968.     }
  26969.     
  26970.     private List<String> getSOAPServices_inoltroBuste_proxyPassReverse_headers = null;
  26971.     public List<String> getSOAPServices_inoltroBuste_proxyPassReverse_headers() throws CoreException {  
  26972.         if(this.getSOAPServices_inoltroBuste_proxyPassReverse_headers==null){
  26973.             try{ 
  26974.                 this.getSOAPServices_inoltroBuste_proxyPassReverse_headers = new ArrayList<>();
  26975.                 
  26976.                 String name = null;
  26977.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.headers");
  26978.                 if(name!=null){
  26979.                     name = name.trim();
  26980.                 }
  26981.                 if(name!=null && !"".equals(name)) {
  26982.                     if(name.contains(",")) {
  26983.                         String [] tmp = name.split(",");
  26984.                         for (int i = 0; i < tmp.length; i++) {
  26985.                             this.getSOAPServices_inoltroBuste_proxyPassReverse_headers.add(tmp[i].trim());
  26986.                         }
  26987.                     }
  26988.                     else {
  26989.                         this.getSOAPServices_inoltroBuste_proxyPassReverse_headers.add(name);
  26990.                     }
  26991.                 }
  26992.             } catch(java.lang.Exception e) {
  26993.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.headers': "+e.getMessage();
  26994.                 this.logError(error,e);
  26995.                 throw new CoreException(error);
  26996.             }    
  26997.         }

  26999.         return this.getSOAPServices_inoltroBuste_proxyPassReverse_headers;
  27000.     }
  27001.     
  27002.     private List<String> getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers = null;
  27003.     public List<String> getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers() throws CoreException {  
  27004.         if(this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers==null){
  27005.             try{ 
  27006.                 this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers = new ArrayList<>();
  27007.                 
  27008.                 String name = null;
  27009.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.headers");
  27010.                 if(name!=null){
  27011.                     name = name.trim();
  27012.                 }
  27013.                 if(name!=null && !"".equals(name)) {
  27014.                     if(name.contains(",")) {
  27015.                         String [] tmp = name.split(",");
  27016.                         for (int i = 0; i < tmp.length; i++) {
  27017.                             this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers.add(tmp[i].trim());
  27018.                         }
  27019.                     }
  27020.                     else {
  27021.                         this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers.add(name);
  27022.                     }
  27023.                 }
  27024.             } catch(java.lang.Exception e) {
  27025.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.headers': "+e.getMessage();
  27026.                 this.logError(error,e);
  27027.                 throw new CoreException(error);
  27028.             }    
  27029.         }

  27031.         return this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_headers;
  27032.     }
  27033.     
  27034.     // Set-Cookie
  27035.     
  27036.     private Boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie = null;
  27037.     public boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie() {   
  27038.         if(this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie==null){
  27039.             String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie";
  27040.             try{ 
  27041.                 String name = null;
  27042.                 name = this.reader.getValueConvertEnvProperties(pName);
  27043.                 if(name==null){
  27044.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  27045.                     name="false";
  27046.                 }
  27047.                 name = name.trim();
  27048.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie = Boolean.parseBoolean(name);
  27049.             } catch(java.lang.Exception e) {
  27050.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27051.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie = false;
  27052.             }    
  27053.         }

  27055.         return this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie;
  27056.     }
  27057.     
  27058.     private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = null;
  27059.     public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie() {   
  27060.         if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie==null){
  27061.             String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie";
  27062.             try{ 
  27063.                 String name = null;
  27064.                 name = this.reader.getValueConvertEnvProperties(pName);
  27065.                 if(name==null){
  27066.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  27067.                     name="false";
  27068.                 }
  27069.                 name = name.trim();
  27070.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = Boolean.parseBoolean(name);
  27071.             } catch(java.lang.Exception e) {
  27072.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27073.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = false;
  27074.             }    
  27075.         }

  27077.         return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie;
  27078.     }
  27079.     
  27080.     private Boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path = null;
  27081.     public boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path() {  
  27082.         if(this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path==null){
  27083.             String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie.path";
  27084.             try{ 
  27085.                 String name = null;
  27086.                 name = this.reader.getValueConvertEnvProperties(pName);
  27087.                 if(name==null){
  27088.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isSOAPServices_inoltroBuste_proxyPassReverse_setCookie()));
  27089.                     name=""+isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
  27090.                 }
  27091.                 name = name.trim();
  27092.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path = Boolean.parseBoolean(name);
  27093.             } catch(java.lang.Exception e) {
  27094.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27095.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path = isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
  27096.             }    
  27097.         }

  27099.         return this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_path;
  27100.     }
  27101.     
  27102.     private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = null;
  27103.     public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path() {  
  27104.         if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path==null){
  27105.             String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.path";
  27106.             try{ 
  27107.                 String name = null;
  27108.                 name = this.reader.getValueConvertEnvProperties(pName);
  27109.                 if(name==null){
  27110.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie()));
  27111.                     name=""+isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  27112.                 }
  27113.                 name = name.trim();
  27114.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = Boolean.parseBoolean(name);
  27115.             } catch(java.lang.Exception e) {
  27116.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27117.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  27118.             }    
  27119.         }

  27121.         return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path;
  27122.     }
  27123.     
  27124.     private Boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain = null;
  27125.     public boolean isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain() {    
  27126.         if(this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain==null){
  27127.             String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie.domain";
  27128.             try{ 
  27129.                 String name = null;
  27130.                 name = this.reader.getValueConvertEnvProperties(pName);
  27131.                 if(name==null){
  27132.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isSOAPServices_inoltroBuste_proxyPassReverse_setCookie()));
  27133.                     name=""+isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
  27134.                 }
  27135.                 name = name.trim();
  27136.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain = Boolean.parseBoolean(name);
  27137.             } catch(java.lang.Exception e) {
  27138.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27139.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain = isSOAPServices_inoltroBuste_proxyPassReverse_setCookie();
  27140.             }    
  27141.         }

  27143.         return this.isSOAPServices_inoltroBuste_proxyPassReverse_setCookie_domain;
  27144.     }
  27145.     
  27146.     private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = null;
  27147.     public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain() {    
  27148.         if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain==null){
  27149.             String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.domain";
  27150.             try{ 
  27151.                 String name = null;
  27152.                 name = this.reader.getValueConvertEnvProperties(pName);
  27153.                 if(name==null){
  27154.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie()));
  27155.                     name=""+isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  27156.                 }
  27157.                 name = name.trim();
  27158.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = Boolean.parseBoolean(name);
  27159.             } catch(java.lang.Exception e) {
  27160.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27161.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  27162.             }    
  27163.         }

  27165.         return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain;
  27166.     }
  27167.     
  27168.     private List<String> getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers = null;
  27169.     public List<String> getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers() throws CoreException {    
  27170.         if(this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers==null){
  27171.             try{ 
  27172.                 this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers = new ArrayList<>();
  27173.                 
  27174.                 String name = null;
  27175.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie.headers");
  27176.                 if(name!=null){
  27177.                     name = name.trim();
  27178.                 }
  27179.                 if(name!=null && !"".equals(name)) {
  27180.                     if(name.contains(",")) {
  27181.                         String [] tmp = name.split(",");
  27182.                         for (int i = 0; i < tmp.length; i++) {
  27183.                             this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers.add(tmp[i].trim());
  27184.                         }
  27185.                     }
  27186.                     else {
  27187.                         this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers.add(name);
  27188.                     }
  27189.                 }
  27190.             } catch(java.lang.Exception e) {
  27191.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.setCookie.headers': "+e.getMessage();
  27192.                 this.logError(error,e);
  27193.                 throw new CoreException(error);
  27194.             }    
  27195.         }

  27197.         return this.getSOAPServices_inoltroBuste_proxyPassReverse_setCookie_headers;
  27198.     }
  27199.     
  27200.     private List<String> getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers = null;
  27201.     public List<String> getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers() throws CoreException {    
  27202.         if(this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers==null){
  27203.             try{ 
  27204.                 this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers = new ArrayList<>();
  27205.                 
  27206.                 String name = null;
  27207.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.headers");
  27208.                 if(name!=null){
  27209.                     name = name.trim();
  27210.                 }
  27211.                 if(name!=null && !"".equals(name)) {
  27212.                     if(name.contains(",")) {
  27213.                         String [] tmp = name.split(",");
  27214.                         for (int i = 0; i < tmp.length; i++) {
  27215.                             this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers.add(tmp[i].trim());
  27216.                         }
  27217.                     }
  27218.                     else {
  27219.                         this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers.add(name);
  27220.                     }
  27221.                 }
  27222.             } catch(java.lang.Exception e) {
  27223.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.headers': "+e.getMessage();
  27224.                 this.logError(error,e);
  27225.                 throw new CoreException(error);
  27226.             }    
  27227.         }

  27229.         return this.getSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers;
  27230.     }
  27231.     
  27232.     // useProtocolPrefix
  27233.     
  27234.     private Boolean isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = null;
  27235.     public boolean isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix() {   
  27236.         if(this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix==null){
  27237.             try{ 
  27238.                 String name = null;
  27239.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix");
  27240.                 if(name==null){
  27241.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix' non impostata, viene utilizzato il default=false");
  27242.                     name="false";
  27243.                 }
  27244.                 name = name.trim();
  27245.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = Boolean.parseBoolean(name);
  27246.             } catch(java.lang.Exception e) {
  27247.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix': "+e.getMessage(),e);
  27248.                 this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = false;
  27249.             }    
  27250.         }

  27252.         return this.isSOAPServices_inoltroBuste_proxyPassReverse_useProtocolPrefix;
  27253.     }
  27254.     
  27255.     private Boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = null;
  27256.     public boolean isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix() {   
  27257.         if(this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix==null){
  27258.             try{ 
  27259.                 String name = null;
  27260.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix");
  27261.                 if(name==null){
  27262.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix' non impostata, viene utilizzato il default=false");
  27263.                     name="false";
  27264.                 }
  27265.                 name = name.trim();
  27266.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = Boolean.parseBoolean(name);
  27267.             } catch(java.lang.Exception e) {
  27268.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix': "+e.getMessage(),e);
  27269.                 this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = false;
  27270.             }    
  27271.         }

  27273.         return this.isSOAPServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix;
  27274.     }
  27275.     
  27276.     private Boolean isSOAPServices_inoltroBuste_response_securityHeaders = null;
  27277.     public boolean isSOAPServices_inoltroBuste_response_securityHeaders() { 
  27278.         if(this.isSOAPServices_inoltroBuste_response_securityHeaders==null){
  27279.             String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.response.securityHeaders";
  27280.             try{ 
  27281.                 String name = null;
  27282.                 name = this.reader.getValueConvertEnvProperties(pName);
  27283.                 if(name==null){
  27284.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  27285.                     name="true";
  27286.                 }
  27287.                 name = name.trim();
  27288.                 this.isSOAPServices_inoltroBuste_response_securityHeaders = Boolean.parseBoolean(name);
  27289.             } catch(java.lang.Exception e) {
  27290.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27291.                 this.isSOAPServices_inoltroBuste_response_securityHeaders = true;
  27292.             }    
  27293.         }

  27295.         return this.isSOAPServices_inoltroBuste_response_securityHeaders;
  27296.     }
  27297.     
  27298.     private Properties getSOAPServices_inoltroBuste_response_securityHeaders = null;
  27299.     public Properties getSOAPServices_inoltroBuste_response_securityHeaders() throws CoreException {    
  27300.         if(this.getSOAPServices_inoltroBuste_response_securityHeaders==null){
  27301.             String pName = "org.openspcoop2.pdd.soap.connettori.inoltroBuste.response.securityHeaders.";
  27302.             try{ 
  27303.                 this.getSOAPServices_inoltroBuste_response_securityHeaders = this.reader.readPropertiesConvertEnvProperties(pName);
  27304.             } catch(java.lang.Exception e) {
  27305.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  27306.                 throw new CoreException(e.getMessage(),e);
  27307.             }    
  27308.         }

  27310.         return this.getSOAPServices_inoltroBuste_response_securityHeaders;
  27311.     }
  27312.     
  27313.     private Boolean isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = null;
  27314.     public boolean isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders() { 
  27315.         if(this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders==null){
  27316.             String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.response.securityHeaders";
  27317.             try{ 
  27318.                 String name = null;
  27319.                 name = this.reader.getValueConvertEnvProperties(pName);
  27320.                 if(name==null){
  27321.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  27322.                     name="true";
  27323.                 }
  27324.                 name = name.trim();
  27325.                 this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = Boolean.parseBoolean(name);
  27326.             } catch(java.lang.Exception e) {
  27327.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27328.                 this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = true;
  27329.             }    
  27330.         }

  27332.         return this.isSOAPServices_consegnaContenutiApplicativi_response_securityHeaders;
  27333.     }
  27334.     
  27335.     private Properties getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = null;
  27336.     public Properties getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders() throws CoreException {    
  27337.         if(this.getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders==null){
  27338.             String pName = "org.openspcoop2.pdd.soap.connettori.consegnaContenutiApplicativi.response.securityHeaders.";
  27339.             try{ 
  27340.                 this.getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders = this.reader.readPropertiesConvertEnvProperties(pName);
  27341.             } catch(java.lang.Exception e) {
  27342.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  27343.                 throw new CoreException(e.getMessage(),e);
  27344.             }    
  27345.         }

  27347.         return this.getSOAPServices_consegnaContenutiApplicativi_response_securityHeaders;
  27348.     }
  27349.     
  27350.     
  27351.     
  27352.     /* ------------- REST (Trasporto - URLParameters) ---------------------*/
  27353.     
  27354.     private Boolean isRESTServicesUrlParametersForward = null;
  27355.     private boolean isRESTServicesUrlParametersForward(){

  27357.         if(this.isRESTServicesUrlParametersForward==null){
  27358.             try{  
  27359.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.urlParameters.forward.enable"); 

  27361.                 if (value != null){
  27362.                     value = value.trim();
  27363.                     this.isRESTServicesUrlParametersForward = Boolean.parseBoolean(value);
  27364.                 }else{
  27365.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.forward.enable' non impostata, viene utilizzato il default=true");
  27366.                     this.isRESTServicesUrlParametersForward = true;
  27367.                 }

  27369.             }catch(java.lang.Exception e) {
  27370.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.forward.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  27371.                 this.isRESTServicesUrlParametersForward = true;
  27372.             }
  27373.         }

  27375.         return this.isRESTServicesUrlParametersForward;
  27376.     }
  27377.     
  27378.     private Boolean getRESTServicesBlackListInternalUrlParametersRead = null;
  27379.     private List<MapKey<String>> getRESTServicesBlackListInternalUrlParametersList = null;
  27380.     private List<MapKey<String>> getRESTServicesBlackListInternalUrlParameters() {  
  27381.         if(this.getRESTServicesBlackListInternalUrlParametersRead==null){
  27382.             try{ 
  27383.                 this.getRESTServicesBlackListInternalUrlParametersList = new ArrayList<>();
  27384.                 String name = null;
  27385.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.urlParameters.blackList.internal");
  27386.                 if(name!=null){
  27387.                     name = name.trim();
  27388.                     String [] split = name.split(",");
  27389.                     if(split!=null){
  27390.                         for (int i = 0; i < split.length; i++) {
  27391.                             this.getRESTServicesBlackListInternalUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27392.                         }
  27393.                     }
  27394.                 }
  27395.                 this.getRESTServicesBlackListInternalUrlParametersRead = true;
  27396.             } catch(java.lang.Exception e) {
  27397.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.blackList.internal': "+e.getMessage(),e);
  27398.             }    
  27399.         }
  27400.         
  27401.         return this.getRESTServicesBlackListInternalUrlParametersList;
  27402.     }
  27403.     
  27404.     private Boolean getRESTServicesBlackListUrlParametersRead = null;
  27405.     private List<MapKey<String>> getRESTServicesBlackListUrlParametersList = null;
  27406.     private List<MapKey<String>> getRESTServicesBlackListUrlParameters() {  
  27407.         if(this.getRESTServicesBlackListUrlParametersRead==null){
  27408.             try{ 
  27409.                 this.getRESTServicesBlackListUrlParametersList = new ArrayList<>();
  27410.                 String name = null;
  27411.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.urlParameters.blackList");
  27412.                 if(name!=null){
  27413.                     name = name.trim();
  27414.                     String [] split = name.split(",");
  27415.                     if(split!=null){
  27416.                         for (int i = 0; i < split.length; i++) {
  27417.                             this.getRESTServicesBlackListUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27418.                         }
  27419.                     }
  27420.                 }
  27421.                 this.getRESTServicesBlackListUrlParametersRead = true;
  27422.             } catch(java.lang.Exception e) {
  27423.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.blackList': "+e.getMessage(),e);
  27424.             }    
  27425.         }
  27426.         
  27427.         return this.getRESTServicesBlackListUrlParametersList;
  27428.     }
  27429.     
  27430.     private Boolean getRESTServicesWhiteListUrlParametersRead = null;
  27431.     private List<MapKey<String>> getRESTServicesWhiteListUrlParametersList = null;
  27432.     private List<MapKey<String>> getRESTServicesWhiteListUrlParameters() {  
  27433.         if(this.getRESTServicesWhiteListUrlParametersRead==null){
  27434.             try{ 
  27435.                 this.getRESTServicesWhiteListUrlParametersList = new ArrayList<>();
  27436.                 String name = null;
  27437.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.urlParameters.whiteList");
  27438.                 if(name!=null){
  27439.                     name = name.trim();
  27440.                     String [] split = name.split(",");
  27441.                     if(split!=null){
  27442.                         for (int i = 0; i < split.length; i++) {
  27443.                             this.getRESTServicesWhiteListUrlParametersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27444.                         }
  27445.                     }
  27446.                 }
  27447.                 this.getRESTServicesWhiteListUrlParametersRead = true;
  27448.             } catch(java.lang.Exception e) {
  27449.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.urlParameters.whiteList': "+e.getMessage(),e);
  27450.             }    
  27451.         }
  27452.         
  27453.         return this.getRESTServicesWhiteListUrlParametersList;
  27454.     }
  27455.         
  27456.     private List<String> _getRESTServicesBlackListUrlParameters() { 
  27457.         
  27458.         List<MapKey<String>> blackList = new ArrayList<>();
  27459.         List<MapKey<String>> tmp = this.getRESTServicesBlackListInternalUrlParameters();
  27460.         this._list_add(tmp, blackList);
  27461.         tmp = this.getRESTServicesBlackListUrlParameters();
  27462.         this._list_add(tmp, blackList);
  27463.         
  27464.         List<String> l = new ArrayList<>();
  27465.         if(!blackList.isEmpty()) {
  27466.             for (MapKey<String> key : blackList) {
  27467.                 l.add(key.getValue());
  27468.             }
  27469.         }
  27470.         return l;
  27471.     }
  27472.     private List<String> _getRESTServicesWhiteListUrlParameters() { 
  27473.         
  27474.         List<MapKey<String>> whiteList = new ArrayList<>();
  27475.         List<MapKey<String>> tmp = this.getRESTServicesWhiteListUrlParameters();
  27476.         this._list_add(tmp, whiteList);
  27477.         
  27478.         List<String> l = new ArrayList<>();
  27479.         if(!whiteList.isEmpty()) {
  27480.             for (MapKey<String> key : whiteList) {
  27481.                 l.add(key.getValue());
  27482.             }
  27483.         }
  27484.         return l;
  27485.     }
  27486.     public ForwardConfig getRESTServicesUrlParametersForwardConfig() {
  27487.         ForwardConfig f = new ForwardConfig();
  27488.         f.setForwardEnable(this.isRESTServicesUrlParametersForward());
  27489.         f.setBlackList(_getRESTServicesBlackListUrlParameters());
  27490.         f.setWhiteList(_getRESTServicesWhiteListUrlParameters());
  27491.         return f;
  27492.     }
  27493.     
  27494.     
  27495.     
  27496.     
  27497.     /* ------------- REST (Trasporto - Headers) ---------------------*/
  27498.     
  27499.     private Boolean isRESTServicesHeadersForward = null;
  27500.     private boolean isRESTServicesHeadersForward(){

  27502.         if(this.isRESTServicesHeadersForward==null){
  27503.             try{  
  27504.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.forward.enable"); 

  27506.                 if (value != null){
  27507.                     value = value.trim();
  27508.                     this.isRESTServicesHeadersForward = Boolean.parseBoolean(value);
  27509.                 }else{
  27510.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.forward.enable' non impostata, viene utilizzato il default=true");
  27511.                     this.isRESTServicesHeadersForward = true;
  27512.                 }

  27514.             }catch(java.lang.Exception e) {
  27515.                 this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.forward.enable' non impostata, viene utilizzato il default=true, errore:"+e.getMessage(),e);
  27516.                 this.isRESTServicesHeadersForward = true;
  27517.             }
  27518.         }

  27520.         return this.isRESTServicesHeadersForward;
  27521.     }
  27522.     
  27523.     private Boolean getRESTServicesBlackListBothInternalHeadersRead = null;
  27524.     private List<MapKey<String>> getRESTServicesBlackListBothInternalHeadersList = null;
  27525.     private List<MapKey<String>> getRESTServicesBlackListBothInternalHeaders() {    
  27526.         if(this.getRESTServicesBlackListBothInternalHeadersRead==null){
  27527.             try{ 
  27528.                 this.getRESTServicesBlackListBothInternalHeadersList = new ArrayList<>();
  27529.                 String name = null;
  27530.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.internal.both");
  27531.                 if(name!=null){
  27532.                     name = name.trim();
  27533.                     String [] split = name.split(",");
  27534.                     if(split!=null){
  27535.                         for (int i = 0; i < split.length; i++) {
  27536.                             this.getRESTServicesBlackListBothInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27537.                         }
  27538.                     }
  27539.                 }
  27540.                 this.getRESTServicesBlackListBothInternalHeadersRead = true;
  27541.             } catch(java.lang.Exception e) {
  27542.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.internal.both': "+e.getMessage(),e);
  27543.             }    
  27544.         }
  27545.         
  27546.         return this.getRESTServicesBlackListBothInternalHeadersList;
  27547.     }
  27548.     
  27549.     private Boolean getRESTServicesBlackListRequestInternalHeadersRead = null;
  27550.     private List<MapKey<String>> getRESTServicesBlackListRequestInternalHeadersList = null;
  27551.     private List<MapKey<String>> getRESTServicesBlackListRequestInternalHeaders() { 
  27552.         if(this.getRESTServicesBlackListRequestInternalHeadersRead==null){
  27553.             try{ 
  27554.                 this.getRESTServicesBlackListRequestInternalHeadersList = new ArrayList<>();
  27555.                 String name = null;
  27556.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.internal.request");
  27557.                 if(name!=null){
  27558.                     name = name.trim();
  27559.                     String [] split = name.split(",");
  27560.                     if(split!=null){
  27561.                         for (int i = 0; i < split.length; i++) {
  27562.                             this.getRESTServicesBlackListRequestInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27563.                         }
  27564.                     }
  27565.                 }
  27566.                 this.getRESTServicesBlackListRequestInternalHeadersRead = true;
  27567.             } catch(java.lang.Exception e) {
  27568.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.internal.request': "+e.getMessage(),e);
  27569.             }    
  27570.         }
  27571.         
  27572.         return this.getRESTServicesBlackListRequestInternalHeadersList;
  27573.     }
  27574.     
  27575.     private Boolean getRESTServicesBlackListResponseInternalHeadersRead = null;
  27576.     private List<MapKey<String>> getRESTServicesBlackListResponseInternalHeadersList = null;
  27577.     private List<MapKey<String>> getRESTServicesBlackListResponseInternalHeaders() {    
  27578.         if(this.getRESTServicesBlackListResponseInternalHeadersRead==null){
  27579.             try{ 
  27580.                 this.getRESTServicesBlackListResponseInternalHeadersList = new ArrayList<>();
  27581.                 String name = null;
  27582.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.internal.response");
  27583.                 if(name!=null){
  27584.                     name = name.trim();
  27585.                     String [] split = name.split(",");
  27586.                     if(split!=null){
  27587.                         for (int i = 0; i < split.length; i++) {
  27588.                             this.getRESTServicesBlackListResponseInternalHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27589.                         }
  27590.                     }
  27591.                 }
  27592.                 this.getRESTServicesBlackListResponseInternalHeadersRead = true;
  27593.             } catch(java.lang.Exception e) {
  27594.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.internal.response': "+e.getMessage(),e);
  27595.             }    
  27596.         }
  27597.         
  27598.         return this.getRESTServicesBlackListResponseInternalHeadersList;
  27599.     }
  27600.     
  27601.     private Boolean getRESTServicesBlackListBothHeadersRead = null;
  27602.     private List<MapKey<String>> getRESTServicesBlackListBothHeadersList = null;
  27603.     private List<MapKey<String>> getRESTServicesBlackListBothHeaders() {    
  27604.         if(this.getRESTServicesBlackListBothHeadersRead==null){
  27605.             try{ 
  27606.                 this.getRESTServicesBlackListBothHeadersList = new ArrayList<>();
  27607.                 String name = null;
  27608.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.both");
  27609.                 if(name!=null){
  27610.                     name = name.trim();
  27611.                     String [] split = name.split(",");
  27612.                     if(split!=null){
  27613.                         for (int i = 0; i < split.length; i++) {
  27614.                             this.getRESTServicesBlackListBothHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27615.                         }
  27616.                     }
  27617.                 }
  27618.                 this.getRESTServicesBlackListBothHeadersRead = true;
  27619.             } catch(java.lang.Exception e) {
  27620.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.both': "+e.getMessage(),e);
  27621.             }    
  27622.         }
  27623.         
  27624.         return this.getRESTServicesBlackListBothHeadersList;
  27625.     }
  27626.     
  27627.     private Boolean getRESTServicesBlackListRequestHeadersRead = null;
  27628.     private List<MapKey<String>> getRESTServicesBlackListRequestHeadersList = null;
  27629.     private List<MapKey<String>> getRESTServicesBlackListRequestHeaders() { 
  27630.         if(this.getRESTServicesBlackListRequestHeadersRead==null){
  27631.             try{ 
  27632.                 this.getRESTServicesBlackListRequestHeadersList = new ArrayList<>();
  27633.                 String name = null;
  27634.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.request");
  27635.                 if(name!=null){
  27636.                     name = name.trim();
  27637.                     String [] split = name.split(",");
  27638.                     if(split!=null){
  27639.                         for (int i = 0; i < split.length; i++) {
  27640.                             this.getRESTServicesBlackListRequestHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27641.                         }
  27642.                     }
  27643.                 }
  27644.                 this.getRESTServicesBlackListRequestHeadersRead = true;
  27645.             } catch(java.lang.Exception e) {
  27646.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.request': "+e.getMessage(),e);
  27647.             }    
  27648.         }
  27649.         
  27650.         return this.getRESTServicesBlackListRequestHeadersList;
  27651.     }
  27652.     
  27653.     private Boolean getRESTServicesBlackListResponseHeadersRead = null;
  27654.     private List<MapKey<String>> getRESTServicesBlackListResponseHeadersList = null;
  27655.     private List<MapKey<String>> getRESTServicesBlackListResponseHeaders() {    
  27656.         if(this.getRESTServicesBlackListResponseHeadersRead==null){
  27657.             try{ 
  27658.                 this.getRESTServicesBlackListResponseHeadersList = new ArrayList<>();
  27659.                 String name = null;
  27660.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.blackList.response");
  27661.                 if(name!=null){
  27662.                     name = name.trim();
  27663.                     String [] split = name.split(",");
  27664.                     if(split!=null){
  27665.                         for (int i = 0; i < split.length; i++) {
  27666.                             this.getRESTServicesBlackListResponseHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27667.                         }
  27668.                     }
  27669.                 }
  27670.                 this.getRESTServicesBlackListResponseHeadersRead = true;
  27671.             } catch(java.lang.Exception e) {
  27672.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.blackList.response': "+e.getMessage(),e);
  27673.             }    
  27674.         }
  27675.         
  27676.         return this.getRESTServicesBlackListResponseHeadersList;
  27677.     }
  27678.     
  27679.     private Boolean getRESTServicesWhiteListBothHeadersRead = null;
  27680.     private List<MapKey<String>> getRESTServicesWhiteListBothHeadersList = null;
  27681.     private List<MapKey<String>> getRESTServicesWhiteListBothHeaders() {    
  27682.         if(this.getRESTServicesWhiteListBothHeadersRead==null){
  27683.             try{ 
  27684.                 this.getRESTServicesWhiteListBothHeadersList = new ArrayList<>();
  27685.                 String name = null;
  27686.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.whiteList.both");
  27687.                 if(name!=null){
  27688.                     name = name.trim();
  27689.                     String [] split = name.split(",");
  27690.                     if(split!=null){
  27691.                         for (int i = 0; i < split.length; i++) {
  27692.                             this.getRESTServicesWhiteListBothHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27693.                         }
  27694.                     }
  27695.                 }
  27696.                 this.getRESTServicesWhiteListBothHeadersRead = true;
  27697.             } catch(java.lang.Exception e) {
  27698.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.whiteList.both': "+e.getMessage(),e);
  27699.             }    
  27700.         }
  27701.         
  27702.         return this.getRESTServicesWhiteListBothHeadersList;
  27703.     }
  27704.     
  27705.     private Boolean getRESTServicesWhiteListRequestHeadersRead = null;
  27706.     private List<MapKey<String>> getRESTServicesWhiteListRequestHeadersList = null;
  27707.     private List<MapKey<String>> getRESTServicesWhiteListRequestHeaders() { 
  27708.         if(this.getRESTServicesWhiteListRequestHeadersRead==null){
  27709.             try{ 
  27710.                 this.getRESTServicesWhiteListRequestHeadersList = new ArrayList<>();
  27711.                 String name = null;
  27712.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.whiteList.request");
  27713.                 if(name!=null){
  27714.                     name = name.trim();
  27715.                     String [] split = name.split(",");
  27716.                     if(split!=null){
  27717.                         for (int i = 0; i < split.length; i++) {
  27718.                             this.getRESTServicesWhiteListRequestHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27719.                         }
  27720.                     }
  27721.                 }
  27722.                 this.getRESTServicesWhiteListRequestHeadersRead = true;
  27723.             } catch(java.lang.Exception e) {
  27724.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.whiteList.request': "+e.getMessage(),e);
  27725.             }    
  27726.         }
  27727.         
  27728.         return this.getRESTServicesWhiteListRequestHeadersList;
  27729.     }
  27730.     
  27731.     private Boolean getRESTServicesWhiteListResponseHeadersRead = null;
  27732.     private List<MapKey<String>> getRESTServicesWhiteListResponseHeadersList = null;
  27733.     private List<MapKey<String>> getRESTServicesWhiteListResponseHeaders() {    
  27734.         if(this.getRESTServicesWhiteListResponseHeadersRead==null){
  27735.             try{ 
  27736.                 this.getRESTServicesWhiteListResponseHeadersList = new ArrayList<>();
  27737.                 String name = null;
  27738.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.headers.whiteList.response");
  27739.                 if(name!=null){
  27740.                     name = name.trim();
  27741.                     String [] split = name.split(",");
  27742.                     if(split!=null){
  27743.                         for (int i = 0; i < split.length; i++) {
  27744.                             this.getRESTServicesWhiteListResponseHeadersList.add(org.openspcoop2.utils.Map.newMapKey(split[i].trim()));
  27745.                         }
  27746.                     }
  27747.                 }
  27748.                 this.getRESTServicesWhiteListResponseHeadersRead = true;
  27749.             } catch(java.lang.Exception e) {
  27750.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.headers.whiteList.response': "+e.getMessage(),e);
  27751.             }    
  27752.         }
  27753.         
  27754.         return this.getRESTServicesWhiteListResponseHeadersList;
  27755.     }
  27756.     
  27757.     private List<String> getRESTServicesBlackListHeaders(boolean request) { 
  27758.         
  27759.         List<MapKey<String>> blackList = new ArrayList<>();
  27760.         List<MapKey<String>> tmp = this.getRESTServicesBlackListBothInternalHeaders();
  27761.         this._list_add(tmp, blackList);
  27762.         tmp = this.getRESTServicesBlackListBothHeaders();
  27763.         this._list_add(tmp, blackList);
  27764.         
  27765.         if(request) {
  27766.             tmp = this.getRESTServicesBlackListRequestInternalHeaders();
  27767.             this._list_add(tmp, blackList);
  27768.             tmp = this.getRESTServicesBlackListRequestHeaders();
  27769.             this._list_add(tmp, blackList);
  27770.         }
  27771.         else {
  27772.             tmp = this.getRESTServicesBlackListResponseInternalHeaders();
  27773.             this._list_add(tmp, blackList);
  27774.             tmp = this.getRESTServicesBlackListResponseHeaders();
  27775.             this._list_add(tmp, blackList);
  27776.         }
  27777.         
  27778.         List<String> l = new ArrayList<>();
  27779.         if(!blackList.isEmpty()) {
  27780.             for (MapKey<String> key : blackList) {
  27781.                 l.add(key.getValue());
  27782.             }
  27783.         }
  27784.         return l;
  27785.     }
  27786.     private List<String> getRESTServicesWhiteListHeaders(boolean request) { 
  27787.         
  27788.         List<MapKey<String>> whiteList = new ArrayList<>();
  27789.         List<MapKey<String>> tmp = this.getRESTServicesWhiteListBothHeaders();
  27790.         this._list_add(tmp, whiteList);
  27791.         if(request) {
  27792.             tmp = this.getRESTServicesWhiteListRequestHeaders();
  27793.             this._list_add(tmp, whiteList);
  27794.         }
  27795.         else {
  27796.             tmp = this.getRESTServicesWhiteListResponseHeaders();
  27797.             this._list_add(tmp, whiteList);
  27798.         }
  27799.         
  27800.         List<String> l = new ArrayList<>();
  27801.         if(!whiteList.isEmpty()) {
  27802.             for (MapKey<String> key : whiteList) {
  27803.                 l.add(key.getValue());
  27804.             }
  27805.         }
  27806.         return l;
  27807.     }
  27808.     public ForwardConfig getRESTServicesHeadersForwardConfig(boolean request) {
  27809.         ForwardConfig f = new ForwardConfig();
  27810.         f.setForwardEnable(this.isRESTServicesHeadersForward());
  27811.         f.setBlackList(getRESTServicesBlackListHeaders(request));
  27812.         f.setWhiteList(getRESTServicesWhiteListHeaders(request));
  27813.         return f;
  27814.     }


  27817.     /* ------------- REST (Trasporto - Headers - Proxy Pass Reverse) ---------------------*/
  27818.     
  27819.     // Location
  27820.     
  27821.     private Boolean isRESTServices_inoltroBuste_proxyPassReverse = null;
  27822.     public boolean isRESTServices_inoltroBuste_proxyPassReverse() { 
  27823.         if(this.isRESTServices_inoltroBuste_proxyPassReverse==null){
  27824.             try{ 
  27825.                 String name = null;
  27826.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse");
  27827.                 if(name==null){
  27828.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse' non impostata, viene utilizzato il default=false");
  27829.                     name="false";
  27830.                 }
  27831.                 name = name.trim();
  27832.                 this.isRESTServices_inoltroBuste_proxyPassReverse = Boolean.parseBoolean(name);
  27833.             } catch(java.lang.Exception e) {
  27834.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse': "+e.getMessage(),e);
  27835.                 this.isRESTServices_inoltroBuste_proxyPassReverse = false;
  27836.             }    
  27837.         }

  27839.         return this.isRESTServices_inoltroBuste_proxyPassReverse;
  27840.     }
  27841.     
  27842.     private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse = null;
  27843.     public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse() { 
  27844.         if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse==null){
  27845.             try{ 
  27846.                 String name = null;
  27847.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse");
  27848.                 if(name==null){
  27849.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse' non impostata, viene utilizzato il default=false");
  27850.                     name="false";
  27851.                 }
  27852.                 name = name.trim();
  27853.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse = Boolean.parseBoolean(name);
  27854.             } catch(java.lang.Exception e) {
  27855.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse': "+e.getMessage(),e);
  27856.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse = false;
  27857.             }    
  27858.         }

  27860.         return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse;
  27861.     }
  27862.         
  27863.     private List<String> getRESTServices_inoltroBuste_proxyPassReverse_headers = null;
  27864.     public List<String> getRESTServices_inoltroBuste_proxyPassReverse_headers() throws CoreException {  
  27865.         if(this.getRESTServices_inoltroBuste_proxyPassReverse_headers==null){
  27866.             try{ 
  27867.                 this.getRESTServices_inoltroBuste_proxyPassReverse_headers = new ArrayList<>();
  27868.                 
  27869.                 String name = null;
  27870.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.headers");
  27871.                 if(name!=null){
  27872.                     name = name.trim();
  27873.                 }
  27874.                 if(name!=null && !"".equals(name)) {
  27875.                     if(name.contains(",")) {
  27876.                         String [] tmp = name.split(",");
  27877.                         for (int i = 0; i < tmp.length; i++) {
  27878.                             this.getRESTServices_inoltroBuste_proxyPassReverse_headers.add(tmp[i].trim());
  27879.                         }
  27880.                     }
  27881.                     else {
  27882.                         this.getRESTServices_inoltroBuste_proxyPassReverse_headers.add(name);
  27883.                     }
  27884.                 }
  27885.             } catch(java.lang.Exception e) {
  27886.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.headers': "+e.getMessage();
  27887.                 this.logError(error,e);
  27888.                 throw new CoreException(error);
  27889.             }    
  27890.         }

  27892.         return this.getRESTServices_inoltroBuste_proxyPassReverse_headers;
  27893.     }
  27894.     
  27895.     private List<String> getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers = null;
  27896.     public List<String> getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers() throws CoreException {  
  27897.         if(this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers==null){
  27898.             try{ 
  27899.                 this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers = new ArrayList<>();
  27900.                 
  27901.                 String name = null;
  27902.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.headers");
  27903.                 if(name!=null){
  27904.                     name = name.trim();
  27905.                 }
  27906.                 if(name!=null && !"".equals(name)) {
  27907.                     if(name.contains(",")) {
  27908.                         String [] tmp = name.split(",");
  27909.                         for (int i = 0; i < tmp.length; i++) {
  27910.                             this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers.add(tmp[i].trim());
  27911.                         }
  27912.                     }
  27913.                     else {
  27914.                         this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers.add(name);
  27915.                     }
  27916.                 }
  27917.             } catch(java.lang.Exception e) {
  27918.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.headers': "+e.getMessage();
  27919.                 this.logError(error,e);
  27920.                 throw new CoreException(error);
  27921.             }    
  27922.         }

  27924.         return this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_headers;
  27925.     }
  27926.     
  27927.     // Set-Cookie
  27928.     
  27929.     private Boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie = null;
  27930.     public boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie() {   
  27931.         if(this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie==null){
  27932.             String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie";
  27933.             try{ 
  27934.                 String name = null;
  27935.                 name = this.reader.getValueConvertEnvProperties(pName);
  27936.                 if(name==null){
  27937.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  27938.                     name="false";
  27939.                 }
  27940.                 name = name.trim();
  27941.                 this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie = Boolean.parseBoolean(name);
  27942.             } catch(java.lang.Exception e) {
  27943.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27944.                 this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie = false;
  27945.             }    
  27946.         }

  27948.         return this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie;
  27949.     }
  27950.     
  27951.     private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = null;
  27952.     public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie() {   
  27953.         if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie==null){
  27954.             String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie";
  27955.             try{ 
  27956.                 String name = null;
  27957.                 name = this.reader.getValueConvertEnvProperties(pName);
  27958.                 if(name==null){
  27959.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  27960.                     name="false";
  27961.                 }
  27962.                 name = name.trim();
  27963.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = Boolean.parseBoolean(name);
  27964.             } catch(java.lang.Exception e) {
  27965.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27966.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie = false;
  27967.             }    
  27968.         }

  27970.         return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie;
  27971.     }
  27972.     
  27973.     private Boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path = null;
  27974.     public boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path() {  
  27975.         if(this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path==null){
  27976.             String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie.path";
  27977.             try{ 
  27978.                 String name = null;
  27979.                 name = this.reader.getValueConvertEnvProperties(pName);
  27980.                 if(name==null){
  27981.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isRESTServices_inoltroBuste_proxyPassReverse_setCookie()));
  27982.                     name=""+isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
  27983.                 }
  27984.                 name = name.trim();
  27985.                 this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path = Boolean.parseBoolean(name);
  27986.             } catch(java.lang.Exception e) {
  27987.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  27988.                 this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path = isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
  27989.             }    
  27990.         }

  27992.         return this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_path;
  27993.     }
  27994.     
  27995.     private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = null;
  27996.     public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path() {  
  27997.         if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path==null){
  27998.             String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.path";
  27999.             try{ 
  28000.                 String name = null;
  28001.                 name = this.reader.getValueConvertEnvProperties(pName);
  28002.                 if(name==null){
  28003.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie()));
  28004.                     name=""+isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  28005.                 }
  28006.                 name = name.trim();
  28007.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = Boolean.parseBoolean(name);
  28008.             } catch(java.lang.Exception e) {
  28009.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  28010.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path = isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  28011.             }    
  28012.         }

  28014.         return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_path;
  28015.     }
  28016.     
  28017.     private Boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain = null;
  28018.     public boolean isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain() {    
  28019.         if(this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain==null){
  28020.             String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie.domain";
  28021.             try{ 
  28022.                 String name = null;
  28023.                 name = this.reader.getValueConvertEnvProperties(pName);
  28024.                 if(name==null){
  28025.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isRESTServices_inoltroBuste_proxyPassReverse_setCookie()));
  28026.                     name=""+isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
  28027.                 }
  28028.                 name = name.trim();
  28029.                 this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain = Boolean.parseBoolean(name);
  28030.             } catch(java.lang.Exception e) {
  28031.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  28032.                 this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain = isRESTServices_inoltroBuste_proxyPassReverse_setCookie();
  28033.             }    
  28034.         }

  28036.         return this.isRESTServices_inoltroBuste_proxyPassReverse_setCookie_domain;
  28037.     }
  28038.     
  28039.     private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = null;
  28040.     public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain() {    
  28041.         if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain==null){
  28042.             String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.domain";
  28043.             try{ 
  28044.                 String name = null;
  28045.                 name = this.reader.getValueConvertEnvProperties(pName);
  28046.                 if(name==null){
  28047.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie()));
  28048.                     name=""+isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  28049.                 }
  28050.                 name = name.trim();
  28051.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = Boolean.parseBoolean(name);
  28052.             } catch(java.lang.Exception e) {
  28053.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  28054.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain = isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie();
  28055.             }    
  28056.         }

  28058.         return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_domain;
  28059.     }
  28060.     
  28061.     private List<String> getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers = null;
  28062.     public List<String> getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers() throws CoreException {    
  28063.         if(this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers==null){
  28064.             try{ 
  28065.                 this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers = new ArrayList<>();
  28066.                 
  28067.                 String name = null;
  28068.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie.headers");
  28069.                 if(name!=null){
  28070.                     name = name.trim();
  28071.                 }
  28072.                 if(name!=null && !"".equals(name)) {
  28073.                     if(name.contains(",")) {
  28074.                         String [] tmp = name.split(",");
  28075.                         for (int i = 0; i < tmp.length; i++) {
  28076.                             this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers.add(tmp[i].trim());
  28077.                         }
  28078.                     }
  28079.                     else {
  28080.                         this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers.add(name);
  28081.                     }
  28082.                 }
  28083.             } catch(java.lang.Exception e) {
  28084.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.setCookie.headers': "+e.getMessage();
  28085.                 this.logError(error,e);
  28086.                 throw new CoreException(error);
  28087.             }    
  28088.         }

  28090.         return this.getRESTServices_inoltroBuste_proxyPassReverse_setCookie_headers;
  28091.     }
  28092.     
  28093.     private List<String> getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers = null;
  28094.     public List<String> getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers() throws CoreException {    
  28095.         if(this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers==null){
  28096.             try{ 
  28097.                 this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers = new ArrayList<>();
  28098.                 
  28099.                 String name = null;
  28100.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.headers");
  28101.                 if(name!=null){
  28102.                     name = name.trim();
  28103.                 }
  28104.                 if(name!=null && !"".equals(name)) {
  28105.                     if(name.contains(",")) {
  28106.                         String [] tmp = name.split(",");
  28107.                         for (int i = 0; i < tmp.length; i++) {
  28108.                             this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers.add(tmp[i].trim());
  28109.                         }
  28110.                     }
  28111.                     else {
  28112.                         this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers.add(name);
  28113.                     }
  28114.                 }
  28115.             } catch(java.lang.Exception e) {
  28116.                 String error = "Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.setCookie.headers': "+e.getMessage();
  28117.                 this.logError(error,e);
  28118.                 throw new CoreException(error);
  28119.             }    
  28120.         }

  28122.         return this.getRESTServices_consegnaContenutiApplicativi_proxyPassReverse_setCookie_headers;
  28123.     }
  28124.     
  28125.     // useProtocolPrefix
  28126.     
  28127.     private Boolean isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = null;
  28128.     public boolean isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix() {   
  28129.         if(this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix==null){
  28130.             try{ 
  28131.                 String name = null;
  28132.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix");
  28133.                 if(name==null){
  28134.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix' non impostata, viene utilizzato il default=false");
  28135.                     name="false";
  28136.                 }
  28137.                 name = name.trim();
  28138.                 this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = Boolean.parseBoolean(name);
  28139.             } catch(java.lang.Exception e) {
  28140.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.inoltroBuste.proxyPassReverse.useProtocolPrefix': "+e.getMessage(),e);
  28141.                 this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix = false;
  28142.             }    
  28143.         }

  28145.         return this.isRESTServices_inoltroBuste_proxyPassReverse_useProtocolPrefix;
  28146.     }
  28147.     
  28148.     private Boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = null;
  28149.     public boolean isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix() {   
  28150.         if(this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix==null){
  28151.             try{ 
  28152.                 String name = null;
  28153.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix");
  28154.                 if(name==null){
  28155.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix' non impostata, viene utilizzato il default=false");
  28156.                     name="false";
  28157.                 }
  28158.                 name = name.trim();
  28159.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = Boolean.parseBoolean(name);
  28160.             } catch(java.lang.Exception e) {
  28161.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.proxyPassReverse.useProtocolPrefix': "+e.getMessage(),e);
  28162.                 this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix = false;
  28163.             }    
  28164.         }

  28166.         return this.isRESTServices_consegnaContenutiApplicativi_proxyPassReverse_useProtocolPrefix;
  28167.     }
  28168.     

  28170.     private Boolean isRESTServices_inoltroBuste_response_securityHeaders = null;
  28171.     public boolean isRESTServices_inoltroBuste_response_securityHeaders() { 
  28172.         if(this.isRESTServices_inoltroBuste_response_securityHeaders==null){
  28173.             String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.response.securityHeaders";
  28174.             try{ 
  28175.                 String name = null;
  28176.                 name = this.reader.getValueConvertEnvProperties(pName);
  28177.                 if(name==null){
  28178.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28179.                     name="true";
  28180.                 }
  28181.                 name = name.trim();
  28182.                 this.isRESTServices_inoltroBuste_response_securityHeaders = Boolean.parseBoolean(name);
  28183.             } catch(java.lang.Exception e) {
  28184.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  28185.                 this.isRESTServices_inoltroBuste_response_securityHeaders = true;
  28186.             }    
  28187.         }
  28188.     
  28189.         return this.isRESTServices_inoltroBuste_response_securityHeaders;
  28190.     }

  28192.     private Properties getRESTServices_inoltroBuste_response_securityHeaders = null;
  28193.     public Properties getRESTServices_inoltroBuste_response_securityHeaders() throws CoreException {    
  28194.         if(this.getRESTServices_inoltroBuste_response_securityHeaders==null){
  28195.             String pName = "org.openspcoop2.pdd.rest.connettori.inoltroBuste.response.securityHeaders.";
  28196.             try{ 
  28197.                 this.getRESTServices_inoltroBuste_response_securityHeaders = this.reader.readPropertiesConvertEnvProperties(pName);
  28198.             } catch(java.lang.Exception e) {
  28199.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  28200.                 throw new CoreException(e.getMessage(),e);
  28201.             }    
  28202.         }
  28203.     
  28204.         return this.getRESTServices_inoltroBuste_response_securityHeaders;
  28205.     }
  28206.     
  28207.     private Boolean isRESTServices_consegnaContenutiApplicativi_response_securityHeaders = null;
  28208.     public boolean isRESTServices_consegnaContenutiApplicativi_response_securityHeaders() { 
  28209.         if(this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders==null){
  28210.             String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.response.securityHeaders";
  28211.             try{ 
  28212.                 String name = null;
  28213.                 name = this.reader.getValueConvertEnvProperties(pName);
  28214.                 if(name==null){
  28215.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28216.                     name="true";
  28217.                 }
  28218.                 name = name.trim();
  28219.                 this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders = Boolean.parseBoolean(name);
  28220.             } catch(java.lang.Exception e) {
  28221.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  28222.                 this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders = true;
  28223.             }    
  28224.         }
  28225.     
  28226.         return this.isRESTServices_consegnaContenutiApplicativi_response_securityHeaders;
  28227.     }
  28228.     
  28229.     private Properties getRESTServices_consegnaContenutiApplicativi_response_securityHeaders = null;
  28230.     public Properties getRESTServices_consegnaContenutiApplicativi_response_securityHeaders() throws CoreException {    
  28231.         if(this.getRESTServices_consegnaContenutiApplicativi_response_securityHeaders==null){
  28232.             String pName = "org.openspcoop2.pdd.rest.connettori.consegnaContenutiApplicativi.response.securityHeaders.";
  28233.             try{ 
  28234.                 this.getRESTServices_consegnaContenutiApplicativi_response_securityHeaders = this.reader.readPropertiesConvertEnvProperties(pName);
  28235.             } catch(java.lang.Exception e) {
  28236.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"*': "+e.getMessage(),e);
  28237.                 throw new CoreException(e.getMessage(),e);
  28238.             }    
  28239.         }
  28240.     
  28241.         return this.getRESTServices_consegnaContenutiApplicativi_response_securityHeaders;
  28242.     }

  28244.     
  28245.     
  28246.     /* ------------- Transazioni ---------------------*/
  28247.     
  28248.     private Boolean isTransazioniEnabled = null;
  28249.     public boolean isTransazioniEnabled() { 
  28250.         if(this.isTransazioniEnabled==null){
  28251.             try{ 
  28252.                 String name = null;
  28253.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.enabled");
  28254.                 if(name==null){
  28255.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.enabled' non impostata, viene utilizzato il default=true");
  28256.                     name="true";
  28257.                 }
  28258.                 name = name.trim();
  28259.                 this.isTransazioniEnabled = Boolean.parseBoolean(name);
  28260.             } catch(java.lang.Exception e) {
  28261.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
  28262.                 this.isTransazioniEnabled = true;
  28263.             }    
  28264.         }

  28266.         return this.isTransazioniEnabled;
  28267.     }   
  28268.     
  28269.     private Boolean isTransazioniDebug = null;
  28270.     public boolean isTransazioniDebug() {   
  28271.         if(this.isTransazioniDebug==null){
  28272.             try{ 
  28273.                 String name = null;
  28274.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.debug");
  28275.                 if(name==null){
  28276.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.debug' non impostata, viene utilizzato il default=true");
  28277.                     name="true";
  28278.                 }
  28279.                 name = name.trim();
  28280.                 this.isTransazioniDebug = Boolean.parseBoolean(name);
  28281.             } catch(java.lang.Exception e) {
  28282.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.debug', viene utilizzato il default=true : "+e.getMessage(),e);
  28283.                 this.isTransazioniDebug = true;
  28284.             }    
  28285.         }

  28287.         return this.isTransazioniDebug;
  28288.     }   
  28289.     
  28290.     private Boolean isTransazioniUsePddRuntimeDatasource = null;
  28291.     public boolean isTransazioniUsePddRuntimeDatasource() { 
  28292.         if(this.isTransazioniUsePddRuntimeDatasource==null){
  28293.             try{ 
  28294.                 String name = null;
  28295.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.dataSource.usePddRuntime");
  28296.                 if(name==null){
  28297.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dataSource.usePddRuntime' non impostata, viene utilizzato il default=true");
  28298.                     name="true";
  28299.                 }
  28300.                 name = name.trim();
  28301.                 this.isTransazioniUsePddRuntimeDatasource = Boolean.parseBoolean(name);
  28302.             } catch(java.lang.Exception e) {
  28303.                 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);
  28304.                 this.isTransazioniUsePddRuntimeDatasource = true;
  28305.             }    
  28306.         }

  28308.         return this.isTransazioniUsePddRuntimeDatasource;
  28309.     }
  28310.     
  28311.     private String getTransazioniDatasource = null;
  28312.     public String getTransazioniDatasource() throws CoreException { 
  28313.         if(this.getTransazioniDatasource==null){
  28314.             try{ 
  28315.                 String name = null;
  28316.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.dataSource");
  28317.                 if(name==null){
  28318.                     throw new CoreException("Proprieta' non impostata");
  28319.                 }
  28320.                 name = name.trim();
  28321.                 this.getTransazioniDatasource = name;
  28322.             } catch(java.lang.Exception e) {
  28323.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dataSource': "+e.getMessage(),e);
  28324.                 throw new CoreException(e.getMessage(),e);
  28325.             }    
  28326.         }

  28328.         return this.getTransazioniDatasource;
  28329.     }
  28330.     
  28331.     private Properties getTransazioniDatasourceJndiContext = null;
  28332.     public Properties getTransazioniDatasourceJndiContext() throws CoreException {  
  28333.         if(this.getTransazioniDatasourceJndiContext==null){
  28334.             try{ 
  28335.                 this.getTransazioniDatasourceJndiContext = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.transazioni.dataSource.property.");
  28336.             } catch(java.lang.Exception e) {
  28337.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dataSource.property.*': "+e.getMessage(),e);
  28338.                 throw new CoreException(e.getMessage(),e);
  28339.             }    
  28340.         }

  28342.         return this.getTransazioniDatasourceJndiContext;
  28343.     }
  28344.     
  28345.     private Boolean isTransazioniDatasourceUseDBUtils = null;
  28346.     public boolean isTransazioniDatasourceUseDBUtils() {    
  28347.         if(this.isTransazioniDatasourceUseDBUtils==null){
  28348.             try{ 
  28349.                 String name = null;
  28350.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.datasource.useDSUtils");
  28351.                 if(name==null){
  28352.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.datasource.useDSUtils' non impostata, viene utilizzato il default=true");
  28353.                     name="true";
  28354.                 }
  28355.                 name = name.trim();
  28356.                 this.isTransazioniDatasourceUseDBUtils = Boolean.parseBoolean(name);
  28357.             } catch(java.lang.Exception e) {
  28358.                 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);
  28359.                 this.isTransazioniDatasourceUseDBUtils = true;
  28360.             }    
  28361.         }

  28363.         return this.isTransazioniDatasourceUseDBUtils;
  28364.     }
  28365.     
  28366.     private Boolean isTransazioniSaveTracceInUniqueTransaction = null;
  28367.     public boolean isTransazioniSaveTracceInUniqueTransaction() {   
  28368.         if(this.isTransazioniSaveTracceInUniqueTransaction==null){
  28369.             try{ 
  28370.                 String name = null;
  28371.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.enabled");
  28372.                 if(name==null){
  28373.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.enabled' non impostata, viene utilizzato il default=true");
  28374.                     name="true";
  28375.                 }
  28376.                 name = name.trim();
  28377.                 this.isTransazioniSaveTracceInUniqueTransaction = Boolean.parseBoolean(name);
  28378.             } catch(java.lang.Exception e) {
  28379.                 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);
  28380.                 this.isTransazioniSaveTracceInUniqueTransaction = true;
  28381.             }    
  28382.         }

  28384.         return this.isTransazioniSaveTracceInUniqueTransaction;
  28385.     }
  28386.     
  28387.     private Boolean isTransazioniSaveDiagnosticiInUniqueTransaction = null;
  28388.     public boolean isTransazioniSaveDiagnosticiInUniqueTransaction() {  
  28389.         if(this.isTransazioniSaveDiagnosticiInUniqueTransaction==null){
  28390.             try{ 
  28391.                 String name = null;
  28392.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.diagnostici.enabled");
  28393.                 if(name==null){
  28394.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.diagnostici.enabled' non impostata, viene utilizzato il default=true");
  28395.                     name="true";
  28396.                 }
  28397.                 name = name.trim();
  28398.                 this.isTransazioniSaveDiagnosticiInUniqueTransaction = Boolean.parseBoolean(name);
  28399.             } catch(java.lang.Exception e) {
  28400.                 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);
  28401.                 this.isTransazioniSaveDiagnosticiInUniqueTransaction = true;
  28402.             }    
  28403.         }

  28405.         return this.isTransazioniSaveDiagnosticiInUniqueTransaction;
  28406.     }
  28407.     
  28408.     private Boolean isTransazioniSaveDumpInUniqueTransaction = null;
  28409.     public boolean isTransazioniSaveDumpInUniqueTransaction() { 
  28410.         if(this.isTransazioniSaveDumpInUniqueTransaction==null){
  28411.             try{ 
  28412.                 String name = null;
  28413.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.dump.enabled");
  28414.                 if(name==null){
  28415.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dump.enabled' non impostata, viene utilizzato il default=true");
  28416.                     name="true";
  28417.                 }
  28418.                 name = name.trim();
  28419.                 this.isTransazioniSaveDumpInUniqueTransaction = Boolean.parseBoolean(name);
  28420.             } catch(java.lang.Exception e) {
  28421.                 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);
  28422.                 this.isTransazioniSaveDumpInUniqueTransaction = true;
  28423.             }    
  28424.         }

  28426.         return this.isTransazioniSaveDumpInUniqueTransaction;
  28427.     }
  28428.     
  28429.     private Boolean isTransazioniValorizzaDataIngressoConDataAccettazione = null;
  28430.     public boolean isTransazioniValorizzaDataIngressoConDataAccettazione() {    
  28431.         String pName = "org.openspcoop2.pdd.transazioni.dataIngresso.valorizzaConDataAccettazione";
  28432.         if(this.isTransazioniValorizzaDataIngressoConDataAccettazione==null){
  28433.             try{ 
  28434.                 String name = null;
  28435.                 name = this.reader.getValueConvertEnvProperties(pName);
  28436.                 if(name==null){
  28437.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28438.                     name="true";
  28439.                 }
  28440.                 name = name.trim();
  28441.                 this.isTransazioniValorizzaDataIngressoConDataAccettazione = Boolean.parseBoolean(name);
  28442.             } catch(java.lang.Exception e) {
  28443.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28444.                 this.isTransazioniValorizzaDataIngressoConDataAccettazione = true;
  28445.             }    
  28446.         }

  28448.         return this.isTransazioniValorizzaDataIngressoConDataAccettazione;
  28449.     }
  28450.     
  28451.     private Boolean isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent = null;
  28452.     public boolean isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent() { 
  28453.         String pName = "org.openspcoop2.pdd.transazioni.dataUscitaRisposta.useDateAfterResponseSent";
  28454.         if(this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent==null){
  28455.             try{ 
  28456.                 String name = null;
  28457.                 name = this.reader.getValueConvertEnvProperties(pName);
  28458.                 if(name==null){
  28459.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28460.                     name="true";
  28461.                 }
  28462.                 name = name.trim();
  28463.                 this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent = Boolean.parseBoolean(name);
  28464.             } catch(java.lang.Exception e) {
  28465.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28466.                 this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent = true;
  28467.             }    
  28468.         }

  28470.         return this.isTransazioniValorizzaDataUscitaRispostaUseDateAfterResponseSent;
  28471.     }
  28472.     
  28473.     private Boolean isTransazioniFaultPrettyPrint = null;
  28474.     public boolean isTransazioniFaultPrettyPrint() {    
  28475.         if(this.isTransazioniFaultPrettyPrint==null){
  28476.             try{ 
  28477.                 String name = null;
  28478.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.fault.prettyPrint");
  28479.                 if(name==null){
  28480.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.fault.prettyPrint' non impostata, viene utilizzato il default=false");
  28481.                     name="false";
  28482.                 }
  28483.                 name = name.trim();
  28484.                 this.isTransazioniFaultPrettyPrint = Boolean.parseBoolean(name);
  28485.             } catch(java.lang.Exception e) {
  28486.                 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);
  28487.                 this.isTransazioniFaultPrettyPrint = false;
  28488.             }    
  28489.         }

  28491.         return this.isTransazioniFaultPrettyPrint;
  28492.     }
  28493.     
  28494.     private Boolean isTransazioniHttpStatusAsEvent_inResponseCode = null;
  28495.     public boolean isTransazioniHttpStatusAsEvent_inResponseCode() {    
  28496.         if(this.isTransazioniHttpStatusAsEvent_inResponseCode==null){
  28497.             String pName = "org.openspcoop2.pdd.transazioni.httpStatusAsEvent.inResponseCode";
  28498.             try{ 
  28499.                 String name = null;
  28500.                 name = this.reader.getValueConvertEnvProperties(pName);
  28501.                 if(name==null){
  28502.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28503.                     name="false";
  28504.                 }
  28505.                 name = name.trim();
  28506.                 this.isTransazioniHttpStatusAsEvent_inResponseCode = Boolean.parseBoolean(name);
  28507.             } catch(java.lang.Exception e) {
  28508.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28509.                 this.isTransazioniHttpStatusAsEvent_inResponseCode = false;
  28510.             }    
  28511.         }

  28513.         return this.isTransazioniHttpStatusAsEvent_inResponseCode;
  28514.     }
  28515.     private Boolean isTransazioniHttpStatusAsEvent_outResponseCode = null;
  28516.     public boolean isTransazioniHttpStatusAsEvent_outResponseCode() {   
  28517.         if(this.isTransazioniHttpStatusAsEvent_outResponseCode==null){
  28518.             String pName = "org.openspcoop2.pdd.transazioni.httpStatusAsEvent.outResponseCode";
  28519.             try{ 
  28520.                 String name = null;
  28521.                 name = this.reader.getValueConvertEnvProperties(pName);
  28522.                 if(name==null){
  28523.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28524.                     name="false";
  28525.                 }
  28526.                 name = name.trim();
  28527.                 this.isTransazioniHttpStatusAsEvent_outResponseCode = Boolean.parseBoolean(name);
  28528.             } catch(java.lang.Exception e) {
  28529.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28530.                 this.isTransazioniHttpStatusAsEvent_outResponseCode = false;
  28531.             }    
  28532.         }

  28534.         return this.isTransazioniHttpStatusAsEvent_outResponseCode;
  28535.     }
  28536.     
  28537.     private Boolean isTransazioniTipoApiAsEvent = null;
  28538.     public boolean isTransazioniTipoApiAsEvent() {  
  28539.         if(this.isTransazioniTipoApiAsEvent==null){
  28540.             String pName = "org.openspcoop2.pdd.transazioni.tipoApiAsEvent";
  28541.             try{ 
  28542.                 String name = null;
  28543.                 name = this.reader.getValueConvertEnvProperties(pName);
  28544.                 if(name==null){
  28545.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28546.                     name="false";
  28547.                 }
  28548.                 name = name.trim();
  28549.                 this.isTransazioniTipoApiAsEvent = Boolean.parseBoolean(name);
  28550.             } catch(java.lang.Exception e) {
  28551.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28552.                 this.isTransazioniTipoApiAsEvent = false;
  28553.             }    
  28554.         }

  28556.         return this.isTransazioniTipoApiAsEvent;
  28557.     }
  28558.     
  28559.     private Boolean isTransazioniConnettoriMultipliAsEvent = null;
  28560.     public boolean isTransazioniConnettoriMultipliAsEvent() {   
  28561.         if(this.isTransazioniConnettoriMultipliAsEvent==null){
  28562.             String pName = "org.openspcoop2.pdd.transazioni.connettoriMultipliAsEvent";
  28563.             try{ 
  28564.                 String name = null;
  28565.                 name = this.reader.getValueConvertEnvProperties(pName);
  28566.                 if(name==null){
  28567.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28568.                     name="false";
  28569.                 }
  28570.                 name = name.trim();
  28571.                 this.isTransazioniConnettoriMultipliAsEvent = Boolean.parseBoolean(name);
  28572.             } catch(java.lang.Exception e) {
  28573.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28574.                 this.isTransazioniConnettoriMultipliAsEvent = false;
  28575.             }    
  28576.         }

  28578.         return this.isTransazioniConnettoriMultipliAsEvent;
  28579.     }
  28580.     
  28581.     private Boolean isTransazioniUpdateUseDayInterval = null;
  28582.     public boolean isTransazioniUpdateUseDayInterval() {    
  28583.         if(this.isTransazioniUpdateUseDayInterval==null){
  28584.             String pName = "org.openspcoop2.pdd.transazioni.update.useDayInterval";
  28585.             try{ 
  28586.                 String name = null;
  28587.                 name = this.reader.getValueConvertEnvProperties(pName);
  28588.                 if(name==null){
  28589.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28590.                     name="true";
  28591.                 }
  28592.                 name = name.trim();
  28593.                 this.isTransazioniUpdateUseDayInterval = Boolean.parseBoolean(name);
  28594.             } catch(java.lang.Exception e) {
  28595.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28596.                 this.isTransazioniUpdateUseDayInterval = true;
  28597.             }    
  28598.         }

  28600.         return this.isTransazioniUpdateUseDayInterval;
  28601.     }
  28602.     
  28603.     private Boolean isTransazioniRegistrazioneSlowLog = null;
  28604.     public boolean isTransazioniRegistrazioneSlowLog() {    
  28605.         if(this.isTransazioniRegistrazioneSlowLog==null){
  28606.             String pName = "org.openspcoop2.pdd.transazioni.slowLog.enabled";
  28607.             try{ 
  28608.                 String name = null;
  28609.                 name = this.reader.getValueConvertEnvProperties(pName);
  28610.                 if(name==null){
  28611.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28612.                     name="false";
  28613.                 }
  28614.                 name = name.trim();
  28615.                 this.isTransazioniRegistrazioneSlowLog = Boolean.parseBoolean(name);
  28616.             } catch(java.lang.Exception e) {
  28617.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28618.                 this.isTransazioniRegistrazioneSlowLog = false;
  28619.             }    
  28620.         }

  28622.         return this.isTransazioniRegistrazioneSlowLog;
  28623.     }
  28624.     
  28625.     private Integer getTransazioniRegistrazioneSlowLogThresholdMs = null;
  28626.     private final int getTransazioniRegistrazioneSlowLogThresholdMs_default = 1000;
  28627.     public int getTransazioniRegistrazioneSlowLogThresholdMs() {    
  28628.         if(this.getTransazioniRegistrazioneSlowLogThresholdMs==null){
  28629.             String pName = "org.openspcoop2.pdd.transazioni.slowLog.thresholdMs";
  28630.             try{ 
  28631.                 String name = null;
  28632.                 name = this.reader.getValueConvertEnvProperties(pName);
  28633.                 if(name==null){
  28634.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,this.getTransazioniRegistrazioneSlowLogThresholdMs_default));
  28635.                     name=""+this.getTransazioniRegistrazioneSlowLogThresholdMs_default;
  28636.                 }
  28637.                 name = name.trim();
  28638.                 this.getTransazioniRegistrazioneSlowLogThresholdMs = Integer.valueOf(name);
  28639.             } catch(java.lang.Exception e) {
  28640.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+this.getTransazioniRegistrazioneSlowLogThresholdMs_default+" : "+e.getMessage(),e);
  28641.                 this.getTransazioniRegistrazioneSlowLogThresholdMs = this.getTransazioniRegistrazioneSlowLogThresholdMs_default;
  28642.             }    
  28643.         }

  28645.         return this.getTransazioniRegistrazioneSlowLogThresholdMs;
  28646.     }
  28647.     
  28648.     private Boolean isTransazioniRegistrazioneSlowLogBuildTransactionDetails = null;
  28649.     public boolean isTransazioniRegistrazioneSlowLogBuildTransactionDetails() { 
  28650.         if(this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails==null){
  28651.             String pName = "org.openspcoop2.pdd.transazioni.slowLog.buildTransactionDetails.enabled";
  28652.             try{ 
  28653.                 String name = null;
  28654.                 name = this.reader.getValueConvertEnvProperties(pName);
  28655.                 if(name==null){
  28656.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28657.                     name="false";
  28658.                 }
  28659.                 name = name.trim();
  28660.                 this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails = Boolean.parseBoolean(name);
  28661.             } catch(java.lang.Exception e) {
  28662.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28663.                 this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails = false;
  28664.             }    
  28665.         }

  28667.         return this.isTransazioniRegistrazioneSlowLogBuildTransactionDetails;
  28668.     }
  28669.     
  28670.     private Boolean isTransazioniRegistrazioneSlowLogRateLimitingDetails = null;
  28671.     public boolean isTransazioniRegistrazioneSlowLogRateLimitingDetails() { 
  28672.         if(this.isTransazioniRegistrazioneSlowLogRateLimitingDetails==null){
  28673.             String pName = "org.openspcoop2.pdd.transazioni.slowLog.rateLimitingDetails.enabled";
  28674.             try{ 
  28675.                 String name = null;
  28676.                 name = this.reader.getValueConvertEnvProperties(pName);
  28677.                 if(name==null){
  28678.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28679.                     name="false";
  28680.                 }
  28681.                 name = name.trim();
  28682.                 this.isTransazioniRegistrazioneSlowLogRateLimitingDetails = Boolean.parseBoolean(name);
  28683.             } catch(java.lang.Exception e) {
  28684.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28685.                 this.isTransazioniRegistrazioneSlowLogRateLimitingDetails = false;
  28686.             }    
  28687.         }

  28689.         return this.isTransazioniRegistrazioneSlowLogRateLimitingDetails;
  28690.     }
  28691.     
  28692.     private Boolean isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails = null;
  28693.     public boolean isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails() {   
  28694.         if(this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails==null){
  28695.             String pName = "org.openspcoop2.pdd.transazioni.slowLog.connettoriMultipli.processTransactionSADetails.enabled";
  28696.             try{ 
  28697.                 String name = null;
  28698.                 name = this.reader.getValueConvertEnvProperties(pName);
  28699.                 if(name==null){
  28700.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28701.                     name="false";
  28702.                 }
  28703.                 name = name.trim();
  28704.                 this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails = Boolean.parseBoolean(name);
  28705.             } catch(java.lang.Exception e) {
  28706.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28707.                 this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails = false;
  28708.             }    
  28709.         }

  28711.         return this.isTransazioniRegistrazioneSlowLogConnettoriMultipliProcessTransactionSADetails;
  28712.     }
  28713.     
  28714.     private Boolean isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails = null;
  28715.     public boolean isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails() {  
  28716.         if(this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails==null){
  28717.             String pName = "org.openspcoop2.pdd.transazioni.slowLog.connettoriMultipli.updateTransactionDetails.enabled";
  28718.             try{ 
  28719.                 String name = null;
  28720.                 name = this.reader.getValueConvertEnvProperties(pName);
  28721.                 if(name==null){
  28722.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28723.                     name="false";
  28724.                 }
  28725.                 name = name.trim();
  28726.                 this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails = Boolean.parseBoolean(name);
  28727.             } catch(java.lang.Exception e) {
  28728.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  28729.                 this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails = false;
  28730.             }    
  28731.         }

  28733.         return this.isTransazioniRegistrazioneSlowLogConnettoriMultipliUpdateTransactionDetails;
  28734.     }
  28735.     
  28736.     
  28737.     // TracciamentoDB

  28739.     private Boolean isTransazioniTracciamentoDBOutRequestThrowRequestException = null;
  28740.     public boolean isTransazioniTracciamentoDBOutRequestThrowRequestException() {   
  28741.         if(this.isTransazioniTracciamentoDBOutRequestThrowRequestException==null){
  28742.             String pName = "org.openspcoop2.pdd.transazioni.tracciamentoDB.outRequest.throwRequestException";
  28743.             try{ 
  28744.                 String name = null;
  28745.                 name = this.reader.getValueConvertEnvProperties(pName);
  28746.                 if(name==null){
  28747.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28748.                     name="true";
  28749.                 }
  28750.                 name = name.trim();
  28751.                 this.isTransazioniTracciamentoDBOutRequestThrowRequestException = Boolean.parseBoolean(name);
  28752.             } catch(java.lang.Exception e) {
  28753.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28754.                 this.isTransazioniTracciamentoDBOutRequestThrowRequestException = true;
  28755.             }    
  28756.         }

  28758.         return this.isTransazioniTracciamentoDBOutRequestThrowRequestException;
  28759.     }
  28760.     
  28761.     private Boolean isTransazioniTracciamentoDBOutResponseThrowRequestException = null;
  28762.     public boolean isTransazioniTracciamentoDBOutResponseThrowRequestException() {  
  28763.         if(this.isTransazioniTracciamentoDBOutResponseThrowRequestException==null){
  28764.             String pName = "org.openspcoop2.pdd.transazioni.tracciamentoDB.outResponse.throwRequestException";
  28765.             try{ 
  28766.                 String name = null;
  28767.                 name = this.reader.getValueConvertEnvProperties(pName);
  28768.                 if(name==null){
  28769.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28770.                     name="true";
  28771.                 }
  28772.                 name = name.trim();
  28773.                 this.isTransazioniTracciamentoDBOutResponseThrowRequestException = Boolean.parseBoolean(name);
  28774.             } catch(java.lang.Exception e) {
  28775.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28776.                 this.isTransazioniTracciamentoDBOutResponseThrowRequestException = true;
  28777.             }    
  28778.         }

  28780.         return this.isTransazioniTracciamentoDBOutResponseThrowRequestException;
  28781.     }
  28782.     
  28783.     private Boolean isTransazioniTracciamentoDBPostOutResponseThrowRequestException = null;
  28784.     public boolean isTransazioniTracciamentoDBPostOutResponseThrowRequestException() {  
  28785.         if(this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException==null){
  28786.             String pName = "org.openspcoop2.pdd.transazioni.tracciamentoDB.postOutResponse.throwRequestException";
  28787.             try{ 
  28788.                 String name = null;
  28789.                 name = this.reader.getValueConvertEnvProperties(pName);
  28790.                 if(name==null){
  28791.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28792.                     name="true";
  28793.                 }
  28794.                 name = name.trim();
  28795.                 this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException = Boolean.parseBoolean(name);
  28796.             } catch(java.lang.Exception e) {
  28797.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28798.                 this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException = true;
  28799.             }    
  28800.         }

  28802.         return this.isTransazioniTracciamentoDBPostOutResponseThrowRequestException;
  28803.     }
  28804.     
  28805.     private Boolean isTransazioniTracciamentoDBPostOutResponseThrowResponseException = null;
  28806.     public boolean isTransazioniTracciamentoDBPostOutResponseThrowResponseException() { 
  28807.         if(this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException==null){
  28808.             String pName = "org.openspcoop2.pdd.transazioni.tracciamentoDB.postOutResponse.throwResponseException";
  28809.             try{ 
  28810.                 String name = null;
  28811.                 name = this.reader.getValueConvertEnvProperties(pName);
  28812.                 if(name==null){
  28813.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  28814.                     name="true";
  28815.                 }
  28816.                 name = name.trim();
  28817.                 this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException = Boolean.parseBoolean(name);
  28818.             } catch(java.lang.Exception e) {
  28819.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  28820.                 this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException = true;
  28821.             }    
  28822.         }

  28824.         return this.isTransazioniTracciamentoDBPostOutResponseThrowResponseException;
  28825.     }
  28826.     
  28827.     
  28828.     // Gestione PurposeId
  28829.     
  28830.     private Boolean isTransazioniPolicyValidazioneSavePurposeIdAlways = null;
  28831.     public boolean isTransazioniPolicyValidazioneSavePurposeIdAlways() {    
  28832.         if(this.isTransazioniPolicyValidazioneSavePurposeIdAlways==null){
  28833.             String pName = "org.openspcoop2.pdd.transazioni.policy.validazione.savePurposeId.always";
  28834.             try{ 
  28835.                 String name = null;
  28836.                 name = this.reader.getValueConvertEnvProperties(pName);
  28837.                 if(name==null){
  28838.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28839.                     name="false";
  28840.                 }
  28841.                 name = name.trim();
  28842.                 this.isTransazioniPolicyValidazioneSavePurposeIdAlways = Boolean.parseBoolean(name);
  28843.             } catch(java.lang.Exception e) {
  28844.                 this.logError(getMessaggioProprietaNonImpostata(pName,e,false));
  28845.                 this.isTransazioniPolicyValidazioneSavePurposeIdAlways = false;
  28846.             }    
  28847.         }

  28849.         return this.isTransazioniPolicyValidazioneSavePurposeIdAlways;
  28850.     }
  28851.     
  28852.     private Boolean isTransazioniPolicyNegoziazioneSavePurposeIdAlways = null;
  28853.     public boolean isTransazioniPolicyNegoziazioneSavePurposeIdAlways() {   
  28854.         if(this.isTransazioniPolicyNegoziazioneSavePurposeIdAlways==null){
  28855.             String pName = "org.openspcoop2.pdd.transazioni.policy.negoziazione.savePurposeId.always";
  28856.             try{ 
  28857.                 String name = null;
  28858.                 name = this.reader.getValueConvertEnvProperties(pName);
  28859.                 if(name==null){
  28860.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  28861.                     name="false";
  28862.                 }
  28863.                 name = name.trim();
  28864.                 this.isTransazioniPolicyNegoziazioneSavePurposeIdAlways = Boolean.parseBoolean(name);
  28865.             } catch(java.lang.Exception e) {
  28866.                 this.logError(getMessaggioProprietaNonImpostata(pName,e,false));
  28867.                 this.isTransazioniPolicyNegoziazioneSavePurposeIdAlways = false;
  28868.             }    
  28869.         }

  28871.         return this.isTransazioniPolicyNegoziazioneSavePurposeIdAlways;
  28872.     }
  28873.     
  28874.     
  28875.     // FiltroDuplicati
  28876.     
  28877.     private Boolean isTransazioniFiltroDuplicatiSaveDateEnabled = null;
  28878.     private boolean _isTransazioniFiltroDuplicatiSaveDateEnabled() throws ProtocolException {   
  28879.         if(this.isTransazioniFiltroDuplicatiSaveDateEnabled==null){
  28880.             try{ 
  28881.                 String name = null;
  28882.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.duplicati.dateIdentificativiProtocolloInCampiSeparati");
  28883.                 if(name==null){
  28884.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.dateIdentificativiProtocolloInCampiSeparati' non impostata, viene utilizzato il default=true");
  28885.                     name="true";
  28886.                 }
  28887.                 name = name.trim();
  28888.                 this.isTransazioniFiltroDuplicatiSaveDateEnabled = Boolean.parseBoolean(name);
  28889.             } catch(java.lang.Exception e) {
  28890.                 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);
  28891.                 this.isTransazioniFiltroDuplicatiSaveDateEnabled = true;
  28892.             }    
  28893.         }

  28895.         return this.isTransazioniFiltroDuplicatiSaveDateEnabled;
  28896.     }
  28897.     public boolean isTransazioniFiltroDuplicatiSaveDateEnabled(IProtocolFactory<?> protocolFactory) throws ProtocolException {  
  28898.         return _isTransazioniFiltroDuplicatiSaveDateEnabled() && protocolFactory.createProtocolConfiguration().isDataPresenteInIdentificativoMessaggio();
  28899.     }
  28900.     
  28901.     private Boolean isTransazioniFiltroDuplicatiTramiteTransazioniEnabled = null;
  28902.     public boolean isTransazioniFiltroDuplicatiTramiteTransazioniEnabled() {    
  28903.         if(this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled==null){
  28904.             try{ 
  28905.                 String name = null;
  28906.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.enabled");
  28907.                 if(name==null){
  28908.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.enabled' non impostata, viene utilizzato il default=true");
  28909.                     name="true";
  28910.                 }
  28911.                 name = name.trim();
  28912.                 this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled = Boolean.parseBoolean(name);
  28913.             } catch(java.lang.Exception e) {
  28914.                 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);
  28915.                 this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled = true;
  28916.             }    
  28917.         }

  28919.         return this.isTransazioniFiltroDuplicatiTramiteTransazioniEnabled;
  28920.     }
  28921.     
  28922.     private Boolean isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection = null;
  28923.     public boolean isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection() {   
  28924.         if(this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection==null){
  28925.             try{ 
  28926.                 String name = null;
  28927.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.usePdDConnection");
  28928.                 if(name==null){
  28929.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.usePdDConnection' non impostata, viene utilizzato il default=true");
  28930.                     name="true";
  28931.                 }
  28932.                 name = name.trim();
  28933.                 this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection = Boolean.parseBoolean(name);
  28934.             } catch(java.lang.Exception e) {
  28935.                 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);
  28936.                 this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection = true;
  28937.             }    
  28938.         }

  28940.         return this.isTransazioniFiltroDuplicatiTramiteTransazioniUsePdDConnection;
  28941.     }
  28942.     
  28943.     private Boolean isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex = null;
  28944.     public boolean isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex() { 
  28945.         if(this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex==null){
  28946.             try{ 
  28947.                 String name = null;
  28948.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.forceIndex");
  28949.                 if(name==null){
  28950.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.duplicati.filtroTramiteTransazioni.forceIndex' non impostata, viene utilizzato il default=false");
  28951.                     name="false";
  28952.                 }
  28953.                 name = name.trim();
  28954.                 this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex = Boolean.parseBoolean(name);
  28955.             } catch(java.lang.Exception e) {
  28956.                 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);
  28957.                 this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex = false;
  28958.             }    
  28959.         }

  28961.         return this.isTransazioniFiltroDuplicatiTramiteTransazioniForceIndex;
  28962.     }
  28963.     
  28964.     
  28965.     // Stateful
  28966.     
  28967.     private Boolean isTransazioniStatefulEnabled = null;
  28968.     public boolean isTransazioniStatefulEnabled() { 
  28969.         if(this.isTransazioniStatefulEnabled==null){
  28970.             try{ 
  28971.                 String name = null;
  28972.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.stateful.enabled");
  28973.                 if(name==null){
  28974.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.stateful.enabled' non impostata, viene utilizzato il default=true");
  28975.                     name="true";
  28976.                 }
  28977.                 name = name.trim();
  28978.                 this.isTransazioniStatefulEnabled = Boolean.parseBoolean(name);
  28979.             } catch(java.lang.Exception e) {
  28980.                 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);
  28981.                 this.isTransazioniStatefulEnabled = true;
  28982.             }    
  28983.         }

  28985.         return this.isTransazioniStatefulEnabled;
  28986.     }
  28987.     
  28988.     private Boolean isTransazioniStatefulDebug = null;
  28989.     public boolean isTransazioniStatefulDebug() {   
  28990.         if(this.isTransazioniStatefulDebug==null){
  28991.             try{ 
  28992.                 String name = null;
  28993.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.stateful.debug");
  28994.                 if(name==null){
  28995.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.stateful.debug' non impostata, viene utilizzato il default=true");
  28996.                     name="true";
  28997.                 }
  28998.                 name = name.trim();
  28999.                 this.isTransazioniStatefulDebug = Boolean.parseBoolean(name);
  29000.             } catch(java.lang.Exception e) {
  29001.                 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);
  29002.                 this.isTransazioniStatefulDebug = true;
  29003.             }    
  29004.         }

  29006.         return this.isTransazioniStatefulDebug;
  29007.     }
  29008.     
  29009.     private Integer getTransazioniStatefulTimerIntervalSeconds = null;
  29010.     public int getTransazioniStatefulTimerIntervalSeconds() throws CoreException {  
  29011.         if(this.getTransazioniStatefulTimerIntervalSeconds==null){
  29012.             try{ 
  29013.                 String name = null;
  29014.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.stateful.seconds");
  29015.                 if(name==null){
  29016.                     throw new CoreException("Proprieta' non impostata");
  29017.                 }
  29018.                 name = name.trim();
  29019.                 this.getTransazioniStatefulTimerIntervalSeconds = Integer.valueOf(name);
  29020.             } catch(java.lang.Exception e) {
  29021.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.stateful.seconds': "+e.getMessage(),e);
  29022.                 throw new CoreException(e.getMessage(),e);
  29023.             }    
  29024.         }

  29026.         return this.getTransazioniStatefulTimerIntervalSeconds;
  29027.     }
  29028.     
  29029.     
  29030.     // Salvataggio
  29031.     
  29032.     private Integer getTransazioniCredenzialiMittenteMaxLength = null;
  29033.     public int getTransazioniCredenzialiMittenteMaxLength() throws CoreException {  
  29034.         if(this.getTransazioniCredenzialiMittenteMaxLength==null){
  29035.             try{ 
  29036.                 String name = null;
  29037.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.credenzialiMittente.maxLength");
  29038.                 if(name==null){
  29039.                     throw new CoreException("Proprieta' non impostata");
  29040.                 }
  29041.                 name = name.trim();
  29042.                 this.getTransazioniCredenzialiMittenteMaxLength = Integer.valueOf(name);
  29043.             } catch(java.lang.Exception e) {
  29044.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.credenzialiMittente.maxLength': "+e.getMessage(),e);
  29045.                 throw new CoreException(e.getMessage(),e);
  29046.             }    
  29047.         }

  29049.         return this.getTransazioniCredenzialiMittenteMaxLength;
  29050.     }
  29051.     
  29052.     private Boolean getTransazioniCredenzialiMittenteLifeSeconds_read = null;
  29053.     private Integer getTransazioniCredenzialiMittenteLifeSeconds = null;
  29054.     public Integer getTransazioniCredenzialiMittenteLifeSeconds() throws CoreException {    
  29055.         if(this.getTransazioniCredenzialiMittenteLifeSeconds_read==null){
  29056.             try{ 
  29057.                 String name = null;
  29058.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.credenzialiMittente.updateAfterSeconds");
  29059.                 if(name==null){
  29060.                     throw new CoreException("Proprieta' non impostata");
  29061.                 }
  29062.                 name = name.trim();
  29063.                 this.getTransazioniCredenzialiMittenteLifeSeconds = Integer.valueOf(name);
  29064.             } catch(java.lang.Exception e) {
  29065.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.credenzialiMittente.updateAfterSeconds': "+e.getMessage(),e);
  29066.                 throw new CoreException(e.getMessage(),e);
  29067.             }    
  29068.             
  29069.             this.getTransazioniCredenzialiMittenteLifeSeconds_read = true;
  29070.         }

  29072.         return this.getTransazioniCredenzialiMittenteLifeSeconds;
  29073.     }
  29074.     
  29075.     private Boolean isTransazioniRegistrazioneTracceProtocolPropertiesEnabled = null;
  29076.     public boolean isTransazioniRegistrazioneTracceProtocolPropertiesEnabled() {    
  29077.         if(this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled==null){
  29078.             try{ 
  29079.                 String name = null;
  29080.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.protocolProperties.enabled");
  29081.                 if(name==null){
  29082.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.protocolProperties.enabled' non impostata, viene utilizzato il default=false");
  29083.                     name="false";
  29084.                 }
  29085.                 name = name.trim();
  29086.                 this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled = Boolean.parseBoolean(name);
  29087.             } catch(java.lang.Exception e) {
  29088.                 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);
  29089.                 this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled = false;
  29090.             }    
  29091.         }

  29093.         return this.isTransazioniRegistrazioneTracceProtocolPropertiesEnabled;
  29094.     }
  29095.     
  29096.     private Boolean isTransazioniRegistrazioneTracceHeaderRawEnabled = null;
  29097.     public boolean isTransazioniRegistrazioneTracceHeaderRawEnabled() { 
  29098.         if(this.isTransazioniRegistrazioneTracceHeaderRawEnabled==null){
  29099.             try{ 
  29100.                 String name = null;
  29101.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.headerRaw.enabled");
  29102.                 if(name==null){
  29103.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.headerRaw.enabled' non impostata, viene utilizzato il default=false");
  29104.                     name="false";
  29105.                 }
  29106.                 name = name.trim();
  29107.                 this.isTransazioniRegistrazioneTracceHeaderRawEnabled = Boolean.parseBoolean(name);
  29108.             } catch(java.lang.Exception e) {
  29109.                 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);
  29110.                 this.isTransazioniRegistrazioneTracceHeaderRawEnabled = false;
  29111.             }    
  29112.         }

  29114.         return this.isTransazioniRegistrazioneTracceHeaderRawEnabled;
  29115.     }
  29116.     
  29117.     private Boolean isTransazioniRegistrazioneTracceDigestEnabled = null;
  29118.     public boolean isTransazioniRegistrazioneTracceDigestEnabled() {    
  29119.         if(this.isTransazioniRegistrazioneTracceDigestEnabled==null){
  29120.             try{ 
  29121.                 String name = null;
  29122.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.digest.enabled");
  29123.                 if(name==null){
  29124.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.digest.enabled' non impostata, viene utilizzato il default=false");
  29125.                     name="false";
  29126.                 }
  29127.                 name = name.trim();
  29128.                 this.isTransazioniRegistrazioneTracceDigestEnabled = Boolean.parseBoolean(name);
  29129.             } catch(java.lang.Exception e) {
  29130.                 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);
  29131.                 this.isTransazioniRegistrazioneTracceDigestEnabled = false;
  29132.             }    
  29133.         }

  29135.         return this.isTransazioniRegistrazioneTracceDigestEnabled;
  29136.     }
  29137.     
  29138.     private ISalvataggioTracceManager getTransazioniRegistrazioneTracceManager = null;
  29139.     private Boolean getTransazioniRegistrazioneTracceManager_read = null;
  29140.     public ISalvataggioTracceManager getTransazioniRegistrazioneTracceManager() throws CoreException {  
  29141.         return this.getTransazioniRegistrazioneTracceManager;
  29142.     }
  29143.     private ISalvataggioTracceManager _getTransazioniRegistrazioneTracceManager(ClassNameProperties className, Loader loader) throws CoreException {    
  29144.         if(this.getTransazioniRegistrazioneTracceManager_read==null){
  29145.             try{ 
  29146.                 String name = null;
  29147.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.tracce.salvataggio");
  29148.                 if(name!=null){
  29149.                     name = name.trim();
  29150.                     
  29151.                     String classe = className.getSalvataggioTracceManager(name);
  29152.                     if(classe == null) {
  29153.                         throw new CoreException("Classe non trovata per il salvataggio delle tracce con tipo '"+name+"'");
  29154.                     }
  29155.                     
  29156.                     this.getTransazioniRegistrazioneTracceManager = (ISalvataggioTracceManager) loader.newInstance(classe);
  29157.                 }
  29158.                 
  29159.                 this.getTransazioniRegistrazioneTracceManager_read = true;
  29160.                 
  29161.             } catch(java.lang.Exception e) {
  29162.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.tracce.salvataggio': "+e.getMessage(),e);
  29163.                 throw new CoreException(e.getMessage(),e);
  29164.             }    
  29165.         }

  29167.         return this.getTransazioniRegistrazioneTracceManager;
  29168.     }
  29169.     
  29170.     private ISalvataggioDiagnosticiManager getTransazioniRegistrazioneDiagnosticiManager = null;
  29171.     private Boolean getTransazioniRegistrazioneDiagnosticiManager_read = null;
  29172.     public ISalvataggioDiagnosticiManager getTransazioniRegistrazioneDiagnosticiManager() throws CoreException {    
  29173.         return this.getTransazioniRegistrazioneDiagnosticiManager;
  29174.     }
  29175.     private ISalvataggioDiagnosticiManager _getTransazioniRegistrazioneDiagnosticiManager(ClassNameProperties className, Loader loader) throws CoreException {  
  29176.         if(this.getTransazioniRegistrazioneDiagnosticiManager_read==null){
  29177.             try{ 
  29178.                 String name = null;
  29179.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.diagnostici.salvataggio");
  29180.                 if(name!=null){
  29181.                     name = name.trim();
  29182.                     
  29183.                     String classe = className.getSalvataggioDiagnosticiManager(name);
  29184.                     if(classe == null) {
  29185.                         throw new CoreException("Classe non trovata per il salvataggio dei diagnostici con tipo '"+name+"'");
  29186.                     }
  29187.                     
  29188.                     this.getTransazioniRegistrazioneDiagnosticiManager = (ISalvataggioDiagnosticiManager) loader.newInstance(classe);
  29189.                 }
  29190.                 
  29191.                 this.getTransazioniRegistrazioneDiagnosticiManager_read = true;
  29192.                 
  29193.             } catch(java.lang.Exception e) {
  29194.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.diagnostici.salvataggio': "+e.getMessage(),e);
  29195.                 throw new CoreException(e.getMessage(),e);
  29196.             }    
  29197.         }

  29199.         return this.getTransazioniRegistrazioneDiagnosticiManager;
  29200.     }
  29201.     
  29202.     private Boolean isTransazioniRegistrazioneDumpHeadersCompactEnabled = null;
  29203.     public boolean isTransazioniRegistrazioneDumpHeadersCompactEnabled() {  
  29204.         if(this.isTransazioniRegistrazioneDumpHeadersCompactEnabled==null){
  29205.             try{ 
  29206.                 String name = null;
  29207.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.transazioni.dump.headers.compact.enabled");
  29208.                 if(name==null){
  29209.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.transazioni.dump.headers.compact.enabled' non impostata, viene utilizzato il default=false");
  29210.                     name="false";
  29211.                 }
  29212.                 name = name.trim();
  29213.                 this.isTransazioniRegistrazioneDumpHeadersCompactEnabled = Boolean.parseBoolean(name);
  29214.             } catch(java.lang.Exception e) {
  29215.                 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);
  29216.                 this.isTransazioniRegistrazioneDumpHeadersCompactEnabled = false;
  29217.             }    
  29218.         }

  29220.         return this.isTransazioniRegistrazioneDumpHeadersCompactEnabled;
  29221.     }
  29222.     
  29223.     // Trace su File
  29224.     
  29225.     private Boolean isTransazioniFileTraceEnabled = null;
  29226.     public boolean isTransazioniFileTraceEnabled() {    
  29227.         if(this.isTransazioniFileTraceEnabled==null){
  29228.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.enabled";
  29229.             try{ 
  29230.                 String name = null;
  29231.                 name = this.reader.getValueConvertEnvProperties(pName);
  29232.                 if(name==null){
  29233.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  29234.                     name="false";
  29235.                 }
  29236.                 name = name.trim();
  29237.                 this.isTransazioniFileTraceEnabled = Boolean.parseBoolean(name);
  29238.             } catch(java.lang.Exception e) {
  29239.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  29240.                 this.isTransazioniFileTraceEnabled = false;
  29241.             }    
  29242.         }

  29244.         return this.isTransazioniFileTraceEnabled;
  29245.     }
  29246.     
  29247.     private Boolean isTransazioniFileTraceDumpBinarioPDEnabled = null;
  29248.     public boolean isTransazioniFileTraceDumpBinarioPDEnabled() {   
  29249.         if(this.isTransazioniFileTraceDumpBinarioPDEnabled==null){
  29250.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.enabled";
  29251.             try{ 
  29252.                 String name = null;
  29253.                 name = this.reader.getValueConvertEnvProperties(pName);
  29254.                 if(name==null){
  29255.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  29256.                     name="false";
  29257.                 }
  29258.                 name = name.trim();
  29259.                 this.isTransazioniFileTraceDumpBinarioPDEnabled = Boolean.parseBoolean(name);
  29260.             } catch(java.lang.Exception e) {
  29261.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  29262.                 this.isTransazioniFileTraceDumpBinarioPDEnabled = false;
  29263.             }    
  29264.         }

  29266.         return this.isTransazioniFileTraceDumpBinarioPDEnabled;
  29267.     }
  29268.     private Boolean isTransazioniFileTraceDumpBinarioPDPayloadEnabled = null;
  29269.     public boolean isTransazioniFileTraceDumpBinarioPDPayloadEnabled() {    
  29270.         if(this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled==null){
  29271.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.payload.enabled";
  29272.             try{ 
  29273.                 String name = null;
  29274.                 name = this.reader.getValueConvertEnvProperties(pName);
  29275.                 if(name==null || "".equals(name)){
  29276.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPDEnabled()));
  29277.                     name=""+isTransazioniFileTraceDumpBinarioPDEnabled();
  29278.                 }
  29279.                 name = name.trim();
  29280.                 this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled = Boolean.parseBoolean(name);
  29281.             } catch(java.lang.Exception e) {
  29282.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPDEnabled()+" : "+e.getMessage(),e);
  29283.                 this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled = isTransazioniFileTraceDumpBinarioPDEnabled();
  29284.             }    
  29285.         }

  29287.         return this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled;
  29288.     }
  29289.     private Boolean isTransazioniFileTraceDumpBinarioPDHeadersEnabled = null;
  29290.     public boolean isTransazioniFileTraceDumpBinarioPDHeadersEnabled() {    
  29291.         if(this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled==null){
  29292.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.headers.enabled";
  29293.             try{ 
  29294.                 String name = null;
  29295.                 name = this.reader.getValueConvertEnvProperties(pName);
  29296.                 if(name==null || "".equals(name)){
  29297.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPDEnabled()));
  29298.                     name=""+isTransazioniFileTraceDumpBinarioPDEnabled();
  29299.                 }
  29300.                 name = name.trim();
  29301.                 this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled = Boolean.parseBoolean(name);
  29302.             } catch(java.lang.Exception e) {
  29303.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPDEnabled()+" : "+e.getMessage(),e);
  29304.                 this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled = isTransazioniFileTraceDumpBinarioPDEnabled();
  29305.             }    
  29306.         }

  29308.         return this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled;
  29309.     }
  29310.     
  29311.     private Boolean isTransazioniFileTraceDumpBinarioPDConnettoreEnabled = null;
  29312.     public boolean isTransazioniFileTraceDumpBinarioPDConnettoreEnabled() { 
  29313.         if(this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled==null){
  29314.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.connettore.enabled";
  29315.             try{ 
  29316.                 String name = null;
  29317.                 name = this.reader.getValueConvertEnvProperties(pName);
  29318.                 if(name==null){
  29319.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  29320.                     name="false";
  29321.                 }
  29322.                 name = name.trim();
  29323.                 this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled = Boolean.parseBoolean(name);
  29324.             } catch(java.lang.Exception e) {
  29325.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  29326.                 this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled = false;
  29327.             }    
  29328.         }

  29330.         return this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled;
  29331.     }
  29332.     private Boolean isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled = null;
  29333.     public boolean isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled() {  
  29334.         if(this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled==null){
  29335.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.connettore.payload.enabled";
  29336.             try{ 
  29337.                 String name = null;
  29338.                 name = this.reader.getValueConvertEnvProperties(pName);
  29339.                 if(name==null || "".equals(name)){
  29340.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()));
  29341.                     name=""+isTransazioniFileTraceDumpBinarioPDConnettoreEnabled();
  29342.                 }
  29343.                 name = name.trim();
  29344.                 this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled = Boolean.parseBoolean(name);
  29345.             } catch(java.lang.Exception e) {
  29346.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()+" : "+e.getMessage(),e);
  29347.                 this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled = isTransazioniFileTraceDumpBinarioPDConnettoreEnabled();
  29348.             }    
  29349.         }

  29351.         return this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled;
  29352.     }
  29353.     private Boolean isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled = null;
  29354.     public boolean isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled() {  
  29355.         if(this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled==null){
  29356.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPD.connettore.headers.enabled";
  29357.             try{ 
  29358.                 String name = null;
  29359.                 name = this.reader.getValueConvertEnvProperties(pName);
  29360.                 if(name==null || "".equals(name)){
  29361.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()));
  29362.                     name=""+isTransazioniFileTraceDumpBinarioPDConnettoreEnabled();
  29363.                 }
  29364.                 name = name.trim();
  29365.                 this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled = Boolean.parseBoolean(name);
  29366.             } catch(java.lang.Exception e) {
  29367.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()+" : "+e.getMessage(),e);
  29368.                 this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled = isTransazioniFileTraceDumpBinarioPDConnettoreEnabled();
  29369.             }    
  29370.         }

  29372.         return this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled;
  29373.     }
  29374.     
  29375.     private Boolean isTransazioniFileTraceDumpBinarioPAEnabled = null;
  29376.     public boolean isTransazioniFileTraceDumpBinarioPAEnabled() {   
  29377.         if(this.isTransazioniFileTraceDumpBinarioPAEnabled==null){
  29378.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.enabled";
  29379.             try{ 
  29380.                 String name = null;
  29381.                 name = this.reader.getValueConvertEnvProperties(pName);
  29382.                 if(name==null){
  29383.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  29384.                     name="false";
  29385.                 }
  29386.                 name = name.trim();
  29387.                 this.isTransazioniFileTraceDumpBinarioPAEnabled = Boolean.parseBoolean(name);
  29388.             } catch(java.lang.Exception e) {
  29389.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  29390.                 this.isTransazioniFileTraceDumpBinarioPAEnabled = false;
  29391.             }    
  29392.         }

  29394.         return this.isTransazioniFileTraceDumpBinarioPAEnabled;
  29395.     }
  29396.     private Boolean isTransazioniFileTraceDumpBinarioPAPayloadEnabled = null;
  29397.     public boolean isTransazioniFileTraceDumpBinarioPAPayloadEnabled() {    
  29398.         if(this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled==null){
  29399.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.payload.enabled";
  29400.             try{ 
  29401.                 String name = null;
  29402.                 name = this.reader.getValueConvertEnvProperties(pName);
  29403.                 if(name==null || "".equals(name)){
  29404.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPAEnabled()));
  29405.                     name=""+isTransazioniFileTraceDumpBinarioPAEnabled();
  29406.                 }
  29407.                 name = name.trim();
  29408.                 this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled = Boolean.parseBoolean(name);
  29409.             } catch(java.lang.Exception e) {
  29410.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPAEnabled()+" : "+e.getMessage(),e);
  29411.                 this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled = isTransazioniFileTraceDumpBinarioPAEnabled();
  29412.             }    
  29413.         }

  29415.         return this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled;
  29416.     }
  29417.     private Boolean isTransazioniFileTraceDumpBinarioPAHeadersEnabled = null;
  29418.     public boolean isTransazioniFileTraceDumpBinarioPAHeadersEnabled() {    
  29419.         if(this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled==null){
  29420.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.headers.enabled";
  29421.             try{ 
  29422.                 String name = null;
  29423.                 name = this.reader.getValueConvertEnvProperties(pName);
  29424.                 if(name==null || "".equals(name)){
  29425.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPAEnabled()));
  29426.                     name=""+isTransazioniFileTraceDumpBinarioPAEnabled();
  29427.                 }
  29428.                 name = name.trim();
  29429.                 this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled = Boolean.parseBoolean(name);
  29430.             } catch(java.lang.Exception e) {
  29431.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPAEnabled()+" : "+e.getMessage(),e);
  29432.                 this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled = isTransazioniFileTraceDumpBinarioPAEnabled();
  29433.             }    
  29434.         }

  29436.         return this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled;
  29437.     }

  29439.     
  29440.     private Boolean isTransazioniFileTraceDumpBinarioPAConnettoreEnabled = null;
  29441.     public boolean isTransazioniFileTraceDumpBinarioPAConnettoreEnabled() { 
  29442.         if(this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled==null){
  29443.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.connettore.enabled";
  29444.             try{ 
  29445.                 String name = null;
  29446.                 name = this.reader.getValueConvertEnvProperties(pName);
  29447.                 if(name==null){
  29448.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  29449.                     name="false";
  29450.                 }
  29451.                 name = name.trim();
  29452.                 this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled = Boolean.parseBoolean(name);
  29453.             } catch(java.lang.Exception e) {
  29454.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  29455.                 this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled = false;
  29456.             }    
  29457.         }

  29459.         return this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled;
  29460.     }
  29461.     private Boolean isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled = null;
  29462.     public boolean isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled() {  
  29463.         if(this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled==null){
  29464.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.connettore.payload.enabled";
  29465.             try{ 
  29466.                 String name = null;
  29467.                 name = this.reader.getValueConvertEnvProperties(pName);
  29468.                 if(name==null || "".equals(name)){
  29469.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()));
  29470.                     name=""+isTransazioniFileTraceDumpBinarioPAConnettoreEnabled();
  29471.                 }
  29472.                 name = name.trim();
  29473.                 this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled = Boolean.parseBoolean(name);
  29474.             } catch(java.lang.Exception e) {
  29475.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()+" : "+e.getMessage(),e);
  29476.                 this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled = isTransazioniFileTraceDumpBinarioPAConnettoreEnabled();
  29477.             }    
  29478.         }

  29480.         return this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled;
  29481.     }
  29482.     private Boolean isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled = null;
  29483.     public boolean isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled() {  
  29484.         if(this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled==null){
  29485.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinarioPA.connettore.headers.enabled";
  29486.             try{ 
  29487.                 String name = null;
  29488.                 name = this.reader.getValueConvertEnvProperties(pName);
  29489.                 if(name==null || "".equals(name)){
  29490.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()));
  29491.                     name=""+isTransazioniFileTraceDumpBinarioPAConnettoreEnabled();
  29492.                 }
  29493.                 name = name.trim();
  29494.                 this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled = Boolean.parseBoolean(name);
  29495.             } catch(java.lang.Exception e) {
  29496.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()+" : "+e.getMessage(),e);
  29497.                 this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled = isTransazioniFileTraceDumpBinarioPAConnettoreEnabled();
  29498.             }    
  29499.         }

  29501.         return this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled;
  29502.     }
  29503.     
  29504.     private Boolean isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase = null;
  29505.     public boolean isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase() {  
  29506.         if(this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase==null){
  29507.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.dumpBinario.releaseInLastTrackingPhase";
  29508.             try{ 
  29509.                 String name = null;
  29510.                 name = this.reader.getValueConvertEnvProperties(pName);
  29511.                 if(name==null || "".equals(name)){
  29512.                     this.logDebug(getMessaggioProprietaNonImpostata(pName,true));
  29513.                     name=""+true;
  29514.                 }
  29515.                 name = name.trim();
  29516.                 this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase = Boolean.parseBoolean(name);
  29517.             } catch(java.lang.Exception e) {
  29518.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+true+" : "+e.getMessage(),e);
  29519.                 this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase = true;
  29520.             }    
  29521.         }

  29523.         return this.isTransazioniFileTraceDumpBinarioReleaseInLastTrackingPhase;
  29524.     }

  29526.     private File getTransazioniFileTraceConfig = null;
  29527.     public File getTransazioniFileTraceConfig() throws CoreException {  
  29528.         if(this.getTransazioniFileTraceConfig==null){
  29529.             String pName = "org.openspcoop2.pdd.transazioni.fileTrace.config";
  29530.             try{ 
  29531.                 String name = null;
  29532.                 name = this.reader.getValueConvertEnvProperties(pName);
  29533.                 if(name==null){
  29534.                     throw new CoreException("Proprieta' non impostata");
  29535.                 }
  29536.                 name = name.trim();
  29537.                 
  29538.                 this.getTransazioniFileTraceConfig = ConfigurazioneTracciamento.toFileTraceConfig(name, this.getRootDirectory(), false);
  29539.                 
  29540.             } catch(java.lang.Exception e) {
  29541.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  29542.                 throw new CoreException(e.getMessage(),e);
  29543.             }    
  29544.         }

  29546.         return this.getTransazioniFileTraceConfig;
  29547.     }
  29548.     
  29549.     public FileTraceGovWayState getFileTraceGovWayState() {
  29550.         FileTraceGovWayState state = new FileTraceGovWayState();
  29551.         state.setEnabled(this.isTransazioniFileTraceEnabled());
  29552.         if(state.isEnabled()) {
  29553.             try {
  29554.                 state.setPath(this.getTransazioniFileTraceConfig().getAbsolutePath());
  29555.             }catch(Exception e) {
  29556.                 state.setPath("ERROR: "+e.getMessage());
  29557.             }
  29558.             state.setEnabledInErogazione(this.isTransazioniFileTraceDumpBinarioPAEnabled());
  29559.             if(this.isTransazioniFileTraceDumpBinarioPAEnabled()) {
  29560.                 state.setEnabledInErogazione_headers(this.isTransazioniFileTraceDumpBinarioPAHeadersEnabled());
  29561.                 state.setEnabledInErogazione_payload(this.isTransazioniFileTraceDumpBinarioPAPayloadEnabled());
  29562.             }
  29563.             
  29564.             state.setEnabledOutErogazione(this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled());
  29565.             if(this.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled()) {
  29566.                 state.setEnabledOutErogazione_headers(this.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled());
  29567.                 state.setEnabledOutErogazione_payload(this.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled());
  29568.             }
  29569.             
  29570.             state.setEnabledInFruizione(this.isTransazioniFileTraceDumpBinarioPDEnabled());
  29571.             if(this.isTransazioniFileTraceDumpBinarioPDEnabled()) {
  29572.                 state.setEnabledInFruizione_headers(this.isTransazioniFileTraceDumpBinarioPDHeadersEnabled());
  29573.                 state.setEnabledInFruizione_payload(this.isTransazioniFileTraceDumpBinarioPDPayloadEnabled());
  29574.             }
  29575.             
  29576.             state.setEnabledOutFruizione(this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled());
  29577.             if(this.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled()) {
  29578.                 state.setEnabledOutFruizione_headers(this.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled());
  29579.                 state.setEnabledOutFruizione_payload(this.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled());
  29580.             }
  29581.         }
  29582.         return state;
  29583.     }
  29584.     
  29585.     
  29586.     /* ------------- Testsuite ---------------------*/
  29587.     
  29588.     private String getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit = null;
  29589.     private Boolean getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommitRead = null;
  29590.     public String getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit() throws CoreException { 
  29591.         if(this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommitRead==null){
  29592.             String pName = "org.openspcoop2.pdd.transazioni.testsuite.manuallyFaultHeader.db.beforeCommit";
  29593.             try{ 
  29594.                 String name = null;
  29595.                 name = this.reader.getValueConvertEnvProperties(pName);
  29596.                 if(name!=null){
  29597.                     name = name.trim();
  29598.                     this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit = name;
  29599.                 }
  29600.             } catch(java.lang.Exception e) {
  29601.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  29602.                 throw new CoreException(e.getMessage(),e);
  29603.             }    
  29604.             this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommitRead=true;
  29605.         }

  29607.         return this.getTransazioniTestsuiteManuallyFaultHeaderDBBeforeCommit;
  29608.     }
  29609.     
  29610.     private String getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog = null;
  29611.     private Boolean getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLogRead = null;
  29612.     public String getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog() throws CoreException { 
  29613.         if(this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLogRead==null){
  29614.             String pName = "org.openspcoop2.pdd.transazioni.testsuite.manuallyFaultHeader.fileTrace.beforeLog";
  29615.             try{ 
  29616.                 String name = null;
  29617.                 name = this.reader.getValueConvertEnvProperties(pName);
  29618.                 if(name!=null){
  29619.                     name = name.trim();
  29620.                     this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog = name;
  29621.                 }
  29622.             } catch(java.lang.Exception e) {
  29623.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  29624.                 throw new CoreException(e.getMessage(),e);
  29625.             }    
  29626.             this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLogRead=true;
  29627.         }

  29629.         return this.getTransazioniTestsuiteManuallyFaultHeaderFileTraceBeforeLog;
  29630.     }
  29631.     
  29632.     /* ------------- Eventi ---------------------*/
  29633.     
  29634.     private Boolean isEventiEnabled = null;
  29635.     public boolean isEventiEnabled() {  
  29636.         if(this.isEventiEnabled==null){
  29637.             try{ 
  29638.                 String name = null;
  29639.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.enabled");
  29640.                 if(name==null){
  29641.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.enabled' non impostata, viene utilizzato il default=true");
  29642.                     name="true";
  29643.                 }
  29644.                 name = name.trim();
  29645.                 this.isEventiEnabled = Boolean.parseBoolean(name);
  29646.             } catch(java.lang.Exception e) {
  29647.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
  29648.                 this.isEventiEnabled = true;
  29649.             }    
  29650.         }

  29652.         return this.isEventiEnabled;
  29653.     }
  29654.     
  29655.     private Boolean isEventiDebug = null;
  29656.     public boolean isEventiDebug() {    
  29657.         if(this.isEventiDebug==null){
  29658.             try{ 
  29659.                 String name = null;
  29660.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.debug");
  29661.                 if(name==null){
  29662.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.debug' non impostata, viene utilizzato il default=true");
  29663.                     name="true";
  29664.                 }
  29665.                 name = name.trim();
  29666.                 this.isEventiDebug = Boolean.parseBoolean(name);
  29667.             } catch(java.lang.Exception e) {
  29668.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.debug', viene utilizzato il default=true : "+e.getMessage(),e);
  29669.                 this.isEventiDebug = true;
  29670.             }    
  29671.         }

  29673.         return this.isEventiDebug;
  29674.     }
  29675.     
  29676.     private Boolean isEventiRegistrazioneStatoPorta = null;
  29677.     public boolean isEventiRegistrazioneStatoPorta() {  
  29678.         if(this.isEventiRegistrazioneStatoPorta==null){
  29679.             try{ 
  29680.                 String name = null;
  29681.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.registraStatoPorta");
  29682.                 if(name==null){
  29683.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.registraStatoPorta' non impostata, viene utilizzato il default=true");
  29684.                     name="true";
  29685.                 }
  29686.                 name = name.trim();
  29687.                 this.isEventiRegistrazioneStatoPorta = Boolean.parseBoolean(name);
  29688.             } catch(java.lang.Exception e) {
  29689.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.registraStatoPorta', viene utilizzato il default=true : "+e.getMessage(),e);
  29690.                 this.isEventiRegistrazioneStatoPorta = true;
  29691.             }    
  29692.         }

  29694.         return this.isEventiRegistrazioneStatoPorta;
  29695.     }
  29696.     
  29697.     private Boolean isEventiTimerEnabled = null;
  29698.     public boolean isEventiTimerEnabled() { 
  29699.         if(this.isEventiTimerEnabled==null){
  29700.             try{ 
  29701.                 String name = null;
  29702.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.timer.enabled");
  29703.                 if(name==null){
  29704.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.timer.enabled' non impostata, viene utilizzato il default=true");
  29705.                     name="true";
  29706.                 }
  29707.                 name = name.trim();
  29708.                 this.isEventiTimerEnabled = Boolean.parseBoolean(name);
  29709.             } catch(java.lang.Exception e) {
  29710.                 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);
  29711.                 this.isEventiTimerEnabled = true;
  29712.             }    
  29713.         }

  29715.         return this.isEventiTimerEnabled;
  29716.     }
  29717.     
  29718.     private Integer getEventiTimerIntervalSeconds = null;
  29719.     public int getEventiTimerIntervalSeconds() throws CoreException {   
  29720.         if(this.getEventiTimerIntervalSeconds==null){
  29721.             try{ 
  29722.                 String name = null;
  29723.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.eventi.timer.seconds");
  29724.                 if(name==null){
  29725.                     throw new CoreException("Proprieta' non impostata");
  29726.                 }
  29727.                 name = name.trim();
  29728.                 this.getEventiTimerIntervalSeconds = Integer.valueOf(name);
  29729.             } catch(java.lang.Exception e) {
  29730.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.eventi.timer.seconds': "+e.getMessage(),e);
  29731.                 throw new CoreException(e.getMessage(),e);
  29732.             }    
  29733.         }

  29735.         return this.getEventiTimerIntervalSeconds;
  29736.     }
  29737.     
  29738.     private Integer getEventiTimerIntervalConnectionTimeoutEveryXTimes = null;
  29739.     public int getEventiTimerIntervalConnectionTimeoutEveryXTimes() throws CoreException {  
  29740.         if(this.getEventiTimerIntervalConnectionTimeoutEveryXTimes==null){
  29741.             String pName = "org.openspcoop2.pdd.eventi.timer.connectionTimeout.everyXtimes";
  29742.             try{ 
  29743.                 String name = null;
  29744.                 name = this.reader.getValueConvertEnvProperties(pName);
  29745.                 if(name==null){
  29746.                     throw new CoreException("Proprieta' non impostata");
  29747.                 }
  29748.                 name = name.trim();
  29749.                 this.getEventiTimerIntervalConnectionTimeoutEveryXTimes = Integer.valueOf(name);
  29750.                 if(this.getEventiTimerIntervalConnectionTimeoutEveryXTimes<=0) {
  29751.                     this.getEventiTimerIntervalConnectionTimeoutEveryXTimes = 1;
  29752.                 }
  29753.             } catch(java.lang.Exception e) {
  29754.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+5+" : "+e.getMessage(),e);
  29755.                 this.getEventiTimerIntervalConnectionTimeoutEveryXTimes = 5;
  29756.             }    
  29757.         }

  29759.         return this.getEventiTimerIntervalConnectionTimeoutEveryXTimes;
  29760.     }
  29761.     
  29762.     private Integer getEventiTimerIntervalRequestReadTimeoutEveryXTimes = null;
  29763.     public int getEventiTimerIntervalRequestReadTimeoutEveryXTimes() throws CoreException { 
  29764.         if(this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes==null){
  29765.             String pName = "org.openspcoop2.pdd.eventi.timer.requestReadTimeout.everyXtimes";
  29766.             try{ 
  29767.                 String name = null;
  29768.                 name = this.reader.getValueConvertEnvProperties(pName);
  29769.                 if(name==null){
  29770.                     throw new CoreException("Proprieta' non impostata");
  29771.                 }
  29772.                 name = name.trim();
  29773.                 this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes = Integer.valueOf(name);
  29774.                 if(this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes<=0) {
  29775.                     this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes = 1;
  29776.                 }
  29777.             } catch(java.lang.Exception e) {
  29778.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=5 : "+e.getMessage(),e);
  29779.                 this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes = 5;
  29780.             }    
  29781.         }

  29783.         return this.getEventiTimerIntervalRequestReadTimeoutEveryXTimes;
  29784.     }
  29785.     
  29786.     private Integer getEventiTimerIntervalReadTimeoutEveryXTimes = null;
  29787.     public int getEventiTimerIntervalReadTimeoutEveryXTimes() throws CoreException {    
  29788.         if(this.getEventiTimerIntervalReadTimeoutEveryXTimes==null){
  29789.             String pName = "org.openspcoop2.pdd.eventi.timer.readTimeout.everyXtimes";
  29790.             try{ 
  29791.                 String name = null;
  29792.                 name = this.reader.getValueConvertEnvProperties(pName);
  29793.                 if(name==null){
  29794.                     throw new CoreException("Proprieta' non impostata");
  29795.                 }
  29796.                 name = name.trim();
  29797.                 this.getEventiTimerIntervalReadTimeoutEveryXTimes = Integer.valueOf(name);
  29798.                 if(this.getEventiTimerIntervalReadTimeoutEveryXTimes<=0) {
  29799.                     this.getEventiTimerIntervalReadTimeoutEveryXTimes = 1;
  29800.                 }
  29801.             } catch(java.lang.Exception e) {
  29802.                 this.logWarn("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=5 : "+e.getMessage(),e);
  29803.                 this.getEventiTimerIntervalReadTimeoutEveryXTimes = 5;
  29804.             }    
  29805.         }

  29807.         return this.getEventiTimerIntervalReadTimeoutEveryXTimes;
  29808.     }
  29809.     
  29810.     
  29811.     
  29812.     
  29813.     /* ------------- Repository ---------------------*/
  29814.     
  29815.     private File getFileSystemRecoveryRepository = null;
  29816.     public File getFileSystemRecoveryRepository() throws CoreException {    
  29817.         if(this.getFileSystemRecoveryRepository==null){
  29818.             try{ 
  29819.                 String name = null;
  29820.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.repository");
  29821.                 if(name==null){
  29822.                     throw new CoreException("Proprieta' non impostata");
  29823.                 }
  29824.                 name = LoggerWrapperFactory.applyClusterIdStrategy(name.trim(), "resources");
  29825.                 this.getFileSystemRecoveryRepository = new File(name);
  29826.                 checkFileSystemRecoveryRepository();
  29827.             } catch(java.lang.Exception e) {
  29828.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.repository': "+e.getMessage(),e);
  29829.                 throw new CoreException(e.getMessage(),e);
  29830.             }    
  29831.         }

  29833.         return this.getFileSystemRecoveryRepository;
  29834.     }
  29835.     private void checkFileSystemRecoveryRepository() throws CoreException {
  29836.         if(this.getFileSystemRecoveryRepository.exists()) {
  29837.             if(!this.getFileSystemRecoveryRepository.isDirectory()) {
  29838.                 throw newCoreExceptionNotDir(this.getFileSystemRecoveryRepository,true);
  29839.             }
  29840.             if(!this.getFileSystemRecoveryRepository.canRead()) {
  29841.                 throw newCoreExceptionCannotRead(this.getFileSystemRecoveryRepository,true);
  29842.             }
  29843.             if(!this.getFileSystemRecoveryRepository.canWrite()) {
  29844.                 throw newCoreExceptionCannotWrite(this.getFileSystemRecoveryRepository,true);
  29845.             }
  29846.         }
  29847.         else {
  29848.             // viene creata automaticamente
  29849.         }
  29850.     }
  29851.     
  29852.     private Boolean isFileSystemRecoveryDebug = null;
  29853.     public boolean isFileSystemRecoveryDebug() {    
  29854.         if(this.isFileSystemRecoveryDebug==null){
  29855.             try{ 
  29856.                 String name = null;
  29857.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.debug");
  29858.                 if(name==null){
  29859.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.debug' non impostata, viene utilizzato il default=true");
  29860.                     name="true";
  29861.                 }
  29862.                 name = name.trim();
  29863.                 this.isFileSystemRecoveryDebug = Boolean.parseBoolean(name);
  29864.             } catch(java.lang.Exception e) {
  29865.                 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);
  29866.                 this.isFileSystemRecoveryDebug = true;
  29867.             }    
  29868.         }

  29870.         return this.isFileSystemRecoveryDebug;
  29871.     }
  29872.     
  29873.     private Boolean isFileSystemRecoveryTimerEnabled = null;
  29874.     public boolean isFileSystemRecoveryTimerEnabled() { 
  29875.         if(this.isFileSystemRecoveryTimerEnabled==null){
  29876.             try{ 
  29877.                 String name = null;
  29878.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.enabled");
  29879.                 if(name==null){
  29880.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.enabled' non impostata, viene utilizzato il default=true");
  29881.                     name="true";
  29882.                 }
  29883.                 name = name.trim();
  29884.                 this.isFileSystemRecoveryTimerEnabled = Boolean.parseBoolean(name);
  29885.             } catch(java.lang.Exception e) {
  29886.                 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);
  29887.                 this.isFileSystemRecoveryTimerEnabled = true;
  29888.             }    
  29889.         }

  29891.         return this.isFileSystemRecoveryTimerEnabled;
  29892.     }
  29893.     
  29894.     private Integer getFileSystemRecoveryTimerIntervalSeconds = null;
  29895.     public int getFileSystemRecoveryTimerIntervalSeconds() throws CoreException {   
  29896.         if(this.getFileSystemRecoveryTimerIntervalSeconds==null){
  29897.             try{ 
  29898.                 String name = null;
  29899.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.timeout");
  29900.                 if(name==null){
  29901.                     throw new CoreException("Proprieta' non impostata");
  29902.                 }
  29903.                 name = name.trim();
  29904.                 this.getFileSystemRecoveryTimerIntervalSeconds = Integer.valueOf(name);
  29905.             } catch(java.lang.Exception e) {
  29906.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.timeout': "+e.getMessage(),e);
  29907.                 throw new CoreException(e.getMessage(),e);
  29908.             }    
  29909.         }

  29911.         return this.getFileSystemRecoveryTimerIntervalSeconds;
  29912.     }
  29913.         
  29914.     private Integer getFileSystemRecoveryTimerMaxAttempts = null;
  29915.     public int getFileSystemRecoveryMaxAttempts() throws CoreException {    
  29916.         if(this.getFileSystemRecoveryTimerMaxAttempts==null){
  29917.             try{ 
  29918.                 String name = null;
  29919.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.maxAttempts");
  29920.                 if(name==null){
  29921.                     throw new CoreException("Proprieta' non impostata");
  29922.                 }
  29923.                 name = name.trim();
  29924.                 this.getFileSystemRecoveryTimerMaxAttempts = Integer.valueOf(name);
  29925.             } catch(java.lang.Exception e) {
  29926.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.maxAttempts': "+e.getMessage(),e);
  29927.                 throw new CoreException(e.getMessage(),e);
  29928.             }    
  29929.         }

  29931.         return this.getFileSystemRecoveryTimerMaxAttempts;
  29932.     }
  29933.     
  29934.     private Boolean isFileSystemRecoveryTimerEventEnabled = null;
  29935.     public boolean isFileSystemRecoveryTimerEventEnabled() {    
  29936.         if(this.isFileSystemRecoveryTimerEventEnabled==null){
  29937.             try{ 
  29938.                 String name = null;
  29939.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.events.enabled");
  29940.                 if(name==null){
  29941.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.events.enabled' non impostata, viene utilizzato il default=true");
  29942.                     name="true";
  29943.                 }
  29944.                 name = name.trim();
  29945.                 this.isFileSystemRecoveryTimerEventEnabled = Boolean.parseBoolean(name);
  29946.             } catch(java.lang.Exception e) {
  29947.                 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);
  29948.                 this.isFileSystemRecoveryTimerEventEnabled = true;
  29949.             }    
  29950.         }

  29952.         return this.isFileSystemRecoveryTimerEventEnabled;
  29953.     }
  29954.     
  29955.     private Boolean isFileSystemRecoveryTimerTransactionEnabled = null;
  29956.     public boolean isFileSystemRecoveryTimerTransactionEnabled() {  
  29957.         if(this.isFileSystemRecoveryTimerTransactionEnabled==null){
  29958.             try{ 
  29959.                 String name = null;
  29960.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.resources.fileSystemRecovery.transaction.enabled");
  29961.                 if(name==null){
  29962.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.resources.fileSystemRecovery.transaction.enabled' non impostata, viene utilizzato il default=true");
  29963.                     name="true";
  29964.                 }
  29965.                 name = name.trim();
  29966.                 this.isFileSystemRecoveryTimerTransactionEnabled = Boolean.parseBoolean(name);
  29967.             } catch(java.lang.Exception e) {
  29968.                 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);
  29969.                 this.isFileSystemRecoveryTimerTransactionEnabled = true;
  29970.             }    
  29971.         }

  29973.         return this.isFileSystemRecoveryTimerTransactionEnabled;
  29974.     }
  29975.     
  29976.     private Long getFileSystemRecoveryEventsProcessingFileAfterMs = null;
  29977.     public long getFileSystemRecoveryEventsProcessingFileAfterMs() throws CoreException {   
  29978.         if(this.getFileSystemRecoveryEventsProcessingFileAfterMs==null){
  29979.             String pName = "org.openspcoop2.pdd.resources.fileSystemRecovery.events.processingFileAfterMs";
  29980.             try{ 
  29981.                 String name = null;
  29982.                 name = this.reader.getValueConvertEnvProperties(pName);
  29983.                 if(name==null){
  29984.                     throw new CoreException("Proprieta' non impostata");
  29985.                 }
  29986.                 name = name.trim();
  29987.                 this.getFileSystemRecoveryEventsProcessingFileAfterMs = Long.valueOf(name);
  29988.             } catch(java.lang.Exception e) {
  29989.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  29990.                 throw new CoreException(e.getMessage(),e);
  29991.             }    
  29992.         }

  29994.         return this.getFileSystemRecoveryEventsProcessingFileAfterMs;
  29995.     }
  29996.     
  29997.     private Long getFileSystemRecoveryTransactionProcessingFileAfterMs = null;
  29998.     public long getFileSystemRecoveryTransactionProcessingFileAfterMs() throws CoreException {  
  29999.         if(this.getFileSystemRecoveryTransactionProcessingFileAfterMs==null){
  30000.             String pName = "org.openspcoop2.pdd.resources.fileSystemRecovery.transaction.processingFileAfterMs";
  30001.             try{ 
  30002.                 String name = null;
  30003.                 name = this.reader.getValueConvertEnvProperties(pName);
  30004.                 if(name==null){
  30005.                     throw new CoreException("Proprieta' non impostata");
  30006.                 }
  30007.                 name = name.trim();
  30008.                 this.getFileSystemRecoveryTransactionProcessingFileAfterMs = Long.valueOf(name);
  30009.             } catch(java.lang.Exception e) {
  30010.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  30011.                 throw new CoreException(e.getMessage(),e);
  30012.             }    
  30013.         }

  30015.         return this.getFileSystemRecoveryTransactionProcessingFileAfterMs;
  30016.     }
  30017.     
  30018.     
  30019.     
  30020.     
  30021.     
  30022.     /* ------------- Controllo Traffico ---------------------*/
  30023.     
  30024.     private Boolean isControlloTrafficoEnabled = null;
  30025.     public boolean isControlloTrafficoEnabled() {   
  30026.         if(this.isControlloTrafficoEnabled==null){
  30027.             try{ 
  30028.                 if(CostantiConfigurazione.CONFIGURAZIONE_XML.equalsIgnoreCase(getTipoConfigurazionePDD())){
  30029.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.enabled' ignorata. Il controllo del traffico e' disabilitato sulla configurazione xml");
  30030.                     this.isControlloTrafficoEnabled = false;
  30031.                 }
  30032.                 else {
  30033.                     String name = null;
  30034.                     name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.enabled");
  30035.                     if(name==null){
  30036.                         this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.enabled' non impostata, viene utilizzato il default=true");
  30037.                         name="true";
  30038.                     }
  30039.                     name = name.trim();
  30040.                     this.isControlloTrafficoEnabled = Boolean.parseBoolean(name);
  30041.                 }
  30042.             } catch(java.lang.Exception e) {
  30043.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.enabled', viene utilizzato il default=true : "+e.getMessage(),e);
  30044.                 this.isControlloTrafficoEnabled = true;
  30045.             }    
  30046.         }

  30048.         return this.isControlloTrafficoEnabled;
  30049.     }
  30050.     
  30051.     private Boolean isControlloTrafficoDebug = null;
  30052.     public boolean isControlloTrafficoDebug() { 
  30053.         if(this.isControlloTrafficoDebug==null){
  30054.             try{ 
  30055.                 String name = null;
  30056.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.debug");
  30057.                 if(name==null){
  30058.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.debug' non impostata, viene utilizzato il default=true");
  30059.                     name="true";
  30060.                 }
  30061.                 name = name.trim();
  30062.                 this.isControlloTrafficoDebug = Boolean.parseBoolean(name);
  30063.             } catch(java.lang.Exception e) {
  30064.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.debug', viene utilizzato il default=true : "+e.getMessage(),e);
  30065.                 this.isControlloTrafficoDebug = true;
  30066.             }    
  30067.         }

  30069.         return this.isControlloTrafficoDebug;
  30070.     }
  30071.     
  30072.     private Boolean isControlloTrafficoViolazioneGenerazioneErroreGenerico = null;
  30073.     private boolean isControlloTrafficoViolazioneGenerazioneErroreGenerico() {  
  30074.         if(this.isControlloTrafficoViolazioneGenerazioneErroreGenerico==null){
  30075.             try{ 
  30076.                 String name = null;
  30077.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.erroreGenerico");
  30078.                 if(name==null){
  30079.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.erroreGenerico' non impostata, viene utilizzato il default=true");
  30080.                     name="true";
  30081.                 }
  30082.                 name = name.trim();
  30083.                 this.isControlloTrafficoViolazioneGenerazioneErroreGenerico = Boolean.parseBoolean(name);
  30084.             } catch(java.lang.Exception e) {
  30085.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.erroreGenerico', viene utilizzato il default=true : "+e.getMessage(),e);
  30086.                 this.isControlloTrafficoViolazioneGenerazioneErroreGenerico = true;
  30087.             }    
  30088.         }

  30090.         return this.isControlloTrafficoViolazioneGenerazioneErroreGenerico;
  30091.     }
  30092.     
  30093.     private Boolean isControlloTrafficoPolicyLetturaDaCacheDinamica = null;
  30094.     private boolean isControlloTrafficoPolicyLetturaDaCacheDinamica() { 
  30095.         if(this.isControlloTrafficoPolicyLetturaDaCacheDinamica==null){
  30096.             try{ 
  30097.                 String name = null;
  30098.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.policy.readWithDynamicCache");
  30099.                 if(name==null){
  30100.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.policy.readWithDynamicCache' non impostata, viene utilizzato il default=true");
  30101.                     name="true";
  30102.                 }
  30103.                 name = name.trim();
  30104.                 this.isControlloTrafficoPolicyLetturaDaCacheDinamica = Boolean.parseBoolean(name);
  30105.             } catch(java.lang.Exception e) {
  30106.                 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);
  30107.                 this.isControlloTrafficoPolicyLetturaDaCacheDinamica = true;
  30108.             }    
  30109.         }

  30111.         return this.isControlloTrafficoPolicyLetturaDaCacheDinamica;
  30112.     }
  30113.     
  30114.     private Map<String, int[]> getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata = new HashMap<>();
  30115.     private int[] getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata(String protocollo) throws CoreException{
  30116.         if(!this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.containsKey(protocollo)){
  30117.             EsitiProperties esitiProperties = null;
  30118.             try{
  30119.                 esitiProperties =EsitiProperties.getInstanceFromProtocolName(this.log,protocollo);
  30120.             }catch(Exception e) {
  30121.                 throw new CoreException(e.getMessage(),e);
  30122.             }
  30123.             try{
  30124.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaDelegata.esitiConsiderati");
  30125.                 if(value!=null){
  30126.                     value = value.trim();
  30127.                     String [] split = value.split(",");
  30128.                     List<Integer> lInt = new ArrayList<>();
  30129.                     for (int i = 0; i < split.length; i++) {
  30130.                         String s = split[i].trim();
  30131.                         int e = -1;
  30132.                         try{
  30133.                             e = Integer.parseInt(s);
  30134.                         }catch(Exception eParse){
  30135.                             throw new CoreException("Valore ["+s+"] non riconosciuto come esito valido: "+eParse.getMessage(),eParse);
  30136.                         }
  30137.                         if(esitiProperties.existsEsitoCode(e)==false){
  30138.                             continue; // non supportato dal protocollo
  30139.                         }
  30140.                         lInt.add(e);
  30141.                     }
  30142.                     if(lInt.isEmpty()) {
  30143.                         throw new CoreException("Nessun valore è utilizzabile per il protocollo '"+protocollo+"'");
  30144.                     }
  30145.                     int [] tmp = new int[lInt.size()];
  30146.                     for (int i = 0; i < lInt.size(); i++) {
  30147.                         tmp[i] = lInt.get(i);
  30148.                     }
  30149.                     this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.put(protocollo, tmp);
  30150.                 }
  30151.                 else{
  30152.                     // default
  30153.                     int defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
  30154.                     this.logWarn("Proprieta' non presente [org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaDelegata.esitiConsiderati] (Uso il default '"+EsitoTransazioneName.OK+"="+defaultEsito+"')");
  30155.                     int [] tmp = new int[1];
  30156.                     tmp[0] = defaultEsito;
  30157.                     this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.put(protocollo, tmp);
  30158.                 }

  30160.             }catch(Exception e){
  30161.                 // default
  30162.                 int defaultEsito = -1;
  30163.                 try{
  30164.                     defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
  30165.                 }catch(Exception eEsito) {
  30166.                     throw new CoreException(eEsito.getMessage(),eEsito);
  30167.                 }
  30168.                 this.logError("Errore durante la lettura della proprieta' [org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaDelegata.esitiConsideratii] (Uso il default '"+EsitoTransazioneName.OK+"="+defaultEsito+"'): "+e.getMessage(),e);
  30169.                 int [] tmp = new int[1];
  30170.                 tmp[0] = defaultEsito;
  30171.                 this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.put(protocollo, tmp);
  30172.             }
  30173.         }
  30174.         return this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata.get(protocollo);
  30175.     }
  30176.     
  30177.     private Map<String, int[]> getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa = new HashMap<>();
  30178.     private int[] getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa(String protocollo) throws CoreException{
  30179.         if(!this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.containsKey(protocollo)){
  30180.             EsitiProperties esitiProperties = null;
  30181.             try{
  30182.                 esitiProperties = EsitiProperties.getInstanceFromProtocolName(this.log,protocollo);
  30183.             }catch(Exception e) {
  30184.                 throw new CoreException(e.getMessage(),e);
  30185.             }
  30186.             try{
  30187.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaApplicativa.esitiConsiderati");
  30188.                 if(value!=null){
  30189.                     value = value.trim();
  30190.                     String [] split = value.split(",");
  30191.                     List<Integer> lInt = new ArrayList<>();
  30192.                     for (int i = 0; i < split.length; i++) {
  30193.                         String s = split[i].trim();
  30194.                         int e = -1;
  30195.                         try{
  30196.                             e = Integer.parseInt(s);
  30197.                         }catch(Exception eParse){
  30198.                             throw new CoreException("Valore ["+s+"] non riconosciuto come esito valido: "+eParse.getMessage(),eParse);
  30199.                         }
  30200.                         if(esitiProperties.existsEsitoCode(e)==false){
  30201.                             continue; // non supportato dal protocollo
  30202.                         }
  30203.                         lInt.add(e);
  30204.                     }
  30205.                     if(lInt.isEmpty()) {
  30206.                         throw new CoreException("Nessun valore è utilizzabile per il protocollo '"+protocollo+"'");
  30207.                     }
  30208.                     int [] tmp = new int[lInt.size()];
  30209.                     for (int i = 0; i < lInt.size(); i++) {
  30210.                         tmp[i] = lInt.get(i);
  30211.                     }
  30212.                     this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.put(protocollo, tmp);
  30213.                 }
  30214.                 else{
  30215.                     // default
  30216.                     int defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
  30217.                     this.logWarn("Proprieta' non presente [org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaApplicativa.esitiConsiderati] (Uso il default '"+EsitoTransazioneName.OK+"="+defaultEsito+"')");
  30218.                     int [] tmp = new int[1];
  30219.                     tmp[0] = defaultEsito;
  30220.                     this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.put(protocollo, tmp);
  30221.                 }

  30223.             }catch(Exception e){
  30224.                 // default
  30225.                 int defaultEsito = -1;
  30226.                 try{
  30227.                     defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.OK);
  30228.                 }catch(Exception eEsito) {
  30229.                     throw new CoreException(eEsito.getMessage(),eEsito);
  30230.                 }
  30231.                 this.logError("Errore durante la lettura della proprieta' [org.openspcoop2.pdd.controlloTraffico.calcoloLatenza.portaApplicativa.esitiConsideratii] (Uso il default '"+EsitoTransazioneName.OK+"="+defaultEsito+"'): "+e.getMessage(),e);
  30232.                 int [] tmp = new int[1];
  30233.                 tmp[0] = defaultEsito;
  30234.                 this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.put(protocollo, tmp);
  30235.             }
  30236.         }
  30237.         return this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa.get(protocollo);
  30238.     }
  30239.     
  30240.     private Boolean isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo = null;
  30241.     private boolean isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo() {    
  30242.         if(this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo==null){
  30243.             try{ 
  30244.                 String name = null;
  30245.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.statistiche.finestraScorrevole.gestioneUltimoIntervallo");
  30246.                 if(name==null){
  30247.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.statistiche.finestraScorrevole.gestioneUltimoIntervallo' non impostata, viene utilizzato il default=true");
  30248.                     name="true";
  30249.                 }
  30250.                 name = name.trim();
  30251.                 this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo = Boolean.parseBoolean(name);
  30252.             } catch(java.lang.Exception e) {
  30253.                 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);
  30254.                 this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo = true;
  30255.             }    
  30256.         }

  30258.         return this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo;
  30259.     }
  30260.     
  30261.     private Boolean isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere = null;
  30262.     private boolean isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere() { 
  30263.         if(this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere==null){
  30264.             String pName = "org.openspcoop2.pdd.controlloTraffico.statistiche.distribuzioneSettimanale.usaStatisticheGiornaliere";
  30265.             try{ 
  30266.                 String name = null;
  30267.                 name = this.reader.getValueConvertEnvProperties(pName);
  30268.                 if(name==null){
  30269.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  30270.                     name="true";
  30271.                 }
  30272.                 name = name.trim();
  30273.                 this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere = Boolean.parseBoolean(name);
  30274.             } catch(java.lang.Exception e) {
  30275.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  30276.                 this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere = true;
  30277.             }    
  30278.         }

  30280.         return this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere;
  30281.     }
  30282.     
  30283.     private Boolean isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere = null;
  30284.     private boolean isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere() { 
  30285.         if(this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere==null){
  30286.             String pName = "org.openspcoop2.pdd.controlloTraffico.statistiche.distribuzioneMensile.usaStatisticheGiornaliere";
  30287.             try{ 
  30288.                 String name = null;
  30289.                 name = this.reader.getValueConvertEnvProperties(pName);
  30290.                 if(name==null){
  30291.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  30292.                     name="true";
  30293.                 }
  30294.                 name = name.trim();
  30295.                 this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere = Boolean.parseBoolean(name);
  30296.             } catch(java.lang.Exception e) {
  30297.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  30298.                 this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere = true;
  30299.             }    
  30300.         }

  30302.         return this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere;
  30303.     }
  30304.     
  30305.     private Boolean isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata = null;
  30306.     private boolean isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata() {    
  30307.         if(this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata==null){
  30308.             String pName = "org.openspcoop2.pdd.controlloTraffico.statistiche.distribuzioneSettimanaleMensile.usaStatisticheGiornaliere.latenza.mediaPesata";
  30309.             try{ 
  30310.                 String name = null;
  30311.                 name = this.reader.getValueConvertEnvProperties(pName);
  30312.                 if(name==null){
  30313.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  30314.                     name="true";
  30315.                 }
  30316.                 name = name.trim();
  30317.                 this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata = Boolean.parseBoolean(name);
  30318.             } catch(java.lang.Exception e) {
  30319.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  30320.                 this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata = true;
  30321.             }    
  30322.         }

  30324.         return this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata;
  30325.     }
  30326.     
  30327.     private Map<String, int[]> getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy = new HashMap<>();
  30328.     private int[] getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy(String protocollo) throws CoreException{
  30329.         if(!this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.containsKey(protocollo)){
  30330.             EsitiProperties esitiProperties = null;
  30331.             try{
  30332.                 esitiProperties = EsitiProperties.getInstanceFromProtocolName(this.log, protocollo);
  30333.             }catch(Exception e) {
  30334.                 throw new CoreException(e.getMessage(),e);
  30335.             }
  30336.             try{
  30337.                 String value = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.violazionePolicy.esitiConsiderati");
  30338.                 if(value!=null){
  30339.                     value = value.trim();
  30340.                     String [] split = value.split(",");
  30341.                     int [] tmp = new int[split.length];
  30342.                     for (int i = 0; i < split.length; i++) {
  30343.                         String s = split[i].trim();
  30344.                         int e = -1;
  30345.                         try{
  30346.                             e = Integer.parseInt(s);
  30347.                         }catch(Exception eParse){
  30348.                             throw new CoreException("Valore ["+s+"] non riconosciuto come esito valido: "+eParse.getMessage(),eParse);
  30349.                         }
  30350.                         if(!esitiProperties.existsEsitoCode(e)){
  30351.                             throw new CoreException("Valore ["+s+"] non riconosciuto come esito valido");
  30352.                         }
  30353.                         tmp[i] = e;
  30354.                     }
  30355.                     this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.put(protocollo, tmp);
  30356.                 }
  30357.                 else{
  30358.                     // default
  30359.                     int defaultEsito =  esitiProperties.convertoToCode(EsitoTransazioneName.CONTROLLO_TRAFFICO_POLICY_VIOLATA);
  30360.                     this.logWarn("Proprieta' non presente [org.openspcoop2.pdd.controlloTraffico.violazionePolicy.esitiConsiderati] (Uso il default '"+defaultEsito+"')");
  30361.                     int [] tmp = new int[1];
  30362.                     tmp[0] = defaultEsito;
  30363.                     this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.put(protocollo, tmp);
  30364.                 }

  30366.             }catch(Exception e){
  30367.                 // default
  30368.                 int defaultEsito = -1;
  30369.                 try {
  30370.                     defaultEsito = esitiProperties.convertoToCode(EsitoTransazioneName.CONTROLLO_TRAFFICO_POLICY_VIOLATA);
  30371.                 }catch(Exception eEsito) {
  30372.                     throw new CoreException(eEsito.getMessage(),eEsito);
  30373.                 }
  30374.                 this.logError("Errore durante la lettura della proprieta' [org.openspcoop2.pdd.controlloTraffico.violazionePolicy.esitiConsiderati] (Uso il default '"+defaultEsito+"'): "+e.getMessage(),e);
  30375.                 int [] tmp = new int[1];
  30376.                 tmp[0] = defaultEsito;
  30377.                 this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.put(protocollo, tmp);
  30378.             }
  30379.         }
  30380.         return this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy.get(protocollo);
  30381.     }
  30382.     
  30383.     private EsitoTransazioneName getControlloTrafficoEsitiPolicyElaborazioneInErrore = null;
  30384.     public EsitoTransazioneName getControlloTrafficoEsitiPolicyElaborazioneInErrore(EsitiProperties esitiProperties) {  
  30385.         if(this.getControlloTrafficoEsitiPolicyElaborazioneInErrore==null){
  30386.             String pName = "org.openspcoop2.pdd.controlloTraffico.violazionePolicy.elaborazioneInErrore";
  30387.             try{ 
  30388.                 String name = null;
  30389.                 name = this.reader.getValueConvertEnvProperties(pName);
  30390.                 if(name==null){
  30391.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default="+EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX);
  30392.                     this.getControlloTrafficoEsitiPolicyElaborazioneInErrore = EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX;
  30393.                 }
  30394.                 else {
  30395.                     name = name.trim();
  30396.                     if(esitiProperties!=null) {
  30397.                         this.getControlloTrafficoEsitiPolicyElaborazioneInErrore = esitiProperties.getEsitoTransazioneName(Integer.parseInt(name));
  30398.                     }
  30399.                     else {
  30400.                         // verrà inizializzato alla prima chiamata
  30401.                     }
  30402.                 }
  30403.             } catch(java.lang.Exception e) {
  30404.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX+" : "+e.getMessage(),e);
  30405.                 this.getControlloTrafficoEsitiPolicyElaborazioneInErrore = EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX;
  30406.             }    
  30407.         }

  30409.         return this.getControlloTrafficoEsitiPolicyElaborazioneInErrore;
  30410.     }
  30411.     
  30412.     private Boolean isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile = null;
  30413.     private boolean isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile() {  
  30414.         if(this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile==null){
  30415.             try{ 
  30416.                 String name = null;
  30417.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.realtime.incrementaSoloPolicyApplicabile");
  30418.                 if(name==null){
  30419.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.realtime.incrementaSoloPolicyApplicabile' non impostata, viene utilizzato il default=false");
  30420.                     name="false";
  30421.                 }
  30422.                 name = name.trim();
  30423.                 this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile = Boolean.parseBoolean(name);
  30424.             } catch(java.lang.Exception e) {
  30425.                 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);
  30426.                 this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile = false;
  30427.             }    
  30428.         }

  30430.         return this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile;
  30431.     }
  30432.     
  30433.     private ConfigurazioneGatewayControlloTraffico controlloTrafficoConfigurazione = null;
  30434.     public void initConfigurazioneControlloTraffico(Loader loaderOpenSPCoop, List<String> protocolli) throws CoreException{
  30435.         if(this.controlloTrafficoConfigurazione==null){
  30436.             
  30437.             this.controlloTrafficoConfigurazione = new ConfigurazioneGatewayControlloTraffico();
  30438.                         
  30439.             AccessoConfigurazionePdD config = null;
  30440.             try {
  30441.                 config = this.getAccessoConfigurazionePdD();
  30442.             }catch(Exception e) {
  30443.                 throw new CoreException(e.getMessage(),e);
  30444.             }
  30445.             this.controlloTrafficoConfigurazione.setTipoDatabaseConfig(config.getTipoDatabase());
  30446.             
  30447.             this.controlloTrafficoConfigurazione.setDebug(this.isControlloTrafficoDebug());
  30448.             
  30449.             this.controlloTrafficoConfigurazione.setErroreGenerico(this.isControlloTrafficoViolazioneGenerazioneErroreGenerico());
  30450.             
  30451.             this.controlloTrafficoConfigurazione.setPolicyReadedWithDynamicCache(this.isControlloTrafficoPolicyLetturaDaCacheDinamica());
  30452.             
  30453.             for (String protocollo : protocolli) {
  30454.                 getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata(protocollo);
  30455.                 getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa(protocollo);
  30456.             }
  30457.             this.controlloTrafficoConfigurazione.setCalcoloLatenzaPortaDelegataEsitiConsiderati(this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaDelegata);
  30458.             this.controlloTrafficoConfigurazione.setCalcoloLatenzaPortaApplicativaEsitiConsiderati(this.getControlloTrafficoEsitiDaConsiderarePerCalcoloLatenzaPortaApplicativa);
  30459.             
  30460.             this.controlloTrafficoConfigurazione.setElaborazioneStatistica_finestraScorrevole_gestioneIntervalloCorrente(this.isControlloTrafficoStatisticheFinestraScorrevoleGestioneUltimoIntervallo());
  30461.             
  30462.             this.controlloTrafficoConfigurazione.setElaborazioneStatistica_distribuzioneSettimanale_usaStatisticheGiornaliere(this.isControlloTrafficoStatisticheDistribuzioneSettimanaleUsaStatisticheGiornaliere());
  30463.             this.controlloTrafficoConfigurazione.setElaborazioneStatistica_distribuzioneMensile_usaStatisticheGiornaliere(this.isControlloTrafficoStatisticheDistribuzioneMensileUsaStatisticheGiornaliere());
  30464.             this.controlloTrafficoConfigurazione.setElaborazioneStatistica_distribuzioneSettimanaleMensile_usaStatisticheGiornaliere_latenza_mediaPesata(this.isControlloTrafficoStatisticheDistribuzioneSettimanaleMensileUsaStatisticheGiornaliereLatenzaMediaPesata());
  30465.                         
  30466.             INotify notifier = this.getControlloTrafficoNotifyImpl(loaderOpenSPCoop);
  30467.             this.controlloTrafficoConfigurazione.setNotifierEnabled(notifier!=null);
  30468.             this.controlloTrafficoConfigurazione.setNotifier(notifier);
  30469.             
  30470.             for (String protocollo : protocolli) {
  30471.                 getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy(protocollo);
  30472.             }
  30473.             this.controlloTrafficoConfigurazione.setEsitiPolicyViolate(this.getControlloTrafficoEsitiDaConsiderarePerViolazionePolicy);
  30474.             
  30475.             getControlloTrafficoEsitiPolicyElaborazioneInErrore(null);
  30476.             
  30477.             this.controlloTrafficoConfigurazione.setElaborazioneRealtime_incrementaSoloPolicyApplicabile(this.isControlloTrafficoRealtimeIncrementaSoloPolicyApplicabile());
  30478.         }
  30479.     }
  30480.     public ConfigurazioneGatewayControlloTraffico getConfigurazioneControlloTraffico(){
  30481.         return this.controlloTrafficoConfigurazione;
  30482.     }
  30483.     
  30484.     
  30485.     private TipoGestorePolicy isControlloTrafficoGestorePolicyTipo = null;
  30486.     public TipoGestorePolicy getControlloTrafficoGestorePolicyTipo() {  
  30487.         if(this.isControlloTrafficoGestorePolicyTipo==null){
  30488.             try{ 
  30489.                 String name = null;
  30490.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.gestorePolicy.tipo");
  30491.                 if(name==null){
  30492.                     TipoGestorePolicy gestoreDefault = TipoGestorePolicy.IN_MEMORY;
  30493.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.tipo' non impostata, viene utilizzato il default="+gestoreDefault);
  30494.                     this.isControlloTrafficoGestorePolicyTipo = gestoreDefault;
  30495.                 }
  30496.                 else {
  30497.                     name = name.trim();
  30498.                     this.isControlloTrafficoGestorePolicyTipo = TipoGestorePolicy.toEnumConstant(name, true);
  30499.                 }
  30500.             } catch(java.lang.Exception e) {
  30501.                 TipoGestorePolicy gestoreDefault = TipoGestorePolicy.IN_MEMORY;
  30502.                 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);
  30503.                 this.isControlloTrafficoGestorePolicyTipo = gestoreDefault;
  30504.             }    
  30505.         }

  30507.         return this.isControlloTrafficoGestorePolicyTipo;
  30508.     }
  30509.     
  30510.     private PolicyGroupByActiveThreadsType getControlloTrafficoGestorePolicyInMemoryType = null;
  30511.     public PolicyGroupByActiveThreadsType getControlloTrafficoGestorePolicyInMemoryType() throws CoreException {    
  30512.         if(this.getControlloTrafficoGestorePolicyInMemoryType==null){
  30513.             try{ 
  30514.                 String name = null;
  30515.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.tipo");
  30516.                 if(name==null){
  30517.                     this.getControlloTrafficoGestorePolicyInMemoryType = PolicyGroupByActiveThreadsType.LOCAL;
  30518.                     this.logWarn("Proprieta' 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.tipo' non impostata; viene usato il default: "+this.getControlloTrafficoGestorePolicyInMemoryType);
  30519.                 }
  30520.                 else {
  30521.                     name = name.trim();
  30522.                     this.getControlloTrafficoGestorePolicyInMemoryType = PolicyGroupByActiveThreadsType.valueOf(name);
  30523.                 }
  30524.             } catch(java.lang.Exception e) {
  30525.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.tipo': "+e.getMessage(),e);
  30526.                 throw new CoreException(e.getMessage(),e);
  30527.             }    
  30528.         }

  30530.         return this.getControlloTrafficoGestorePolicyInMemoryType;
  30531.     }
  30532.     
  30533.     private Map<PolicyGroupByActiveThreadsType, Boolean> getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization = null;
  30534.     public boolean isControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization(PolicyGroupByActiveThreadsType type) throws CoreException {   
  30535.         if(this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization==null){
  30536.             this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization = new HashMap<PolicyGroupByActiveThreadsType, Boolean>();
  30537.             for (PolicyGroupByActiveThreadsType initType : PolicyGroupByActiveThreadsType.values()) {
  30538.                 String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory."+initType.name()+".lazyInitialization";
  30539.                 try{ 
  30540.                     String name = this.reader.getValueConvertEnvProperties(pName);
  30541.                     if(name==null){
  30542.                         this.logWarn("Proprieta' '"+pName+"' non impostata; viene usato il default: "+true);
  30543.                         this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization.put(initType, true);
  30544.                     }
  30545.                     else {
  30546.                         name = name.trim();
  30547.                         Boolean v = Boolean.valueOf(name);
  30548.                         this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization.put(initType, v);
  30549.                     }
  30550.                 } catch(java.lang.Exception e) {
  30551.                     this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"'; viene usato il default: "+true+". Errore: "+e.getMessage(),e);
  30552.                     this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization.put(initType, true);
  30553.                 }           
  30554.             }
  30555.         }

  30557.         return this.getControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization.get(type);
  30558.     }
  30559.     
  30560.     private Boolean isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock = null;
  30561.     public boolean isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock(){
  30562.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.counters.useLocalLock";
  30563.         if(this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock==null){
  30564.             try{  
  30565.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30567.                 if(value!=null){
  30568.                     value = value.trim();
  30569.                     this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock = Boolean.parseBoolean(value);
  30570.                 }else{
  30571.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  30572.                     this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock = false;
  30573.                 }

  30575.             }catch(java.lang.Exception e) {
  30576.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  30577.                 this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock = false;
  30578.             }
  30579.         }
  30580.         return this.isControlloTrafficoGestorePolicyInMemoryRemoteCountersUseLocalLock;
  30581.     }
  30582.     
  30583.     private Boolean isControlloTrafficoGestioneClusterRemainingZeroValue = null;
  30584.     public boolean isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodesRemainingZeroValue(){
  30585.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.LOCAL_DIVIDED_BY_NODES.remaining.zeroValue";
  30586.         if(this.isControlloTrafficoGestioneClusterRemainingZeroValue==null){
  30587.             try{  
  30588.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30590.                 if(value!=null){
  30591.                     value = value.trim();
  30592.                     this.isControlloTrafficoGestioneClusterRemainingZeroValue = Boolean.parseBoolean(value);
  30593.                 }else{
  30594.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  30595.                     this.isControlloTrafficoGestioneClusterRemainingZeroValue = false;
  30596.                 }

  30598.             }catch(java.lang.Exception e) {
  30599.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  30600.                 this.isControlloTrafficoGestioneClusterRemainingZeroValue = false;
  30601.             }
  30602.         }
  30603.         return this.isControlloTrafficoGestioneClusterRemainingZeroValue;
  30604.     }
  30605.     
  30606.     private Boolean isControlloTrafficoGestioneClusterLimitRoundingDown = null;
  30607.     public boolean isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodesLimitRoundingDown(){
  30608.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.LOCAL_DIVIDED_BY_NODES.limit.roundingDown";
  30609.         if(this.isControlloTrafficoGestioneClusterLimitRoundingDown==null){
  30610.             try{  
  30611.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30613.                 if(value!=null){
  30614.                     value = value.trim();
  30615.                     this.isControlloTrafficoGestioneClusterLimitRoundingDown = Boolean.parseBoolean(value);
  30616.                 }else{
  30617.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  30618.                     this.isControlloTrafficoGestioneClusterLimitRoundingDown = true;
  30619.                 }

  30621.             }catch(java.lang.Exception e) {
  30622.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  30623.                 this.isControlloTrafficoGestioneClusterLimitRoundingDown = true;
  30624.             }
  30625.         }
  30626.         return this.isControlloTrafficoGestioneClusterLimitRoundingDown;
  30627.     }
  30628.     
  30629.     private Boolean isControlloTrafficoGestioneClusterLimitNormalizedQuota = null;
  30630.     public boolean isControlloTrafficoGestorePolicyInMemoryLocalDividedByNodesLimitNormalizedQuota(){
  30631.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.LOCAL_DIVIDED_BY_NODES.limit.normalizedQuota";
  30632.         if(this.isControlloTrafficoGestioneClusterLimitNormalizedQuota==null){
  30633.             try{  
  30634.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30636.                 if(value!=null){
  30637.                     value = value.trim();
  30638.                     this.isControlloTrafficoGestioneClusterLimitNormalizedQuota = Boolean.parseBoolean(value);
  30639.                 }else{
  30640.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  30641.                     this.isControlloTrafficoGestioneClusterLimitNormalizedQuota = false;
  30642.                 }

  30644.             }catch(java.lang.Exception e) {
  30645.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  30646.                 this.isControlloTrafficoGestioneClusterLimitNormalizedQuota = false;
  30647.             }
  30648.         }
  30649.         return this.isControlloTrafficoGestioneClusterLimitNormalizedQuota;
  30650.     }
  30651.     
  30652.     private Boolean getControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction = null;
  30653.     public boolean isControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction() {
  30654.         if(this.getControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction==null){
  30655.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.DATABASE.useTransaction";
  30656.             try{ 
  30657.                 String name = null;
  30658.                 name = this.reader.getValueConvertEnvProperties(pName);
  30659.                 if (name != null) {
  30660.                     name = name.trim();
  30661.                     this.getControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction = Boolean.valueOf(name);
  30662.                 } else {
  30663.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  30664.                     this.getControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction =  true;
  30665.                 }
  30666.             }catch(java.lang.Exception e) {
  30667.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, true),e);
  30668.                 this.getControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction = true;
  30669.             }   
  30670.         }

  30672.         return this.getControlloTrafficoGestorePolicyInMemoryDatabaseUseTransaction;
  30673.     }
  30674.     
  30675.     private Long getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva = null;
  30676.     public long getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva() { 
  30677.         if(this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva==null){
  30678.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.DATABASE.serializable.attesaAttiva";
  30679.             try{ 
  30680.                 String name = null;
  30681.                 name = this.reader.getValueConvertEnvProperties(pName);
  30682.                 if (name != null) {
  30683.                     name = name.trim();
  30684.                     long time = java.lang.Long.parseLong(name);
  30685.                     this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva = time*1000;
  30686.                 } else {
  30687.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA));
  30688.                     this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva =  Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA;
  30689.                 }
  30690.             }catch(java.lang.Exception e) {
  30691.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA),e);
  30692.                 this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva = Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA;
  30693.             }   
  30694.         }

  30696.         return this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBAttesaAttiva;
  30697.     }

  30699.     private Integer getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval = null;
  30700.     public int getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval() { 
  30701.         if(this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval==null){
  30702.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.DATABASE.serializable.check";
  30703.             try{ 
  30704.                 String name = null;
  30705.                 name = this.reader.getValueConvertEnvProperties(pName);
  30706.                 if (name != null){
  30707.                     name = name.trim();
  30708.                     int time = java.lang.Integer.parseInt(name);
  30709.                     this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval = time;
  30710.                 } else{
  30711.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL));
  30712.                     this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval = Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL;
  30713.                 }
  30714.             }catch(java.lang.Exception e) {
  30715.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL),e);
  30716.                 this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval = Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL;
  30717.             }    
  30718.         }

  30720.         return this.getControlloTrafficoGestorePolicyInMemoryDatabaseSerializableDBCheckInterval;
  30721.     }

  30723.     private Boolean isHazelcastEngineEnabled = null;
  30724.     public boolean isHazelcastEngineEnabled() { 
  30725.         if(this.isHazelcastEngineEnabled==null){
  30726.             String pName = "org.openspcoop2.pdd.hazelcast.enabled";
  30727.             try{ 
  30728.                 String name = null;
  30729.                 name = this.reader.getValueConvertEnvProperties(pName);
  30730.                 if(name==null){
  30731.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  30732.                     name="true";
  30733.                 }
  30734.                 name = name.trim();
  30735.                 this.isHazelcastEngineEnabled = Boolean.parseBoolean(name);
  30736.             } catch(java.lang.Exception e) {
  30737.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  30738.                 this.isHazelcastEngineEnabled = true;
  30739.             }    
  30740.         }

  30742.         return this.isHazelcastEngineEnabled;
  30743.     }
  30744.     
  30745.     
  30746.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPathRead = null;
  30747.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath = null;
  30748.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath() throws CoreException {
  30749.         
  30750.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPathRead==null){
  30751.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_MAP.config";

  30753.             try{  
  30754.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30756.                 if (value != null){
  30757.                     value = value.trim();
  30758.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath = value;
  30759.                 }
  30760.                 
  30761.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPathRead = true;
  30762.                 
  30763.             }catch(java.lang.Exception e) {
  30764.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30765.                 this.logError(msgError,e);
  30766.                 throw new CoreException(msgError,e);
  30767.             }
  30768.         }

  30770.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath;        
  30771.     }
  30772.     
  30773.     
  30774.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPathRead = null;
  30775.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath = null;
  30776.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath() throws CoreException {
  30777.         
  30778.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPathRead==null){
  30779.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_PNCOUNTER.config";

  30781.             try{  
  30782.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30784.                 if (value != null){
  30785.                     value = value.trim();
  30786.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath = value;
  30787.                 }
  30788.                 
  30789.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPathRead = true;
  30790.                 
  30791.             }catch(java.lang.Exception e) {
  30792.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30793.                 this.logError(msgError,e);
  30794.                 throw new CoreException(msgError,e);
  30795.             }
  30796.         }

  30798.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath;      
  30799.     }
  30800.     
  30801.     
  30802.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPathRead = null;
  30803.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath = null;
  30804.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath() throws CoreException {
  30805.         
  30806.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPathRead==null){
  30807.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_ATOMIC_LONG.config";

  30809.             try{  
  30810.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30812.                 if (value != null){
  30813.                     value = value.trim();
  30814.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath = value;
  30815.                 }
  30816.                 
  30817.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPathRead = true;
  30818.                 
  30819.             }catch(java.lang.Exception e) {
  30820.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30821.                 this.logError(msgError,e);
  30822.                 throw new CoreException(msgError,e);
  30823.             }
  30824.         }

  30826.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath;     
  30827.     }
  30828.     
  30829.     
  30830.     
  30831.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPathRead = null;
  30832.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath = null;
  30833.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath() throws CoreException {
  30834.         
  30835.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPathRead==null){
  30836.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_ATOMIC_LONG_ASYNC.config";

  30838.             try{  
  30839.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30841.                 if (value != null){
  30842.                     value = value.trim();
  30843.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath = value;
  30844.                 }
  30845.                 
  30846.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPathRead = true;
  30847.                 
  30848.             }catch(java.lang.Exception e) {
  30849.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30850.                 this.logError(msgError,e);
  30851.                 throw new CoreException(msgError,e);
  30852.             }
  30853.         }

  30855.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath;        
  30856.     }
  30857.     
  30858.     
  30859.         
  30860.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPathRead = null;
  30861.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath = null;
  30862.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath() throws CoreException {
  30863.         
  30864.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPathRead==null){
  30865.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_NEAR_CACHE.config";

  30867.             try{  
  30868.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30870.                 if (value != null){
  30871.                     value = value.trim();
  30872.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath = value;
  30873.                 }

  30875.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPathRead = true;
  30876.                 
  30877.             }catch(java.lang.Exception e) {
  30878.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30879.                 this.logError(msgError,e);
  30880.                 throw new CoreException(msgError,e);
  30881.             }
  30882.         }

  30884.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath;      
  30885.     }
  30886.     
  30887.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPathRead = null;
  30888.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath = null;
  30889.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath() throws CoreException {
  30890.         
  30891.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPathRead==null){
  30892.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_NEAR_CACHE_UNSAFE_SYNC_MAP.config";

  30894.             try{  
  30895.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30897.                 if (value != null){
  30898.                     value = value.trim();
  30899.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath = value;
  30900.                 }

  30902.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPathRead = true;
  30903.                 
  30904.             }catch(java.lang.Exception e) {
  30905.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30906.                 this.logError(msgError,e);
  30907.                 throw new CoreException(msgError,e);
  30908.             }
  30909.         }

  30911.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath;     
  30912.     }
  30913.     
  30914.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPathRead = null;
  30915.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath = null;
  30916.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath() throws CoreException {
  30917.         
  30918.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPathRead==null){
  30919.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_NEAR_CACHE_UNSAFE_ASYNC_MAP.config";

  30921.             try{  
  30922.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30924.                 if (value != null){
  30925.                     value = value.trim();
  30926.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath = value;
  30927.                 }

  30929.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPathRead = true;
  30930.                 
  30931.             }catch(java.lang.Exception e) {
  30932.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30933.                 this.logError(msgError,e);
  30934.                 throw new CoreException(msgError,e);
  30935.             }
  30936.         }

  30938.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath;        
  30939.     }
  30940.     
  30941.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPathRead = null;
  30942.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath = null;
  30943.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath() throws CoreException {
  30944.         
  30945.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPathRead==null){
  30946.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_REPLICATED_MAP.config";

  30948.             try{  
  30949.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30951.                 if (value != null){
  30952.                     value = value.trim();
  30953.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath = value;
  30954.                 }

  30956.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPathRead = true;
  30957.                 
  30958.             }catch(java.lang.Exception e) {
  30959.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30960.                 this.logError(msgError,e);
  30961.                 throw new CoreException(msgError,e);
  30962.             }
  30963.         }

  30965.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath;      
  30966.     }
  30967.     
  30968.     
  30969.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastLocalConfigPathRead = null;
  30970.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath = null;
  30971.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath() throws CoreException {
  30972.         
  30973.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalConfigPathRead==null){
  30974.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_LOCAL_CACHE.config";

  30976.             try{  
  30977.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  30979.                 if (value != null){
  30980.                     value = value.trim();
  30981.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath = value;
  30982.                 }

  30984.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalConfigPathRead = true;
  30985.                 
  30986.             }catch(java.lang.Exception e) {
  30987.                 String msgError = "Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage();
  30988.                 this.logError(msgError,e);
  30989.                 throw new CoreException(msgError,e);
  30990.             }
  30991.         }

  30993.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath;     
  30994.     }
  30995.     
  30996.     private Boolean isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy = null;
  30997.     public Boolean isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy() {
  30998.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST.oneMapForeachPolicy";
  30999.         
  31000.         if(this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy==null){
  31001.             try{  
  31002.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  31004.                 if(value!=null){
  31005.                     value = value.trim();
  31006.                     this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy = Boolean.parseBoolean(value);
  31007.                 }else{
  31008.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  31009.                     this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy = false;
  31010.                 }

  31012.             }catch(java.lang.Exception e) {
  31013.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  31014.                 this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy = false;
  31015.             }
  31016.         }
  31017.         
  31018.         return this.isControlloTrafficoGestorePolicyInMemoryHazelcastOneMapForeachPolicy;
  31019.     }
  31020.     
  31021.     private String getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId = null;
  31022.     public String getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId() {
  31023.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST.group_id";
  31024.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId==null){
  31025.             try{ 
  31026.                 String name = null;
  31027.                 name = this.reader.getValueConvertEnvProperties(pName);
  31028.                 if(name==null) {
  31029.                     throw new CoreException(NON_DEFINITA);
  31030.                 }
  31031.                 else {
  31032.                     name = name.trim();
  31033.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId = name;
  31034.                 }
  31035.             }catch(java.lang.Exception e) {
  31036.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  31037.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId = null;
  31038.             }  
  31039.         }

  31041.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId;
  31042.     }
  31043.     
  31044.     private File getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig = null;
  31045.     private Boolean getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfigRead = null;
  31046.     public File getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig() throws CoreException {
  31047.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST.sharedConfig";
  31048.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfigRead==null){
  31049.             initControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfigEngine(pName);
  31050.         }

  31052.         return this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig;
  31053.     }
  31054.     private void initControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfigEngine(String pName) throws CoreException {
  31055.         try{ 
  31056.             String name = null;
  31057.             name = this.reader.getValueConvertEnvProperties(pName);
  31058.             if(name!=null) {
  31059.                 name = name.trim();
  31060.                 this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig = new File(name);
  31061.                 if(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig.exists()) {
  31062.                     if(!this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig.isFile()) {
  31063.                         throw newCoreExceptionNotFile(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig,false);
  31064.                     }
  31065.                     if(!this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig.canRead()) {
  31066.                         throw newCoreExceptionCannotRead(this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig,false);
  31067.                     }
  31068.                 }
  31069.                 else {
  31070.                     this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig=null;
  31071.                 }
  31072.             }
  31073.         }catch(java.lang.Exception e) {
  31074.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  31075.             throw new CoreException(e.getMessage(),e);
  31076.         }
  31077.         this.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfigRead = true;
  31078.     }

  31080.     private Integer getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval = null;  
  31081.     public Integer getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheTimerUpdate() {
  31082.         if(this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval==null){
  31083.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.HAZELCAST_LOCAL_CACHE.updateInterval";
  31084.             
  31085.             try{ 
  31086.                 String name = null;
  31087.                 name = this.reader.getValueConvertEnvProperties(pName);
  31088.                 if (name != null) {
  31089.                     name = name.trim();
  31090.                     this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval = Integer.valueOf(name);
  31091.                 } else {
  31092.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,5));
  31093.                     this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval =  5;
  31094.                 }
  31095.             }catch(java.lang.Exception e) {
  31096.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,5),e);
  31097.                 this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval = 5;
  31098.             }   
  31099.         }

  31101.         return this.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheUpdateInterval;
  31102.     }
  31103.     
  31104.     private Boolean isHazelcastSecurityRecommendationsEnabled = null;
  31105.     public boolean isHazelcastSecurityRecommendationsEnabled() {    
  31106.         if(this.isHazelcastSecurityRecommendationsEnabled==null){
  31107.             String pName = "org.openspcoop2.pdd.hazelcast.security.recommendations";
  31108.             try{ 
  31109.                 String name = null;
  31110.                 name = this.reader.getValueConvertEnvProperties(pName);
  31111.                 if(name==null){
  31112.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  31113.                     name="true";
  31114.                 }
  31115.                 name = name.trim();
  31116.                 this.isHazelcastSecurityRecommendationsEnabled = Boolean.parseBoolean(name);
  31117.             } catch(java.lang.Exception e) {
  31118.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, true));
  31119.                 this.isHazelcastSecurityRecommendationsEnabled = true;
  31120.             }    
  31121.         }

  31123.         return this.isHazelcastSecurityRecommendationsEnabled;
  31124.     }
  31125.     
  31126.     private Boolean isHazelcastDiagnosticsEnabled = null;
  31127.     public boolean isHazelcastDiagnosticsEnabled() {    
  31128.         if(this.isHazelcastDiagnosticsEnabled==null){
  31129.             String pName = "org.openspcoop2.pdd.hazelcast.diagnostics.enabled";
  31130.             try{ 
  31131.                 String name = null;
  31132.                 name = this.reader.getValueConvertEnvProperties(pName);
  31133.                 if(name==null){
  31134.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  31135.                     name="true";
  31136.                 }
  31137.                 name = name.trim();
  31138.                 this.isHazelcastDiagnosticsEnabled = Boolean.parseBoolean(name);
  31139.             } catch(java.lang.Exception e) {
  31140.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, true));
  31141.                 this.isHazelcastDiagnosticsEnabled = true;
  31142.             }    
  31143.         }

  31145.         return this.isHazelcastDiagnosticsEnabled;
  31146.     }
  31147.     
  31148.     private File getHazelcastDiagnosticsDirectory = null;
  31149.     public File getHazelcastDiagnosticsDirectory() throws CoreException {   
  31150.         if(this.getHazelcastDiagnosticsDirectory==null){
  31151.             String pName = "org.openspcoop2.pdd.hazelcast.diagnostics.directory";
  31152.             try{ 
  31153.                 String name = null;
  31154.                 name = this.reader.getValueConvertEnvProperties(pName);
  31155.                 if(name==null){
  31156.                     throw new CoreException("Hazelcast diagnostics dir non impostata");
  31157.                 }
  31158.                 name = LoggerWrapperFactory.applyClusterIdStrategy(name.trim(), "hazelcast");
  31159.                 this.getHazelcastDiagnosticsDirectory = new File(name);
  31160.                 checkHazelcastDiagnosticsDirectory();
  31161.             } catch(java.lang.Exception e) {
  31162.                 this.logError("Riscontrato errore per la directory della diagnostica di hazelcast ("+pName+"): "+e.getMessage(),e);
  31163.                 throw new CoreException(e.getMessage(),e);
  31164.             }    
  31165.         }

  31167.         return this.getHazelcastDiagnosticsDirectory;
  31168.     }
  31169.     private void checkHazelcastDiagnosticsDirectory() throws CoreException {    
  31170.         if(this.getHazelcastDiagnosticsDirectory.exists()) {
  31171.             if(!this.getHazelcastDiagnosticsDirectory.isDirectory()) {
  31172.                 throw newCoreExceptionNotDir(this.getHazelcastDiagnosticsDirectory,true);
  31173.             }
  31174.             if(!this.getHazelcastDiagnosticsDirectory.canRead()) {
  31175.                 throw newCoreExceptionCannotRead(this.getHazelcastDiagnosticsDirectory, true);
  31176.             }
  31177.             if(!this.getHazelcastDiagnosticsDirectory.canWrite()) {
  31178.                 throw newCoreExceptionCannotWrite(this.getHazelcastDiagnosticsDirectory, true);
  31179.             }
  31180.         }
  31181.         else {
  31182.             // viene creata automaticamente
  31183.         }
  31184.     }
  31185.     
  31186.     private Integer getHazelcastDiagnosticsMaxRolledFileCount = null;
  31187.     public int getHazelcastDiagnosticsMaxRolledFileCount() throws CoreException {   
  31188.         if(this.getHazelcastDiagnosticsMaxRolledFileCount==null){
  31189.             String pName = "org.openspcoop2.pdd.hazelcast.diagnostics.max.rolled.file.count";
  31190.             try{ 
  31191.                 String name = null;
  31192.                 name = this.reader.getValueConvertEnvProperties(pName);
  31193.                 if(name==null){
  31194.                     throw new CoreException("Hazelcast diagnostics max.rolled.file.count config not found");
  31195.                 }
  31196.                 name = name.trim();
  31197.                 this.getHazelcastDiagnosticsMaxRolledFileCount = Integer.valueOf(name);
  31198.             } catch(java.lang.Exception e) {
  31199.                 this.logError("Riscontrato errore durante la lettura delle configurazione diagnostica di hazelcast ("+pName+"): "+e.getMessage(),e);
  31200.                 throw new CoreException(e.getMessage(),e);
  31201.             }    
  31202.         }

  31204.         return this.getHazelcastDiagnosticsMaxRolledFileCount;
  31205.     }
  31206.     
  31207.     private Integer getHazelcastDiagnosticsMaxFileSizeMb = null;
  31208.     public int getHazelcastDiagnosticsMaxFileSizeMb() throws CoreException {    
  31209.         if(this.getHazelcastDiagnosticsMaxFileSizeMb==null){
  31210.             String pName = "org.openspcoop2.pdd.hazelcast.diagnostics.max.file.size.mb";
  31211.             try{ 
  31212.                 String name = null;
  31213.                 name = this.reader.getValueConvertEnvProperties(pName);
  31214.                 if(name==null){
  31215.                     throw new CoreException("Hazelcast diagnostics max.rolled.file.count config not found");
  31216.                 }
  31217.                 name = name.trim();
  31218.                 this.getHazelcastDiagnosticsMaxFileSizeMb = Integer.valueOf(name);
  31219.             } catch(java.lang.Exception e) {
  31220.                 this.logError("Riscontrato errore durante la lettura delle configurazione diagnostica di hazelcast ("+pName+"): "+e.getMessage(),e);
  31221.                 throw new CoreException(e.getMessage(),e);
  31222.             }    
  31223.         }

  31225.         return this.getHazelcastDiagnosticsMaxFileSizeMb;
  31226.     }
  31227.     
  31228.     private Integer getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover = null;
  31229.     public int getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover() {   
  31230.         if(this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover==null){
  31231.             String pName = "org.openspcoop2.pdd.hazelcast.CPSubsystem.distributedObjectDestroyedException.failover";
  31232.             try{ 
  31233.                 String name = null;
  31234.                 name = this.reader.getValueConvertEnvProperties(pName);
  31235.                 if(name==null){
  31236.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, -1));
  31237.                     name="-1";
  31238.                 }
  31239.                 name = name.trim();
  31240.                 this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover = Integer.valueOf(name);
  31241.             } catch(java.lang.Exception e) {
  31242.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, -1));
  31243.                 this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover = -1;
  31244.             }    
  31245.         }

  31247.         return this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailover;
  31248.     }
  31249.     
  31250.     private Integer getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs = null;
  31251.     public int getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs() {   
  31252.         if(this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs==null){
  31253.             String pName = "org.openspcoop2.pdd.hazelcast.CPSubsystem.distributedObjectDestroyedException.failover.checkEveryMs";
  31254.             try{ 
  31255.                 String name = null;
  31256.                 name = this.reader.getValueConvertEnvProperties(pName);
  31257.                 if(name==null){
  31258.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, 500));
  31259.                     name="500";
  31260.                 }
  31261.                 name = name.trim();
  31262.                 this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs = Integer.valueOf(name);
  31263.             } catch(java.lang.Exception e) {
  31264.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, 500));
  31265.                 this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs = 500;
  31266.             }    
  31267.         }

  31269.         return this.getHazelcastCPSubsystemDistributedObjectDestroyedExceptionFailoverCheckEveryMs;
  31270.     }
  31271.     
  31272.     private Boolean isRedisEngineEnabled = null;
  31273.     public boolean isRedisEngineEnabled() { 
  31274.         if(this.isRedisEngineEnabled==null){
  31275.             String pName = "org.openspcoop2.pdd.redis.enabled";
  31276.             try{ 
  31277.                 String name = null;
  31278.                 name = this.reader.getValueConvertEnvProperties(pName);
  31279.                 if(name==null){
  31280.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  31281.                     name="true";
  31282.                 }
  31283.                 name = name.trim();
  31284.                 this.isRedisEngineEnabled = Boolean.parseBoolean(name);
  31285.             } catch(java.lang.Exception e) {
  31286.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  31287.                 this.isRedisEngineEnabled = true;
  31288.             }    
  31289.         }

  31291.         return this.isRedisEngineEnabled;
  31292.     }
  31293.     
  31294.     private List<String> getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl = null;
  31295.     private boolean getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrlRead = false;
  31296.     public List<String> getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl() throws CoreException {    
  31297.         if(!this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrlRead){
  31298.             String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.REDIS.connectionUrl";
  31299.             try{ 

  31301.                 String name = null;
  31302.                 name = this.reader.getValueConvertEnvProperties(pName);
  31303.                 if(name==null){
  31304.                     throw new CoreException(NON_DEFINITA);
  31305.                 }else{
  31306.                     String [] r = name.trim().split(",");
  31307.                     List<String> l = new ArrayList<>();
  31308.                     for(int i=0; i<r.length; i++){
  31309.                         r[i] = r[i].trim();
  31310.                         l.add(r[i]);
  31311.                     }
  31312.                     
  31313.                     if(!l.isEmpty()) {
  31314.                         this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl = new ArrayList<>();
  31315.                         this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl.addAll(l);
  31316.                     }
  31317.                     else {
  31318.                         throw new CoreException(NON_DEFINITA);
  31319.                     }
  31320.                 }
  31321.             }catch(java.lang.Exception e) {
  31322.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  31323.                 throw new CoreException("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  31324.             }  
  31325.             this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrlRead = true;
  31326.         }

  31328.         return this.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl;
  31329.     }
  31330.     
  31331.     private Boolean isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy = null;
  31332.     public Boolean isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy() {
  31333.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.REDIS.oneMapForeachPolicy";
  31334.         
  31335.         if(this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy==null){
  31336.             try{  
  31337.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  31339.                 if(value!=null){
  31340.                     value = value.trim();
  31341.                     this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy = Boolean.parseBoolean(value);
  31342.                 }else{
  31343.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  31344.                     this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy = false;
  31345.                 }

  31347.             }catch(java.lang.Exception e) {
  31348.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  31349.                 this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy = false;
  31350.             }
  31351.         }
  31352.         
  31353.         return this.isControlloTrafficoGestorePolicyInMemoryRedisOneMapForeachPolicy;
  31354.     }
  31355.     
  31356.     private Boolean isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady = null;
  31357.     public Boolean isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady() {
  31358.         String pName = "org.openspcoop2.pdd.controlloTraffico.gestorePolicy.inMemory.REDIS.startupGovWay.throwExceptionIfRedisNotReady";
  31359.         
  31360.         if(this.isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady==null){
  31361.             try{  
  31362.                 String value = this.reader.getValueConvertEnvProperties(pName); 

  31364.                 if(value!=null){
  31365.                     value = value.trim();
  31366.                     this.isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady = Boolean.parseBoolean(value);
  31367.                 }else{
  31368.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  31369.                     this.isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady = false;
  31370.                 }

  31372.             }catch(java.lang.Exception e) {
  31373.                 this.logWarn(getMessaggioProprietaNonImpostata(pName, e, false),e);
  31374.                 this.isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady = false;
  31375.             }
  31376.         }
  31377.         
  31378.         return this.isControlloTrafficoGestorePolicyInMemoryRedisThrowExceptionIfRedisNotReady;
  31379.     }
  31380.     
  31381.     
  31382.     private String getControlloTrafficoGestorePolicyWSUrl = null;
  31383.     public String getControlloTrafficoGestorePolicyWSUrl() throws CoreException {   
  31384.         if(this.getControlloTrafficoGestorePolicyWSUrl==null){
  31385.             try{ 
  31386.                 String name = null;
  31387.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.gestorePolicy.ws.url");
  31388.                 if(name==null){
  31389.                     throw new CoreException("Proprieta' non impostata");
  31390.                 }
  31391.                 else {
  31392.                     name = name.trim();
  31393.                     @SuppressWarnings("unused")
  31394.                     String s = (new URL(name)).toString();
  31395.                     this.getControlloTrafficoGestorePolicyWSUrl = name;
  31396.                 }
  31397.             } catch(java.lang.Exception e) {
  31398.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.ws.url': "+e.getMessage(),e);
  31399.                 throw new CoreException(e.getMessage(),e);
  31400.             }    
  31401.         }

  31403.         return this.getControlloTrafficoGestorePolicyWSUrl;
  31404.     }
  31405.         
  31406.     private Boolean getControlloTrafficoNotifyImplRead = null;
  31407.     private INotify getControlloTrafficoNotifyImpl = null;
  31408.     public INotify getControlloTrafficoNotifyImpl(Loader loaderOpenSPCoop) throws CoreException {   
  31409.         if(this.getControlloTrafficoNotifyImplRead==null){
  31410.             try{ 
  31411.                 String name = null;
  31412.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.notifier.implementation");
  31413.                 if(name!=null){
  31414.                     name = name.trim();
  31415.                     this.getControlloTrafficoNotifyImpl = (INotify) loaderOpenSPCoop.newInstance(name);
  31416.                 }
  31417.             } catch(java.lang.Exception e) {
  31418.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.notifier.implementation': "+e.getMessage(),e);
  31419.                 throw new CoreException(e.getMessage(),e);
  31420.             }  
  31421.             this.getControlloTrafficoNotifyImplRead = true;
  31422.         }

  31424.         return this.getControlloTrafficoNotifyImpl;
  31425.     }
  31426.     
  31427.     private File getControlloTrafficoGestorePolicyFileSystemRecoveryRepository = null;
  31428.     public File getControlloTrafficoGestorePolicyFileSystemRecoveryRepository() throws CoreException {  
  31429.         if(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository==null){
  31430.             try{ 
  31431.                 String name = null;
  31432.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.gestorePolicy.fileSystemRecovery.repository");
  31433.                 if(name!=null){
  31434.                     name = LoggerWrapperFactory.applyClusterIdStrategy(name.trim(), "controlloTraffico");
  31435.                     initControlloTrafficoGestorePolicyFileSystemRecoveryRepository(name);
  31436.                 }
  31437.             } catch(java.lang.Exception e) {
  31438.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.gestorePolicy.fileSystemRecovery.repository': "+e.getMessage(),e);
  31439.                 throw new CoreException(e.getMessage(),e);
  31440.             }    
  31441.         }

  31443.         return this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository;
  31444.     }
  31445.     private void initControlloTrafficoGestorePolicyFileSystemRecoveryRepository(String name) throws CoreException { 
  31446.         this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository = new File(name);
  31447.         if(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository.exists()) {
  31448.             if(!this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository.isDirectory()) {
  31449.                 throw newCoreExceptionNotDir(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository, true);
  31450.             }
  31451.             if(!this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository.canRead()) {
  31452.                 throw newCoreExceptionCannotRead(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository, true);
  31453.             }
  31454.             if(!this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository.canWrite()) {
  31455.                 throw newCoreExceptionCannotWrite(this.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository, true);
  31456.             }
  31457.         }
  31458.         else {
  31459.             // viene creata automaticamente
  31460.         }
  31461.     }
  31462.     
  31463.     
  31464.     
  31465.     
  31466.     
  31467.     // Limit
  31468.     
  31469.     private String [] getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit = null;
  31470.     private Boolean getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimitRead = null;
  31471.     public String [] getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit() throws CoreException {  
  31472.         if(this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimitRead==null){
  31473.             try{ 
  31474.                 String name = null;
  31475.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteSimultanee.header.limit");
  31476.                 if(name!=null){
  31477.                     name = name.trim();
  31478.                     this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit = name.split(",");
  31479.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit.length; i++) {
  31480.                         this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit[i].trim();
  31481.                     }
  31482.                 }
  31483.                 
  31484.                 this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimitRead = true;
  31485.                 
  31486.             } catch(java.lang.Exception e) {
  31487.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteSimultanee.header.limit': "+e.getMessage(),e);
  31488.                 throw new CoreException(e.getMessage(),e);
  31489.             }    
  31490.         }

  31492.         return this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit;
  31493.     }
  31494.     
  31495.     private String [] getControlloTrafficoNumeroRichiesteHeaderLimit = null;
  31496.     private Boolean getControlloTrafficoNumeroRichiesteHeaderLimitRead = null;
  31497.     public String [] getControlloTrafficoNumeroRichiesteHeaderLimit() throws CoreException {    
  31498.         if(this.getControlloTrafficoNumeroRichiesteHeaderLimitRead==null){
  31499.             try{ 
  31500.                 String name = null;
  31501.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit");
  31502.                 if(name!=null){
  31503.                     name = name.trim();
  31504.                     this.getControlloTrafficoNumeroRichiesteHeaderLimit = name.split(",");
  31505.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteHeaderLimit.length; i++) {
  31506.                         this.getControlloTrafficoNumeroRichiesteHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteHeaderLimit[i].trim();
  31507.                     }
  31508.                 }
  31509.                 
  31510.                 this.getControlloTrafficoNumeroRichiesteHeaderLimitRead = true;
  31511.                 
  31512.             } catch(java.lang.Exception e) {
  31513.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit': "+e.getMessage(),e);
  31514.                 throw new CoreException(e.getMessage(),e);
  31515.             }    
  31516.         }

  31518.         return this.getControlloTrafficoNumeroRichiesteHeaderLimit;
  31519.     }
  31520.     
  31521.     private String [] getControlloTrafficoOccupazioneBandaHeaderLimit = null;
  31522.     private Boolean getControlloTrafficoOccupazioneBandaHeaderLimitRead = null;
  31523.     public String [] getControlloTrafficoOccupazioneBandaHeaderLimit() throws CoreException {   
  31524.         if(this.getControlloTrafficoOccupazioneBandaHeaderLimitRead==null){
  31525.             try{ 
  31526.                 String name = null;
  31527.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.limit");
  31528.                 if(name!=null){
  31529.                     name = name.trim();
  31530.                     this.getControlloTrafficoOccupazioneBandaHeaderLimit = name.split(",");
  31531.                     for (int i = 0; i < this.getControlloTrafficoOccupazioneBandaHeaderLimit.length; i++) {
  31532.                         this.getControlloTrafficoOccupazioneBandaHeaderLimit[i]=this.getControlloTrafficoOccupazioneBandaHeaderLimit[i].trim();
  31533.                     }
  31534.                 }
  31535.                 
  31536.                 this.getControlloTrafficoOccupazioneBandaHeaderLimitRead = true;
  31537.                 
  31538.             } catch(java.lang.Exception e) {
  31539.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.limit': "+e.getMessage(),e);
  31540.                 throw new CoreException(e.getMessage(),e);
  31541.             }    
  31542.         }

  31544.         return this.getControlloTrafficoOccupazioneBandaHeaderLimit;
  31545.     }
  31546.     
  31547.     private String [] getControlloTrafficoTempoComplessivoRispostaHeaderLimit = null;
  31548.     private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderLimitRead = null;
  31549.     public String [] getControlloTrafficoTempoComplessivoRispostaHeaderLimit() throws CoreException {   
  31550.         if(this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitRead==null){
  31551.             try{ 
  31552.                 String name = null;
  31553.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.limit");
  31554.                 if(name!=null){
  31555.                     name = name.trim();
  31556.                     this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit = name.split(",");
  31557.                     for (int i = 0; i < this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit.length; i++) {
  31558.                         this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit[i]=this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit[i].trim();
  31559.                     }
  31560.                 }
  31561.                 
  31562.                 this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitRead = true;
  31563.                 
  31564.             } catch(java.lang.Exception e) {
  31565.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.limit': "+e.getMessage(),e);
  31566.                 throw new CoreException(e.getMessage(),e);
  31567.             }    
  31568.         }

  31570.         return this.getControlloTrafficoTempoComplessivoRispostaHeaderLimit;
  31571.     }
  31572.     
  31573.     private String [] getControlloTrafficoTempoMedioRispostaHeaderLimit = null;
  31574.     private Boolean getControlloTrafficoTempoMedioRispostaHeaderLimitRead = null;
  31575.     public String [] getControlloTrafficoTempoMedioRispostaHeaderLimit() throws CoreException { 
  31576.         if(this.getControlloTrafficoTempoMedioRispostaHeaderLimitRead==null){
  31577.             try{ 
  31578.                 String name = null;
  31579.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.limit");
  31580.                 if(name!=null){
  31581.                     name = name.trim();
  31582.                     this.getControlloTrafficoTempoMedioRispostaHeaderLimit = name.split(",");
  31583.                     for (int i = 0; i < this.getControlloTrafficoTempoMedioRispostaHeaderLimit.length; i++) {
  31584.                         this.getControlloTrafficoTempoMedioRispostaHeaderLimit[i]=this.getControlloTrafficoTempoMedioRispostaHeaderLimit[i].trim();
  31585.                     }
  31586.                 }
  31587.                 
  31588.                 this.getControlloTrafficoTempoMedioRispostaHeaderLimitRead = true;
  31589.                 
  31590.             } catch(java.lang.Exception e) {
  31591.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.limit': "+e.getMessage(),e);
  31592.                 throw new CoreException(e.getMessage(),e);
  31593.             }    
  31594.         }

  31596.         return this.getControlloTrafficoTempoMedioRispostaHeaderLimit;
  31597.     }
  31598.     
  31599.     private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit = null;
  31600.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitRead = null;
  31601.     public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit() throws CoreException {   
  31602.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitRead==null){
  31603.             try{ 
  31604.                 String name = null;
  31605.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.limit");
  31606.                 if(name!=null){
  31607.                     name = name.trim();
  31608.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit = name.split(",");
  31609.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit.length; i++) {
  31610.                         this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit[i].trim();
  31611.                     }
  31612.                 }
  31613.                 
  31614.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitRead = true;
  31615.                 
  31616.             } catch(java.lang.Exception e) {
  31617.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.limit': "+e.getMessage(),e);
  31618.                 throw new CoreException(e.getMessage(),e);
  31619.             }    
  31620.         }

  31622.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit;
  31623.     }
  31624.     
  31625.     private String [] getControlloTrafficoNumeroRichiesteFalliteHeaderLimit = null;
  31626.     private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderLimitRead = null;
  31627.     public String [] getControlloTrafficoNumeroRichiesteFalliteHeaderLimit() throws CoreException { 
  31628.         if(this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitRead==null){
  31629.             try{ 
  31630.                 String name = null;
  31631.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.limit");
  31632.                 if(name!=null){
  31633.                     name = name.trim();
  31634.                     this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit = name.split(",");
  31635.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit.length; i++) {
  31636.                         this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit[i].trim();
  31637.                     }
  31638.                 }
  31639.                 
  31640.                 this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitRead = true;
  31641.                 
  31642.             } catch(java.lang.Exception e) {
  31643.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.limit': "+e.getMessage(),e);
  31644.                 throw new CoreException(e.getMessage(),e);
  31645.             }    
  31646.         }

  31648.         return this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit;
  31649.     }
  31650.     
  31651.     private String [] getControlloTrafficoNumeroFaultApplicativiHeaderLimit = null;
  31652.     private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderLimitRead = null;
  31653.     public String [] getControlloTrafficoNumeroFaultApplicativiHeaderLimit() throws CoreException { 
  31654.         if(this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitRead==null){
  31655.             try{ 
  31656.                 String name = null;
  31657.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.limit");
  31658.                 if(name!=null){
  31659.                     name = name.trim();
  31660.                     this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit = name.split(",");
  31661.                     for (int i = 0; i < this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit.length; i++) {
  31662.                         this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit[i]=this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit[i].trim();
  31663.                     }
  31664.                 }
  31665.                 
  31666.                 this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitRead = true;
  31667.                 
  31668.             } catch(java.lang.Exception e) {
  31669.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.limit': "+e.getMessage(),e);
  31670.                 throw new CoreException(e.getMessage(),e);
  31671.             }    
  31672.         }

  31674.         return this.getControlloTrafficoNumeroFaultApplicativiHeaderLimit;
  31675.     }
  31676.     
  31677.     private String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit = null;
  31678.     private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitRead = null;
  31679.     public String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit() throws CoreException {    
  31680.         if(this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitRead==null){
  31681.             try{ 
  31682.                 String name = null;
  31683.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.limit");
  31684.                 if(name!=null){
  31685.                     name = name.trim();
  31686.                     this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit = name.split(",");
  31687.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit.length; i++) {
  31688.                         this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit[i].trim();
  31689.                     }
  31690.                 }
  31691.                 
  31692.                 this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitRead = true;
  31693.                 
  31694.             } catch(java.lang.Exception e) {
  31695.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.limit': "+e.getMessage(),e);
  31696.                 throw new CoreException(e.getMessage(),e);
  31697.             }    
  31698.         }

  31700.         return this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit;
  31701.     }   
  31702.         
  31703.     private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit = null;
  31704.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitRead = null;
  31705.     public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit() throws CoreException {  
  31706.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitRead==null){
  31707.             try{ 
  31708.                 String name = null;
  31709.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.limit");
  31710.                 if(name!=null){
  31711.                     name = name.trim();
  31712.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit = name.split(",");
  31713.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit.length; i++) {
  31714.                         this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit[i].trim();
  31715.                     }
  31716.                 }
  31717.                 
  31718.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitRead = true;
  31719.                 
  31720.             } catch(java.lang.Exception e) {
  31721.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.limit': "+e.getMessage(),e);
  31722.                 throw new CoreException(e.getMessage(),e);
  31723.             }    
  31724.         }

  31726.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit;
  31727.     }   
  31728.     
  31729.     
  31730.     // Windows
  31731.     
  31732.     private Boolean getControlloTrafficoNumeroRichiesteHeaderLimitWindows = null;
  31733.     private Boolean getControlloTrafficoNumeroRichiesteHeaderLimitWindowsRead = null;
  31734.     public Boolean getControlloTrafficoNumeroRichiesteHeaderLimitWindows() throws CoreException {   
  31735.         if(this.getControlloTrafficoNumeroRichiesteHeaderLimitWindowsRead==null){
  31736.             try{ 
  31737.                 String name = null;
  31738.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit.windows");
  31739.                 if(name!=null){
  31740.                     name = name.trim();
  31741.                     this.getControlloTrafficoNumeroRichiesteHeaderLimitWindows = Boolean.valueOf(name);
  31742.                 }
  31743.                 
  31744.                 this.getControlloTrafficoNumeroRichiesteHeaderLimitWindowsRead = true;
  31745.                 
  31746.             } catch(java.lang.Exception e) {
  31747.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit.windows': "+e.getMessage(),e);
  31748.                 throw new CoreException(e.getMessage(),e);
  31749.             }    
  31750.         }

  31752.         return this.getControlloTrafficoNumeroRichiesteHeaderLimitWindows;
  31753.     }
  31754.     
  31755.     private Boolean getControlloTrafficoOccupazioneBandaHeaderLimitWindows = null;
  31756.     private Boolean getControlloTrafficoOccupazioneBandaHeaderLimitWindowsRead = null;
  31757.     public Boolean getControlloTrafficoOccupazioneBandaHeaderLimitWindows() throws CoreException {  
  31758.         if(this.getControlloTrafficoOccupazioneBandaHeaderLimitWindowsRead==null){
  31759.             try{ 
  31760.                 String name = null;
  31761.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.limit.windows");
  31762.                 if(name!=null){
  31763.                     name = name.trim();
  31764.                     this.getControlloTrafficoOccupazioneBandaHeaderLimitWindows = Boolean.valueOf(name);
  31765.                 }
  31766.                 
  31767.                 this.getControlloTrafficoOccupazioneBandaHeaderLimitWindowsRead = true;
  31768.                 
  31769.             } catch(java.lang.Exception e) {
  31770.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.limit.windows': "+e.getMessage(),e);
  31771.                 throw new CoreException(e.getMessage(),e);
  31772.             }    
  31773.         }

  31775.         return this.getControlloTrafficoOccupazioneBandaHeaderLimitWindows;
  31776.     }
  31777.     
  31778.     private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows = null;
  31779.     private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindowsRead = null;
  31780.     public Boolean getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows() throws CoreException {  
  31781.         if(this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindowsRead==null){
  31782.             try{ 
  31783.                 String name = null;
  31784.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.limit.windows");
  31785.                 if(name!=null){
  31786.                     name = name.trim();
  31787.                     this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows = Boolean.valueOf(name);
  31788.                 }
  31789.                 
  31790.                 this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindowsRead = true;
  31791.                 
  31792.             } catch(java.lang.Exception e) {
  31793.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.limit.windows': "+e.getMessage(),e);
  31794.                 throw new CoreException(e.getMessage(),e);
  31795.             }    
  31796.         }

  31798.         return this.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows;
  31799.     }
  31800.     
  31801.     private Boolean getControlloTrafficoTempoMedioRispostaHeaderLimitWindows = null;
  31802.     private Boolean getControlloTrafficoTempoMedioRispostaHeaderLimitWindowsRead = null;
  31803.     public Boolean getControlloTrafficoTempoMedioRispostaHeaderLimitWindows() throws CoreException {    
  31804.         if(this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindowsRead==null){
  31805.             try{ 
  31806.                 String name = null;
  31807.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.limit.windows");
  31808.                 if(name!=null){
  31809.                     name = name.trim();
  31810.                     this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindows = Boolean.valueOf(name);
  31811.                 }
  31812.                 
  31813.                 this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindowsRead = true;
  31814.                 
  31815.             } catch(java.lang.Exception e) {
  31816.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.limit.windows': "+e.getMessage(),e);
  31817.                 throw new CoreException(e.getMessage(),e);
  31818.             }    
  31819.         }

  31821.         return this.getControlloTrafficoTempoMedioRispostaHeaderLimitWindows;
  31822.     }
  31823.     
  31824.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows = null;
  31825.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindowsRead = null;
  31826.     public Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows() throws CoreException {  
  31827.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindowsRead==null){
  31828.             try{ 
  31829.                 String name = null;
  31830.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.limit.windows");
  31831.                 if(name!=null){
  31832.                     name = name.trim();
  31833.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows = Boolean.valueOf(name);
  31834.                 }
  31835.                 
  31836.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindowsRead = true;
  31837.                 
  31838.             } catch(java.lang.Exception e) {
  31839.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.limit.windows': "+e.getMessage(),e);
  31840.                 throw new CoreException(e.getMessage(),e);
  31841.             }    
  31842.         }

  31844.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows;
  31845.     }
  31846.     
  31847.     private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows = null;
  31848.     private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindowsRead = null;
  31849.     public Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows() throws CoreException {    
  31850.         if(this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindowsRead==null){
  31851.             try{ 
  31852.                 String name = null;
  31853.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.limit.windows");
  31854.                 if(name!=null){
  31855.                     name = name.trim();
  31856.                     this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows = Boolean.valueOf(name);
  31857.                 }
  31858.                 
  31859.                 this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindowsRead = true;
  31860.                 
  31861.             } catch(java.lang.Exception e) {
  31862.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.limit.windows': "+e.getMessage(),e);
  31863.                 throw new CoreException(e.getMessage(),e);
  31864.             }    
  31865.         }

  31867.         return this.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows;
  31868.     }
  31869.     
  31870.     private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows = null;
  31871.     private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindowsRead = null;
  31872.     public Boolean getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows() throws CoreException {    
  31873.         if(this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindowsRead==null){
  31874.             try{ 
  31875.                 String name = null;
  31876.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.limit.windows");
  31877.                 if(name!=null){
  31878.                     name = name.trim();
  31879.                     this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows = Boolean.valueOf(name);
  31880.                 }
  31881.                 
  31882.                 this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindowsRead = true;
  31883.                 
  31884.             } catch(java.lang.Exception e) {
  31885.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.limit.windows': "+e.getMessage(),e);
  31886.                 throw new CoreException(e.getMessage(),e);
  31887.             }    
  31888.         }

  31890.         return this.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows;
  31891.     }
  31892.     
  31893.     private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows = null;
  31894.     private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindowsRead = null;
  31895.     public Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows() throws CoreException {   
  31896.         if(this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindowsRead==null){
  31897.             try{ 
  31898.                 String name = null;
  31899.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.limit.windows");
  31900.                 if(name!=null){
  31901.                     name = name.trim();
  31902.                     this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows = Boolean.valueOf(name);
  31903.                 }
  31904.                 
  31905.                 this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindowsRead = true;
  31906.                 
  31907.             } catch(java.lang.Exception e) {
  31908.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.limit.windows': "+e.getMessage(),e);
  31909.                 throw new CoreException(e.getMessage(),e);
  31910.             }    
  31911.         }

  31913.         return this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows;
  31914.     }   
  31915.     
  31916.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindows = null;
  31917.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindowsRead = null;
  31918.     public Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindows() throws CoreException { 
  31919.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindowsRead==null){
  31920.             try{ 
  31921.                 String name = null;
  31922.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.limit.windows");
  31923.                 if(name!=null){
  31924.                     name = name.trim();
  31925.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindows = Boolean.valueOf(name);
  31926.                 }
  31927.                 
  31928.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindowsRead = true;
  31929.                 
  31930.             } catch(java.lang.Exception e) {
  31931.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.limit.windows': "+e.getMessage(),e);
  31932.                 throw new CoreException(e.getMessage(),e);
  31933.             }    
  31934.         }

  31936.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindows;
  31937.     }   

  31939.     
  31940.     // Remaining
  31941.     
  31942.     private String [] getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining = null;
  31943.     private Boolean getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemainingRead = null;
  31944.     public String [] getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining() throws CoreException {  
  31945.         if(this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemainingRead==null){
  31946.             try{ 
  31947.                 String name = null;
  31948.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteSimultanee.header.remaining");
  31949.                 if(name!=null){
  31950.                     name = name.trim();
  31951.                     this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining = name.split(",");
  31952.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining.length; i++) {
  31953.                         this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining[i].trim();
  31954.                     }
  31955.                 }
  31956.                 
  31957.                 this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemainingRead = true;
  31958.                 
  31959.             } catch(java.lang.Exception e) {
  31960.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteSimultanee.header.remaining': "+e.getMessage(),e);
  31961.                 throw new CoreException(e.getMessage(),e);
  31962.             }    
  31963.         }

  31965.         return this.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining;
  31966.     }
  31967.     
  31968.     private String [] getControlloTrafficoNumeroRichiesteHeaderRemaining = null;
  31969.     private Boolean getControlloTrafficoNumeroRichiesteHeaderRemainingRead = null;
  31970.     public String [] getControlloTrafficoNumeroRichiesteHeaderRemaining() throws CoreException {    
  31971.         if(this.getControlloTrafficoNumeroRichiesteHeaderRemainingRead==null){
  31972.             try{ 
  31973.                 String name = null;
  31974.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.remaining");
  31975.                 if(name!=null){
  31976.                     name = name.trim();
  31977.                     this.getControlloTrafficoNumeroRichiesteHeaderRemaining = name.split(",");
  31978.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteHeaderRemaining.length; i++) {
  31979.                         this.getControlloTrafficoNumeroRichiesteHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteHeaderRemaining[i].trim();
  31980.                     }
  31981.                 }
  31982.                 
  31983.                 this.getControlloTrafficoNumeroRichiesteHeaderRemainingRead = true;
  31984.                 
  31985.             } catch(java.lang.Exception e) {
  31986.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.remaining': "+e.getMessage(),e);
  31987.                 throw new CoreException(e.getMessage(),e);
  31988.             }    
  31989.         }

  31991.         return this.getControlloTrafficoNumeroRichiesteHeaderRemaining;
  31992.     }
  31993.     
  31994.     private String [] getControlloTrafficoOccupazioneBandaHeaderRemaining = null;
  31995.     private Boolean getControlloTrafficoOccupazioneBandaHeaderRemainingRead = null;
  31996.     public String [] getControlloTrafficoOccupazioneBandaHeaderRemaining() throws CoreException {   
  31997.         if(this.getControlloTrafficoOccupazioneBandaHeaderRemainingRead==null){
  31998.             try{ 
  31999.                 String name = null;
  32000.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.remaining");
  32001.                 if(name!=null){
  32002.                     name = name.trim();
  32003.                     this.getControlloTrafficoOccupazioneBandaHeaderRemaining = name.split(",");
  32004.                     for (int i = 0; i < this.getControlloTrafficoOccupazioneBandaHeaderRemaining.length; i++) {
  32005.                         this.getControlloTrafficoOccupazioneBandaHeaderRemaining[i]=this.getControlloTrafficoOccupazioneBandaHeaderRemaining[i].trim();
  32006.                     }
  32007.                 }
  32008.                 
  32009.                 this.getControlloTrafficoOccupazioneBandaHeaderRemainingRead = true;
  32010.                 
  32011.             } catch(java.lang.Exception e) {
  32012.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.remaining': "+e.getMessage(),e);
  32013.                 throw new CoreException(e.getMessage(),e);
  32014.             }    
  32015.         }

  32017.         return this.getControlloTrafficoOccupazioneBandaHeaderRemaining;
  32018.     }
  32019.     
  32020.     private String [] getControlloTrafficoTempoComplessivoRispostaHeaderRemaining = null;
  32021.     private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderRemainingRead = null;
  32022.     public String [] getControlloTrafficoTempoComplessivoRispostaHeaderRemaining() throws CoreException {   
  32023.         if(this.getControlloTrafficoTempoComplessivoRispostaHeaderRemainingRead==null){
  32024.             try{ 
  32025.                 String name = null;
  32026.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.remaining");
  32027.                 if(name!=null){
  32028.                     name = name.trim();
  32029.                     this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining = name.split(",");
  32030.                     for (int i = 0; i < this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining.length; i++) {
  32031.                         this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining[i]=this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining[i].trim();
  32032.                     }
  32033.                 }
  32034.                 
  32035.                 this.getControlloTrafficoTempoComplessivoRispostaHeaderRemainingRead = true;
  32036.                 
  32037.             } catch(java.lang.Exception e) {
  32038.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.remaining': "+e.getMessage(),e);
  32039.                 throw new CoreException(e.getMessage(),e);
  32040.             }    
  32041.         }

  32043.         return this.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining;
  32044.     }
  32045.         
  32046.     private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining = null;
  32047.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemainingRead = null;
  32048.     public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining() throws CoreException {   
  32049.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemainingRead==null){
  32050.             try{ 
  32051.                 String name = null;
  32052.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.remaining");
  32053.                 if(name!=null){
  32054.                     name = name.trim();
  32055.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining = name.split(",");
  32056.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining.length; i++) {
  32057.                         this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining[i].trim();
  32058.                     }
  32059.                 }
  32060.                 
  32061.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemainingRead = true;
  32062.                 
  32063.             } catch(java.lang.Exception e) {
  32064.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.remaining': "+e.getMessage(),e);
  32065.                 throw new CoreException(e.getMessage(),e);
  32066.             }    
  32067.         }

  32069.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining;
  32070.     }
  32071.     
  32072.     private String [] getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining = null;
  32073.     private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderRemainingRead = null;
  32074.     public String [] getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining() throws CoreException { 
  32075.         if(this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemainingRead==null){
  32076.             try{ 
  32077.                 String name = null;
  32078.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.remaining");
  32079.                 if(name!=null){
  32080.                     name = name.trim();
  32081.                     this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining = name.split(",");
  32082.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining.length; i++) {
  32083.                         this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining[i].trim();
  32084.                     }
  32085.                 }
  32086.                 
  32087.                 this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemainingRead = true;
  32088.                 
  32089.             } catch(java.lang.Exception e) {
  32090.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.remaining': "+e.getMessage(),e);
  32091.                 throw new CoreException(e.getMessage(),e);
  32092.             }    
  32093.         }

  32095.         return this.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining;
  32096.     }
  32097.     
  32098.     private String [] getControlloTrafficoNumeroFaultApplicativiHeaderRemaining = null;
  32099.     private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderRemainingRead = null;
  32100.     public String [] getControlloTrafficoNumeroFaultApplicativiHeaderRemaining() throws CoreException { 
  32101.         if(this.getControlloTrafficoNumeroFaultApplicativiHeaderRemainingRead==null){
  32102.             try{ 
  32103.                 String name = null;
  32104.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.remaining");
  32105.                 if(name!=null){
  32106.                     name = name.trim();
  32107.                     this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining = name.split(",");
  32108.                     for (int i = 0; i < this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining.length; i++) {
  32109.                         this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining[i]=this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining[i].trim();
  32110.                     }
  32111.                 }
  32112.                 
  32113.                 this.getControlloTrafficoNumeroFaultApplicativiHeaderRemainingRead = true;
  32114.                 
  32115.             } catch(java.lang.Exception e) {
  32116.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.remaining': "+e.getMessage(),e);
  32117.                 throw new CoreException(e.getMessage(),e);
  32118.             }    
  32119.         }

  32121.         return this.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining;
  32122.     }
  32123.     
  32124.     private String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining = null;
  32125.     private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemainingRead = null;
  32126.     public String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining() throws CoreException {    
  32127.         if(this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemainingRead==null){
  32128.             try{ 
  32129.                 String name = null;
  32130.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.remaining");
  32131.                 if(name!=null){
  32132.                     name = name.trim();
  32133.                     this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining = name.split(",");
  32134.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining.length; i++) {
  32135.                         this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining[i].trim();
  32136.                     }
  32137.                 }
  32138.                 
  32139.                 this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemainingRead = true;
  32140.                 
  32141.             } catch(java.lang.Exception e) {
  32142.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteNonCompletateConSuccesso.header.remaining': "+e.getMessage(),e);
  32143.                 throw new CoreException(e.getMessage(),e);
  32144.             }    
  32145.         }

  32147.         return this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining;
  32148.     }
  32149.     
  32150.     private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining = null;
  32151.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemainingRead = null;
  32152.     public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining() throws CoreException {  
  32153.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemainingRead==null){
  32154.             try{ 
  32155.                 String name = null;
  32156.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.remaining");
  32157.                 if(name!=null){
  32158.                     name = name.trim();
  32159.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining = name.split(",");
  32160.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining.length; i++) {
  32161.                         this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining[i].trim();
  32162.                     }
  32163.                 }
  32164.                 
  32165.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemainingRead = true;
  32166.                 
  32167.             } catch(java.lang.Exception e) {
  32168.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.remaining': "+e.getMessage(),e);
  32169.                 throw new CoreException(e.getMessage(),e);
  32170.             }    
  32171.         }

  32173.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining;
  32174.     }
  32175.     

  32177.     
  32178.     
  32179.     
  32180.     // Reset
  32181.     
  32182.     private String [] getControlloTrafficoNumeroRichiesteHeaderReset = null;
  32183.     private Boolean getControlloTrafficoNumeroRichiesteHeaderResetRead = null;
  32184.     public String [] getControlloTrafficoNumeroRichiesteHeaderReset() throws CoreException {    
  32185.         if(this.getControlloTrafficoNumeroRichiesteHeaderResetRead==null){
  32186.             try{ 
  32187.                 String name = null;
  32188.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.reset");
  32189.                 if(name!=null){
  32190.                     name = name.trim();
  32191.                     this.getControlloTrafficoNumeroRichiesteHeaderReset = name.split(",");
  32192.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteHeaderReset.length; i++) {
  32193.                         this.getControlloTrafficoNumeroRichiesteHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteHeaderReset[i].trim();
  32194.                     }
  32195.                 }
  32196.                 
  32197.                 this.getControlloTrafficoNumeroRichiesteHeaderResetRead = true;
  32198.                 
  32199.             } catch(java.lang.Exception e) {
  32200.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.reset': "+e.getMessage(),e);
  32201.                 throw new CoreException(e.getMessage(),e);
  32202.             }    
  32203.         }

  32205.         return this.getControlloTrafficoNumeroRichiesteHeaderReset;
  32206.     }
  32207.     
  32208.     private String [] getControlloTrafficoOccupazioneBandaHeaderReset = null;
  32209.     private Boolean getControlloTrafficoOccupazioneBandaHeaderResetRead = null;
  32210.     public String [] getControlloTrafficoOccupazioneBandaHeaderReset() throws CoreException {   
  32211.         if(this.getControlloTrafficoOccupazioneBandaHeaderResetRead==null){
  32212.             try{ 
  32213.                 String name = null;
  32214.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.reset");
  32215.                 if(name!=null){
  32216.                     name = name.trim();
  32217.                     this.getControlloTrafficoOccupazioneBandaHeaderReset = name.split(",");
  32218.                     for (int i = 0; i < this.getControlloTrafficoOccupazioneBandaHeaderReset.length; i++) {
  32219.                         this.getControlloTrafficoOccupazioneBandaHeaderReset[i]=this.getControlloTrafficoOccupazioneBandaHeaderReset[i].trim();
  32220.                     }
  32221.                 }
  32222.                 
  32223.                 this.getControlloTrafficoOccupazioneBandaHeaderResetRead = true;
  32224.                 
  32225.             } catch(java.lang.Exception e) {
  32226.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.occupazioneBanda.header.reset': "+e.getMessage(),e);
  32227.                 throw new CoreException(e.getMessage(),e);
  32228.             }    
  32229.         }

  32231.         return this.getControlloTrafficoOccupazioneBandaHeaderReset;
  32232.     }
  32233.     
  32234.     private String [] getControlloTrafficoTempoComplessivoRispostaHeaderReset = null;
  32235.     private Boolean getControlloTrafficoTempoComplessivoRispostaHeaderResetRead = null;
  32236.     public String [] getControlloTrafficoTempoComplessivoRispostaHeaderReset() throws CoreException {   
  32237.         if(this.getControlloTrafficoTempoComplessivoRispostaHeaderResetRead==null){
  32238.             try{ 
  32239.                 String name = null;
  32240.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.reset");
  32241.                 if(name!=null){
  32242.                     name = name.trim();
  32243.                     this.getControlloTrafficoTempoComplessivoRispostaHeaderReset = name.split(",");
  32244.                     for (int i = 0; i < this.getControlloTrafficoTempoComplessivoRispostaHeaderReset.length; i++) {
  32245.                         this.getControlloTrafficoTempoComplessivoRispostaHeaderReset[i]=this.getControlloTrafficoTempoComplessivoRispostaHeaderReset[i].trim();
  32246.                     }
  32247.                 }
  32248.                 
  32249.                 this.getControlloTrafficoTempoComplessivoRispostaHeaderResetRead = true;
  32250.                 
  32251.             } catch(java.lang.Exception e) {
  32252.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoComplessivoRisposta.header.reset': "+e.getMessage(),e);
  32253.                 throw new CoreException(e.getMessage(),e);
  32254.             }    
  32255.         }

  32257.         return this.getControlloTrafficoTempoComplessivoRispostaHeaderReset;
  32258.     }
  32259.     
  32260.     private String [] getControlloTrafficoTempoMedioRispostaHeaderReset = null;
  32261.     private Boolean getControlloTrafficoTempoMedioRispostaHeaderResetRead = null;
  32262.     public String [] getControlloTrafficoTempoMedioRispostaHeaderReset() throws CoreException { 
  32263.         if(this.getControlloTrafficoTempoMedioRispostaHeaderResetRead==null){
  32264.             try{ 
  32265.                 String name = null;
  32266.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.reset");
  32267.                 if(name!=null){
  32268.                     name = name.trim();
  32269.                     this.getControlloTrafficoTempoMedioRispostaHeaderReset = name.split(",");
  32270.                     for (int i = 0; i < this.getControlloTrafficoTempoMedioRispostaHeaderReset.length; i++) {
  32271.                         this.getControlloTrafficoTempoMedioRispostaHeaderReset[i]=this.getControlloTrafficoTempoMedioRispostaHeaderReset[i].trim();
  32272.                     }
  32273.                 }
  32274.                 
  32275.                 this.getControlloTrafficoTempoMedioRispostaHeaderResetRead = true;
  32276.                 
  32277.             } catch(java.lang.Exception e) {
  32278.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.tempoMedioRisposta.header.reset': "+e.getMessage(),e);
  32279.                 throw new CoreException(e.getMessage(),e);
  32280.             }    
  32281.         }

  32283.         return this.getControlloTrafficoTempoMedioRispostaHeaderReset;
  32284.     }
  32285.     
  32286.     private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset = null;
  32287.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderResetRead = null;
  32288.     public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset() throws CoreException {   
  32289.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderResetRead==null){
  32290.             try{ 
  32291.                 String name = null;
  32292.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.reset");
  32293.                 if(name!=null){
  32294.                     name = name.trim();
  32295.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset = name.split(",");
  32296.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset.length; i++) {
  32297.                         this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset[i].trim();
  32298.                     }
  32299.                 }
  32300.                 
  32301.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderResetRead = true;
  32302.                 
  32303.             } catch(java.lang.Exception e) {
  32304.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccesso.header.reset': "+e.getMessage(),e);
  32305.                 throw new CoreException(e.getMessage(),e);
  32306.             }    
  32307.         }

  32309.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset;
  32310.     }
  32311.     
  32312.     private String [] getControlloTrafficoNumeroRichiesteFalliteHeaderReset = null;
  32313.     private Boolean getControlloTrafficoNumeroRichiesteFalliteHeaderResetRead = null;
  32314.     public String [] getControlloTrafficoNumeroRichiesteFalliteHeaderReset() throws CoreException { 
  32315.         if(this.getControlloTrafficoNumeroRichiesteFalliteHeaderResetRead==null){
  32316.             try{ 
  32317.                 String name = null;
  32318.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.reset");
  32319.                 if(name!=null){
  32320.                     name = name.trim();
  32321.                     this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset = name.split(",");
  32322.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset.length; i++) {
  32323.                         this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset[i].trim();
  32324.                     }
  32325.                 }
  32326.                 
  32327.                 this.getControlloTrafficoNumeroRichiesteFalliteHeaderResetRead = true;
  32328.                 
  32329.             } catch(java.lang.Exception e) {
  32330.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFallite.header.reset': "+e.getMessage(),e);
  32331.                 throw new CoreException(e.getMessage(),e);
  32332.             }    
  32333.         }

  32335.         return this.getControlloTrafficoNumeroRichiesteFalliteHeaderReset;
  32336.     }
  32337.     
  32338.     private String [] getControlloTrafficoNumeroFaultApplicativiHeaderReset = null;
  32339.     private Boolean getControlloTrafficoNumeroFaultApplicativiHeaderResetRead = null;
  32340.     public String [] getControlloTrafficoNumeroFaultApplicativiHeaderReset() throws CoreException { 
  32341.         if(this.getControlloTrafficoNumeroFaultApplicativiHeaderResetRead==null){
  32342.             try{ 
  32343.                 String name = null;
  32344.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.reset");
  32345.                 if(name!=null){
  32346.                     name = name.trim();
  32347.                     this.getControlloTrafficoNumeroFaultApplicativiHeaderReset = name.split(",");
  32348.                     for (int i = 0; i < this.getControlloTrafficoNumeroFaultApplicativiHeaderReset.length; i++) {
  32349.                         this.getControlloTrafficoNumeroFaultApplicativiHeaderReset[i]=this.getControlloTrafficoNumeroFaultApplicativiHeaderReset[i].trim();
  32350.                     }
  32351.                 }
  32352.                 
  32353.                 this.getControlloTrafficoNumeroFaultApplicativiHeaderResetRead = true;
  32354.                 
  32355.             } catch(java.lang.Exception e) {
  32356.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroFaultApplicativi.header.reset': "+e.getMessage(),e);
  32357.                 throw new CoreException(e.getMessage(),e);
  32358.             }    
  32359.         }

  32361.         return this.getControlloTrafficoNumeroFaultApplicativiHeaderReset;
  32362.     }
  32363.     
  32364.     private String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset = null;
  32365.     private Boolean getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderResetRead = null;
  32366.     public String [] getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset() throws CoreException {    
  32367.         if(this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderResetRead==null){
  32368.             try{ 
  32369.                 String name = null;
  32370.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.reset");
  32371.                 if(name!=null){
  32372.                     name = name.trim();
  32373.                     this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset = name.split(",");
  32374.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset.length; i++) {
  32375.                         this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset[i].trim();
  32376.                     }
  32377.                 }
  32378.                 
  32379.                 this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderResetRead = true;
  32380.                 
  32381.             } catch(java.lang.Exception e) {
  32382.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteFalliteOFaultApplicativi.header.reset': "+e.getMessage(),e);
  32383.                 throw new CoreException(e.getMessage(),e);
  32384.             }    
  32385.         }

  32387.         return this.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset;
  32388.     }
  32389.     
  32390.     private String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset = null;
  32391.     private Boolean getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderResetRead = null;
  32392.     public String [] getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset() throws CoreException {  
  32393.         if(this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderResetRead==null){
  32394.             try{ 
  32395.                 String name = null;
  32396.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.reset");
  32397.                 if(name!=null){
  32398.                     name = name.trim();
  32399.                     this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset = name.split(",");
  32400.                     for (int i = 0; i < this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset.length; i++) {
  32401.                         this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset[i]=this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset[i].trim();
  32402.                     }
  32403.                 }
  32404.                 
  32405.                 this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderResetRead = true;
  32406.                 
  32407.             } catch(java.lang.Exception e) {
  32408.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichiesteCompletateConSuccessoOFaultApplicativi.header.reset': "+e.getMessage(),e);
  32409.                 throw new CoreException(e.getMessage(),e);
  32410.             }    
  32411.         }

  32413.         return this.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset;
  32414.     }
  32415.     
  32416.     
  32417.     
  32418.     // Header Retry After
  32419.     
  32420.     private String [] getControlloTrafficoRetryAfterHeader = null;
  32421.     private Boolean getControlloTrafficoRetryAfterHeaderRead = null;
  32422.     public String [] getControlloTrafficoRetryAfterHeader() throws CoreException {  
  32423.         if(this.getControlloTrafficoRetryAfterHeaderRead==null){
  32424.             try{ 
  32425.                 String name = null;
  32426.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.policyViolate.retryAfter");
  32427.                 if(name!=null){
  32428.                     name = name.trim();
  32429.                     this.getControlloTrafficoRetryAfterHeader = name.split(",");
  32430.                     for (int i = 0; i < this.getControlloTrafficoRetryAfterHeader.length; i++) {
  32431.                         this.getControlloTrafficoRetryAfterHeader[i]=this.getControlloTrafficoRetryAfterHeader[i].trim();
  32432.                     }
  32433.                 }
  32434.                 
  32435.                 this.getControlloTrafficoRetryAfterHeaderRead = true;
  32436.                 
  32437.             } catch(java.lang.Exception e) {
  32438.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.numeroRichieste.header.limit': "+e.getMessage(),e);
  32439.                 throw new CoreException(e.getMessage(),e);
  32440.             }    
  32441.         }

  32443.         return this.getControlloTrafficoRetryAfterHeader;
  32444.     }
  32445.         
  32446.     private Integer getControlloTrafficoRetryAfterHeaderRandomBackoff = null;
  32447.     public Integer getControlloTrafficoRetryAfterHeaderRandomBackoff() {    
  32448.         if(this.getControlloTrafficoRetryAfterHeaderRandomBackoff==null){
  32449.             try{ 
  32450.                 String name = null;
  32451.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.controlloTraffico.policyViolate.retryAfter.randomBackoff.seconds");
  32452.                 if(name!=null){
  32453.                     name = name.trim();
  32454.                     this.getControlloTrafficoRetryAfterHeaderRandomBackoff = Integer.parseInt(name);
  32455.                 }
  32456.                 else {
  32457.                     this.getControlloTrafficoRetryAfterHeaderRandomBackoff = 0;
  32458.                 }
  32459.             } catch(java.lang.Exception e) {
  32460.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.controlloTraffico.policyViolate.retryAfter.randomBackoff.seconds': "+e.getMessage(),e);
  32461.                 this.getControlloTrafficoRetryAfterHeaderRandomBackoff = 0;
  32462.             }    
  32463.         }

  32465.         return this.getControlloTrafficoRetryAfterHeaderRandomBackoff;
  32466.     }
  32467.     
  32468.     
  32469.     
  32470.     /* ------------- Allarmi ---------------------*/
  32471.     
  32472.     private Boolean isAllarmiEnabled = null;
  32473.     public boolean isAllarmiEnabled() { 
  32474.         if(this.isAllarmiEnabled==null){
  32475.             try{ 
  32476.                 if(CostantiConfigurazione.CONFIGURAZIONE_XML.equalsIgnoreCase(getTipoConfigurazionePDD())){
  32477.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.enabled' ignorata. La segnalazione degli allarmi è disabilitata sulla configurazione xml");
  32478.                     this.isAllarmiEnabled = false;
  32479.                 }
  32480.                 else {
  32481.                     String name = null;
  32482.                     name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.allarmi.enabled");
  32483.                     if(name==null){
  32484.                         this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.enabled' non impostata, viene utilizzato il default=false");
  32485.                         name="false";
  32486.                     }
  32487.                     name = name.trim();
  32488.                     this.isAllarmiEnabled = Boolean.parseBoolean(name);
  32489.                 }
  32490.             } catch(java.lang.Exception e) {
  32491.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.enabled', viene utilizzato il default=false : "+e.getMessage(),e);
  32492.                 this.isAllarmiEnabled = true;
  32493.             }    
  32494.         }

  32496.         return this.isAllarmiEnabled;
  32497.     }
  32498.     
  32499.     private Boolean isAllarmiDebug = null;
  32500.     public boolean isAllarmiDebug() {   
  32501.         if(this.isAllarmiDebug==null){
  32502.             try{ 
  32503.                 String name = null;
  32504.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.allarmi.debug");
  32505.                 if(name==null){
  32506.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.debug' non impostata, viene utilizzato il default=true");
  32507.                     name="true";
  32508.                 }
  32509.                 name = name.trim();
  32510.                 this.isAllarmiDebug = Boolean.parseBoolean(name);
  32511.             } catch(java.lang.Exception e) {
  32512.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.allarmi.debug', viene utilizzato il default=true : "+e.getMessage(),e);
  32513.                 this.isAllarmiDebug = true;
  32514.             }    
  32515.         }

  32517.         return this.isAllarmiDebug;
  32518.     }
  32519.     
  32520.     
  32521.     
  32522.     
  32523.     /* ------------- Service Unavailable ---------------------*/
  32524.     
  32525.     private Integer getServiceUnavailableRetryAfterSecondsPD = null;
  32526.     public Integer getServiceUnavailableRetryAfterSecondsPD() { 
  32527.         if(this.getServiceUnavailableRetryAfterSecondsPD==null){
  32528.             try{ 
  32529.                 String name = null;
  32530.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.seconds");
  32531.                 if(name!=null){
  32532.                     name = name.trim();
  32533.                     this.getServiceUnavailableRetryAfterSecondsPD = Integer.parseInt(name);
  32534.                 }
  32535.                 else {
  32536.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  32537.                 }
  32538.             } catch(java.lang.Exception e) {
  32539.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.seconds', default:60 : "+e.getMessage(),e);
  32540.                 this.getServiceUnavailableRetryAfterSecondsPD = 60;
  32541.             }    
  32542.         }

  32544.         return this.getServiceUnavailableRetryAfterSecondsPD;
  32545.     }
  32546.     
  32547.     private Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPD = null;
  32548.     public Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPD() {    
  32549.         if(this.getServiceUnavailableRetryAfterSecondsRandomBackoffPD==null){
  32550.             try{ 
  32551.                 String name = null;
  32552.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.randomBackoff.seconds");
  32553.                 if(name!=null){
  32554.                     name = name.trim();
  32555.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPD = Integer.parseInt(name);
  32556.                 }
  32557.                 else {
  32558.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPD = 0;
  32559.                 }
  32560.             } catch(java.lang.Exception e) {
  32561.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.randomBackoff.seconds': "+e.getMessage(),e);
  32562.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPD = 0;
  32563.             }    
  32564.         }

  32566.         return this.getServiceUnavailableRetryAfterSecondsRandomBackoffPD;
  32567.     }
  32568.     
  32569.     private Integer getServiceUnavailableRetryAfterSecondsPA = null;
  32570.     public Integer getServiceUnavailableRetryAfterSecondsPA() { 
  32571.         if(this.getServiceUnavailableRetryAfterSecondsPA==null){
  32572.             try{ 
  32573.                 String name = null;
  32574.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.seconds");
  32575.                 if(name!=null){
  32576.                     name = name.trim();
  32577.                     this.getServiceUnavailableRetryAfterSecondsPA = Integer.parseInt(name);
  32578.                 }
  32579.                 else {
  32580.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  32581.                 }
  32582.             } catch(java.lang.Exception e) {
  32583.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.seconds', default:60 : "+e.getMessage(),e);
  32584.                 this.getServiceUnavailableRetryAfterSecondsPA = 60;
  32585.             }    
  32586.         }

  32588.         return this.getServiceUnavailableRetryAfterSecondsPA;
  32589.     }
  32590.     
  32591.     private Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPA = null;
  32592.     public Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPA() {    
  32593.         if(this.getServiceUnavailableRetryAfterSecondsRandomBackoffPA==null){
  32594.             try{ 
  32595.                 String name = null;
  32596.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.randomBackoff.seconds");
  32597.                 if(name!=null){
  32598.                     name = name.trim();
  32599.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPA = Integer.parseInt(name);
  32600.                 }
  32601.                 else {
  32602.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPA = 0;
  32603.                 }
  32604.             } catch(java.lang.Exception e) {
  32605.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.randomBackoff.seconds': "+e.getMessage(),e);
  32606.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPA = 0;
  32607.             }    
  32608.         }

  32610.         return this.getServiceUnavailableRetryAfterSecondsRandomBackoffPA;
  32611.     }
  32612.     
  32613.     
  32614.     
  32615.     private Boolean isEnabledServiceUnavailableRetryAfterPDSuspend = null;
  32616.     public boolean isEnabledServiceUnavailableRetryAfterPDSuspend() {   
  32617.         if(this.isEnabledServiceUnavailableRetryAfterPDSuspend==null){
  32618.             try{ 
  32619.                 String name = null;
  32620.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.enabled");
  32621.                 if(name==null){
  32622.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.enabled' non impostata, viene utilizzato il default=true");
  32623.                     name="true";
  32624.                 }
  32625.                 name = name.trim();
  32626.                 this.isEnabledServiceUnavailableRetryAfterPDSuspend = Boolean.parseBoolean(name);
  32627.             } catch(java.lang.Exception e) {
  32628.                 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);
  32629.                 this.isEnabledServiceUnavailableRetryAfterPDSuspend = true;
  32630.             }    
  32631.         }

  32633.         return this.isEnabledServiceUnavailableRetryAfterPDSuspend;
  32634.     }
  32635.     
  32636.     private Integer getServiceUnavailableRetryAfterSecondsPDSuspend = null;
  32637.     public Integer getServiceUnavailableRetryAfterSecondsPDSuspend() {  
  32638.         if(this.getServiceUnavailableRetryAfterSecondsPDSuspend==null){
  32639.             try{ 
  32640.                 String name = null;
  32641.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.seconds");
  32642.                 if(name!=null){
  32643.                     name = name.trim();
  32644.                     this.getServiceUnavailableRetryAfterSecondsPDSuspend = Integer.parseInt(name);
  32645.                 }
  32646.                 else {
  32647.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  32648.                 }
  32649.             } catch(java.lang.Exception e) {
  32650.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.seconds', default:60 : "+e.getMessage(),e);
  32651.                 this.getServiceUnavailableRetryAfterSecondsPDSuspend = 60;
  32652.             }    
  32653.         }

  32655.         return this.getServiceUnavailableRetryAfterSecondsPDSuspend;
  32656.     }
  32657.     
  32658.     private Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend = null;
  32659.     public Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend() { 
  32660.         if(this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend==null){
  32661.             try{ 
  32662.                 String name = null;
  32663.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.randomBackoff.seconds");
  32664.                 if(name!=null){
  32665.                     name = name.trim();
  32666.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend = Integer.parseInt(name);
  32667.                 }
  32668.                 else {
  32669.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend = 0;
  32670.                 }
  32671.             } catch(java.lang.Exception e) {
  32672.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.suspend.randomBackoff.seconds': "+e.getMessage(),e);
  32673.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend = 0;
  32674.             }    
  32675.         }

  32677.         return this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend;
  32678.     }
  32679.     
  32680.     private Boolean isEnabledServiceUnavailableRetryAfterPASuspend = null;
  32681.     public boolean isEnabledServiceUnavailableRetryAfterPASuspend() {   
  32682.         if(this.isEnabledServiceUnavailableRetryAfterPASuspend==null){
  32683.             try{ 
  32684.                 String name = null;
  32685.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.enabled");
  32686.                 if(name==null){
  32687.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.enabled' non impostata, viene utilizzato il default=true");
  32688.                     name="true";
  32689.                 }
  32690.                 name = name.trim();
  32691.                 this.isEnabledServiceUnavailableRetryAfterPASuspend = Boolean.parseBoolean(name);
  32692.             } catch(java.lang.Exception e) {
  32693.                 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);
  32694.                 this.isEnabledServiceUnavailableRetryAfterPASuspend = true;
  32695.             }    
  32696.         }

  32698.         return this.isEnabledServiceUnavailableRetryAfterPASuspend;
  32699.     }
  32700.     
  32701.     private Integer getServiceUnavailableRetryAfterSecondsPASuspend = null;
  32702.     public Integer getServiceUnavailableRetryAfterSecondsPASuspend() {  
  32703.         if(this.getServiceUnavailableRetryAfterSecondsPASuspend==null){
  32704.             try{ 
  32705.                 String name = null;
  32706.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.seconds");
  32707.                 if(name!=null){
  32708.                     name = name.trim();
  32709.                     this.getServiceUnavailableRetryAfterSecondsPASuspend = Integer.parseInt(name);
  32710.                 }
  32711.                 else {
  32712.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  32713.                 }
  32714.             } catch(java.lang.Exception e) {
  32715.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.seconds', default:60 : "+e.getMessage(),e);
  32716.                 this.getServiceUnavailableRetryAfterSecondsPASuspend = 60;
  32717.             }    
  32718.         }

  32720.         return this.getServiceUnavailableRetryAfterSecondsPASuspend;
  32721.     }
  32722.     
  32723.     private Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend = null;
  32724.     public Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend() { 
  32725.         if(this.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend==null){
  32726.             try{ 
  32727.                 String name = null;
  32728.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.randomBackoff.seconds");
  32729.                 if(name!=null){
  32730.                     name = name.trim();
  32731.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend = Integer.parseInt(name);
  32732.                 }
  32733.                 else {
  32734.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend = 0;
  32735.                 }
  32736.             } catch(java.lang.Exception e) {
  32737.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.suspend.randomBackoff.seconds': "+e.getMessage(),e);
  32738.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend = 0;
  32739.             }    
  32740.         }

  32742.         return this.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend;
  32743.     }
  32744.     
  32745.     private Boolean isEnabledServiceUnavailableRetryAfterPDConnectionFailed = null;
  32746.     public boolean isEnabledServiceUnavailableRetryAfterPDConnectionFailed() {  
  32747.         if(this.isEnabledServiceUnavailableRetryAfterPDConnectionFailed==null){
  32748.             try{ 
  32749.                 String name = null;
  32750.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.enabled");
  32751.                 if(name==null){
  32752.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.enabled' non impostata, viene utilizzato il default=true");
  32753.                     name="true";
  32754.                 }
  32755.                 name = name.trim();
  32756.                 this.isEnabledServiceUnavailableRetryAfterPDConnectionFailed = Boolean.parseBoolean(name);
  32757.             } catch(java.lang.Exception e) {
  32758.                 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);
  32759.                 this.isEnabledServiceUnavailableRetryAfterPDConnectionFailed = true;
  32760.             }    
  32761.         }

  32763.         return this.isEnabledServiceUnavailableRetryAfterPDConnectionFailed;
  32764.     }
  32765.     
  32766.     private Integer getServiceUnavailableRetryAfterSecondsPDConnectionFailed = null;
  32767.     public Integer getServiceUnavailableRetryAfterSecondsPDConnectionFailed() { 
  32768.         if(this.getServiceUnavailableRetryAfterSecondsPDConnectionFailed==null){
  32769.             try{ 
  32770.                 String name = null;
  32771.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.seconds");
  32772.                 if(name!=null){
  32773.                     name = name.trim();
  32774.                     this.getServiceUnavailableRetryAfterSecondsPDConnectionFailed = Integer.parseInt(name);
  32775.                 }
  32776.                 else {
  32777.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  32778.                 }
  32779.             } catch(java.lang.Exception e) {
  32780.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.seconds', default:60 : "+e.getMessage(),e);
  32781.                 this.getServiceUnavailableRetryAfterSecondsPDConnectionFailed = 60;
  32782.             }    
  32783.         }

  32785.         return this.getServiceUnavailableRetryAfterSecondsPDConnectionFailed;
  32786.     }
  32787.     
  32788.     private Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed = null;
  32789.     public Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed() {    
  32790.         if(this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed==null){
  32791.             try{ 
  32792.                 String name = null;
  32793.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.randomBackoff.seconds");
  32794.                 if(name!=null){
  32795.                     name = name.trim();
  32796.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed = Integer.parseInt(name);
  32797.                 }
  32798.                 else {
  32799.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed = 0;
  32800.                 }
  32801.             } catch(java.lang.Exception e) {
  32802.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pd.connectionFailed.randomBackoff.seconds': "+e.getMessage(),e);
  32803.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed = 0;
  32804.             }    
  32805.         }

  32807.         return this.getServiceUnavailableRetryAfterSecondsRandomBackoffPDConnectionFailed;
  32808.     }
  32809.     
  32810.     private Boolean isEnabledServiceUnavailableRetryAfterPAConnectionFailed = null;
  32811.     public boolean isEnabledServiceUnavailableRetryAfterPAConnectionFailed() {  
  32812.         if(this.isEnabledServiceUnavailableRetryAfterPAConnectionFailed==null){
  32813.             try{ 
  32814.                 String name = null;
  32815.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.enabled");
  32816.                 if(name==null){
  32817.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.enabled' non impostata, viene utilizzato il default=true");
  32818.                     name="true";
  32819.                 }
  32820.                 name = name.trim();
  32821.                 this.isEnabledServiceUnavailableRetryAfterPAConnectionFailed = Boolean.parseBoolean(name);
  32822.             } catch(java.lang.Exception e) {
  32823.                 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);
  32824.                 this.isEnabledServiceUnavailableRetryAfterPAConnectionFailed = true;
  32825.             }    
  32826.         }

  32828.         return this.isEnabledServiceUnavailableRetryAfterPAConnectionFailed;
  32829.     }
  32830.     
  32831.     private Integer getServiceUnavailableRetryAfterSecondsPAConnectionFailed = null;
  32832.     public Integer getServiceUnavailableRetryAfterSecondsPAConnectionFailed() { 
  32833.         if(this.getServiceUnavailableRetryAfterSecondsPAConnectionFailed==null){
  32834.             try{ 
  32835.                 String name = null;
  32836.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.seconds");
  32837.                 if(name!=null){
  32838.                     name = name.trim();
  32839.                     this.getServiceUnavailableRetryAfterSecondsPAConnectionFailed = Integer.parseInt(name);
  32840.                 }
  32841.                 else {
  32842.                     throw new CoreException(PROPRIETA_NON_DEFINITA);
  32843.                 }
  32844.             } catch(java.lang.Exception e) {
  32845.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.seconds', default:60 : "+e.getMessage(),e);
  32846.                 this.getServiceUnavailableRetryAfterSecondsPAConnectionFailed = 60;
  32847.             }    
  32848.         }

  32850.         return this.getServiceUnavailableRetryAfterSecondsPAConnectionFailed;
  32851.     }
  32852.     
  32853.     private Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed = null;
  32854.     public Integer getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed() {    
  32855.         if(this.getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed==null){
  32856.             try{ 
  32857.                 String name = null;
  32858.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.randomBackoff.seconds");
  32859.                 if(name!=null){
  32860.                     name = name.trim();
  32861.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed = Integer.parseInt(name);
  32862.                 }
  32863.                 else {
  32864.                     this.getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed = 0;
  32865.                 }
  32866.             } catch(java.lang.Exception e) {
  32867.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.retryAfter.pa.connectionFailed.randomBackoff.seconds': "+e.getMessage(),e);
  32868.                 this.getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed = 0;
  32869.             }    
  32870.         }

  32872.         return this.getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed;
  32873.     }
  32874.     
  32875.     
  32876.     private List<String> isReadTimedOut = null;
  32877.     public boolean isServiceUnavailableReadTimedOut(String msg) {   
  32878.         if(this.isReadTimedOut==null){
  32879.             initServiceUnavailableReadTimedOut();
  32880.         }

  32882.         if(!this.isReadTimedOut.isEmpty()) {
  32883.             for (String s : this.isReadTimedOut) {
  32884.                 if(msg.contains(s)) {
  32885.                     return true;
  32886.                 }
  32887.             }
  32888.         }
  32889.         
  32890.         return false;
  32891.     }
  32892.     private void initServiceUnavailableReadTimedOut() { 
  32893.         try{ 
  32894.             Properties p = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.serviceUnavailable.readTimedOut.");
  32895.             this.isReadTimedOut = new ArrayList<>();
  32896.             if(p!=null && !p.isEmpty()) {
  32897.                 Iterator<Object> it = p.values().iterator();
  32898.                 while (it.hasNext()) {
  32899.                     Object o = it.next();
  32900.                     if(o instanceof String) {
  32901.                         String s = (String) o;
  32902.                         this.isReadTimedOut.add(s);
  32903.                     }
  32904.                 }
  32905.             }
  32906.         } catch(java.lang.Exception e) {
  32907.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.serviceUnavailable.error.': "+e.getMessage(),e);
  32908.             this.isReadTimedOut = new ArrayList<>();
  32909.         }    
  32910.     }
  32911.     
  32912.     
  32913.     /* ------------- Statistiche ---------------------*/
  32914.     
  32915.     private Boolean isStatisticheGenerazioneEnabled = null;
  32916.     public boolean isStatisticheGenerazioneEnabled() {  
  32917.         if(this.isStatisticheGenerazioneEnabled==null){
  32918.             try{ 
  32919.                 String name = null;
  32920.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.enabled");
  32921.                 if(name==null){
  32922.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.enabled' non impostata, viene utilizzato il default=true");
  32923.                     name="true";
  32924.                 }
  32925.                 name = name.trim();
  32926.                 this.isStatisticheGenerazioneEnabled = Boolean.parseBoolean(name);
  32927.             } catch(java.lang.Exception e) {
  32928.                 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);
  32929.                 this.isStatisticheGenerazioneEnabled = true;
  32930.             }    
  32931.         }

  32933.         return this.isStatisticheGenerazioneEnabled;
  32934.     }
  32935.     
  32936.     
  32937.     private Boolean isStatisticheUsePddRuntimeDatasource = null;
  32938.     public boolean isStatisticheUsePddRuntimeDatasource() { 
  32939.         if(this.isStatisticheUsePddRuntimeDatasource==null){
  32940.             try{ 
  32941.                 String name = null;
  32942.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.dataSource.usePddRuntime");
  32943.                 if(name==null){
  32944.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource.usePddRuntime' non impostata, viene utilizzato il default=true");
  32945.                     name="true";
  32946.                 }
  32947.                 name = name.trim();
  32948.                 this.isStatisticheUsePddRuntimeDatasource = Boolean.parseBoolean(name);
  32949.             } catch(java.lang.Exception e) {
  32950.                 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);
  32951.                 this.isStatisticheUsePddRuntimeDatasource = false;
  32952.             }    
  32953.         }

  32955.         return this.isStatisticheUsePddRuntimeDatasource;
  32956.     }
  32957.     
  32958.     private Boolean isStatisticheUseTransazioniDatasource = null;
  32959.     public boolean isStatisticheUseTransazioniDatasource() {    
  32960.         if(this.isStatisticheUseTransazioniDatasource==null){
  32961.             try{ 
  32962.                 String name = null;
  32963.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.dataSource.useTransazioni");
  32964.                 if(name==null){
  32965.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource.useTransazioni' non impostata, viene utilizzato il default=true");
  32966.                     name="true";
  32967.                 }
  32968.                 name = name.trim();
  32969.                 this.isStatisticheUseTransazioniDatasource = Boolean.parseBoolean(name);
  32970.             } catch(java.lang.Exception e) {
  32971.                 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);
  32972.                 this.isStatisticheUseTransazioniDatasource = true;
  32973.             }    
  32974.         }

  32976.         return this.isStatisticheUseTransazioniDatasource;
  32977.     }
  32978.     
  32979.     private String getStatisticheDatasource = null;
  32980.     public String getStatisticheDatasource() throws CoreException { 
  32981.         if(this.getStatisticheDatasource==null){
  32982.             try{ 
  32983.                 String name = null;
  32984.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.dataSource");
  32985.                 if(name==null){
  32986.                     throw new CoreException("Proprieta' non impostata");
  32987.                 }
  32988.                 name = name.trim();
  32989.                 this.getStatisticheDatasource = name;
  32990.             } catch(java.lang.Exception e) {
  32991.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource': "+e.getMessage(),e);
  32992.                 throw new CoreException(e.getMessage(),e);
  32993.             }    
  32994.         }

  32996.         return this.getStatisticheDatasource;
  32997.     }
  32998.     
  32999.     private Properties getStatisticheDatasourceJndiContext = null;
  33000.     public Properties getStatisticheDatasourceJndiContext() throws CoreException {  
  33001.         if(this.getStatisticheDatasourceJndiContext==null){
  33002.             try{ 
  33003.                 this.getStatisticheDatasourceJndiContext = this.reader.readPropertiesConvertEnvProperties("org.openspcoop2.pdd.statistiche.dataSource.property.");
  33004.             } catch(java.lang.Exception e) {
  33005.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.dataSource.property.*': "+e.getMessage(),e);
  33006.                 throw new CoreException(e.getMessage(),e);
  33007.             }    
  33008.         }

  33010.         return this.getStatisticheDatasourceJndiContext;
  33011.     }
  33012.     
  33013.     private Boolean isStatisticheDatasourceUseDBUtils = null;
  33014.     public boolean isStatisticheDatasourceUseDBUtils() {    
  33015.         if(this.isStatisticheDatasourceUseDBUtils==null){
  33016.             try{ 
  33017.                 String name = null;
  33018.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.datasource.useDSUtils");
  33019.                 if(name==null){
  33020.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.datasource.useDSUtils' non impostata, viene utilizzato il default=true");
  33021.                     name="true";
  33022.                 }
  33023.                 name = name.trim();
  33024.                 this.isStatisticheDatasourceUseDBUtils = Boolean.parseBoolean(name);
  33025.             } catch(java.lang.Exception e) {
  33026.                 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);
  33027.                 this.isStatisticheDatasourceUseDBUtils = true;
  33028.             }    
  33029.         }

  33031.         return this.isStatisticheDatasourceUseDBUtils;
  33032.     }

  33034.     private Boolean isStatisticheGenerazioneUseUnionForLatency = null;
  33035.     public boolean isStatisticheGenerazioneUseUnionForLatency() {   
  33036.         if(this.isStatisticheGenerazioneUseUnionForLatency==null){
  33037.             try{ 
  33038.                 String name = null;
  33039.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.useUnionForLatency");
  33040.                 if(name==null){
  33041.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.useUnionForLatency' non impostata, viene utilizzato il default=true");
  33042.                     name="true";
  33043.                 }
  33044.                 name = name.trim();
  33045.                 this.isStatisticheGenerazioneUseUnionForLatency = Boolean.parseBoolean(name);
  33046.             } catch(java.lang.Exception e) {
  33047.                 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);
  33048.                 this.isStatisticheGenerazioneUseUnionForLatency = true;
  33049.             }    
  33050.         }

  33052.         return this.isStatisticheGenerazioneUseUnionForLatency;
  33053.     }
  33054.     
  33055.     private Boolean isStatisticheGenerazioneCustomEnabled = null;
  33056.     public boolean isStatisticheGenerazioneCustomEnabled() {    
  33057.         if(this.isStatisticheGenerazioneCustomEnabled==null){
  33058.             try{ 
  33059.                 String name = null;
  33060.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.custom.enabled");
  33061.                 if(name==null){
  33062.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.custom.enabled' non impostata, viene utilizzato il default=false");
  33063.                     name="false";
  33064.                 }
  33065.                 name = name.trim();
  33066.                 this.isStatisticheGenerazioneCustomEnabled = Boolean.parseBoolean(name);
  33067.             } catch(java.lang.Exception e) {
  33068.                 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);
  33069.                 this.isStatisticheGenerazioneCustomEnabled = false;
  33070.             }    
  33071.         }

  33073.         return this.isStatisticheGenerazioneCustomEnabled;
  33074.     }
  33075.     
  33076.     private Boolean isStatisticheGenerazioneCustomSdkEnabled = null;
  33077.     public boolean isStatisticheGenerazioneCustomSdkEnabled() { 
  33078.         if(this.isStatisticheGenerazioneCustomSdkEnabled==null){
  33079.             try{ 
  33080.                 String name = null;
  33081.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.custom.transazioniSdk.enabled");
  33082.                 if(name==null){
  33083.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.custom.transazioniSdk.enabled' non impostata, viene utilizzato il default=false");
  33084.                     name="false";
  33085.                 }
  33086.                 name = name.trim();
  33087.                 this.isStatisticheGenerazioneCustomSdkEnabled = Boolean.parseBoolean(name);
  33088.             } catch(java.lang.Exception e) {
  33089.                 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);
  33090.                 this.isStatisticheGenerazioneCustomSdkEnabled = false;
  33091.             }    
  33092.         }

  33094.         return this.isStatisticheGenerazioneCustomSdkEnabled;
  33095.     }
  33096.     
  33097.     private Boolean isStatisticheGenerazioneDebug = null;
  33098.     public boolean isStatisticheGenerazioneDebug() {    
  33099.         if(this.isStatisticheGenerazioneDebug==null){
  33100.             try{ 
  33101.                 String name = null;
  33102.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.debug");
  33103.                 if(name==null){
  33104.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.debug' non impostata, viene utilizzato il default=true");
  33105.                     name="true";
  33106.                 }
  33107.                 name = name.trim();
  33108.                 this.isStatisticheGenerazioneDebug = Boolean.parseBoolean(name);
  33109.             } catch(java.lang.Exception e) {
  33110.                 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);
  33111.                 this.isStatisticheGenerazioneDebug = true;
  33112.             }    
  33113.         }

  33115.         return this.isStatisticheGenerazioneDebug;
  33116.     }
  33117.     
  33118.     private Integer getStatisticheOrarieGenerazioneTimerIntervalSeconds = null;
  33119.     public int getStatisticheOrarieGenerazioneTimerIntervalSeconds() throws CoreException { 
  33120.         if(this.getStatisticheOrarieGenerazioneTimerIntervalSeconds==null){
  33121.             try{ 
  33122.                 String name = null;
  33123.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseOraria.timer.intervalloSecondi");
  33124.                 if(name==null){
  33125.                     throw new CoreException("Proprieta' non impostata");
  33126.                 }
  33127.                 name = name.trim();
  33128.                 this.getStatisticheOrarieGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
  33129.             } catch(java.lang.Exception e) {
  33130.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseOraria.timer.intervalloSecondi': "+e.getMessage(),e);
  33131.                 throw new CoreException(e.getMessage(),e);
  33132.             }    
  33133.         }

  33135.         return this.getStatisticheOrarieGenerazioneTimerIntervalSeconds;
  33136.     }
  33137.     
  33138.     private Integer getStatisticheGiornaliereGenerazioneTimerIntervalSeconds = null;
  33139.     public int getStatisticheGiornaliereGenerazioneTimerIntervalSeconds() throws CoreException {    
  33140.         if(this.getStatisticheGiornaliereGenerazioneTimerIntervalSeconds==null){
  33141.             try{ 
  33142.                 String name = null;
  33143.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.timer.intervalloSecondi");
  33144.                 if(name==null){
  33145.                     throw new CoreException("Proprieta' non impostata");
  33146.                 }
  33147.                 name = name.trim();
  33148.                 this.getStatisticheGiornaliereGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
  33149.             } catch(java.lang.Exception e) {
  33150.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.timer.intervalloSecondi': "+e.getMessage(),e);
  33151.                 throw new CoreException(e.getMessage(),e);
  33152.             }    
  33153.         }

  33155.         return this.getStatisticheGiornaliereGenerazioneTimerIntervalSeconds;
  33156.     }
  33157.     
  33158.     private Integer getStatisticheSettimanaliGenerazioneTimerIntervalSeconds = null;
  33159.     public int getStatisticheSettimanaliGenerazioneTimerIntervalSeconds() throws CoreException {    
  33160.         if(this.getStatisticheSettimanaliGenerazioneTimerIntervalSeconds==null){
  33161.             try{ 
  33162.                 String name = null;
  33163.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.timer.intervalloSecondi");
  33164.                 if(name==null){
  33165.                     throw new CoreException("Proprieta' non impostata");
  33166.                 }
  33167.                 name = name.trim();
  33168.                 this.getStatisticheSettimanaliGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
  33169.             } catch(java.lang.Exception e) {
  33170.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.timer.intervalloSecondi': "+e.getMessage(),e);
  33171.                 throw new CoreException(e.getMessage(),e);
  33172.             }    
  33173.         }

  33175.         return this.getStatisticheSettimanaliGenerazioneTimerIntervalSeconds;
  33176.     }
  33177.     
  33178.     private Integer getStatisticheMensiliGenerazioneTimerIntervalSeconds = null;
  33179.     public int getStatisticheMensiliGenerazioneTimerIntervalSeconds() throws CoreException {    
  33180.         if(this.getStatisticheMensiliGenerazioneTimerIntervalSeconds==null){
  33181.             try{ 
  33182.                 String name = null;
  33183.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseMensile.timer.intervalloSecondi");
  33184.                 if(name==null){
  33185.                     throw new CoreException("Proprieta' non impostata");
  33186.                 }
  33187.                 name = name.trim();
  33188.                 this.getStatisticheMensiliGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
  33189.             } catch(java.lang.Exception e) {
  33190.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseMensile.timer.intervalloSecondi': "+e.getMessage(),e);
  33191.                 throw new CoreException(e.getMessage(),e);
  33192.             }    
  33193.         }

  33195.         return this.getStatisticheMensiliGenerazioneTimerIntervalSeconds;
  33196.     }
  33197.     
  33198.     private Integer getStatisticheGenerazioneTimerLockMaxLife = null;
  33199.     public int getStatisticheGenerazioneTimerLockMaxLife() {    
  33200.         if(this.getStatisticheGenerazioneTimerLockMaxLife==null){
  33201.             try{ 
  33202.                 String name = null;
  33203.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.timer.lock.maxLife");

  33205.                 if(name!=null){
  33206.                     name = name.trim();
  33207.                     this.getStatisticheGenerazioneTimerLockMaxLife = java.lang.Integer.parseInt(name);
  33208.                 }else{
  33209.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.timer.lock.maxLife' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_MAX_LIFE);
  33210.                     this.getStatisticheGenerazioneTimerLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  33211.                 }
  33212.             }catch(java.lang.Exception e) {
  33213.                 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);
  33214.                 this.getStatisticheGenerazioneTimerLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  33215.             }
  33216.             if(this.getStatisticheGenerazioneTimerLockMaxLife!=null && this.getStatisticheGenerazioneTimerLockMaxLife>0) {
  33217.                 // trasformo in millisecondi l'informazione fornita in secondi
  33218.                 this.getStatisticheGenerazioneTimerLockMaxLife = this.getStatisticheGenerazioneTimerLockMaxLife *1000;
  33219.             }
  33220.         }

  33222.         if(this.getStatisticheGenerazioneTimerLockMaxLife!=null) {
  33223.             return this.getStatisticheGenerazioneTimerLockMaxLife.intValue();
  33224.         }
  33225.         return -1;
  33226.     }
  33227.     
  33228.     private Integer getStatisticheGenerazioneTimerLockIdleTime = null;
  33229.     public int getStatisticheGenerazioneTimerLockIdleTime() {   
  33230.         if(this.getStatisticheGenerazioneTimerLockIdleTime==null){
  33231.             try{ 
  33232.                 String name = null;
  33233.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.timer.lock.idleTime");

  33235.                 if(name!=null){
  33236.                     name = name.trim();
  33237.                     this.getStatisticheGenerazioneTimerLockIdleTime = java.lang.Integer.parseInt(name);
  33238.                 }else{
  33239.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.timer.lock.idleTime' non impostata, viene utilizzato il default="+CostantiPdD.TIMER_LOCK_IDLE_TIME);
  33240.                     this.getStatisticheGenerazioneTimerLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  33241.                 }
  33242.             }catch(java.lang.Exception e) {
  33243.                 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);
  33244.                 this.getStatisticheGenerazioneTimerLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  33245.             }
  33246.             if(this.getStatisticheGenerazioneTimerLockIdleTime!=null && this.getStatisticheGenerazioneTimerLockIdleTime>0) {
  33247.                 // trasformo in millisecondi l'informazione fornita in secondi
  33248.                 this.getStatisticheGenerazioneTimerLockIdleTime = this.getStatisticheGenerazioneTimerLockIdleTime *1000;
  33249.             }
  33250.         }

  33252.         if(this.getStatisticheGenerazioneTimerLockIdleTime!=null) {
  33253.             return this.getStatisticheGenerazioneTimerLockIdleTime.intValue();
  33254.         }
  33255.         return -1;
  33256.     }
  33257.     
  33258.     private Long getStatisticheGenerazioneTimerLockAttesaAttiva = null;
  33259.     public long getStatisticheGenerazioneTimerLockAttesaAttiva() {  
  33260.         if(this.getStatisticheGenerazioneTimerLockAttesaAttiva==null){
  33261.             String pName = "org.openspcoop2.pdd.statistiche.generazione.timer.lock.attesaAttiva";
  33262.             try{ 
  33263.                 String name = null;
  33264.                 name = this.reader.getValueConvertEnvProperties(pName);

  33266.                 if(name!=null){
  33267.                     name = name.trim();
  33268.                     long time = java.lang.Long.parseLong(name);
  33269.                     this.getStatisticheGenerazioneTimerLockAttesaAttiva = time*1000;
  33270.                 }else{
  33271.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
  33272.                     this.getStatisticheGenerazioneTimerLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
  33273.                 }

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

  33281.         return this.getStatisticheGenerazioneTimerLockAttesaAttiva;
  33282.     }

  33284.     private Integer getStatisticheGenerazioneTimerLockCheckInterval = null;
  33285.     public int getStatisticheGenerazioneTimerLockCheckInterval() {  
  33286.         if(this.getStatisticheGenerazioneTimerLockCheckInterval==null){
  33287.             String pName = "org.openspcoop2.pdd.statistiche.generazione.timer.lock.check";
  33288.             try{ 
  33289.                 String name = null;
  33290.                 name = this.reader.getValueConvertEnvProperties(pName);

  33292.                 if(name!=null){
  33293.                     name = name.trim();
  33294.                     int time = java.lang.Integer.parseInt(name);
  33295.                     this.getStatisticheGenerazioneTimerLockCheckInterval = time;
  33296.                 }else{
  33297.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  33298.                     this.getStatisticheGenerazioneTimerLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  33299.                 }
  33300.             }catch(java.lang.Exception e) {
  33301.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  33302.                 this.getStatisticheGenerazioneTimerLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  33303.             }  
  33304.         }

  33306.         return this.getStatisticheGenerazioneTimerLockCheckInterval;
  33307.     }
  33308.     
  33309.     private Boolean isStatisticheGenerazioneBaseOrariaEnabled = null;
  33310.     public boolean isStatisticheGenerazioneBaseOrariaEnabled() {    
  33311.         if(this.isStatisticheGenerazioneBaseOrariaEnabled==null){
  33312.             try{ 
  33313.                 String name = null;
  33314.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseOraria.enabled");
  33315.                 if(name==null){
  33316.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseOraria.enabled' non impostata, viene utilizzato il default=true");
  33317.                     name="true";
  33318.                 }
  33319.                 name = name.trim();
  33320.                 this.isStatisticheGenerazioneBaseOrariaEnabled = Boolean.parseBoolean(name);
  33321.             } catch(java.lang.Exception e) {
  33322.                 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);
  33323.                 this.isStatisticheGenerazioneBaseOrariaEnabled = true;
  33324.             }    
  33325.         }

  33327.         return this.isStatisticheGenerazioneBaseOrariaEnabled;
  33328.     }
  33329.     
  33330.     private Boolean isStatisticheGenerazioneBaseGiornalieraEnabled = null;
  33331.     public boolean isStatisticheGenerazioneBaseGiornalieraEnabled() {   
  33332.         if(this.isStatisticheGenerazioneBaseGiornalieraEnabled==null){
  33333.             try{ 
  33334.                 String name = null;
  33335.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.enabled");
  33336.                 if(name==null){
  33337.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.enabled' non impostata, viene utilizzato il default=true");
  33338.                     name="true";
  33339.                 }
  33340.                 name = name.trim();
  33341.                 this.isStatisticheGenerazioneBaseGiornalieraEnabled = Boolean.parseBoolean(name);
  33342.             } catch(java.lang.Exception e) {
  33343.                 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);
  33344.                 this.isStatisticheGenerazioneBaseGiornalieraEnabled = true;
  33345.             }    
  33346.         }

  33348.         return this.isStatisticheGenerazioneBaseGiornalieraEnabled;
  33349.     }
  33350.     
  33351.     private Boolean isStatisticheGenerazioneBaseSettimanaleEnabled = null;
  33352.     public boolean isStatisticheGenerazioneBaseSettimanaleEnabled() {   
  33353.         if(this.isStatisticheGenerazioneBaseSettimanaleEnabled==null){
  33354.             try{ 
  33355.                 String name = null;
  33356.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.enabled");
  33357.                 if(name==null){
  33358.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.enabled' non impostata, viene utilizzato il default=true");
  33359.                     name="true";
  33360.                 }
  33361.                 name = name.trim();
  33362.                 this.isStatisticheGenerazioneBaseSettimanaleEnabled = Boolean.parseBoolean(name);
  33363.             } catch(java.lang.Exception e) {
  33364.                 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);
  33365.                 this.isStatisticheGenerazioneBaseSettimanaleEnabled = true;
  33366.             }    
  33367.         }

  33369.         return this.isStatisticheGenerazioneBaseSettimanaleEnabled;
  33370.     }
  33371.     
  33372.     private Boolean isStatisticheGenerazioneBaseMensileEnabled = null;
  33373.     public boolean isStatisticheGenerazioneBaseMensileEnabled() {   
  33374.         if(this.isStatisticheGenerazioneBaseMensileEnabled==null){
  33375.             try{ 
  33376.                 String name = null;
  33377.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseMensile.enabled");
  33378.                 if(name==null){
  33379.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseMensile.enabled' non impostata, viene utilizzato il default=true");
  33380.                     name="true";
  33381.                 }
  33382.                 name = name.trim();
  33383.                 this.isStatisticheGenerazioneBaseMensileEnabled = Boolean.parseBoolean(name);
  33384.             } catch(java.lang.Exception e) {
  33385.                 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);
  33386.                 this.isStatisticheGenerazioneBaseMensileEnabled = true;
  33387.             }    
  33388.         }

  33390.         return this.isStatisticheGenerazioneBaseMensileEnabled;
  33391.     }
  33392.     
  33393.     
  33394.     private Boolean isStatisticheGenerazioneBaseOrariaEnabledUltimaOra = null;
  33395.     public boolean isStatisticheGenerazioneBaseOrariaEnabledUltimaOra() {   
  33396.         if(this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra==null){
  33397.             try{ 
  33398.                 String name = null;
  33399.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseOraria.gestioneUltimaOra");
  33400.                 if(name==null){
  33401.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseOraria.gestioneUltimaOra' non impostata, viene utilizzato il default=true");
  33402.                     name="true";
  33403.                 }
  33404.                 name = name.trim();
  33405.                 this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra = Boolean.parseBoolean(name);
  33406.             } catch(java.lang.Exception e) {
  33407.                 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);
  33408.                 this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra = true;
  33409.             }    
  33410.         }

  33412.         return this.isStatisticheGenerazioneBaseOrariaEnabledUltimaOra;
  33413.     }
  33414.     
  33415.     private Boolean isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno = null;
  33416.     public boolean isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno() {   
  33417.         if(this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno==null){
  33418.             try{ 
  33419.                 String name = null;
  33420.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.gestioneUltimoGiorno");
  33421.                 if(name==null){
  33422.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseGiornaliera.gestioneUltimoGiorno' non impostata, viene utilizzato il default=true");
  33423.                     name="true";
  33424.                 }
  33425.                 name = name.trim();
  33426.                 this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno = Boolean.parseBoolean(name);
  33427.             } catch(java.lang.Exception e) {
  33428.                 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);
  33429.                 this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno = true;
  33430.             }    
  33431.         }

  33433.         return this.isStatisticheGenerazioneBaseGiornalieraEnabledUltimoGiorno;
  33434.     }
  33435.     
  33436.     private Boolean isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana = null;
  33437.     public boolean isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana() {    
  33438.         if(this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana==null){
  33439.             try{ 
  33440.                 String name = null;
  33441.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.gestioneUltimaSettimana");
  33442.                 if(name==null){
  33443.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseSettimanale.gestioneUltimaSettimana' non impostata, viene utilizzato il default=true");
  33444.                     name="true";
  33445.                 }
  33446.                 name = name.trim();
  33447.                 this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana = Boolean.parseBoolean(name);
  33448.             } catch(java.lang.Exception e) {
  33449.                 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);
  33450.                 this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana = true;
  33451.             }    
  33452.         }

  33454.         return this.isStatisticheGenerazioneBaseSettimanaleEnabledUltimaSettimana;
  33455.     }
  33456.     
  33457.     private Boolean isStatisticheGenerazioneBaseMensileEnabledUltimoMese = null;
  33458.     public boolean isStatisticheGenerazioneBaseMensileEnabledUltimoMese() { 
  33459.         if(this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese==null){
  33460.             try{ 
  33461.                 String name = null;
  33462.                 name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.baseMensile.gestioneUltimoMese");
  33463.                 if(name==null){
  33464.                     this.logWarn("Proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.baseMensile.gestioneUltimoMese' non impostata, viene utilizzato il default=true");
  33465.                     name="true";
  33466.                 }
  33467.                 name = name.trim();
  33468.                 this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese = Boolean.parseBoolean(name);
  33469.             } catch(java.lang.Exception e) {
  33470.                 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);
  33471.                 this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese = true;
  33472.             }    
  33473.         }

  33475.         return this.isStatisticheGenerazioneBaseMensileEnabledUltimoMese;
  33476.     }
  33477.     
  33478.     private Boolean isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie = null;
  33479.     public boolean isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie() {  
  33480.         if(this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie==null){
  33481.             String pName = "org.openspcoop2.pdd.statistiche.generazione.attendiCompletamentoTransazioniInFasiIntermedie";
  33482.             try{ 
  33483.                 String name = null;
  33484.                 name = this.reader.getValueConvertEnvProperties(pName);
  33485.                 if(name==null){
  33486.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata, viene utilizzato il default=true");
  33487.                     name="true";
  33488.                 }
  33489.                 name = name.trim();
  33490.                 this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie = Boolean.parseBoolean(name);
  33491.             } catch(java.lang.Exception e) {
  33492.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  33493.                 this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie = true;
  33494.             }    
  33495.         }

  33497.         return this.isStatisticheGenerazioneAttendiCompletamentoTransazioniInFasiIntermedie;
  33498.     }
  33499.     
  33500.     private Long getStatisticheGenerazioneTradeOffMs = null;
  33501.     public long getStatisticheGenerazioneTradeOffMs() { 
  33502.         if(this.getStatisticheGenerazioneTradeOffMs==null){
  33503.             String pName = "org.openspcoop2.pdd.statistiche.generazione.tradeOffSeconds";
  33504.             try{ 
  33505.                 String name = null;
  33506.                 name = this.reader.getValueConvertEnvProperties(pName);
  33507.                 if(name==null){
  33508.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostata");
  33509.                     name="-1";
  33510.                 }
  33511.                 name = name.trim();
  33512.                 this.getStatisticheGenerazioneTradeOffMs = Long.parseLong(name);
  33513.                 if(this.getStatisticheGenerazioneTradeOffMs>0) {
  33514.                     this.getStatisticheGenerazioneTradeOffMs = this.getStatisticheGenerazioneTradeOffMs * 1000l; // traduco in ms
  33515.                 }
  33516.             } catch(java.lang.Exception e) {
  33517.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=300 : "+e.getMessage(),e);
  33518.                 this.getStatisticheGenerazioneTradeOffMs = 300l * 1000l;  // traduco in ms
  33519.             }    
  33520.         }

  33522.         return this.getStatisticheGenerazioneTradeOffMs;
  33523.     }

  33525.     // NOTA: DEVE ESSERE RILETTO TUTTE LE VOLTE CHE VIENE CHIAMATO!!!!!!!
  33526.     public StatisticsForceIndexConfig getStatisticheGenerazioneExternalForceIndexRepository() throws CoreException {    
  33527.         try{ 
  33528.             String name = null;
  33529.             name = this.reader.getValueConvertEnvProperties("org.openspcoop2.pdd.statistiche.generazione.forceIndex.repository");
  33530.             if(name!=null){
  33531.                 name = name.trim();
  33532.                 return readStatisticsForceIndexConfig(name);
  33533.             }
  33534.             
  33535.             return null;
  33536.             
  33537.         } catch(java.lang.Exception e) {
  33538.             this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop 'org.openspcoop2.pdd.statistiche.generazione.forceIndex.repository': "+e.getMessage(),e);
  33539.             throw new CoreException(e.getMessage(),e);
  33540.         }    
  33541.         
  33542.     }
  33543.     private StatisticsForceIndexConfig readStatisticsForceIndexConfig(String name) throws CoreException, IOException {
  33544.         File f = new File(name);
  33545.         if(f.exists()) {
  33546.             if(f.isDirectory()) {
  33547.                 throw newCoreExceptionNotFile(f,false);
  33548.             }
  33549.             if(!f.canRead()) {
  33550.                 throw newCoreExceptionCannotRead(f, false);
  33551.             }
  33552.         }
  33553.         else {
  33554.             // provo a cercarlo nel classpath
  33555.         }
  33556.         try (InputStream is = f.exists() ? new FileInputStream(f) : OpenSPCoop2Properties.class.getResourceAsStream(name);){
  33557.             if(is!=null) {
  33558.                 Properties p = new Properties();
  33559.                 p.load(is);
  33560.                 return new StatisticsForceIndexConfig(p);
  33561.             }
  33562.         }
  33563.         return null;
  33564.     }
  33565.     
  33566.     /* ------------- Tracing PDND ---------------------*/

  33568.     private Integer getStatistichePdndTracciamentoGenerazioneTimerIntervalSeconds = null;
  33569.     public int getStatistichePdndTracciamentoGenerazioneTimerIntervalSeconds() throws CoreException {   
  33570.         if(this.getStatistichePdndTracciamentoGenerazioneTimerIntervalSeconds==null){
  33571.             String key = "org.openspcoop2.pdd.statistiche.pdnd.tracciamento.generazione.timer.intervalloSecondi";
  33572.             try{ 
  33573.                 String name = null;
  33574.                 name = this.reader.getValueConvertEnvProperties(key);
  33575.                 if(name==null){
  33576.                     throw new CoreException("Proprieta' non impostata");
  33577.                 }
  33578.                 name = name.trim();
  33579.                 this.getStatistichePdndTracciamentoGenerazioneTimerIntervalSeconds = Integer.valueOf(name);
  33580.             } catch(java.lang.Exception e) {
  33581.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '" + key +"': "+e.getMessage(),e);
  33582.                 throw new CoreException(e.getMessage(),e);
  33583.             }    
  33584.         }

  33586.         return this.getStatistichePdndTracciamentoGenerazioneTimerIntervalSeconds;
  33587.     }
  33588.     
  33589.     private Integer getStatistichePdndTracciamentoPubblicazioneTimerIntervalSeconds = null;
  33590.     public int getStatistichePdndTracciamentoPubblicazioneTimerIntervalSeconds() throws CoreException { 
  33591.         if(this.getStatistichePdndTracciamentoPubblicazioneTimerIntervalSeconds==null){
  33592.             String key = "org.openspcoop2.pdd.statistiche.pdnd.tracciamento.pubblicazione.timer.intervalloSecondi";
  33593.             try{ 
  33594.                 String name = null;
  33595.                 name = this.reader.getValueConvertEnvProperties(key);
  33596.                 if(name==null){
  33597.                     throw new CoreException("Proprieta' non impostata");
  33598.                 }
  33599.                 name = name.trim();
  33600.                 this.getStatistichePdndTracciamentoPubblicazioneTimerIntervalSeconds = Integer.valueOf(name);
  33601.             } catch(java.lang.Exception e) {
  33602.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '" + key +"': "+e.getMessage(),e);
  33603.                 throw new CoreException(e.getMessage(),e);
  33604.             }    
  33605.         }

  33607.         return this.getStatistichePdndTracciamentoPubblicazioneTimerIntervalSeconds;
  33608.     }
  33609.     
  33610.     private Boolean isStatistichePdndTracciamentoGenerazione = null;
  33611.     public boolean isStatistichePdndTracciamentoGenerazioneEnabled() {  
  33612.         String key = "org.openspcoop2.pdd.statistiche.pdnd.tracciamento.generazione.enabled";
  33613.         if(this.isStatistichePdndTracciamentoGenerazione==null){
  33614.             try{ 
  33615.                 String name = null;
  33616.                 name = this.reader.getValueConvertEnvProperties(key);
  33617.                 if(name==null){
  33618.                     this.logWarn("Proprieta' di openspcoop '" + key + "' non impostata, viene utilizzato il default=true");
  33619.                     name="true";
  33620.                 }
  33621.                 name = name.trim();
  33622.                 this.isStatistichePdndTracciamentoGenerazione = Boolean.parseBoolean(name);
  33623.             } catch(java.lang.Exception e) {
  33624.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '" + key + "', viene utilizzato il default=true : "+e.getMessage(),e);
  33625.                 this.isStatistichePdndTracciamentoGenerazione = true;
  33626.             }    
  33627.         }

  33629.         return this.isStatistichePdndTracciamentoGenerazione;
  33630.     }
  33631.     
  33632.     private Boolean isStatistichePdndTracciamentoPubblicazione = null;
  33633.     public boolean isStatistichePdndTracciamentoPubblicazioneEnabled() {    
  33634.         String key = "org.openspcoop2.pdd.statistiche.pdnd.tracciamento.pubblicazione.enabled";
  33635.         if(this.isStatistichePdndTracciamentoPubblicazione==null){
  33636.             try{ 
  33637.                 String name = null;
  33638.                 name = this.reader.getValueConvertEnvProperties(key);
  33639.                 if(name==null){
  33640.                     this.logWarn("Proprieta' di openspcoop '" + key + "' non impostata, viene utilizzato il default=true");
  33641.                     name="true";
  33642.                 }
  33643.                 name = name.trim();
  33644.                 this.isStatistichePdndTracciamentoPubblicazione = Boolean.parseBoolean(name);
  33645.             } catch(java.lang.Exception e) {
  33646.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '" + key + "', viene utilizzato il default=true : "+e.getMessage(),e);
  33647.                 this.isStatistichePdndTracciamentoPubblicazione = true;
  33648.             }    
  33649.         }

  33651.         return this.isStatistichePdndTracciamentoPubblicazione;
  33652.     }
  33653.     
  33654.     private Set<String> getStatistichePdndTracciamentoSoggettiEnabled = null;
  33655.     private boolean isStatistichePdndTracciamentoSoggettiDisabled = false;
  33656.     public boolean isStatistichePdndTracciamentoSoggettiDisabled() {
  33657.         return this.isStatistichePdndTracciamentoSoggettiDisabled;
  33658.     }
  33659.     public Set<String> getStatistichePdndTracciamentoSoggettiEnabled() throws CoreException {   
  33660.         if(this.getStatistichePdndTracciamentoSoggettiEnabled==null){
  33661.             String key = "org.openspcoop2.pdd.statistiche.pdnd.tracciamento.soggetti.enabled";
  33662.             try{ 
  33663.                 String name = null;
  33664.                 name = this.reader.getValueConvertEnvProperties(key);
  33665.                 if (name == null || StringUtils.isEmpty(name)) {
  33666.                     this.isStatistichePdndTracciamentoSoggettiDisabled = true;
  33667.                     this.getStatistichePdndTracciamentoSoggettiEnabled = Set.of();
  33668.                 } 
  33669.                 else {
  33670.                     name = name.trim();
  33671.                     if("*".equals(name)) {
  33672.                         this.getStatistichePdndTracciamentoSoggettiEnabled = Set.of();
  33673.                     }
  33674.                     else {
  33675.                         this.getStatistichePdndTracciamentoSoggettiEnabled = Set.of(name.split(","));
  33676.                     }
  33677.                 }
  33678.             } catch(java.lang.Exception e) {
  33679.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '" + key +"': "+e.getMessage(),e);
  33680.                 throw new CoreException(e.getMessage(),e);
  33681.             }    
  33682.         }

  33684.         return this.getStatistichePdndTracciamentoSoggettiEnabled;
  33685.     }
  33686.     
  33687.     private Integer getStatistichePdndTracciamentoMaxAttempts = null;
  33688.     public Integer getStatistichePdndTracciamentoMaxAttempts() throws CoreException {   
  33689.         if(this.getStatistichePdndTracciamentoMaxAttempts==null){
  33690.             String key = "org.openspcoop2.pdd.statistiche.pdnd.tracciamento.maxAttempts";
  33691.             try{ 
  33692.                 String name = null;
  33693.                 name = this.reader.getValueConvertEnvProperties(key);
  33694.                 if(name==null){
  33695.                     this.getStatistichePdndTracciamentoMaxAttempts = 0;
  33696.                 } else {
  33697.                     name = name.trim();
  33698.                     this.getStatistichePdndTracciamentoMaxAttempts = Integer.valueOf(name);
  33699.                 }
  33700.             } catch(java.lang.Exception e) {
  33701.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '" + key +"': "+e.getMessage(),e);
  33702.                 throw new CoreException(e.getMessage(),e);
  33703.             }    
  33704.         }

  33706.         return this.getStatistichePdndTracciamentoMaxAttempts == 0 ? null : this.getStatistichePdndTracciamentoMaxAttempts;
  33707.     }
  33708.     
  33709.     private List<Integer> getStatistichePdndTracciamentoPendingCheck = null;
  33710.     public List<Integer> getStatistichePdndTracciamentoPendingCheck() throws CoreException {    
  33711.         if(this.getStatistichePdndTracciamentoPendingCheck==null){
  33712.             String key = "org.openspcoop2.pdd.statistiche.pdnd.tracciamento.pending.check";
  33713.             try{ 
  33714.                 String name = null;
  33715.                 name = this.reader.getValueConvertEnvProperties(key);
  33716.                 if(name==null){
  33717.                     this.getStatistichePdndTracciamentoPendingCheck = List.of(0);
  33718.                 } else {
  33719.                     name = name.trim();
  33720.                     this.getStatistichePdndTracciamentoPendingCheck = Arrays.stream(name.split(","))
  33721.                             .map(Integer::valueOf)
  33722.                             .collect(Collectors.toList());
  33723.                 }
  33724.             } catch(java.lang.Exception e) {
  33725.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '" + key +"': "+e.getMessage(),e);
  33726.                 throw new CoreException(e.getMessage(),e);
  33727.             }    
  33728.         }

  33730.         return this.getStatistichePdndTracciamentoPendingCheck;
  33731.     }
  33732.     
  33733.     private Boolean isStatistichePdndTracciamentoErogazioniEnabled = null;
  33734.     public boolean isStatistichePdndTracciamentoErogazioniEnabled() {   
  33735.         String key = "org.openspcoop2.pdd.statistiche.pdnd.tracciamento.erogazioni.enabled";
  33736.         if(this.isStatistichePdndTracciamentoErogazioniEnabled==null){
  33737.             try{ 
  33738.                 String name = null;
  33739.                 name = this.reader.getValueConvertEnvProperties(key);
  33740.                 if(name==null){
  33741.                     this.logWarn("Proprieta' di openspcoop '" + key + "' non impostata, viene utilizzato il default=true");
  33742.                     name="true";
  33743.                 }
  33744.                 name = name.trim();
  33745.                 this.isStatistichePdndTracciamentoErogazioniEnabled = Boolean.parseBoolean(name);
  33746.             } catch(java.lang.Exception e) {
  33747.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '" + key + "', viene utilizzato il default=true : "+e.getMessage(),e);
  33748.                 this.isStatistichePdndTracciamentoErogazioniEnabled = true;
  33749.             }    
  33750.         }

  33752.         return this.isStatistichePdndTracciamentoErogazioniEnabled;
  33753.     }
  33754.     
  33755.     private Boolean isStatistichePdndTracciamentoFruizioniEnabled = null;
  33756.     public boolean isStatistichePdndTracciamentoFruizioniEnabled() {    
  33757.         String key = "org.openspcoop2.pdd.statistiche.pdnd.tracciamento.fruizioni.enabled";
  33758.         if(this.isStatistichePdndTracciamentoFruizioniEnabled==null){
  33759.             try{ 
  33760.                 String name = null;
  33761.                 name = this.reader.getValueConvertEnvProperties(key);
  33762.                 if(name==null){
  33763.                     this.logWarn("Proprieta' di openspcoop '" + key + "' non impostata, viene utilizzato il default=true");
  33764.                     name="true";
  33765.                 }
  33766.                 name = name.trim();
  33767.                 this.isStatistichePdndTracciamentoFruizioniEnabled = Boolean.parseBoolean(name);
  33768.             } catch(java.lang.Exception e) {
  33769.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '" + key + "', viene utilizzato il default=true : "+e.getMessage(),e);
  33770.                 this.isStatistichePdndTracciamentoFruizioniEnabled = true;
  33771.             }    
  33772.         }

  33774.         return this.isStatistichePdndTracciamentoFruizioniEnabled;
  33775.     }
  33776.     
  33777.     private HttpRequestConfig statistichePdndTracciamentoHttpRequestConfig = null;
  33778.     public HttpRequestConfig getStatistichePdndTracciamentoHttpRequestConfig() {    
  33779.         if(this.statistichePdndTracciamentoHttpRequestConfig==null){
  33780.             this.statistichePdndTracciamentoHttpRequestConfig = new HttpRequestConfig("org.openspcoop2.pdd.statistiche.pdnd.tracciamento", p -> {
  33781.                 try {
  33782.                     return this.reader.getValueConvertEnvProperties(p);
  33783.                 } catch (UtilsException e) {
  33784.                     return null;
  33785.                 }
  33786.             });   
  33787.         }

  33789.         return this.statistichePdndTracciamentoHttpRequestConfig;
  33790.     }
  33791.     
  33792.     
  33793.     
  33794.     /* ------------- Gestore Chiavi PDND ---------------------*/
  33795.     
  33796.     private Boolean isGestoreChiaviPDNDEnabled = null;
  33797.     public boolean isGestoreChiaviPDNDEnabled() {   
  33798.         if(this.isGestoreChiaviPDNDEnabled==null){
  33799.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.enabled";
  33800.             try{ 
  33801.                 String name = null;
  33802.                 name = this.reader.getValueConvertEnvProperties(pName);
  33803.                 if(name==null){
  33804.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, false));
  33805.                     name="false";
  33806.                 }
  33807.                 name = name.trim();
  33808.                 this.isGestoreChiaviPDNDEnabled = Boolean.parseBoolean(name);
  33809.             } catch(java.lang.Exception e) {
  33810.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=false : "+e.getMessage(),e);
  33811.                 this.isGestoreChiaviPDNDEnabled = false;
  33812.             }    
  33813.         }

  33815.         return this.isGestoreChiaviPDNDEnabled;
  33816.     }
  33817.     
  33818.     private Boolean isGestoreChiaviPDNDDebug = null;
  33819.     public boolean isGestoreChiaviPDNDDebug() { 
  33820.         if(this.isGestoreChiaviPDNDDebug==null){
  33821.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.debug";
  33822.             try{ 
  33823.                 String name = null;
  33824.                 name = this.reader.getValueConvertEnvProperties(pName);
  33825.                 if(name==null){
  33826.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  33827.                     name="true";
  33828.                 }
  33829.                 name = name.trim();
  33830.                 this.isGestoreChiaviPDNDDebug = Boolean.parseBoolean(name);
  33831.             } catch(java.lang.Exception e) {
  33832.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  33833.                 this.isGestoreChiaviPDNDDebug = true;
  33834.             }    
  33835.         }

  33837.         return this.isGestoreChiaviPDNDDebug;
  33838.     }
  33839.     
  33840.     private Boolean isGestoreChiaviPDNDEventiAdd = null;
  33841.     public boolean isGestoreChiaviPDNDEventiAdd() { 
  33842.         if(this.isGestoreChiaviPDNDEventiAdd==null){
  33843.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.eventi.add";
  33844.             try{ 
  33845.                 String name = null;
  33846.                 name = this.reader.getValueConvertEnvProperties(pName);
  33847.                 if(name==null){
  33848.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  33849.                     name="true";
  33850.                 }
  33851.                 name = name.trim();
  33852.                 this.isGestoreChiaviPDNDEventiAdd = Boolean.parseBoolean(name);
  33853.             } catch(java.lang.Exception e) {
  33854.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  33855.                 this.isGestoreChiaviPDNDEventiAdd = true;
  33856.             }    
  33857.         }

  33859.         return this.isGestoreChiaviPDNDEventiAdd;
  33860.     }
  33861.     
  33862.     private Boolean isGestoreChiaviPDNDEventiUpdate = null;
  33863.     public boolean isGestoreChiaviPDNDEventiUpdate() {  
  33864.         if(this.isGestoreChiaviPDNDEventiUpdate==null){
  33865.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.eventi.update";
  33866.             try{ 
  33867.                 String name = null;
  33868.                 name = this.reader.getValueConvertEnvProperties(pName);
  33869.                 if(name==null){
  33870.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  33871.                     name="true";
  33872.                 }
  33873.                 name = name.trim();
  33874.                 this.isGestoreChiaviPDNDEventiUpdate = Boolean.parseBoolean(name);
  33875.             } catch(java.lang.Exception e) {
  33876.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  33877.                 this.isGestoreChiaviPDNDEventiUpdate = true;
  33878.             }    
  33879.         }

  33881.         return this.isGestoreChiaviPDNDEventiUpdate;
  33882.     }
  33883.     
  33884.     private Boolean isGestoreChiaviPDNDEventiDelete = null;
  33885.     public boolean isGestoreChiaviPDNDEventiDelete() {  
  33886.         if(this.isGestoreChiaviPDNDEventiDelete==null){
  33887.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.eventi.delete";
  33888.             try{ 
  33889.                 String name = null;
  33890.                 name = this.reader.getValueConvertEnvProperties(pName);
  33891.                 if(name==null){
  33892.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  33893.                     name="true";
  33894.                 }
  33895.                 name = name.trim();
  33896.                 this.isGestoreChiaviPDNDEventiDelete = Boolean.parseBoolean(name);
  33897.             } catch(java.lang.Exception e) {
  33898.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default=true : "+e.getMessage(),e);
  33899.                 this.isGestoreChiaviPDNDEventiDelete = true;
  33900.             }    
  33901.         }

  33903.         return this.isGestoreChiaviPDNDEventiDelete;
  33904.     }
  33905.     
  33906.     private List<String> getGestoreChiaviPDNDRemoteStoreName = null;
  33907.     public List<String> getGestoreChiaviPDNDRemoteStoreName() throws CoreException {    
  33908.         if(this.getGestoreChiaviPDNDRemoteStoreName==null){
  33909.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.remoteStore.name";
  33910.             try{ 
  33911.                 String name = null;
  33912.                 name = this.reader.getValueConvertEnvProperties(pName);
  33913.                 if(name==null){
  33914.                     throw new CoreException("Proprieta' non impostata");
  33915.                 }
  33916.                 name = name.trim();
  33917.                 this.getGestoreChiaviPDNDRemoteStoreName = new ArrayList<>();
  33918.                 
  33919.                 initSplitValues(this.getGestoreChiaviPDNDRemoteStoreName, name, false);
  33920.                 
  33921.             } catch(java.lang.Exception e) {
  33922.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  33923.                 throw new CoreException(e.getMessage(),e);
  33924.             }    
  33925.         }

  33927.         return this.getGestoreChiaviPDNDRemoteStoreName;
  33928.     }
  33929.     
  33930.     private Boolean isGestoreChiaviPDNDEventiCheckAllStores = null;
  33931.     public boolean isGestoreChiaviPDNDEventiCheckAllStores() {  
  33932.         if(this.isGestoreChiaviPDNDEventiCheckAllStores==null){
  33933.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.remoteStore.checkAllStores";
  33934.             try{ 
  33935.                 String name = null;
  33936.                 name = this.reader.getValueConvertEnvProperties(pName);
  33937.                 if(name==null){
  33938.                     this.logWarn(getMessaggioProprietaNonImpostata(pName, true));
  33939.                     name="true";
  33940.                 }
  33941.                 name = name.trim();
  33942.                 this.isGestoreChiaviPDNDEventiCheckAllStores = Boolean.parseBoolean(name);
  33943.             } catch(java.lang.Exception e) {
  33944.                 this.logError(getMessaggioProprietaNonImpostata(pName, e, true));
  33945.                 this.isGestoreChiaviPDNDEventiCheckAllStores = true;
  33946.             }    
  33947.         }

  33949.         return this.isGestoreChiaviPDNDEventiCheckAllStores;
  33950.     }
  33951.     
  33952.     private Integer getGestoreChiaviPDNDkeysMaxLifeMinutes = null;
  33953.     public int getGestoreChiaviPDNDkeysMaxLifeMinutes() {   
  33954.         if(this.getGestoreChiaviPDNDkeysMaxLifeMinutes==null){
  33955.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.keys.maxLifeMinutes";
  33956.             int defaultValue = 43200;
  33957.             try{ 
  33958.                 String name = null;
  33959.                 name = this.reader.getValueConvertEnvProperties(pName);
  33960.                 if(name==null){
  33961.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
  33962.                     name=defaultValue+"";
  33963.                 }
  33964.                 name = name.trim();
  33965.                 this.getGestoreChiaviPDNDkeysMaxLifeMinutes = Integer.valueOf(name);
  33966.                 /**if(this.getGestoreChiaviPDNDkeysMaxLifeMinutes<=0) {
  33967.                     throw new CoreException("Atteso un limite maggiore di zero");
  33968.                 }*/ // Se la proprietà viene valorizzata con un valore <=0 le informazioni hanno vita infinita
  33969.             } catch(java.lang.Exception e) {
  33970.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
  33971.                 this.getGestoreChiaviPDNDkeysMaxLifeMinutes = defaultValue;
  33972.             }    
  33973.         }

  33975.         return this.getGestoreChiaviPDNDkeysMaxLifeMinutes;
  33976.     }
  33977.         
  33978.     private String getGestoreChiaviPDNDkeysPath = null;
  33979.     public String getGestoreChiaviPDNDkeysPath() throws CoreException { 
  33980.         if(this.getGestoreChiaviPDNDkeysPath==null){
  33981.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.keys.path";
  33982.             try{ 
  33983.                 String name = null;
  33984.                 name = this.reader.getValueConvertEnvProperties(pName);
  33985.                 if(name==null){
  33986.                     throw new CoreException("Proprieta' non impostata");
  33987.                 }
  33988.                 name = name.trim();
  33989.                 this.getGestoreChiaviPDNDkeysPath = name;
  33990.             } catch(java.lang.Exception e) {
  33991.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  33992.                 throw new CoreException(e.getMessage(),e);
  33993.             }    
  33994.         }

  33996.         return this.getGestoreChiaviPDNDkeysPath;
  33997.     }
  33998.     
  33999.     private String getGestoreChiaviPDNDeventsKeysPath = null;
  34000.     public String getGestoreChiaviPDNDeventsKeysPath() throws CoreException {   
  34001.         if(this.getGestoreChiaviPDNDeventsKeysPath==null){
  34002.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.path";
  34003.             try{ 
  34004.                 String name = null;
  34005.                 name = this.reader.getValueConvertEnvProperties(pName);
  34006.                 if(name==null){
  34007.                     throw new CoreException("Proprieta' non impostata");
  34008.                 }
  34009.                 name = name.trim();
  34010.                 this.getGestoreChiaviPDNDeventsKeysPath = name;
  34011.             } catch(java.lang.Exception e) {
  34012.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34013.                 throw new CoreException(e.getMessage(),e);
  34014.             }    
  34015.         }

  34017.         return this.getGestoreChiaviPDNDeventsKeysPath;
  34018.     }
  34019.     
  34020.     private String getGestoreChiaviPDNDeventsKeysParameterLastEventId = null;
  34021.     public String getGestoreChiaviPDNDeventsKeysParameterLastEventId() throws CoreException {   
  34022.         if(this.getGestoreChiaviPDNDeventsKeysParameterLastEventId==null){
  34023.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.parameter.lastEventId";
  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.getGestoreChiaviPDNDeventsKeysParameterLastEventId = name;
  34032.             } catch(java.lang.Exception e) {
  34033.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34034.                 throw new CoreException(e.getMessage(),e);
  34035.             }    
  34036.         }

  34038.         return this.getGestoreChiaviPDNDeventsKeysParameterLastEventId;
  34039.     }
  34040.     
  34041.     private String getGestoreChiaviPDNDeventsKeysParameterLimit = null;
  34042.     public String getGestoreChiaviPDNDeventsKeysParameterLimit() throws CoreException { 
  34043.         if(this.getGestoreChiaviPDNDeventsKeysParameterLimit==null){
  34044.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.parameter.limit";
  34045.             try{ 
  34046.                 String name = null;
  34047.                 name = this.reader.getValueConvertEnvProperties(pName);
  34048.                 if(name==null){
  34049.                     throw new CoreException("Proprieta' non impostata");
  34050.                 }
  34051.                 name = name.trim();
  34052.                 this.getGestoreChiaviPDNDeventsKeysParameterLimit = name;
  34053.             } catch(java.lang.Exception e) {
  34054.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34055.                 throw new CoreException(e.getMessage(),e);
  34056.             }    
  34057.         }

  34059.         return this.getGestoreChiaviPDNDeventsKeysParameterLimit;
  34060.     }

  34062.     private Integer getGestoreChiaviPDNDeventsKeysLimit = null;
  34063.     public int getGestoreChiaviPDNDeventsKeysLimit() {  
  34064.         if(this.getGestoreChiaviPDNDeventsKeysLimit==null){
  34065.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.limit";
  34066.             int defaultValue = 100;
  34067.             try{ 
  34068.                 String name = null;
  34069.                 name = this.reader.getValueConvertEnvProperties(pName);
  34070.                 if(name==null){
  34071.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
  34072.                     name=defaultValue+"";
  34073.                 }
  34074.                 name = name.trim();
  34075.                 this.getGestoreChiaviPDNDeventsKeysLimit = Integer.valueOf(name);
  34076.                 if(this.getGestoreChiaviPDNDeventsKeysLimit<=0) {
  34077.                     throw new CoreException("Atteso un limite maggiore di zero");
  34078.                 }
  34079.             } catch(java.lang.Exception e) {
  34080.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
  34081.                 this.getGestoreChiaviPDNDeventsKeysLimit = defaultValue;
  34082.             }    
  34083.         }

  34085.         return this.getGestoreChiaviPDNDeventsKeysLimit;
  34086.     }

  34088.     private Long getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi = null;
  34089.     public long getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi() {    
  34090.         if(this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi==null){
  34091.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.intervalloSecondi";
  34092.             long defaultValue = 3600;
  34093.             try{ 
  34094.                 String name = null;
  34095.                 name = this.reader.getValueConvertEnvProperties(pName);
  34096.                 if(name==null){
  34097.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
  34098.                     name=defaultValue+"";
  34099.                 }
  34100.                 name = name.trim();
  34101.                 this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi = Long.valueOf(name);
  34102.                 if(this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi<=0) {
  34103.                     throw new CoreException("Atteso un intervallo maggiore di zero");
  34104.                 }
  34105.             } catch(java.lang.Exception e) {
  34106.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
  34107.                 this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi = defaultValue;
  34108.             }    
  34109.         }

  34111.         return this.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi;
  34112.     }
  34113.     
  34114.     private Long getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi = null;
  34115.     public long getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi() { 
  34116.         if(this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi==null){
  34117.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.cache.keys.timer.intervalloSecondi";
  34118.             long defaultValue = 300;
  34119.             try{ 
  34120.                 String name = null;
  34121.                 name = this.reader.getValueConvertEnvProperties(pName);
  34122.                 if(name==null){
  34123.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
  34124.                     name=defaultValue+"";
  34125.                 }
  34126.                 name = name.trim();
  34127.                 this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi = Long.valueOf(name);
  34128.                 if(this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi<=0) {
  34129.                     throw new CoreException("Atteso un intervallo maggiore di zero");
  34130.                 }
  34131.             } catch(java.lang.Exception e) {
  34132.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
  34133.                 this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi = defaultValue;
  34134.             }    
  34135.         }

  34137.         return this.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi;
  34138.     }
  34139.     
  34140.     private Integer getGestoreChiaviPDNDTimerLockMaxLife = null;
  34141.     public int getGestoreChiaviPDNDTimerLockMaxLife() { 
  34142.         if(this.getGestoreChiaviPDNDTimerLockMaxLife==null){
  34143.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.lock.maxLife";
  34144.             try{ 
  34145.                 String name = null;
  34146.                 name = this.reader.getValueConvertEnvProperties(pName);

  34148.                 if(name!=null){
  34149.                     name = name.trim();
  34150.                     this.getGestoreChiaviPDNDTimerLockMaxLife = java.lang.Integer.parseInt(name);
  34151.                 }else{
  34152.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.TIMER_LOCK_MAX_LIFE));
  34153.                     this.getGestoreChiaviPDNDTimerLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  34154.                 }
  34155.             }catch(java.lang.Exception e) {
  34156.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.TIMER_LOCK_MAX_LIFE),e);
  34157.                 this.getGestoreChiaviPDNDTimerLockMaxLife = CostantiPdD.TIMER_LOCK_MAX_LIFE;
  34158.             }
  34159.             if(this.getGestoreChiaviPDNDTimerLockMaxLife!=null && this.getGestoreChiaviPDNDTimerLockMaxLife>0) {
  34160.                 // trasformo in millisecondi l'informazione fornita in secondi
  34161.                 this.getGestoreChiaviPDNDTimerLockMaxLife = this.getGestoreChiaviPDNDTimerLockMaxLife *1000;
  34162.             }
  34163.         }

  34165.         if(this.getGestoreChiaviPDNDTimerLockMaxLife!=null) {
  34166.             return this.getGestoreChiaviPDNDTimerLockMaxLife.intValue();
  34167.         }
  34168.         return -1;
  34169.     }
  34170.     
  34171.     private Integer getGestoreChiaviPDNDTimerLockIdleTime = null;
  34172.     public int getGestoreChiaviPDNDTimerLockIdleTime() {    
  34173.         if(this.getGestoreChiaviPDNDTimerLockIdleTime==null){
  34174.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.lock.idleTime";
  34175.             try{ 
  34176.                 String name = null;
  34177.                 name = this.reader.getValueConvertEnvProperties(pName);

  34179.                 if(name!=null){
  34180.                     name = name.trim();
  34181.                     this.getGestoreChiaviPDNDTimerLockIdleTime = java.lang.Integer.parseInt(name);
  34182.                 }else{
  34183.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,CostantiPdD.TIMER_LOCK_IDLE_TIME));
  34184.                     this.getGestoreChiaviPDNDTimerLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  34185.                 }
  34186.             }catch(java.lang.Exception e) {
  34187.                 this.logWarn(getMessaggioProprietaNonImpostata(pName,e,CostantiPdD.TIMER_LOCK_IDLE_TIME),e);
  34188.                 this.getGestoreChiaviPDNDTimerLockIdleTime = CostantiPdD.TIMER_LOCK_IDLE_TIME;
  34189.             }
  34190.             if(this.getGestoreChiaviPDNDTimerLockIdleTime!=null && this.getGestoreChiaviPDNDTimerLockIdleTime>0) {
  34191.                 // trasformo in millisecondi l'informazione fornita in secondi
  34192.                 this.getGestoreChiaviPDNDTimerLockIdleTime = this.getGestoreChiaviPDNDTimerLockIdleTime *1000;
  34193.             }
  34194.         }

  34196.         if(this.getGestoreChiaviPDNDTimerLockIdleTime!=null) {
  34197.             return this.getGestoreChiaviPDNDTimerLockIdleTime.intValue();
  34198.         }
  34199.         return -1;
  34200.     }
  34201.     
  34202.     private Long getGestoreChiaviPDNDTimerLockAttesaAttiva = null;
  34203.     public long getGestoreChiaviPDNDTimerLockAttesaAttiva() {   
  34204.         if(this.getGestoreChiaviPDNDTimerLockAttesaAttiva==null){
  34205.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.lock.attesaAttiva";
  34206.             try{ 
  34207.                 String name = null;
  34208.                 name = this.reader.getValueConvertEnvProperties(pName);

  34210.                 if(name!=null){
  34211.                     name = name.trim();
  34212.                     long time = java.lang.Long.parseLong(name);
  34213.                     this.getGestoreChiaviPDNDTimerLockAttesaAttiva = time*1000;
  34214.                 }else{
  34215.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_ATTESA_ATTIVA);
  34216.                     this.getGestoreChiaviPDNDTimerLockAttesaAttiva = CostantiPdD.GET_LOCK_ATTESA_ATTIVA;
  34217.                 }

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

  34225.         return this.getGestoreChiaviPDNDTimerLockAttesaAttiva;
  34226.     }

  34228.     private Integer getGestoreChiaviPDNDTimerLockCheckInterval = null;
  34229.     public int getGestoreChiaviPDNDTimerLockCheckInterval() {   
  34230.         if(this.getGestoreChiaviPDNDTimerLockCheckInterval==null){
  34231.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.events.keys.timer.lock.check";
  34232.             try{ 
  34233.                 String name = null;
  34234.                 name = this.reader.getValueConvertEnvProperties(pName);

  34236.                 if(name!=null){
  34237.                     name = name.trim();
  34238.                     int time = java.lang.Integer.parseInt(name);
  34239.                     this.getGestoreChiaviPDNDTimerLockCheckInterval = time;
  34240.                 }else{
  34241.                     this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL);
  34242.                     this.getGestoreChiaviPDNDTimerLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  34243.                 }
  34244.             }catch(java.lang.Exception e) {
  34245.                 this.logWarn("Proprieta' di openspcoop '"+pName+"' non impostato, viene utilizzato il default="+CostantiPdD.GET_LOCK_CHECK_INTERVAL+", errore:"+e.getMessage(),e);
  34246.                 this.getGestoreChiaviPDNDTimerLockCheckInterval = CostantiPdD.GET_LOCK_CHECK_INTERVAL;
  34247.             }  
  34248.         }

  34250.         return this.getGestoreChiaviPDNDTimerLockCheckInterval;
  34251.     }
  34252.     
  34253.     private String getGestoreChiaviPDNDclientsPath = null;
  34254.     public String getGestoreChiaviPDNDclientsPath() throws CoreException {  
  34255.         if(this.getGestoreChiaviPDNDclientsPath==null){
  34256.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.clients.path";
  34257.             try{ 
  34258.                 String name = null;
  34259.                 name = this.reader.getValueConvertEnvProperties(pName);
  34260.                 if(name==null){
  34261.                     throw new CoreException("Proprieta' non impostata");
  34262.                 }
  34263.                 name = name.trim();
  34264.                 this.getGestoreChiaviPDNDclientsPath = name;
  34265.             } catch(java.lang.Exception e) {
  34266.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34267.                 throw new CoreException(e.getMessage(),e);
  34268.             }    
  34269.         }

  34271.         return this.getGestoreChiaviPDNDclientsPath;
  34272.     }
  34273.         
  34274.     private String getGestoreChiaviPDNDclientsOrganizationJsonPath = null;
  34275.     public String getGestoreChiaviPDNDclientsOrganizationJsonPath() throws CoreException {  
  34276.         if(this.getGestoreChiaviPDNDclientsOrganizationJsonPath==null){
  34277.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.clients.organizationJsonPath";
  34278.             try{ 
  34279.                 String name = null;
  34280.                 name = this.reader.getValueConvertEnvProperties(pName);
  34281.                 if(name==null){
  34282.                     throw new CoreException("Proprieta' non impostata");
  34283.                 }
  34284.                 name = name.trim();
  34285.                 this.getGestoreChiaviPDNDclientsOrganizationJsonPath = name;
  34286.             } catch(java.lang.Exception e) {
  34287.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34288.                 throw new CoreException(e.getMessage(),e);
  34289.             }    
  34290.         }

  34292.         return this.getGestoreChiaviPDNDclientsOrganizationJsonPath;
  34293.     }
  34294.     
  34295.     private String getGestoreChiaviPDNDorganizationsPath = null;
  34296.     public String getGestoreChiaviPDNDorganizationsPath() throws CoreException {    
  34297.         if(this.getGestoreChiaviPDNDorganizationsPath==null){
  34298.             String pName = "org.openspcoop2.pdd.gestoreChiaviPDND.organizations.path";
  34299.             try{ 
  34300.                 String name = null;
  34301.                 name = this.reader.getValueConvertEnvProperties(pName);
  34302.                 if(name==null){
  34303.                     throw new CoreException("Proprieta' non impostata");
  34304.                 }
  34305.                 name = name.trim();
  34306.                 this.getGestoreChiaviPDNDorganizationsPath = name;
  34307.             } catch(java.lang.Exception e) {
  34308.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34309.                 throw new CoreException(e.getMessage(),e);
  34310.             }    
  34311.         }

  34313.         return this.getGestoreChiaviPDNDorganizationsPath;
  34314.     }
  34315.     
  34316.     
  34317.     
  34318.     private Boolean isGestoreChiaviPDNDclientInfoEnabled = null;
  34319.     public boolean isGestoreChiaviPDNDclientInfoEnabled() throws CoreException {    
  34320.         if(this.isGestoreChiaviPDNDclientInfoEnabled==null){
  34321.             String pName = "org.openspcoop2.pdd.gestorePDND.clientInfo.enabled";
  34322.             try{ 
  34323.                 String name = null;
  34324.                 name = this.reader.getValueConvertEnvProperties(pName);
  34325.                 if(name==null){
  34326.                     throw new CoreException("Proprieta' non impostata");
  34327.                 }
  34328.                 name = name.trim();
  34329.                 this.isGestoreChiaviPDNDclientInfoEnabled = Boolean.valueOf(name);
  34330.                 
  34331.                 if(this.isGestoreChiaviPDNDclientInfoEnabled.booleanValue() && !this.isGestoreChiaviPDNDEnabled()) {
  34332.                     throw new CoreException("per abilitare la proprietà è richiesto che sia abilitata la gestione delle chiavi PDND");
  34333.                 }
  34334.                 
  34335.             } catch(java.lang.Exception e) {
  34336.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34337.                 throw new CoreException(e.getMessage(),e);
  34338.             }    
  34339.         }

  34341.         return this.isGestoreChiaviPDNDclientInfoEnabled;
  34342.     }
  34343.     
  34344.     private Integer getGestoreChiaviPDNDclientInfoMaxLifeMinutes = null;
  34345.     public int getGestoreChiaviPDNDclientInfoMaxLifeMinutes() { 
  34346.         if(this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes==null){
  34347.             String pName = "org.openspcoop2.pdd.gestorePDND.clientInfo.maxLifeMinutes";
  34348.             int defaultValue = 43200;
  34349.             try{ 
  34350.                 String name = null;
  34351.                 name = this.reader.getValueConvertEnvProperties(pName);
  34352.                 if(name==null){
  34353.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
  34354.                     name=defaultValue+"";
  34355.                 }
  34356.                 name = name.trim();
  34357.                 this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes = Integer.valueOf(name);
  34358.                 /**if(this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes<=0) {
  34359.                     throw new CoreException("Atteso un limite maggiore di zero");
  34360.                 }*/ // Se la proprietà viene valorizzata con un valore <=0 le informazioni hanno vita infinita
  34361.             } catch(java.lang.Exception e) {
  34362.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
  34363.                 this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes = defaultValue;
  34364.             }    
  34365.         }

  34367.         return this.getGestoreChiaviPDNDclientInfoMaxLifeMinutes;
  34368.     }
  34369.     
  34370.     private Integer getGestoreChiaviPDNDclientInfoCacheFallbackMaxLifeMinutes = null;
  34371.     public int getGestoreChiaviPDNDclientInfoCacheFallbackMaxLifeMinutes() {    
  34372.         if(this.getGestoreChiaviPDNDclientInfoCacheFallbackMaxLifeMinutes==null){
  34373.             String pName = "org.openspcoop2.pdd.gestorePDND.clientInfo.cacheFallbackMaxLifeMinutes";
  34374.             int defaultValue = 5;
  34375.             try{ 
  34376.                 String name = null;
  34377.                 name = this.reader.getValueConvertEnvProperties(pName);
  34378.                 if(name==null){
  34379.                     this.logWarn(getMessaggioProprietaNonImpostata(pName,defaultValue));
  34380.                     name=defaultValue+"";
  34381.                 }
  34382.                 name = name.trim();
  34383.                 this.getGestoreChiaviPDNDclientInfoCacheFallbackMaxLifeMinutes = Integer.valueOf(name);
  34384.                 /**if(this.getGestoreChiaviPDNDclientInfoCacheFallbackMaxLifeMinutes<=0) {
  34385.                     throw new CoreException("Atteso un limite maggiore di zero");
  34386.                 }*/ // Se la proprietà viene valorizzata con un valore <=0 le informazioni hanno vita infinita
  34387.             } catch(java.lang.Exception e) {
  34388.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '"+pName+"', viene utilizzato il default="+defaultValue+" : "+e.getMessage(),e);
  34389.                 this.getGestoreChiaviPDNDclientInfoCacheFallbackMaxLifeMinutes = defaultValue;
  34390.             }    
  34391.         }

  34393.         return this.getGestoreChiaviPDNDclientInfoCacheFallbackMaxLifeMinutes;
  34394.     }
  34395.         
  34396.     private Boolean isGestoreChiaviPDNDclientsErrorAbortTransaction = null;
  34397.     public boolean isGestoreChiaviPDNDclientsErrorAbortTransaction() throws CoreException { 
  34398.         if(this.isGestoreChiaviPDNDclientsErrorAbortTransaction==null){
  34399.             String pName = "org.openspcoop2.pdd.gestorePDND.clients.error.abortTransaction";
  34400.             try{ 
  34401.                 String name = null;
  34402.                 name = this.reader.getValueConvertEnvProperties(pName);
  34403.                 if(name==null){
  34404.                     throw new CoreException("Proprieta' non impostata");
  34405.                 }
  34406.                 name = name.trim();
  34407.                 this.isGestoreChiaviPDNDclientsErrorAbortTransaction = Boolean.valueOf(name);
  34408.             } catch(java.lang.Exception e) {
  34409.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34410.                 throw new CoreException(e.getMessage(),e);
  34411.             }    
  34412.         }

  34414.         return this.isGestoreChiaviPDNDclientsErrorAbortTransaction;
  34415.     }
  34416.     
  34417.     private Boolean isGestoreChiaviPDNDorganizationsErrorAbortTransaction = null;
  34418.     public boolean isGestoreChiaviPDNDorganizationsErrorAbortTransaction() throws CoreException {   
  34419.         if(this.isGestoreChiaviPDNDorganizationsErrorAbortTransaction==null){
  34420.             String pName = "org.openspcoop2.pdd.gestorePDND.organizations.error.abortTransaction";
  34421.             try{ 
  34422.                 String name = null;
  34423.                 name = this.reader.getValueConvertEnvProperties(pName);
  34424.                 if(name==null){
  34425.                     throw new CoreException("Proprieta' non impostata");
  34426.                 }
  34427.                 name = name.trim();
  34428.                 this.isGestoreChiaviPDNDorganizationsErrorAbortTransaction = Boolean.valueOf(name);
  34429.             } catch(java.lang.Exception e) {
  34430.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34431.                 throw new CoreException(e.getMessage(),e);
  34432.             }    
  34433.         }

  34435.         return this.isGestoreChiaviPDNDorganizationsErrorAbortTransaction;
  34436.     }
  34437.     
  34438.     private Boolean isGestoreChiaviPDNDRateLimitingInfoNotAvailableAbortTransaction = null;
  34439.     public boolean isGestoreChiaviPDNDRateLimitingInfoNotAvailableAbortTransaction() throws CoreException { 
  34440.         if(this.isGestoreChiaviPDNDRateLimitingInfoNotAvailableAbortTransaction==null){
  34441.             String pName = "org.openspcoop2.pdd.gestorePDND.rateLimiting.infoNotAvailable.abortTransaction";
  34442.             try{ 
  34443.                 String name = null;
  34444.                 name = this.reader.getValueConvertEnvProperties(pName);
  34445.                 if(name==null){
  34446.                     throw new CoreException("Proprieta' non impostata");
  34447.                 }
  34448.                 name = name.trim();
  34449.                 this.isGestoreChiaviPDNDRateLimitingInfoNotAvailableAbortTransaction = Boolean.valueOf(name);
  34450.             } catch(java.lang.Exception e) {
  34451.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34452.                 throw new CoreException(e.getMessage(),e);
  34453.             }    
  34454.         }

  34456.         return this.isGestoreChiaviPDNDRateLimitingInfoNotAvailableAbortTransaction;
  34457.     }
  34458.     
  34459.     private Boolean isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation = null;
  34460.     public boolean isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation() throws CoreException { 
  34461.         if(this.isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation==null){
  34462.             String pName = "org.openspcoop2.pdd.gestorePDND.clientInfo.retrieveAfterVoucherPDNDValidation";
  34463.             try{ 
  34464.                 String name = null;
  34465.                 name = this.reader.getValueConvertEnvProperties(pName);
  34466.                 if(name==null){
  34467.                     throw new CoreException("Proprieta' non impostata");
  34468.                 }
  34469.                 name = name.trim();
  34470.                 this.isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation = Boolean.valueOf(name);
  34471.             } catch(java.lang.Exception e) {
  34472.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34473.                 throw new CoreException(e.getMessage(),e);
  34474.             }    
  34475.         }

  34477.         return this.isGestoreChiaviPDNDretrieveClientInfoAfterVoucherPDNDValidation;
  34478.     }
  34479.     
  34480.     private Boolean isGestoreChiaviPDNDclientsTraceJsonResponse = null;
  34481.     public boolean isGestoreChiaviPDNDclientsTraceJsonResponse() throws CoreException { 
  34482.         if(this.isGestoreChiaviPDNDclientsTraceJsonResponse==null){
  34483.             String pName = "org.openspcoop2.pdd.gestorePDND.clients.traceJsonResponse";
  34484.             try{ 
  34485.                 String name = null;
  34486.                 name = this.reader.getValueConvertEnvProperties(pName);
  34487.                 if(name==null){
  34488.                     throw new CoreException("Proprieta' non impostata");
  34489.                 }
  34490.                 name = name.trim();
  34491.                 this.isGestoreChiaviPDNDclientsTraceJsonResponse = Boolean.valueOf(name);
  34492.             } catch(java.lang.Exception e) {
  34493.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34494.                 throw new CoreException(e.getMessage(),e);
  34495.             }    
  34496.         }

  34498.         return this.isGestoreChiaviPDNDclientsTraceJsonResponse;
  34499.     }
  34500.     
  34501.     private Boolean isGestoreChiaviPDNDorganizationsTraceJsonResponse = null;
  34502.     public boolean isGestoreChiaviPDNDorganizationsTraceJsonResponse() throws CoreException {   
  34503.         if(this.isGestoreChiaviPDNDorganizationsTraceJsonResponse==null){
  34504.             String pName = "org.openspcoop2.pdd.gestorePDND.organizations.traceJsonResponse";
  34505.             try{ 
  34506.                 String name = null;
  34507.                 name = this.reader.getValueConvertEnvProperties(pName);
  34508.                 if(name==null){
  34509.                     throw new CoreException("Proprieta' non impostata");
  34510.                 }
  34511.                 name = name.trim();
  34512.                 this.isGestoreChiaviPDNDorganizationsTraceJsonResponse = Boolean.valueOf(name);
  34513.             } catch(java.lang.Exception e) {
  34514.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34515.                 throw new CoreException(e.getMessage(),e);
  34516.             }    
  34517.         }

  34519.         return this.isGestoreChiaviPDNDorganizationsTraceJsonResponse;
  34520.     }
  34521.     
  34522.     private Boolean isGestoreChiaviPDNDorganizationsTraceName = null;
  34523.     public boolean isGestoreChiaviPDNDorganizationsTraceName() throws CoreException {   
  34524.         if(this.isGestoreChiaviPDNDorganizationsTraceName==null){
  34525.             String pName = "org.openspcoop2.pdd.gestorePDND.organizations.traceName";
  34526.             try{ 
  34527.                 String name = null;
  34528.                 name = this.reader.getValueConvertEnvProperties(pName);
  34529.                 if(name==null){
  34530.                     throw new CoreException("Proprieta' non impostata");
  34531.                 }
  34532.                 name = name.trim();
  34533.                 this.isGestoreChiaviPDNDorganizationsTraceName = Boolean.valueOf(name);
  34534.             } catch(java.lang.Exception e) {
  34535.                 this.logError("Riscontrato errore durante la lettura della proprieta' di openspcoop '"+pName+"': "+e.getMessage(),e);
  34536.                 throw new CoreException(e.getMessage(),e);
  34537.             }    
  34538.         }

  34540.         return this.isGestoreChiaviPDNDorganizationsTraceName;
  34541.     }
  34542.     
  34543.     private Integer headersPeerRegexpCacheSize = null;
  34544.     public Integer getHeadersPeerRegexpCacheSize() throws CoreException {
  34545.         if (this.headersPeerRegexpCacheSize == null) {
  34546.             String pName = "org.openspcoop2.pdd.headers.peer.regexp.cacheSize";
  34547.             try{ 
  34548.                 String value = null;
  34549.                 value = this.reader.getValueConvertEnvProperties(pName);
  34550.                 if(value == null){
  34551.                     throw new CoreException("Proprieta' non impostata");
  34552.                 }
  34553.                 this.headersPeerRegexpCacheSize = Integer.parseInt(value.trim());
  34554.             } catch(java.lang.Exception e) {
  34555.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '"+pName+"': "+e.getMessage(),e);
  34556.                 throw new CoreException(e.getMessage(),e);
  34557.             }    
  34558.         }

  34560.         return this.headersPeerRegexpCacheSize;
  34561.     }
  34562.     
  34563.     private List<PeerHeaderDescriptor> headersDescriptors = null;
  34564.     public List<PeerHeaderDescriptor> getHeadersPeer() throws CoreException {
  34565.         if (this.headersDescriptors == null) {
  34566.             this.headersDescriptors = new ArrayList<>();
  34567.             
  34568.             String startPName = "org.openspcoop2.pdd.headers.peer.";
  34569.             String endHeaderName = ".headers";
  34570.             String endRegexpName = ".regexp";
  34571.             
  34572.             try {
  34573.                 Properties prop = this.reader.readProperties(startPName);
  34574.                 prop.forEach((k, v) -> {
  34575.                     String key = k.toString();
  34576.                     String value = v.toString();
  34577.                     
  34578.                     PeerHeaderDescriptor desc;
  34579.                     
  34580.                     if (key.endsWith(endHeaderName)) {
  34581.                         key = key.substring(0, key.length() - endHeaderName.length());
  34582.                         desc = new StringPeerHeaderDescriptor(key, value);
  34583.                     } else if (key.endsWith(endRegexpName)) {
  34584.                         key = key.substring(0, key.length() - endRegexpName.length());
  34585.                         desc = new RegexpPeerHeaderDescriptor(key, value);
  34586.                     } else {
  34587.                         String suffix = key.substring(key.lastIndexOf('.'));
  34588.                         this.logWarn("Proprieta " + key + " con prefisso: " + startPName + "ha un suffisso '" + suffix + "' non conosciuto");
  34589.                         return;
  34590.                     }
  34591.                     
  34592.                     this.headersDescriptors.add(desc);
  34593.                 });
  34594.                 this.headersDescriptors = Collections.unmodifiableList(this.headersDescriptors);
  34595.                 
  34596.             } catch (UtilsException e) {
  34597.                 this.logError("Riscontrato errore durante la lettura della proprietà di govway '" + startPName + "<Peer-Header-Name>.header': " + e.getMessage(), e);
  34598.                 throw new CoreException(e.getMessage(),e);
  34599.             }
  34600.             
  34601.         }
  34602.         return this.headersDescriptors;
  34603.     }
  34604.     
  34605. }
Created with JaCoCo 0.8.8.202204050719