ConfigurazionePdDReader.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.sql.Connection;
  28. import java.util.ArrayList;
  29. import java.util.HashMap;
  30. import java.util.Iterator;
  31. import java.util.List;
  32. import java.util.Map;
  33. import java.util.Properties;
  34. import java.util.concurrent.ConcurrentHashMap;

  36. import javax.servlet.http.HttpServletRequest;

  38. import org.apache.commons.lang.StringUtils;
  39. import org.apache.logging.log4j.Level;
  40. import org.openspcoop2.core.allarmi.Allarme;
  41. import org.openspcoop2.core.allarmi.utils.FiltroRicercaAllarmi;
  42. import org.openspcoop2.core.commons.CoreException;
  43. import org.openspcoop2.core.commons.IMonitoraggioRisorsa;
  44. import org.openspcoop2.core.config.AccessoConfigurazione;
  45. import org.openspcoop2.core.config.AccessoConfigurazionePdD;
  46. import org.openspcoop2.core.config.AccessoDatiAttributeAuthority;
  47. import org.openspcoop2.core.config.AccessoDatiAutenticazione;
  48. import org.openspcoop2.core.config.AccessoDatiAutorizzazione;
  49. import org.openspcoop2.core.config.AccessoDatiConsegnaApplicativi;
  50. import org.openspcoop2.core.config.AccessoDatiGestioneToken;
  51. import org.openspcoop2.core.config.AccessoDatiKeystore;
  52. import org.openspcoop2.core.config.AccessoDatiRichieste;
  53. import org.openspcoop2.core.config.AccessoRegistro;
  54. import org.openspcoop2.core.config.AutorizzazioneRuoli;
  55. import org.openspcoop2.core.config.Cache;
  56. import org.openspcoop2.core.config.CanaleConfigurazione;
  57. import org.openspcoop2.core.config.CanaleConfigurazioneNodo;
  58. import org.openspcoop2.core.config.CanaliConfigurazione;
  59. import org.openspcoop2.core.config.Configurazione;
  60. import org.openspcoop2.core.config.ConfigurazioneGeneraleHandler;
  61. import org.openspcoop2.core.config.ConfigurazioneHandler;
  62. import org.openspcoop2.core.config.ConfigurazioneMultitenant;
  63. import org.openspcoop2.core.config.ConfigurazionePortaHandler;
  64. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazione;
  65. import org.openspcoop2.core.config.Connettore;
  66. import org.openspcoop2.core.config.CorrelazioneApplicativa;
  67. import org.openspcoop2.core.config.CorrelazioneApplicativaRisposta;
  68. import org.openspcoop2.core.config.CorsConfigurazione;
  69. import org.openspcoop2.core.config.Credenziali;
  70. import org.openspcoop2.core.config.Dump;
  71. import org.openspcoop2.core.config.DumpConfigurazione;
  72. import org.openspcoop2.core.config.GenericProperties;
  73. import org.openspcoop2.core.config.GestioneErrore;
  74. import org.openspcoop2.core.config.GestioneToken;
  75. import org.openspcoop2.core.config.InvocazioneCredenziali;
  76. import org.openspcoop2.core.config.InvocazionePortaGestioneErrore;
  77. import org.openspcoop2.core.config.InvocazioneServizio;
  78. import org.openspcoop2.core.config.MessageSecurity;
  79. import org.openspcoop2.core.config.MessageSecurityFlow;
  80. import org.openspcoop2.core.config.MessaggiDiagnostici;
  81. import org.openspcoop2.core.config.MtomProcessor;
  82. import org.openspcoop2.core.config.MtomProcessorFlow;
  83. import org.openspcoop2.core.config.PortaApplicativa;
  84. import org.openspcoop2.core.config.PortaDelegata;
  85. import org.openspcoop2.core.config.Property;
  86. import org.openspcoop2.core.config.Proprieta;
  87. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  88. import org.openspcoop2.core.config.ResponseCachingConfigurazioneGenerale;
  89. import org.openspcoop2.core.config.RispostaAsincrona;
  90. import org.openspcoop2.core.config.Route;
  91. import org.openspcoop2.core.config.RoutingTable;
  92. import org.openspcoop2.core.config.RoutingTableDestinazione;
  93. import org.openspcoop2.core.config.Ruolo;
  94. import org.openspcoop2.core.config.ServizioApplicativo;
  95. import org.openspcoop2.core.config.ServizioApplicativoRuoli;
  96. import org.openspcoop2.core.config.Soggetto;
  97. import org.openspcoop2.core.config.StatoServiziPdd;
  98. import org.openspcoop2.core.config.SystemProperties;
  99. import org.openspcoop2.core.config.TipoFiltroAbilitazioneServizi;
  100. import org.openspcoop2.core.config.Tracciamento;
  101. import org.openspcoop2.core.config.Transazioni;
  102. import org.openspcoop2.core.config.TrasformazioneRegolaRichiesta;
  103. import org.openspcoop2.core.config.TrasformazioneRegolaRisposta;
  104. import org.openspcoop2.core.config.Trasformazioni;
  105. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  106. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  107. import org.openspcoop2.core.config.constants.RuoloContesto;
  108. import org.openspcoop2.core.config.constants.RuoloTipoMatch;
  109. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  110. import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
  111. import org.openspcoop2.core.config.driver.BeanUtilities;
  112. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  113. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  114. import org.openspcoop2.core.config.driver.FiltroRicercaPorteApplicative;
  115. import org.openspcoop2.core.config.driver.FiltroRicercaPorteDelegate;
  116. import org.openspcoop2.core.config.driver.FiltroRicercaServiziApplicativi;
  117. import org.openspcoop2.core.config.driver.IDriverConfigurazioneGet;
  118. import org.openspcoop2.core.config.driver.ValidazioneSemantica;
  119. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  120. import org.openspcoop2.core.config.driver.xml.DriverConfigurazioneXML;
  121. import org.openspcoop2.core.constants.CostantiConnettori;
  122. import org.openspcoop2.core.constants.CostantiLabel;
  123. import org.openspcoop2.core.constants.StatoCheck;
  124. import org.openspcoop2.core.constants.TipiConnettore;
  125. import org.openspcoop2.core.constants.TipoPdD;
  126. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  127. import org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale;
  128. import org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy;
  129. import org.openspcoop2.core.controllo_traffico.ElencoIdPolicy;
  130. import org.openspcoop2.core.controllo_traffico.ElencoIdPolicyAttive;
  131. import org.openspcoop2.core.controllo_traffico.beans.DatiTransazione;
  132. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  133. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsaPolicyAttiva;
  134. import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
  135. import org.openspcoop2.core.id.IDAccordo;
  136. import org.openspcoop2.core.id.IDConnettore;
  137. import org.openspcoop2.core.id.IDGenericProperties;
  138. import org.openspcoop2.core.id.IDPortaApplicativa;
  139. import org.openspcoop2.core.id.IDPortaDelegata;
  140. import org.openspcoop2.core.id.IDServizio;
  141. import org.openspcoop2.core.id.IDServizioApplicativo;
  142. import org.openspcoop2.core.id.IDSoggetto;
  143. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  144. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  145. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  146. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  147. import org.openspcoop2.core.registry.Fruitore;
  148. import org.openspcoop2.core.registry.RuoliSoggetto;
  149. import org.openspcoop2.core.registry.constants.RuoloTipologia;
  150. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  151. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  152. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  153. import org.openspcoop2.core.registry.driver.IDriverRegistroServiziGet;
  154. import org.openspcoop2.core.registry.driver.db.DriverRegistroServiziDB;
  155. import org.openspcoop2.core.registry.wsdl.WSDLValidatorConfig;
  156. import org.openspcoop2.message.OpenSPCoop2Message;
  157. import org.openspcoop2.message.constants.ServiceBinding;
  158. import org.openspcoop2.message.soap.mtom.MtomXomPackageInfo;
  159. import org.openspcoop2.message.soap.reader.OpenSPCoop2MessageSoapStreamReader;
  160. import org.openspcoop2.monitor.engine.dynamic.IRegistroPluginsReader;
  161. import org.openspcoop2.monitor.sdk.alarm.AlarmStatus;
  162. import org.openspcoop2.monitor.sdk.alarm.IAlarm;
  163. import org.openspcoop2.pdd.core.PdDContext;
  164. import org.openspcoop2.pdd.core.ValidatoreMessaggiApplicativiRest;
  165. import org.openspcoop2.pdd.core.autorizzazione.canali.CanaliUtils;
  166. import org.openspcoop2.pdd.core.byok.BYOKUnwrapPolicyUtilities;
  167. import org.openspcoop2.pdd.core.connettori.ConnettoreCheck;
  168. import org.openspcoop2.pdd.core.connettori.ConnettoreHTTPSProperties;
  169. import org.openspcoop2.pdd.core.connettori.ConnettoreMsg;
  170. import org.openspcoop2.pdd.core.connettori.GestoreErroreConnettore;
  171. import org.openspcoop2.pdd.core.connettori.InfoConnettoreIngresso;
  172. import org.openspcoop2.pdd.core.controllo_traffico.DimensioneMessaggiConfigurationUtils;
  173. import org.openspcoop2.pdd.core.controllo_traffico.ReadTimeoutConfigurationUtils;
  174. import org.openspcoop2.pdd.core.controllo_traffico.ReadTimeoutContextParam;
  175. import org.openspcoop2.pdd.core.controllo_traffico.SogliaReadTimeout;
  176. import org.openspcoop2.pdd.core.controllo_traffico.SoglieDimensioneMessaggi;
  177. import org.openspcoop2.pdd.core.controllo_traffico.policy.InterceptorPolicyUtilities;
  178. import org.openspcoop2.pdd.core.controllo_traffico.policy.config.PolicyConfiguration;
  179. import org.openspcoop2.pdd.core.dynamic.DynamicMapBuilderUtils;
  180. import org.openspcoop2.pdd.core.dynamic.Template;
  181. import org.openspcoop2.pdd.core.integrazione.HeaderIntegrazione;
  182. import org.openspcoop2.pdd.core.token.AbstractPolicyToken;
  183. import org.openspcoop2.pdd.core.token.Costanti;
  184. import org.openspcoop2.pdd.core.token.InformazioniToken;
  185. import org.openspcoop2.pdd.core.token.PolicyGestioneToken;
  186. import org.openspcoop2.pdd.core.token.PolicyNegoziazioneToken;
  187. import org.openspcoop2.pdd.core.token.TokenException;
  188. import org.openspcoop2.pdd.core.token.TokenUtilities;
  189. import org.openspcoop2.pdd.core.token.attribute_authority.AttributeAuthorityUtilities;
  190. import org.openspcoop2.pdd.core.token.attribute_authority.PolicyAttributeAuthority;
  191. import org.openspcoop2.pdd.logger.LogLevels;
  192. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  193. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  194. import org.openspcoop2.protocol.engine.constants.ModalitaIdentificazioneAzione;
  195. import org.openspcoop2.protocol.engine.mapping.IdentificazioneDinamicaException;
  196. import org.openspcoop2.protocol.engine.mapping.OperationFinder;
  197. import org.openspcoop2.protocol.engine.utils.NamingUtils;
  198. import org.openspcoop2.protocol.registry.CertificateCheck;
  199. import org.openspcoop2.protocol.registry.CertificateUtils;
  200. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  201. import org.openspcoop2.protocol.registry.RegistroServiziReader;
  202. import org.openspcoop2.protocol.sdk.Context;
  203. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  204. import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
  205. import org.openspcoop2.protocol.sdk.constants.FunzionalitaProtocollo;
  206. import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
  207. import org.openspcoop2.protocol.sdk.state.IState;
  208. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  209. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  210. import org.openspcoop2.protocol.utils.ModIUtils;
  211. import org.openspcoop2.protocol.utils.PorteNamingUtils;
  212. import org.openspcoop2.security.SecurityException;
  213. import org.openspcoop2.security.message.constants.SecurityConstants;
  214. import org.openspcoop2.security.message.jose.JOSEUtils;
  215. import org.openspcoop2.security.message.utils.SecurityUtils;
  216. import org.openspcoop2.utils.LoggerWrapperFactory;
  217. import org.openspcoop2.utils.NameValue;
  218. import org.openspcoop2.utils.SemaphoreLock;
  219. import org.openspcoop2.utils.cache.CacheType;
  220. import org.openspcoop2.utils.certificate.CertificateInfo;
  221. import org.openspcoop2.utils.certificate.KeystoreParams;
  222. import org.openspcoop2.utils.crypt.CryptConfig;
  223. import org.openspcoop2.utils.transport.TransportUtils;
  224. import org.openspcoop2.utils.transport.http.IBYOKUnwrapManager;
  225. import org.openspcoop2.utils.transport.http.SSLConfig;
  226. import org.slf4j.Logger;


  229. /**
  230.  * Classe utilizzata per ottenere informazioni che interessano ad OpenSPCoop
  231.  *
  232.  * @author Poli Andrea (apoli@link.it)
  233.  * @author $Author$
  234.  * @version $Rev$, $Date$
  235.  */
  236. public class ConfigurazionePdDReader {

  238.     /* istanza di ConfigurazioneReader */
  239.     private static  ConfigurazionePdDReader configurazionePdDReader;
  240.     /* informazione sull'inizializzazione dell'istanza */
  241.     private static boolean initialize = false;

  243.     /* Configurazione della PdD */
  244.     private ConfigurazionePdD configurazionePdD;
  245.     /** ConfigurazioneDinamica */
  246.     private boolean configurazioneDinamica = false;

  248.     /** Registro dei Servizi Reader per il routing */
  249.     /** private RegistroServiziReader registroServiziReader;*/

  251.     /** Logger utilizzato per debug. */
  252.     private Logger logger = null;
  253.     private void logDebug(String msg) {
  254.         this.logDebug(msg, null);
  255.     }
  256.     private void logDebug(String msg, Throwable e) {
  257.         if(this.logger!=null) {
  258.             if(e!=null) {
  259.                 this.logger.debug(msg, e);
  260.             }
  261.             else {
  262.                 this.logger.debug(msg);
  263.             }
  264.         }
  265.     }
  266.     private void logInfo(String msg) {
  267.         this.logInfo(msg, null);
  268.     }
  269.     private void logInfo(String msg, Throwable e) {
  270.         if(this.logger!=null) {
  271.             if(e!=null) {
  272.                 this.logger.info(msg, e);
  273.             }
  274.             else {
  275.                 this.logger.info(msg);
  276.             }
  277.         }
  278.     }
  279.     @SuppressWarnings("unused")
  280.     private void logWarn(String msg) {
  281.         this.logWarn(msg, null);
  282.     }
  283.     private void logWarn(String msg, Throwable e) {
  284.         if(this.logger!=null) {
  285.             if(e!=null) {
  286.                 this.logger.warn(msg, e);
  287.             }
  288.             else {
  289.                 this.logger.warn(msg);
  290.             }
  291.         }
  292.     }
  293.     private void logError(String msg) {
  294.         this.logError(msg, null);
  295.     }
  296.     private void logError(String msg, Throwable e) {
  297.         if(this.logger!=null) {
  298.             if(e!=null) {
  299.                 this.logger.error(msg, e);
  300.             }
  301.             else {
  302.                 this.logger.error(msg);
  303.             }
  304.         }
  305.     }
  306.     /** OpenSPCoopProperties */
  307.     private OpenSPCoop2Properties openspcoopProperties = null;
  308.     private PddProperties pddProperties = null;

  310.     /** Server J2EE */
  311.     private boolean serverJ2EE;



  315.     /* --------------- Cache --------------------*/
  316.     public static boolean isCacheAbilitata() throws DriverConfigurazioneException{
  317.         try{
  318.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  319.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  320.                 return configurazionePdDReader.configurazionePdD.isCacheAbilitata();
  321.             }
  322.             return false;
  323.         }catch(Exception e){
  324.             throw new DriverConfigurazioneException("IsCacheAbilitata, recupero informazione della cache della Configurazione non riuscita: "+e.getMessage(),e);
  325.         }
  326.     }
  327.     public static void resetCache() throws DriverConfigurazioneException{
  328.         try{
  329.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  330.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  331.                 configurazionePdDReader.configurazionePdD.resetCache();
  332.             }
  333.         }catch(Exception e){
  334.             throw new DriverConfigurazioneException("Reset della cache della Configurazione non riuscita: "+e.getMessage(),e);
  335.         }
  336.     }
  337.     public static void prefillCache(CryptConfig configApplicativi) throws DriverConfigurazioneException{
  338.         try{
  339.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  340.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  341.                 configurazionePdDReader.configurazionePdD.prefillCache(null, OpenSPCoop2Logger.getLoggerOpenSPCoopCore(), configApplicativi);
  342.                 configurazionePdDReader.configurazionePdD.prefillCacheConInformazioniRegistro(OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  343.             }
  344.         }catch(Exception e){
  345.             throw new DriverConfigurazioneException("Prefill della cache della Configurazione non riuscita: "+e.getMessage(),e);
  346.         }
  347.     }
  348.     public static String printStatsCache(String separator) throws DriverConfigurazioneException{
  349.         try{
  350.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  351.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  352.                 return configurazionePdDReader.configurazionePdD.printStatsCache(separator);
  353.             }
  354.             else{
  355.                 throw new Exception("ConfigurazionePdD Non disponibile");
  356.             }
  357.         }catch(Exception e){
  358.             throw new DriverConfigurazioneException("Visualizzazione Statistiche riguardante la cache della Configurazione non riuscita: "+e.getMessage(),e);
  359.         }
  360.     }
  361.     public static void abilitaCache() throws DriverConfigurazioneException{
  362.         try{
  363.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  364.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  365.                 configurazionePdDReader.configurazionePdD.abilitaCache();
  366.             }
  367.         }catch(Exception e){
  368.             throw new DriverConfigurazioneException("Abilitazione cache della Configurazione non riuscita: "+e.getMessage(),e);
  369.         }
  370.     }
  371.     public static void abilitaCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond, CryptConfig configApplicativi) throws DriverConfigurazioneException{
  372.         try{
  373.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  374.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  375.                 configurazionePdDReader.configurazionePdD.abilitaCache(dimensioneCache,algoritmoCacheLRU,itemIdleTime,itemLifeSecond, configApplicativi);
  376.             }
  377.         }catch(Exception e){
  378.             throw new DriverConfigurazioneException("Abilitazione cache della Configurazione non riuscita: "+e.getMessage(),e);
  379.         }
  380.     }
  381.     public static void disabilitaCache() throws DriverConfigurazioneException{
  382.         try{
  383.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  384.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  385.                 configurazionePdDReader.configurazionePdD.disabilitaCache();
  386.             }
  387.         }catch(Exception e){
  388.             throw new DriverConfigurazioneException("Disabilitazione cache della Configurazione non riuscita: "+e.getMessage(),e);
  389.         }
  390.     }
  391.     public static String listKeysCache(String separator) throws DriverConfigurazioneException{
  392.         try{
  393.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  394.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  395.                 return configurazionePdDReader.configurazionePdD.listKeysCache(separator);
  396.             }
  397.             else{
  398.                 throw new Exception("ConfigurazionePdD Non disponibile");
  399.             }
  400.         }catch(Exception e){
  401.             throw new DriverConfigurazioneException("Visualizzazione chiavi presenti nella cache della Configurazione non riuscita: "+e.getMessage(),e);
  402.         }
  403.     }
  404.     public static List<String> keysCache() throws DriverConfigurazioneException{
  405.         try{
  406.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  407.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  408.                 return configurazionePdDReader.configurazionePdD.keysCache();
  409.             }
  410.             else{
  411.                 throw new Exception("ConfigurazionePdD Non disponibile");
  412.             }
  413.         }catch(Exception e){
  414.             throw new DriverConfigurazioneException("Visualizzazione chiavi presenti nella cache della Configurazione non riuscita: "+e.getMessage(),e);
  415.         }
  416.     }

  418.     public static String getObjectCache(String key) throws DriverConfigurazioneException{
  419.         try{
  420.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  421.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  422.                 return configurazionePdDReader.configurazionePdD.getObjectCache(key);
  423.             }
  424.             else{
  425.                 throw new Exception("ConfigurazionePdD Non disponibile");
  426.             }
  427.         }catch(Exception e){
  428.             throw new DriverConfigurazioneException("Visualizzazione oggetto presente nella cache della Configurazione non riuscita: "+e.getMessage(),e);
  429.         }
  430.     }
  431.     
  432.     public static Object getRawObjectCache(String key) throws DriverConfigurazioneException{
  433.         try{
  434.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  435.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  436.                 return configurazionePdDReader.configurazionePdD.getRawObjectCache(key);
  437.             }
  438.             else{
  439.                 throw new Exception("ConfigurazionePdD Non disponibile");
  440.             }
  441.         }catch(Exception e){
  442.             throw new DriverConfigurazioneException("Visualizzazione oggetto presente nella cache della Configurazione non riuscita: "+e.getMessage(),e);
  443.         }
  444.     }

  446.     public static void removeObjectCache(String key) throws DriverConfigurazioneException{
  447.         try{
  448.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  449.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  450.                 configurazionePdDReader.configurazionePdD.removeObjectCache(key);
  451.             }
  452.             else{
  453.                 throw new Exception("ConfigurazionePdD Non disponibile");
  454.             }
  455.         }catch(Exception e){
  456.             throw new DriverConfigurazioneException("Rimozione oggetto presente nella cache della Configurazione non riuscita: "+e.getMessage(),e);
  457.         }
  458.     }
  459.     
  460.     public static org.openspcoop2.utils.cache.Cache getCache() throws DriverConfigurazioneException {
  461.         try{
  462.             ConfigurazionePdDReader configurazionePdDReader = org.openspcoop2.pdd.config.ConfigurazionePdDReader.getInstance();
  463.             if(configurazionePdDReader!=null && configurazionePdDReader.configurazionePdD!=null){
  464.                 return configurazionePdDReader.configurazionePdD.getCache();
  465.             }
  466.             else{
  467.                 throw new DriverConfigurazioneException("ConfigurazionePdD Non disponibile");
  468.             }
  469.         }catch(Exception e){
  470.             throw new DriverConfigurazioneException("Lettura cache della Configurazione non riuscita: "+e.getMessage(),e);
  471.         }
  472.     } 
  473.     
  474.     
  475.     
  476.     /*----------------- CLEANER --------------------*/
  477.     
  478.     public static void removeErogazione(IDServizio idServizio) throws Exception {
  479.         removeApiImpl(null, idServizio, true);
  480.     }
  481.     public static void removeFruizione(IDSoggetto fruitore, IDServizio idServizio) throws Exception {
  482.         removeApiImpl(fruitore, idServizio, false);
  483.     }
  484.     private static void removeApiImpl(IDSoggetto idFruitore, IDServizio idServizio, boolean erogazione) throws Exception {
  485.         if(ConfigurazionePdDReader.isCacheAbilitata()) {
  486.             
  487.             boolean soggettiVirtuali = OpenSPCoop2Properties.getInstance().isSoggettiVirtualiEnabled();
  488.             
  489.             if(soggettiVirtuali) {
  490.                 String keyServizi_SoggettiVirtuali = ConfigurazionePdD.getKeyMethodGetServiziSoggettiVirtuali();
  491.                 Object oServizi_SoggettiVirtuali = ConfigurazionePdDReader.getRawObjectCache(keyServizi_SoggettiVirtuali);
  492.                 if(oServizi_SoggettiVirtuali!=null && oServizi_SoggettiVirtuali instanceof List<?>) {
  493.                     List<?> l = (List<?>) oServizi_SoggettiVirtuali;
  494.                     if(l!=null && !l.isEmpty()) {
  495.                         boolean checkAzione = true;
  496.                         for (Object object : l) {
  497.                             if(object!=null && object instanceof IDServizio) {
  498.                                 IDServizio idS = (IDServizio) object;
  499.                                 if(idS.equals(idServizio, !checkAzione)) {
  500.                                     ConfigurazionePdDReader.removeObjectCache(keyServizi_SoggettiVirtuali);
  501.                                     break;
  502.                                 }
  503.                             }
  504.                         }
  505.                     }
  506.                 }
  507.             }
  508.             
  509.             List<String> keyForClean = new ArrayList<>();
  510.             List<String> keys = ConfigurazionePdDReader.keysCache();
  511.             if(keys!=null && !keys.isEmpty()) {
  512.                 
  513.                 String prefixPorta = null;
  514.                 if(erogazione) {
  515.                     prefixPorta = ConfigurazionePdD._getKey_MappingErogazionePortaApplicativaList(idServizio, false);
  516.                 }
  517.                 else {
  518.                     prefixPorta = ConfigurazionePdD._getKey_MappingFruizionePortaDelegataList(idFruitore, idServizio, false);
  519.                 }
  520.                 
  521.                 String prefixForwardProxy = ConfigurazionePdD._toKey_ForwardProxyConfigPrefix(!erogazione);
  522.                 String suffixForwardProxy = ConfigurazionePdD._toKey_ForwardProxyConfigSuffix(idServizio);
  523.                 
  524.                 String prefixPorteApplicativeRicercaPuntuale = null;
  525.                 String prefixPorteApplicativeRicercaNonPuntuale = null;
  526.                 if(erogazione) {
  527.                     prefixPorteApplicativeRicercaPuntuale = ConfigurazionePdD._toKey_getPorteApplicativePrefix(idServizio, true);
  528.                     prefixPorteApplicativeRicercaNonPuntuale = ConfigurazionePdD._toKey_getPorteApplicativePrefix(idServizio, false);
  529.                 }
  530.                 
  531.                 String prefixPorteApplicativeVirtualiRicercaPuntuale = null;
  532.                 String prefixPorteApplicativeVirtualiRicercaNonPuntuale = null;
  533.                 String porteApplicativeVirtualiIdServizio = null;
  534.                 if(soggettiVirtuali) {
  535.                     prefixPorteApplicativeVirtualiRicercaPuntuale = ConfigurazionePdD._toKey_getPorteApplicativeVirtualiPrefix(true);
  536.                     prefixPorteApplicativeVirtualiRicercaNonPuntuale = ConfigurazionePdD._toKey_getPorteApplicativeVirtualiPrefix(false);
  537.                     porteApplicativeVirtualiIdServizio = ConfigurazionePdD._toKey_getPorteApplicativeVirtuali_idServizio(idServizio);
  538.                 }
  539.                 
  540.                 String prefixPorteApplicativeSoggettiVirtuali = null;
  541.                 if(soggettiVirtuali) {
  542.                     prefixPorteApplicativeSoggettiVirtuali = ConfigurazionePdD.toKeyMethodGetPorteApplicativeSoggettiVirtualiPrefix(idServizio);
  543.                 }
  544.                 
  545.                 for (String key : keys) {
  546.                     if(key!=null) {
  547.                         if(key.startsWith(prefixPorta) ) {
  548.                             keyForClean.add(key);
  549.                         }
  550.                         else if(key.startsWith(prefixForwardProxy) && key.endsWith(suffixForwardProxy) ) {
  551.                             keyForClean.add(key);
  552.                         }
  553.                         else if(erogazione &&
  554.                                 (key.startsWith(prefixPorteApplicativeRicercaPuntuale) || key.startsWith(prefixPorteApplicativeRicercaNonPuntuale)) ) {
  555.                             keyForClean.add(key);
  556.                         }
  557.                         else if( soggettiVirtuali &&
  558.                             ((key.startsWith(prefixPorteApplicativeVirtualiRicercaPuntuale)) || (key.startsWith(prefixPorteApplicativeVirtualiRicercaNonPuntuale)))
  559.                             &&
  560.                             key.contains(porteApplicativeVirtualiIdServizio)) {
  561.                             keyForClean.add(key);
  562.                         }
  563.                         else if( soggettiVirtuali &&
  564.                                 key.startsWith(prefixPorteApplicativeSoggettiVirtuali)) {
  565.                             keyForClean.add(key);
  566.                         }
  567.                     }
  568.                 }
  569.             }
  570.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  571.                 for (String key : keyForClean) {
  572.                     removeObjectCache(key);
  573.                 }
  574.             }
  575.             
  576.         }
  577.     }
  578.     
  579.     public static void removePortaDelegata(IDPortaDelegata idPD) throws Exception {
  580.         if(ConfigurazionePdDReader.isCacheAbilitata()) {
  581.             
  582.             boolean removeControlloTraffico = true; 
  583.             
  584.             IProtocolFactory<?> protocolFactory = null;
  585.             PorteNamingUtils namingUtils = null;
  586.             try {
  587.                 ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance();
  588.                 String protocol = protocolFactoryManager.getProtocolByOrganizationType(idPD.getIdentificativiFruizione().getSoggettoFruitore().getTipo());
  589.                 protocolFactory = protocolFactoryManager.getProtocolFactoryByName(protocol);
  590.                 namingUtils = new PorteNamingUtils(protocolFactory);
  591.             }catch(Exception t) {
  592.                 OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Errore durante la comprensione del protocol factory della PD ["+idPD+"]");
  593.             }
  594.                         
  595.             List<String> keyForClean = new ArrayList<>();
  596.             List<String> keys = ConfigurazionePdDReader.keysCache();
  597.             if(keys!=null && !keys.isEmpty()) {
  598.                 
  599.                 String nomePorta = idPD.getNome(); 
  600.                 String nomePorta_normalized = null; 
  601.                 if(namingUtils!=null) {
  602.                     nomePorta_normalized = namingUtils.normalizePD(nomePorta);
  603.                 }
  604.                 
  605.                 String prefixKeyIdPD = ConfigurazionePdD._getKey_getIDPortaDelegata(nomePorta);
  606.                 String prefixKeyIdPD_normalized = null; 
  607.                 if(nomePorta_normalized!=null) {
  608.                     prefixKeyIdPD_normalized = ConfigurazionePdD._getKey_getIDPortaDelegata(nomePorta_normalized);
  609.                 }
  610.                 
  611.                 String prefixKeyPD = ConfigurazionePdD._getKey_getPortaDelegata(idPD);
  612.                 
  613.                 String prefixCT = ConfigurazionePdD.getKeyMethodElencoIdPolicyAttiveAPI(TipoPdD.DELEGATA, nomePorta);
  614.                 String prefixCTNormalized = null; 
  615.                 if(nomePorta_normalized!=null) {
  616.                     prefixCTNormalized  = ConfigurazionePdD.getKeyMethodElencoIdPolicyAttiveAPI(TipoPdD.DELEGATA, nomePorta_normalized);
  617.                 }
  618.                 
  619.                 String prefixCTDimensioneMessaggio = ConfigurazionePdD.getKeyMethodElencoIdPolicyAttiveAPIDimensioneMessaggio(TipoPdD.DELEGATA, nomePorta);
  620.                 String prefixCTDimensioneMessaggioNormalized = null; 
  621.                 if(nomePorta_normalized!=null) {
  622.                     prefixCTDimensioneMessaggioNormalized  = ConfigurazionePdD.getKeyMethodElencoIdPolicyAttiveAPIDimensioneMessaggio(TipoPdD.DELEGATA, nomePorta_normalized);
  623.                 }
  624.                 
  625.                 String prefixGetAllId = ConfigurazionePdD._toKey_getAllIdPorteDelegate_method();
  626.                 
  627.                 String prefixAttivazionePolicy = ConfigurazionePdD._toKey_AttivazionePolicyPrefix();
  628.                 
  629.                 for (String key : keys) {
  630.                     if(key!=null) {
  631.                         if(key.startsWith(prefixKeyIdPD)) {
  632.                             keyForClean.add(key);
  633.                         }
  634.                         else if(prefixKeyIdPD_normalized!=null && key.startsWith(prefixKeyIdPD_normalized)) {
  635.                             keyForClean.add(key);
  636.                         }
  637.                         else if(key.startsWith(prefixKeyPD)) {
  638.                             keyForClean.add(key);
  639.                         }
  640.                         if(removeControlloTraffico && key.startsWith(prefixCT)) {
  641.                             keyForClean.add(key);
  642.                         }
  643.                         else if(removeControlloTraffico && prefixCTNormalized!=null && key.startsWith(prefixCTNormalized)) {
  644.                             keyForClean.add(key);
  645.                         }
  646.                         if(removeControlloTraffico && key.startsWith(prefixCTDimensioneMessaggio)) {
  647.                             keyForClean.add(key);
  648.                         }
  649.                         else if(removeControlloTraffico && prefixCTDimensioneMessaggioNormalized!=null && key.startsWith(prefixCTDimensioneMessaggioNormalized)) {
  650.                             keyForClean.add(key);
  651.                         }
  652.                         else if(key.startsWith(prefixGetAllId)) {
  653.                             Object oCode = ConfigurazionePdDReader.getRawObjectCache(key);
  654.                             if(oCode!=null) {
  655.                                 if(oCode instanceof List<?>) {
  656.                                     List<?> l = (List<?>) oCode;
  657.                                     if(l!=null && !l.isEmpty()) {
  658.                                         for (Object object : l) {
  659.                                             if(object!=null && object instanceof IDPortaDelegata) {
  660.                                                 IDPortaDelegata idPDcheck = (IDPortaDelegata) object;
  661.                                                 if(idPDcheck.getNome().equals(nomePorta)) {
  662.                                                     keyForClean.add(key);
  663.                                                     break;
  664.                                                 }
  665.                                                 else if(nomePorta_normalized!=null && idPDcheck.getNome().equals(nomePorta_normalized)) {
  666.                                                     keyForClean.add(key);
  667.                                                     break;
  668.                                                 }
  669.                                             }
  670.                                         }
  671.                                     }
  672.                                 }
  673.                                 else if(oCode instanceof Exception) {
  674.                                     Exception t = (Exception) oCode;
  675.                                     String msg = t.getMessage();
  676.                                     if(msg!=null) {
  677.                                         String check = FiltroRicercaPorteDelegate.PREFIX_PORTA_DELEGANTE + nomePorta + FiltroRicercaPorteDelegate.SUFFIX_PORTA_DELEGANTE;
  678.                                         if(msg.contains(check)){
  679.                                             keyForClean.add(key);
  680.                                         }
  681.                                         else {
  682.                                             if(nomePorta_normalized!=null) {
  683.                                                 String check_normalized = FiltroRicercaPorteDelegate.PREFIX_PORTA_DELEGANTE + nomePorta_normalized + FiltroRicercaPorteDelegate.SUFFIX_PORTA_DELEGANTE;
  684.                                                 if(msg.contains(check_normalized)){
  685.                                                     keyForClean.add(key);
  686.                                                 }
  687.                                             }
  688.                                         }
  689.                                     }
  690.                                 }
  691.                             }
  692.                         }
  693.                         else if(removeControlloTraffico && key.startsWith(prefixAttivazionePolicy)) {
  694.                             Object oCode = ConfigurazionePdDReader.getRawObjectCache(key);
  695.                             if(oCode!=null && oCode instanceof AttivazionePolicy) {
  696.                                 AttivazionePolicy aPolicy = (AttivazionePolicy) oCode;
  697.                                 if(aPolicy.getFiltro()!=null && aPolicy.getFiltro().isEnabled() && 
  698.                                         RuoloPolicy.DELEGATA.equals(aPolicy.getFiltro().getRuoloPorta())){
  699.                                     if(nomePorta.equals(aPolicy.getFiltro().getNomePorta())) {
  700.                                         keyForClean.add(key);
  701.                                     }
  702.                                     else if(nomePorta_normalized!=null && nomePorta_normalized.equals(aPolicy.getFiltro().getNomePorta())) {
  703.                                         keyForClean.add(key);
  704.                                     }
  705.                                 }
  706.                             }
  707.                         }
  708.                     }
  709.                 }
  710.             }
  711.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  712.                 for (String key : keyForClean) {
  713.                     removeObjectCache(key);
  714.                 }
  715.             }
  716.         }
  717.     }
  718.     
  719.     public static void removePortaApplicativa(IDPortaApplicativa idPA) throws Exception {
  720.         if(ConfigurazionePdDReader.isCacheAbilitata()) {
  721.             
  722.             boolean removeControlloTraffico = true; 
  723.             
  724.             IProtocolFactory<?> protocolFactory = null;
  725.             PorteNamingUtils namingUtils = null;
  726.             try {
  727.                 ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance();
  728.                 String protocol = protocolFactoryManager.getProtocolByOrganizationType(idPA.getIdentificativiErogazione().getIdServizio().getSoggettoErogatore().getTipo());
  729.                 protocolFactory = protocolFactoryManager.getProtocolFactoryByName(protocol);
  730.                 namingUtils = new PorteNamingUtils(protocolFactory);
  731.             }catch(Exception t) {
  732.                 OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Errore durante la comprensione del protocol factory della PA ["+idPA+"]");
  733.             }
  734.                             
  735.             List<String> keyForClean = new ArrayList<>();
  736.             List<String> keys = ConfigurazionePdDReader.keysCache();
  737.             if(keys!=null && !keys.isEmpty()) {
  738.                 
  739.                 String nomePorta = idPA.getNome(); 
  740.                 String nomePorta_normalized = null; 
  741.                 if(namingUtils!=null) {
  742.                     nomePorta_normalized = namingUtils.normalizePA(nomePorta);
  743.                 }
  744.                 
  745.                 String prefixKeyIdPA = ConfigurazionePdD._getKey_getIDPortaApplicativa(nomePorta);
  746.                 String prefixKeyIdPA_normalized = null; 
  747.                 if(nomePorta_normalized!=null) {
  748.                     prefixKeyIdPA_normalized = ConfigurazionePdD._getKey_getIDPortaApplicativa(nomePorta_normalized);
  749.                 }
  750.                 
  751.                 String prefixKeyPA = ConfigurazionePdD._getKey_getPortaApplicativa(idPA);
  752.                 
  753.                 String prefixCT = ConfigurazionePdD.getKeyMethodElencoIdPolicyAttiveAPI(TipoPdD.APPLICATIVA, nomePorta);
  754.                 String prefixCTNormalized = null; 
  755.                 if(nomePorta_normalized!=null) {
  756.                     prefixCTNormalized  = ConfigurazionePdD.getKeyMethodElencoIdPolicyAttiveAPI(TipoPdD.APPLICATIVA, nomePorta_normalized);
  757.                 }
  758.                 
  759.                 String prefixCTDimensioneMessaggio = ConfigurazionePdD.getKeyMethodElencoIdPolicyAttiveAPIDimensioneMessaggio(TipoPdD.APPLICATIVA, nomePorta);
  760.                 String prefixCTDimensioneMessaggioNormalized = null; 
  761.                 if(nomePorta_normalized!=null) {
  762.                     prefixCTDimensioneMessaggioNormalized  = ConfigurazionePdD.getKeyMethodElencoIdPolicyAttiveAPIDimensioneMessaggio(TipoPdD.APPLICATIVA, nomePorta_normalized);
  763.                 }
  764.                 
  765.                 String prefixGetAllId = ConfigurazionePdD._toKey_getAllIdPorteApplicative_method();
  766.                 
  767.                 String prefixAttivazionePolicy = ConfigurazionePdD._toKey_AttivazionePolicyPrefix();
  768.                 
  769.                 for (String key : keys) {
  770.                     if(key!=null) {
  771.                         if(key.startsWith(prefixKeyIdPA)) {
  772.                             keyForClean.add(key);
  773.                         }
  774.                         else if(prefixKeyIdPA_normalized!=null && key.startsWith(prefixKeyIdPA_normalized)) {
  775.                             keyForClean.add(key);
  776.                         }
  777.                         else if(key.startsWith(prefixKeyPA)) {
  778.                             keyForClean.add(key);
  779.                         }
  780.                         if(removeControlloTraffico && key.startsWith(prefixCT)) {
  781.                             keyForClean.add(key);
  782.                         }
  783.                         else if(removeControlloTraffico && prefixCTNormalized!=null && key.startsWith(prefixCTNormalized)) {
  784.                             keyForClean.add(key);
  785.                         }
  786.                         if(removeControlloTraffico && key.startsWith(prefixCTDimensioneMessaggio)) {
  787.                             keyForClean.add(key);
  788.                         }
  789.                         else if(removeControlloTraffico && prefixCTDimensioneMessaggioNormalized!=null && key.startsWith(prefixCTDimensioneMessaggioNormalized)) {
  790.                             keyForClean.add(key);
  791.                         }
  792.                         else if(key.startsWith(prefixGetAllId)) {
  793.                             Object oCode = ConfigurazionePdDReader.getRawObjectCache(key);
  794.                             if(oCode!=null) {                               
  795.                                 if(oCode instanceof List<?>) {
  796.                                     List<?> l = (List<?>) oCode;
  797.                                     if(l!=null && !l.isEmpty()) {
  798.                                         for (Object object : l) {
  799.                                             if(object!=null && object instanceof IDPortaApplicativa) {
  800.                                                 IDPortaApplicativa idPAcheck = (IDPortaApplicativa) object;
  801.                                                 if(idPAcheck.getNome().equals(nomePorta)) {
  802.                                                     keyForClean.add(key);
  803.                                                     break;
  804.                                                 }
  805.                                                 else if(nomePorta_normalized!=null && idPAcheck.getNome().equals(nomePorta_normalized)) {
  806.                                                     keyForClean.add(key);
  807.                                                     break;
  808.                                                 }
  809.                                             }
  810.                                         }
  811.                                     }
  812.                                 }
  813.                                 else if(oCode instanceof Exception) {
  814.                                     Exception t = (Exception) oCode;
  815.                                     String msg = t.getMessage();
  816.                                     if(msg!=null) {
  817.                                         String check = FiltroRicercaPorteApplicative.PREFIX_PORTA_DELEGANTE + nomePorta + FiltroRicercaPorteApplicative.SUFFIX_PORTA_DELEGANTE;
  818.                                         if(msg.contains(check)){
  819.                                             keyForClean.add(key);
  820.                                         }
  821.                                         else {
  822.                                             if(nomePorta_normalized!=null) {
  823.                                                 String check_normalized = FiltroRicercaPorteApplicative.PREFIX_PORTA_DELEGANTE + nomePorta_normalized + FiltroRicercaPorteApplicative.SUFFIX_PORTA_DELEGANTE;
  824.                                                 if(msg.contains(check_normalized)){
  825.                                                     keyForClean.add(key);
  826.                                                 }
  827.                                             }
  828.                                         }
  829.                                     }
  830.                                 }
  831.                             }
  832.                         }
  833.                         else if(removeControlloTraffico && key.startsWith(prefixAttivazionePolicy)) {
  834.                             Object oCode = ConfigurazionePdDReader.getRawObjectCache(key);
  835.                             if(oCode!=null && oCode instanceof AttivazionePolicy) {
  836.                                 AttivazionePolicy aPolicy = (AttivazionePolicy) oCode;
  837.                                 if(aPolicy.getFiltro()!=null && aPolicy.getFiltro().isEnabled() && 
  838.                                         RuoloPolicy.APPLICATIVA.equals(aPolicy.getFiltro().getRuoloPorta())){
  839.                                     if(nomePorta.equals(aPolicy.getFiltro().getNomePorta())) {
  840.                                         keyForClean.add(key);
  841.                                     }
  842.                                     else if(nomePorta_normalized!=null && nomePorta_normalized.equals(aPolicy.getFiltro().getNomePorta())) {
  843.                                         keyForClean.add(key);
  844.                                     }
  845.                                 }
  846.                             }
  847.                         }
  848.                     }
  849.                 }
  850.             }
  851.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  852.                 for (String key : keyForClean) {
  853.                     removeObjectCache(key);
  854.                 }
  855.             }
  856.         }
  857.     }
  858.     
  859.     public static void removeConnettore(IDConnettore idConnettore) throws Exception {
  860.         if(ConfigurazionePdDReader.isCacheAbilitata()) {
  861.             
  862.             OpenSPCoop2Properties openSPCoop2Properties = OpenSPCoop2Properties.getInstance();
  863.             
  864.             if(openSPCoop2Properties.isTimerConsegnaContenutiApplicativiAbilitato()) {
  865.                 List<String> code = openSPCoop2Properties.getTimerConsegnaContenutiApplicativiCode();
  866.                 for (String coda : code) {
  867.                     String key = ConfigurazionePdD.getKey_getConnettoriConsegnaNotifichePrioritarie(coda);
  868.                     Object oCode = ConfigurazionePdDReader.getRawObjectCache(key);
  869.                     if(oCode!=null && oCode instanceof List<?>) {
  870.                         List<?> l = (List<?>) oCode;
  871.                         if(l!=null && !l.isEmpty()) {
  872.                             for (Object object : l) {
  873.                                 if(object!=null && object instanceof IDConnettore) {
  874.                                     IDConnettore idC = (IDConnettore) object;
  875.                                     if(idC.equals(idConnettore)) {
  876.                                         ConfigurazionePdDReader.removeObjectCache(key);
  877.                                         break;
  878.                                     }
  879.                                 }
  880.                             }
  881.                         }
  882.                     }
  883.                 }
  884.             }
  885.                     
  886.         }
  887.     }
  888.     
  889.     public static void removeSoggetto(IDSoggetto idSoggetto) throws Exception {
  890.         if(ConfigurazionePdDReader.isCacheAbilitata()) {
  891.             
  892.             boolean soggettiVirtuali = OpenSPCoop2Properties.getInstance().isSoggettiVirtualiEnabled();
  893.             
  894.             String keySoggetto = ConfigurazionePdD._getKey_getSoggettoByID(idSoggetto);
  895.             ConfigurazionePdDReader.removeObjectCache(keySoggetto);
  896.             
  897.             String keyRouter = ConfigurazionePdD._getKey_getRouter();
  898.             Object oRouter = ConfigurazionePdDReader.getRawObjectCache(keyRouter);
  899.             if(oRouter!=null && oRouter instanceof Soggetto) {
  900.                 Soggetto s = (Soggetto) oRouter;
  901.                 if(s.getTipo().equals(idSoggetto.getTipo()) 
  902.                         &&
  903.                     s.getNome().equals(idSoggetto.getNome()) ) {
  904.                     ConfigurazionePdDReader.removeObjectCache(keyRouter);
  905.                 }
  906.             }
  907.             
  908.             if(soggettiVirtuali) {
  909.                 String keySoggettiVirtuali = ConfigurazionePdD._getKey_getSoggettiVirtuali();
  910.                 Object oSoggettiVirtuali = ConfigurazionePdDReader.getRawObjectCache(keySoggettiVirtuali);
  911.                 if(oSoggettiVirtuali!=null && oSoggettiVirtuali instanceof List<?>) {
  912.                     List<?> l = (List<?>) oSoggettiVirtuali;
  913.                     if(l!=null && !l.isEmpty()) {
  914.                         for (Object object : l) {
  915.                             if(object!=null && object instanceof IDSoggetto) {
  916.                                 IDSoggetto idS = (IDSoggetto) object;
  917.                                 if(idS.equals(idSoggetto)) {
  918.                                     ConfigurazionePdDReader.removeObjectCache(keySoggettiVirtuali);
  919.                                     break;
  920.                                 }
  921.                             }
  922.                         }
  923.                     }
  924.                 }
  925.             }
  926.             
  927.             if(soggettiVirtuali) {
  928.                 List<String> keyForClean = new ArrayList<>();
  929.                 List<String> keys = ConfigurazionePdDReader.keysCache();
  930.                 if(keys!=null && !keys.isEmpty()) {
  931.                     String prefixPorteApplicativeVirtualiRicercaPuntuale = ConfigurazionePdD._toKey_getPorteApplicativeVirtualiPrefix(true);
  932.                     String prefixPorteApplicativeVirtualiRicercaNonPuntuale = ConfigurazionePdD._toKey_getPorteApplicativeVirtualiPrefix(false);
  933.                     String porteApplicativeVirtualiIdSoggetto = ConfigurazionePdD._toKey_getPorteApplicativeVirtuali_idSoggettoVirtuale(idSoggetto);
  934.                     for (String key : keys) {
  935.                         if(key!=null) {
  936.                             if( 
  937.                                 ((key.startsWith(prefixPorteApplicativeVirtualiRicercaPuntuale)) || (key.startsWith(prefixPorteApplicativeVirtualiRicercaNonPuntuale)))
  938.                                 &&
  939.                                 key.contains(porteApplicativeVirtualiIdSoggetto)) {
  940.                                 keyForClean.add(key);
  941.                             }
  942.                         }
  943.                     }
  944.                 }
  945.                 if(keyForClean!=null && !keyForClean.isEmpty()) {
  946.                     for (String key : keyForClean) {
  947.                         removeObjectCache(key);
  948.                     }
  949.                 }
  950.             }

  952.         }
  953.     }
  954.     
  955.     public static void removeApplicativo(IDServizioApplicativo idApplicativo) throws Exception {
  956.         if(ConfigurazionePdDReader.isCacheAbilitata()) {
  957.             
  958.             String keyApplicativo = ConfigurazionePdD._getKey_getServizioApplicativo(idApplicativo);
  959.             ConfigurazionePdDReader.removeObjectCache(keyApplicativo);
  960.             
  961.             List<String> keyForClean = new ArrayList<>();
  962.             List<String> keys = ConfigurazionePdDReader.keysCache();
  963.             if(keys!=null && !keys.isEmpty()) {
  964.                 
  965.                 String prefixCredenzialiBasic = ConfigurazionePdD._toKey_getServizioApplicativoByCredenzialiBasicPrefix();
  966.                 String prefixCredenzialiApiKey = ConfigurazionePdD._toKey_getServizioApplicativoByCredenzialiApiKeyPrefix(false);
  967.                 String prefixCredenzialiApiKeyAppId = ConfigurazionePdD._toKey_getServizioApplicativoByCredenzialiApiKeyPrefix(true);
  968.                 String prefixCredenzialiSsl = ConfigurazionePdD._toKey_getServizioApplicativoByCredenzialiSslPrefix(true);
  969.                 String prefixCredenzialiSslCert = ConfigurazionePdD._toKey_getServizioApplicativoByCredenzialiSslCertPrefix(true);
  970.                 String prefixCredenzialiPrincipal = ConfigurazionePdD._toKey_getServizioApplicativoByCredenzialiPrincipalPrefix();
  971.                 String prefixCredenzialiToken = ConfigurazionePdD._toKey_getServizioApplicativoByCredenzialiTokenPrefix();
  972.                 
  973.                 String prefixGetAllId = ConfigurazionePdD._toKey_getAllIdServiziApplicativi_method();
  974.                                 
  975.                 for (String key : keys) {
  976.                     if(key!=null) {
  977.                         if(key.startsWith(prefixCredenzialiBasic) ||
  978.                                 key.startsWith(prefixCredenzialiApiKey) || 
  979.                                 key.startsWith(prefixCredenzialiApiKeyAppId) || 
  980.                                 key.startsWith(prefixCredenzialiSsl) || 
  981.                                 key.startsWith(prefixCredenzialiSslCert) || 
  982.                                 key.startsWith(prefixCredenzialiPrincipal) || 
  983.                                 key.startsWith(prefixCredenzialiToken)) {
  984.                             
  985.                             Object o = ConfigurazionePdDReader.getRawObjectCache(key);
  986.                             if(o!=null && o instanceof ServizioApplicativo) {
  987.                                 ServizioApplicativo sa = (ServizioApplicativo) o;
  988.                                 if(idApplicativo.getNome().equals(sa.getNome()) &&
  989.                                         idApplicativo.getIdSoggettoProprietario().getTipo().equals(sa.getTipoSoggettoProprietario()) &&
  990.                                         idApplicativo.getIdSoggettoProprietario().getNome().equals(sa.getNomeSoggettoProprietario())) {
  991.                                     keyForClean.add(key);
  992.                                 }
  993.                             }
  994.                             
  995.                         }
  996.                         else if(key.startsWith(prefixGetAllId)) {
  997.                             Object oCode = ConfigurazionePdDReader.getRawObjectCache(key);
  998.                             if(oCode!=null && oCode instanceof List<?>) {
  999.                                 List<?> l = (List<?>) oCode;
  1000.                                 if(l!=null && !l.isEmpty()) {
  1001.                                     for (Object object : l) {
  1002.                                         if(object!=null && object instanceof IDServizioApplicativo) {
  1003.                                             IDServizioApplicativo idSAcheck = (IDServizioApplicativo) object;
  1004.                                             if(idSAcheck.equals(idApplicativo)) {
  1005.                                                 keyForClean.add(key);
  1006.                                                 break;
  1007.                                             }
  1008.                                         }
  1009.                                     }
  1010.                                 }
  1011.                             }
  1012.                         }
  1013.                     }
  1014.                 }
  1015.             }
  1016.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  1017.                 for (String key : keyForClean) {
  1018.                     removeObjectCache(key);
  1019.                 }
  1020.             }
  1021.             
  1022.             OpenSPCoop2Properties openSPCoop2Properties = OpenSPCoop2Properties.getInstance();
  1023.             
  1024.             if(openSPCoop2Properties.isTimerConsegnaContenutiApplicativiAbilitato()) {
  1025.                 List<String> code = openSPCoop2Properties.getTimerConsegnaContenutiApplicativiCode();
  1026.                 for (String coda : code) {
  1027.                     String key = ConfigurazionePdD.getKey_getConnettoriConsegnaNotifichePrioritarie(coda);
  1028.                     Object oCode = ConfigurazionePdDReader.getRawObjectCache(key);
  1029.                     if(oCode!=null && oCode instanceof List<?>) {
  1030.                         List<?> l = (List<?>) oCode;
  1031.                         if(l!=null && !l.isEmpty()) {
  1032.                             for (Object object : l) {
  1033.                                 if(object!=null && object instanceof IDConnettore) {
  1034.                                     IDConnettore idC = (IDConnettore) object;
  1035.                                     if(idC.getNome().equals(idApplicativo.getNome()) &&
  1036.                                             idC.getIdSoggettoProprietario().equals(idApplicativo.getIdSoggettoProprietario())) {
  1037.                                         ConfigurazionePdDReader.removeObjectCache(key);
  1038.                                         break;
  1039.                                     }
  1040.                                 }
  1041.                             }
  1042.                         }
  1043.                     }
  1044.                 }
  1045.             }
  1046.         }
  1047.     }
  1048.     
  1049.     public static void removeGenericProperties(IDGenericProperties idGP) throws Exception {
  1050.         if(ConfigurazionePdDReader.isCacheAbilitata()) {
  1051.             
  1052.             String keyGP = ConfigurazionePdD._getKey_getGenericProperties(idGP.getTipologia(), idGP.getNome());
  1053.             ConfigurazionePdDReader.removeObjectCache(keyGP);
  1054.             
  1055.             String keyGPTipologia = ConfigurazionePdD._getKey_getGenericProperties(idGP.getTipologia());
  1056.             ConfigurazionePdDReader.removeObjectCache(keyGPTipologia);
  1057.             
  1058.             String prefixForwardProxy = ConfigurazionePdD.PREFIX_FORWARD_PROXY;
  1059.             String forwardProxyGP = ConfigurazionePdD._toKey_ForwardProxyConfigSuffix(idGP);
  1060.             
  1061.             List<String> keyForClean = new ArrayList<>();
  1062.             List<String> keys = ConfigurazionePdDReader.keysCache();
  1063.             if(keys!=null && !keys.isEmpty()) {
  1064.                 for (String key : keys) {
  1065.                     if(key!=null) {
  1066.                         if(forwardProxyGP!=null && key.startsWith(prefixForwardProxy)&& key.contains(forwardProxyGP)) {
  1067.                             keyForClean.add(key);
  1068.                         }
  1069.                     }
  1070.                 }
  1071.             }
  1072.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  1073.                 for (String key : keyForClean) {
  1074.                     removeObjectCache(key);
  1075.                 }
  1076.             }
  1077.             
  1078.         }
  1079.     }
  1080.     
  1081.     


  1084.     /*   -------------- Metodi di inizializzazione -----------------  */
  1085.     /**
  1086.      * Si occupa di inizializzare l'engine che permette di effettuare
  1087.      * query alla configurazione di OpenSPCoop.
  1088.      * L'engine inizializzato sara' diverso a seconda del <var>tipo</var> di configurazione :
  1089.      * <ul>
  1090.      * <li> {@link org.openspcoop2.core.config.driver.xml.DriverConfigurazioneXML}, interroga una configurazione realizzata tramite un file xml.
  1091.      * <li> {@link org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB}, interroga una configurazione realizzata tramite un database relazionale.
  1092.      * </ul>
  1093.      *
  1094.      * @param accessoConfigurazione Informazioni per accedere alla configurazione della PdD OpenSPCoop.
  1095.      * @return true se l'inizializzazione ha successo, false altrimenti.
  1096.      */
  1097.     public static boolean initialize(AccessoConfigurazionePdD accessoConfigurazione,Logger aLog,Logger aLogconsole,Properties localProperties, 
  1098.             String jndiNameDatasourcePdD, boolean forceDisableCache,
  1099.             boolean useOp2UtilsDatasource, boolean bindJMX, 
  1100.             boolean prefillCache, CryptConfig configApplicativi,
  1101.             CacheType cacheType){

  1103.         try {
  1104.             ConfigurazionePdDReader.configurazionePdDReader = new ConfigurazionePdDReader(accessoConfigurazione,aLog,aLogconsole,localProperties,jndiNameDatasourcePdD, 
  1105.                     forceDisableCache, useOp2UtilsDatasource, bindJMX, 
  1106.                     prefillCache, configApplicativi,
  1107.                     cacheType); 
  1108.             return ConfigurazionePdDReader.initialize;
  1109.         }
  1110.         catch(Exception e) {
  1111.             aLog.error(e.getMessage(),e);
  1112.             aLogconsole.error(e.getMessage());
  1113.             return false;
  1114.         }
  1115.     }

  1117.     public static void prefillCacheConInformazioniRegistro(Logger aLogconsole){
  1118.         getInstance().configurazionePdD.prefillCacheConInformazioniRegistro(aLogconsole);
  1119.     }

  1121.     /**
  1122.      * Ritorna lo stato dell'engine che permette di effettuare
  1123.      * query alla configurazione
  1124.      *
  1125.      * @return true se l'inizializzazione all'engine e' stata precedentemente effettuata, false altrimenti.
  1126.      */
  1127.     public static boolean isInitialize(){
  1128.         return ConfigurazionePdDReader.initialize;
  1129.     }

  1131.     /**
  1132.      * Ritorna l'istanza di questa classe
  1133.      *
  1134.      * @return Istanza del Reader della Configurazione
  1135.      */
  1136.     public static ConfigurazionePdDReader getInstance(){
  1137.         return ConfigurazionePdDReader.configurazionePdDReader;
  1138.     }

  1140.     public static IDriverConfigurazioneGet getDriverConfigurazionePdD() {
  1141.         return ConfigurazionePdDReader.configurazionePdDReader.configurazionePdD.getDriverConfigurazionePdD();
  1142.     } 










  1153.     /*   -------------- Costruttore -----------------  */ 

  1155.     /**
  1156.      * Inizializza il reader
  1157.      *
  1158.      * @param accessoConfigurazione Informazioni per accedere alla configurazione della PdD OpenSPCoop.
  1159.      */
  1160.     public ConfigurazionePdDReader(AccessoConfigurazionePdD accessoConfigurazione,Logger aLog,Logger aLogconsole,Properties localProperties, 
  1161.             String jndiNameDatasourcePdD, boolean forceDisableCache,
  1162.             boolean useOp2UtilsDatasource, boolean bindJMX, 
  1163.             boolean prefillCache, CryptConfig configApplicativi,
  1164.             CacheType cacheType)throws DriverConfigurazioneException{
  1165.         try{
  1166.             if(aLog!=null)
  1167.                 this.logger = aLog;
  1168.             else
  1169.                 this.logger = LoggerWrapperFactory.getLogger(ConfigurazionePdDReader.class);
  1170.             this.configurazionePdD = new ConfigurazionePdD(accessoConfigurazione,this.logger,aLogconsole,localProperties,jndiNameDatasourcePdD, forceDisableCache,
  1171.                     useOp2UtilsDatasource, bindJMX, 
  1172.                     prefillCache, configApplicativi,
  1173.                     cacheType);

  1175.             // OpenSPCoop Properties
  1176.             this.openspcoopProperties = OpenSPCoop2Properties.getInstance();
  1177.             this.pddProperties = PddProperties.getInstance();

  1179.             // configurazioneDinamica
  1180.             this.configurazioneDinamica = this.openspcoopProperties.isConfigurazioneDinamica();

  1182.             // Server J2EE
  1183.             this.serverJ2EE = this.openspcoopProperties.isServerJ2EE();
  1184.             
  1185.             ConfigurazionePdDReader.initialize = true;
  1186.         }catch(Exception e){
  1187.             if(this.logger!=null)
  1188.                 this.logError("Configurazione non inizializzata",e);
  1189.             else
  1190.                 aLogconsole.error("Configurazione non inizializzata:"+e.getMessage(),e);
  1191.             ConfigurazionePdDReader.initialize = false;
  1192.         }
  1193.     }



  1197.     /**
  1198.      * Inixializza il reader del registro servizi, per il routing
  1199.      * 
  1200.      * @throws DriverConfigurazioneException
  1201.      */
  1202.     //  public void initializeRegistroServiziReader()throws DriverConfigurazioneException{
  1203.     //      //   RegistroServizi
  1204.     //      if(RegistroServiziReader.isInitialize()==false){
  1205.     //          throw new DriverConfigurazioneException("Registro dei Servizi non risulta inizializzato");
  1206.     //      }
  1207.     //      this.registroServiziReader = RegistroServiziReader.getInstance();
  1208.     //  }








  1217.     /**
  1218.      * Metodo che verica la connessione ad una risorsa.
  1219.      * Se la connessione non e' presente, viene lanciata una eccezione che contiene il motivo della mancata connessione
  1220.      * 
  1221.      * @throws CoreException eccezione che contiene il motivo della mancata connessione
  1222.      */
  1223.     protected void isAlive() throws CoreException{
  1224.         ((IMonitoraggioRisorsa)this.configurazionePdD.getDriverConfigurazionePdD()).isAlive();
  1225.     }


  1228.     /**
  1229.      * Validazione semantica dei registri servizi
  1230.      * 
  1231.      * @throws CoreException eccezione che contiene il motivo della validazione semantica errata
  1232.      */
  1233.     protected void validazioneSemantica(String[] tipiConnettori,String[] tipiMsgDiagnosticoAppender,String[] tipiTracciamentoAppender,String [] tipiDumpAppender,
  1234.             String[]tipoAutenticazionePortaDelegata,String[]tipoAutenticazionePortaApplicativa,
  1235.             String[]tipoAutorizzazionePortaDelegata,String[]tipoAutorizzazionePortaApplicativa,
  1236.             String[]tipoAutorizzazioneContenutoPortaDelegata,String[]tipoAutorizzazioneContenutoPortaApplicativa,
  1237.             String [] tipiIntegrazionePD, String [] tipiIntegrazionePA,
  1238.             boolean validazioneSemanticaAbilitataXML,boolean validazioneSemanticaAbilitataAltreConfigurazioni,boolean validaConfigurazione,
  1239.             Logger logConsole) throws CoreException{
  1240.         try{
  1241.             Object o = this.configurazionePdD.getDriverConfigurazionePdD();
  1242.             boolean validazione = false;
  1243.             if(o instanceof DriverConfigurazioneXML){
  1244.                 validazione = validazioneSemanticaAbilitataXML;
  1245.             }else{
  1246.                 validazione = validazioneSemanticaAbilitataAltreConfigurazioni;
  1247.             }
  1248.             if(validazione){
  1249.                 BeanUtilities driverConfigurazione = (BeanUtilities) o;
  1250.                 org.openspcoop2.core.config.Openspcoop2 configurazionePdD = driverConfigurazione.getImmagineCompletaConfigurazionePdD();

  1252.                 ValidazioneSemantica validazioneSemantica = new ValidazioneSemantica(configurazionePdD,
  1253.                         tipiConnettori,ProtocolFactoryManager.getInstance().getOrganizationTypesAsArray(),
  1254.                         ProtocolFactoryManager.getInstance().getServiceTypesAsArray(org.openspcoop2.protocol.manifest.constants.ServiceBinding.SOAP),
  1255.                         ProtocolFactoryManager.getInstance().getServiceTypesAsArray(org.openspcoop2.protocol.manifest.constants.ServiceBinding.REST),
  1256.                         tipiMsgDiagnosticoAppender,tipiTracciamentoAppender,tipiDumpAppender,
  1257.                         tipoAutenticazionePortaDelegata, tipoAutenticazionePortaApplicativa,
  1258.                         tipoAutorizzazionePortaDelegata, tipoAutorizzazionePortaApplicativa,
  1259.                         tipoAutorizzazioneContenutoPortaDelegata, tipoAutorizzazioneContenutoPortaApplicativa, 
  1260.                         tipiIntegrazionePD,tipiIntegrazionePA,validaConfigurazione);
  1261.                 validazioneSemantica.validazioneSemantica(false);
  1262.                 if(logConsole!=null){
  1263.                     logConsole.info("Validazione semantica della configurazione effettuata.");
  1264.                 }
  1265.             }
  1266.         }catch(Exception e){
  1267.             throw new CoreException(e.getMessage(),e);
  1268.         }
  1269.     }

  1271.     protected void setValidazioneSemanticaModificaConfigurazionePdDXML(String[] tipiConnettori,
  1272.             String[]tipoMsgDiagnosticiAppender,String[]tipoTracciamentoAppender,String [] tipiDumpAppender,
  1273.             String[]tipoAutenticazionePortaDelegata,String[]tipoAutenticazionePortaApplicativa,
  1274.             String[]tipoAutorizzazionePortaDelegata,String[]tipoAutorizzazionePortaApplicativa,
  1275.             String[]tipoAutorizzazioneContenutoPortaDelegata,String[]tipoAutorizzazioneContenutoPortaApplicativa,
  1276.             String[]tipoIntegrazionePD,String[]tipoIntegrazionePA) throws CoreException{
  1277.         try{
  1278.             Object o = this.configurazionePdD.getDriverConfigurazionePdD();
  1279.             if(o instanceof DriverConfigurazioneXML){
  1280.                 DriverConfigurazioneXML driver = (DriverConfigurazioneXML) o;
  1281.                 driver.abilitazioneValidazioneSemanticaDuranteModificaXML(tipiConnettori, 
  1282.                         ProtocolFactoryManager.getInstance().getOrganizationTypesAsArray(),
  1283.                         ProtocolFactoryManager.getInstance().getServiceTypesAsArray(org.openspcoop2.protocol.manifest.constants.ServiceBinding.SOAP),
  1284.                         ProtocolFactoryManager.getInstance().getServiceTypesAsArray(org.openspcoop2.protocol.manifest.constants.ServiceBinding.REST),
  1285.                         tipoMsgDiagnosticiAppender, tipoTracciamentoAppender, tipiDumpAppender, 
  1286.                         tipoAutenticazionePortaDelegata, tipoAutenticazionePortaApplicativa,
  1287.                         tipoAutorizzazionePortaDelegata, tipoAutorizzazionePortaApplicativa,
  1288.                         tipoAutorizzazioneContenutoPortaDelegata, tipoAutorizzazioneContenutoPortaApplicativa, 
  1289.                         tipoIntegrazionePD, tipoIntegrazionePA);
  1290.             }
  1291.         }catch(Exception e){
  1292.             throw new CoreException(e.getMessage(),e);
  1293.         }
  1294.     }

  1296.     protected void verificaConsistenzaConfigurazione() throws DriverConfigurazioneException {
  1297.         Object o = this.configurazionePdD.getDriverConfigurazionePdD();
  1298.         if(o instanceof DriverConfigurazioneXML){
  1299.             DriverConfigurazioneXML driver = (DriverConfigurazioneXML) o;
  1300.             driver.refreshConfigurazioneXML();
  1301.         }
  1302.     }












  1315.     /* ********  SOGGETTI (Interfaccia)  ******** */

  1317.     /**
  1318.      * Restituisce Il dominio di un soggetto  identificato da <var>idSoggetto</var>
  1319.      *
  1320.      * @param idSoggetto Identificativo di un soggetto
  1321.      * @return Il dominio del Soggetto.
  1322.      * 
  1323.      */
  1324.     protected String getIdentificativoPorta(Connection connectionPdD, IDSoggetto idSoggetto,IProtocolFactory<?> protocolFactory, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 
  1325.         Soggetto soggetto = this.configurazionePdD.getSoggetto(connectionPdD,idSoggetto);
  1326.         if(soggetto == null)
  1327.             throw new DriverConfigurazioneNotFound("Soggetto["+idSoggetto.toString()+"] per lettura Dominio non trovato");

  1329.         if( soggetto.getIdentificativoPorta() != null  )
  1330.             return soggetto.getIdentificativoPorta();
  1331.         else{
  1332.             if(soggetto.getNome() != null){
  1333.                 try{
  1334.                     return protocolFactory.createTraduttore().getIdentificativoPortaDefault(idSoggetto);
  1335.                 }catch(Exception e){
  1336.                     throw new DriverConfigurazioneException(e.getMessage(),e);
  1337.                 }
  1338.             }else{
  1339.                 OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  1340.                 return properties.getIdentificativoPortaDefault(protocolFactory.getProtocol(), requestInfo);
  1341.             }
  1342.         }
  1343.     }

  1345.     /**
  1346.      * Restituisce L'indicazione se il soggetto e' un soggetto virtuale
  1347.      *
  1348.      * @param idSoggetto Identificativo di un soggetto 
  1349.      * @return true se il soggetto e' un soggetto virtuale gestito dalla porta di dominio.
  1350.      * 
  1351.      */
  1352.     protected boolean isSoggettoVirtuale(Connection connectionPdD, IDSoggetto idSoggetto) throws DriverConfigurazioneException { 

  1354.         if(!this.openspcoopProperties.isSoggettiVirtualiEnabled()) {
  1355.             return false;
  1356.         }
  1357.         
  1358.         // il soggetto virtuale e' stato registrato come tale?

  1360.         if(idSoggetto == null || idSoggetto.getTipo()==null || idSoggetto.getNome()==null)
  1361.             return false;

  1363.         /** Lista di Soggetti Virtuali */
  1364.         List<IDSoggetto> listaSoggettiVirtuali = null;
  1365.         try{
  1366.             listaSoggettiVirtuali = this.configurazionePdD.getSoggettiVirtuali(connectionPdD);
  1367.         }catch(DriverConfigurazioneNotFound de){
  1368.             this.logInfo("Soggetti virtuali non presenti.");
  1369.             return false;
  1370.         }

  1372.         if(listaSoggettiVirtuali!=null && listaSoggettiVirtuali.size()>0) {
  1373.             for (int i = 0; i < listaSoggettiVirtuali.size(); i++) {
  1374.                 if(listaSoggettiVirtuali.get(i).equals(idSoggetto)) {
  1375.                     return true;
  1376.                 }
  1377.             }
  1378.         }

  1380.         return false;
  1381.     }

  1383.     protected Soggetto getSoggetto(Connection connectionPdD, IDSoggetto idSoggetto)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{  
  1384.         Soggetto soggetto = this.configurazionePdD.getSoggetto(connectionPdD, idSoggetto);
  1385.         return soggetto;
  1386.     }
  1387.     
  1388.     /**
  1389.      * Restituisce l'indicazione se la PdD gestisce il soggetto indicato
  1390.      *
  1391.      * @param idSoggetto Identificativo di un soggetto 
  1392.      * @return true se il soggetto e' un soggetto gestito dalla porta di dominio.
  1393.      * 
  1394.      */
  1395.     protected boolean existsSoggetto(Connection connectionPdD, IDSoggetto idSoggetto)throws DriverConfigurazioneException{  
  1396.         Soggetto soggetto = null;
  1397.         try{
  1398.             soggetto = this.configurazionePdD.getSoggetto(connectionPdD, idSoggetto);
  1399.         }catch(DriverConfigurazioneNotFound e){
  1400.             //this.logDebug("existsSoggetto (not found): "+e.getMessage());
  1401.             return false;
  1402.         }
  1403.         return soggetto!=null;
  1404.     }

  1406.     /**
  1407.      * Restituisce la lista dei soggetti virtuali gestiti dalla PdD
  1408.      * 
  1409.      * @return Restituisce la lista dei servizi associati a soggetti virtuali gestiti dalla PdD
  1410.      * @throws DriverConfigurazioneException
  1411.      */
  1412.     protected  List<IDServizio> getServiziSoggettiVirtuali(Connection connectionPdD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1413.         return this.configurazionePdD.getServiziSoggettiVirtuali(connectionPdD);
  1414.     }










  1425.     /* ************* ROUTING **************** */

  1427.     /**
  1428.      * Restituisce la rotta per il dato soggetto seguendo queste regole:
  1429.      * <ul>
  1430.      * </li>1) Se la PdD non contiene una entry per il soggetto indicato, 
  1431.      * viene acceduto normalmente il registro per ottenere il connettore del destinatario reale della busta.
  1432.      * </li>2) Se la PdD contiene una entry specifica (destinazione) per il soggetto destinatario
  1433.      *         vengono eseguite le rotte elencate nella entry fino a che non viene trovato un connettore.
  1434.      *         Nel caso non venga trovato un connettore si rimanda al punto 3.
  1435.      * </li> 3) Viene utilizzata l'entry di default (obbligatorio) per trovare un connettore.
  1436.      *          Vengono eseguite le rotte elencate nella entry fino a che non viene trovato un connettore
  1437.      * </ul>
  1438.      *
  1439.      * @param idSoggettoDestinatario Identificativo del soggetto destinatario della busta 
  1440.      * @return Il connettore da utilizzare per la spedizione della busta.
  1441.      * 
  1442.      */
  1443.     protected Connettore getForwardRoute(Connection connectionPdD, RegistroServiziManager registroServiziManager ,IDSoggetto idSoggettoDestinatario,boolean functionAsRouter, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1444.         return getForwardRoute(connectionPdD,registroServiziManager,null,this.buildIDServizioWithOnlySoggetto(idSoggettoDestinatario),functionAsRouter, requestInfo);
  1445.     }

  1447.     @SuppressWarnings("deprecation")
  1448.     private IDServizio buildIDServizioWithOnlySoggetto(IDSoggetto idSoggettoDestinatario){
  1449.         IDServizio idServizio = new IDServizio();
  1450.         idServizio.setSoggettoErogatore(idSoggettoDestinatario);
  1451.         return idServizio;
  1452.     }

  1454.     /**
  1455.      * Restituisce la rotta per il dato soggetto seguendo queste regole:
  1456.      * <ul>
  1457.      * </li>1) Se la PdD non contiene una entry per il soggetto indicato, 
  1458.      * viene acceduto normalmente il registro per ottenere il connettore del destinatario reale della busta.
  1459.      * </li>2) Se la PdD contiene una entry specifica (destinazione) per il soggetto destinatario
  1460.      *         vengono eseguite le rotte elencate nella entry fino a che non viene trovato un connettore.
  1461.      *         Nel caso non venga trovato un connettore si rimanda al punto 3.
  1462.      * </li> 3) Viene utilizzata l'entry di default (obbligatorio) per trovare un connettore.
  1463.      *          Vengono eseguite le rotte elencate nella entry fino a che non viene trovato un connettore
  1464.      * </ul>
  1465.      *
  1466.      * @param idSoggettoMittente Identificativo del mittente della busta
  1467.      * @param idServizio Identificativo del servizio richiesto (soggetto destinatario, servizio e azione della busta) 
  1468.      * @return Il connettore da utilizzare per la spedizione della busta.
  1469.      * 
  1470.      */
  1471.     protected Connettore getForwardRoute(Connection connectionPdD, RegistroServiziManager registroServiziManager , IDSoggetto idSoggettoMittente, IDServizio idServizio,boolean functionAsRouter, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{


  1474.         if(idServizio == null)
  1475.             throw new DriverConfigurazioneException("getForwardRoute error: Identificativo servizio non definito");
  1476.         if(idServizio.getSoggettoErogatore()==null)
  1477.             throw new DriverConfigurazioneException("getForwardRoute error: Soggetto Erogatore non definito");
  1478.         String nome = idServizio.getSoggettoErogatore().getNome();
  1479.         String tipo= idServizio.getSoggettoErogatore().getTipo();
  1480.         if(nome==null || tipo==null)
  1481.             throw new DriverConfigurazioneException("getForwardRoute error: Soggetto Erogatore con tipo/nome non definito");

  1483.         // 1) Se la PdD non contiene una forward route, utilizza normalmente il registro
  1484.         RoutingTable routingTable = this.configurazionePdD.getRoutingTable(connectionPdD);
  1485.         /*if(routingTable.isAbilitata()==false){
  1486.             System.out.println("ROUTING TABLE DISABILITATA");
  1487.         }
  1488.         else{
  1489.             Route[] routesDefault = routingTable.get_defaultList();
  1490.             if(routesDefault!=null){
  1491.                 for (int i = 0; i < routesDefault.length; i++) {
  1492.                     if(routesDefault[i].getGateway()!=null){
  1493.                         System.out.println("ROUTING TABLE DEFAULT ["+i+"] GATEWAY: "+routesDefault[i].getGateway().getTipo()+"/"+routesDefault[i].getGateway().getNome());
  1494.                     }else{
  1495.                         System.out.println("ROUTING TABLE DEFAULT ["+i+"] REGISTRO: "+routesDefault[i].getRegistro().getNome());
  1496.                     }
  1497.                 }
  1498.             }
  1499.             RoutingTableDestinazione [] rdt = routingTable.getDestinazioneList();
  1500.             if(rdt!=null){
  1501.                 for (int i = 0; i < rdt.length; i++) {
  1502.                     if(rdt[i].getRoute(0).getGateway()!=null){
  1503.                         System.out.println("ROUTING TABLE ("+rdt[i].getTipo()+"/"+rdt[i].getNome()+") ["+i+"] GATEWAY: "+rdt[i].getRoute(0).getGateway().getTipo()+"/"+rdt[i].getRoute(0).getGateway().getNome());
  1504.                     }else{
  1505.                         System.out.println("ROUTING TABLE ("+rdt[i].getTipo()+"/"+rdt[i].getNome()+") ["+i+"] REGISTRO: "+rdt[i].getRoute(0).getRegistro().getNome());
  1506.                     }
  1507.                 }
  1508.             }
  1509.         }   */
  1510.         if( (routingTable.getAbilitata()==null || routingTable.getAbilitata()==false) 
  1511.                 || 
  1512.                 ( 
  1513.                         ( (routingTable.getDefault()==null) || (routingTable.getDefault().sizeRouteList()==0) ) 
  1514.                         && 
  1515.                         (routingTable.sizeDestinazioneList()==0) 
  1516.                         ) 
  1517.                 ){

  1519.             if(routingTable.getAbilitata()==null || routingTable.getAbilitata()==false)
  1520.                 this.logDebug("getForwardRoute: routing table disabilitata");
  1521.             else
  1522.                 this.logDebug("getForwardRoute: routing table senza rotte");

  1524.             Connettore connettoreDominio = null;
  1525.             try{
  1526.                 if(idSoggettoMittente!=null && idServizio.getNome()!=null){
  1527.                     connettoreDominio = registroServiziManager.getConnettore(idSoggettoMittente,idServizio,null, requestInfo); // null=allRegistri
  1528.                     if(!functionAsRouter)
  1529.                         setPDUrlPrefixRewriter(connectionPdD,connettoreDominio, idSoggettoMittente, requestInfo);
  1530.                 }else{
  1531.                     connettoreDominio = registroServiziManager.getConnettore(idServizio.getSoggettoErogatore(),null, requestInfo); // null=allRegistri
  1532.                 }
  1533.             }catch(DriverRegistroServiziNotFound e){
  1534.                 throw new DriverConfigurazioneNotFound("getForwardRoute[RoutingTable Non Abilitata], ricerca nel RegistroServizi effettuata: "+e.getMessage(),e);
  1535.             }
  1536.             catch(Exception e){
  1537.                 throw new DriverConfigurazioneException("getForwardRoute[RoutingTable Non Abilitata], errore durante la lettura dal Registro dei Servizi: "+e.getMessage(),e);
  1538.             }
  1539.             if(connettoreDominio!=null && !CostantiConfigurazione.NONE.equals(connettoreDominio.getTipo()) 
  1540.                     && !CostantiConfigurazione.DISABILITATO.equals(connettoreDominio.getTipo()) )
  1541.                 return connettoreDominio;
  1542.             else
  1543.                 throw new DriverConfigurazioneException("getForwardRoute[RoutingTable Non Abilitata], connettore per la busta non trovato.");
  1544.         }

  1546.         StringBuilder bf = new StringBuilder();
  1547.         bf.append("Ricerca connettore del servizio...");
  1548.         this.logDebug("getForwardRoute: routing table abilitata");

  1550.         // Se la PdD contiene una forward route, utilizza la tabella di routing 
  1551.         // 2) Destinazioni specifiche
  1552.         for(int i=0;i<routingTable.sizeDestinazioneList();i++){
  1553.             if(nome.equals(routingTable.getDestinazione(i).getNome()) &&
  1554.                     tipo.equals(routingTable.getDestinazione(i).getTipo())){    
  1555.                 bf.append("\nRotta di destinazione ["+routingTable.getDestinazione(i).getTipo()+"/"+routingTable.getDestinazione(i).getNome()+"]...\n");
  1556.                 this.logDebug("getForwardRoute: esamino routing table, destinazione ["+routingTable.getDestinazione(i).getTipo()+"/"+routingTable.getDestinazione(i).getNome()+"]");

  1558.                 // Utilizzo le rotte della destinazione specifica fino a trovare un connettore
  1559.                 // Se un connettore non viene trovato, utilizzero poi il Default della tabella di routing.
  1560.                 RoutingTableDestinazione routingTableDest = routingTable.getDestinazione(i);
  1561.                 for(int j=0;j<routingTableDest.sizeRouteList();j++){
  1562.                     Route route = routingTableDest.getRoute(j);
  1563.                     Connettore connettoreDominio = null;
  1564.                     boolean error = false;
  1565.                     String soggettoGateway = "";
  1566.                     try{
  1567.                         if(route.getRegistro()!=null){ 
  1568.                             this.logDebug("getForwardRoute: esamino routing table, destinazione ["
  1569.                                     +routingTable.getDestinazione(i).getTipo()+"/"+routingTable.getDestinazione(i).getNome()+"] RegistroNome["+route.getRegistro().getNome()+"]");

  1571.                             bf.append("\tRegistro nomeRegistro["+route.getRegistro().getNome()+"]: ");

  1573.                             // Utilizzo del registro con l'identita reale della busta
  1574.                             if(idSoggettoMittente!=null && idServizio.getNome()!=null){
  1575.                                 connettoreDominio = registroServiziManager.getConnettore(idSoggettoMittente,idServizio,route.getRegistro().getNome(), requestInfo);
  1576.                                 if(!functionAsRouter)
  1577.                                     setPDUrlPrefixRewriter(connectionPdD,connettoreDominio, idSoggettoMittente, requestInfo);
  1578.                             }else{
  1579.                                 connettoreDominio = registroServiziManager.getConnettore(idServizio.getSoggettoErogatore(),route.getRegistro().getNome(), requestInfo);
  1580.                             }
  1581.                             // Registro da utilizzare anche per l'imbustamento
  1582.                             if(connettoreDominio!=null && !CostantiConfigurazione.NONE.equals(connettoreDominio.getTipo()) &&
  1583.                                     !CostantiConfigurazione.DISABILITATO.equals(connettoreDominio.getTipo()) )
  1584.                                 connettoreDominio.setNomeRegistro(route.getRegistro().getNome());
  1585.                         }else if(route.getGateway()!=null){ 
  1586.                             this.logDebug("getForwardRoute: esamino routing table, destinazione ["
  1587.                                     +routingTable.getDestinazione(i).getTipo()+"/"+routingTable.getDestinazione(i).getNome()+"] GateWay["+route.getGateway().getTipo()+"/"+route.getGateway().getNome()+"]"); 
  1588.                             bf.append("\tGateWay["+route.getGateway().getTipo()+"/"+route.getGateway().getNome()+"]: ");

  1590.                             // Utilizzo del gateway
  1591.                             IDSoggetto gateway = new IDSoggetto(route.getGateway().getTipo(),
  1592.                                     route.getGateway().getNome());
  1593.                             soggettoGateway = " [Gateway:"+gateway.toString()+"]";
  1594.                             connettoreDominio = registroServiziManager.getConnettore(gateway,null, requestInfo); //null=allRegistri
  1595.                             // Rotta diversa dalla destinazione della busta per l'elemento trasmissione
  1596.                             if(connettoreDominio!=null && !CostantiConfigurazione.NONE.equals(connettoreDominio.getTipo()) &&
  1597.                                     !CostantiConfigurazione.DISABILITATO.equals(connettoreDominio.getTipo())){
  1598.                                 connettoreDominio.setNomeDestinatarioTrasmissioneBusta(gateway.getNome());
  1599.                                 connettoreDominio.setTipoDestinatarioTrasmissioneBusta(gateway.getTipo());
  1600.                             }
  1601.                         }
  1602.                     }catch(DriverRegistroServiziNotFound e){
  1603.                         // Ricerca Connettore fallita
  1604.                         error = true;
  1605.                         bf.append(" non trovata: "+e.getMessage());
  1606.                     }
  1607.                     catch(Exception e){
  1608.                         throw new DriverConfigurazioneException("getForwardRoute: esamino routing table, destinazione ["
  1609.                                 +routingTable.getDestinazione(i).getTipo()+"/"+routingTable.getDestinazione(i).getNome()+"]: Accesso al registro non riuscito"+soggettoGateway+": "+e.getMessage(),e);
  1610.                     }
  1611.                     if(connettoreDominio!=null && !CostantiConfigurazione.NONE.equals(connettoreDominio.getTipo()) 
  1612.                             && !CostantiConfigurazione.DISABILITATO.equals(connettoreDominio.getTipo()))
  1613.                         return connettoreDominio;
  1614.                     else{
  1615.                         if(!error){
  1616.                             bf.append(" non trovata: connettore non definito");
  1617.                         }
  1618.                     }
  1619.                 }
  1620.             }
  1621.         }

  1623.         // 3) Default (obbligatorio)    
  1624.         // Utilizzo le rotte del default fino a trovare un connettore
  1625.         // Se un connettore non viene trovato, significa che e' stata effettuata una scorretta installazione
  1626.         if(routingTable.getDefault()!=null){
  1627.             for(int i=0;i<routingTable.getDefault().sizeRouteList();i++){
  1628.                 this.logDebug("getForwardRoute: esamino routing table, rotta di default");
  1629.                 bf.append("\nRotta di default");
  1630.                 Route route = routingTable.getDefault().getRoute(i);
  1631.                 Connettore connettoreDominio = null;
  1632.                 boolean error = false;
  1633.                 String soggettoGateway = "";
  1634.                 try{
  1635.                     if(route.getRegistro()!=null){ 
  1636.                         this.logDebug("getForwardRoute: esamino routing table, rotta di default, Registro nomeRegistro["+route.getRegistro().getNome()+"]");
  1637.                         bf.append(" Registro nomeRegistro["+route.getRegistro().getNome()+"]: ");

  1639.                         // Utilizzo del registro con l'identita reale della busta
  1640.                         if(idSoggettoMittente!=null && idServizio.getNome()!=null){
  1641.                             connettoreDominio = registroServiziManager.getConnettore(idSoggettoMittente,idServizio,route.getRegistro().getNome(), requestInfo);
  1642.                             if(!functionAsRouter)
  1643.                                 setPDUrlPrefixRewriter(connectionPdD,connettoreDominio, idSoggettoMittente, requestInfo);
  1644.                         }else{
  1645.                             connettoreDominio = registroServiziManager.getConnettore(idServizio.getSoggettoErogatore(),route.getRegistro().getNome(), requestInfo);
  1646.                         }
  1647.                         // Registro da utilizzare anche per l'imbustamento
  1648.                         if(connettoreDominio!=null && !CostantiConfigurazione.NONE.equals(connettoreDominio.getTipo()) && 
  1649.                                 !CostantiConfigurazione.DISABILITATO.equals(connettoreDominio.getTipo()))
  1650.                             connettoreDominio.setNomeRegistro(route.getRegistro().getNome());
  1651.                     }else if(route.getGateway()!=null){ 
  1652.                         this.logDebug("getForwardRoute: esamino routing table, rotta di default, GateWay["+route.getGateway().getTipo()+"/"+route.getGateway().getNome()+"]");
  1653.                         bf.append(" GateWay["+route.getGateway().getTipo()+"/"+route.getGateway().getNome()+"]: ");

  1655.                         // Utilizzo del gateway
  1656.                         IDSoggetto gateway = new IDSoggetto(route.getGateway().getTipo(),
  1657.                                 route.getGateway().getNome());
  1658.                         soggettoGateway = " [Gateway:"+gateway.toString()+"]";
  1659.                         connettoreDominio = registroServiziManager.getConnettore(gateway,null, requestInfo);//null=allRegistri
  1660.                         // Rotta diversa dalla destinazione della busta per l'elemento trasmissione
  1661.                         if(connettoreDominio!=null && !CostantiConfigurazione.NONE.equals(connettoreDominio.getTipo()) &&
  1662.                                 !CostantiConfigurazione.DISABILITATO.equals(connettoreDominio.getTipo())){
  1663.                             connettoreDominio.setNomeDestinatarioTrasmissioneBusta(gateway.getNome());
  1664.                             connettoreDominio.setTipoDestinatarioTrasmissioneBusta(gateway.getTipo());
  1665.                         }
  1666.                     }
  1667.                 }catch(DriverRegistroServiziNotFound e){
  1668.                     // Ricerca Connettore fallita
  1669.                     error = true;
  1670.                     bf.append(" non trovata: "+e.getMessage());
  1671.                 }
  1672.                 catch(Exception e){
  1673.                     throw new DriverConfigurazioneException("getForwardRoute: esamino routing table, rotta di default: Accesso al registro non riuscito"+soggettoGateway+": "+e.getMessage(),e);
  1674.                 }
  1675.                 if(connettoreDominio!=null && !CostantiConfigurazione.NONE.equals(connettoreDominio.getTipo())
  1676.                         && !CostantiConfigurazione.DISABILITATO.equals(connettoreDominio.getTipo()))
  1677.                     return connettoreDominio;
  1678.                 else{
  1679.                     if(!error){
  1680.                         bf.append(" non trovata: connettore non definito");
  1681.                     }
  1682.                 }
  1683.             }
  1684.         }

  1686.         // connettore non trovato?
  1687.         throw new DriverConfigurazioneNotFound("getForwardRoute [Routing Table] error: connettore per la busta non trovato: \n"+bf.toString());
  1688.     }

  1690.     /**
  1691.      * Restituisce il nome di un registro dei servizi da utilizzare per effettuare il processo di imbustamento.
  1692.      * Viene restituito null se e' possibile utilizzare qualsiasi registro, in ordine di definizione.
  1693.      *
  1694.      * @param idSoggettoMittente Identificativo del mittente della busta
  1695.      * @param idServizio Identificativo del servizio richiesto (soggetto destinatario, servizio e azione della busta) 
  1696.      * @return Il nome di un registro dei servizi da utilizzare per effettuare il processo di imbustamento.
  1697.      * 
  1698.      */
  1699.     protected String getRegistroForImbustamento(Connection connectionPdD, RegistroServiziManager registroServiziManager , IDSoggetto idSoggettoMittente, IDServizio idServizio,boolean functionAsRouter, RequestInfo requestInfo)throws DriverConfigurazioneException{
  1700.         Connettore conn = null;
  1701.         try {
  1702.             conn = getForwardRoute(connectionPdD,registroServiziManager,idSoggettoMittente,idServizio,functionAsRouter, requestInfo);
  1703.         }catch(DriverConfigurazioneNotFound e){}
  1704.         if(conn!=null)
  1705.             return conn.getNomeRegistro();
  1706.         else
  1707.             return null;
  1708.     }

  1710.     /**
  1711.      * Restituisce l'indicazione se la PdD e' stata configurata per funzionare anche come router.
  1712.      *
  1713.      * @return true se la PdD deve funzionare anche come router.
  1714.      * 
  1715.      */
  1716.     protected boolean routerFunctionActive(Connection connectionPdD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  1718.         // Per essere configurata come Router, una PdD deve possedere una tabella di routing:
  1719.         RoutingTable routingTable = null;
  1720.         try{
  1721.             routingTable = this.configurazionePdD.getRoutingTable(connectionPdD);
  1722.         }catch(Exception e){
  1723.             this.logDebug("routerFunctionActive[getRoutingTable]",e);
  1724.         }
  1725.         if(routingTable == null || (routingTable.getAbilitata()==null || routingTable.getAbilitata()==false) || 
  1726.                 ( 
  1727.                         (routingTable.getDefault()==null || routingTable.getDefault().sizeRouteList()==0) 
  1728.                         && 
  1729.                         (routingTable.sizeDestinazioneList()==0) 
  1730.                         ) 
  1731.                 ){
  1732.             return false;
  1733.         }

  1735.         // Inoltre deve possedere un soggetto configurato come Router
  1736.         Soggetto router = null;
  1737.         try{
  1738.             router = this.configurazionePdD.getRouter(connectionPdD);
  1739.         }catch(DriverConfigurazioneNotFound e){
  1740.             return false;
  1741.             //this.logDebug("routerFunctionActive[getRouter] (not found): "+e.getMessage());
  1742.         }   
  1743.         return router!=null;
  1744.     }

  1746.     /**
  1747.      * Restituisce l'identita della PdD nel caso debba funzionare come router.
  1748.      *
  1749.      * @return idSoggetto Identita
  1750.      * 
  1751.      */
  1752.     protected IDSoggetto getRouterIdentity(Connection connectionPdD,IProtocolFactory<?> protocolFactory, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  1754.         // Per essere configurata come Router, una PdD deve possedere una tabella di routing:
  1755.         RoutingTable routingTable = null;
  1756.         try{
  1757.             routingTable = this.configurazionePdD.getRoutingTable(connectionPdD);
  1758.         }catch(Exception e){
  1759.             this.logDebug("getRouterIdentity[routingTable]",e);
  1760.         }
  1761.         if(routingTable == null || (routingTable.getAbilitata()==null || routingTable.getAbilitata()==false) || 
  1762.                 ( 
  1763.                         (routingTable.getDefault()==null || routingTable.getDefault().sizeRouteList()==0) 
  1764.                         && 
  1765.                         (routingTable.sizeDestinazioneList()==0) 
  1766.                         ) 
  1767.                 ){
  1768.             throw new DriverConfigurazioneException("getRouterIdentity error: RoutingTable non definita");
  1769.         }

  1771.         // Inoltre deve possedere un soggetto configurato come Router
  1772.         Soggetto router = this.configurazionePdD.getRouter(connectionPdD);
  1773.         if(router==null)
  1774.             throw new DriverConfigurazioneNotFound("Router non trovato");

  1776.         String codicePorta = router.getIdentificativoPorta();
  1777.         if(codicePorta==null){
  1778.             if(router.getNome()!=null)
  1779.                 try{
  1780.                     codicePorta = protocolFactory.createTraduttore().getIdentificativoPortaDefault(new IDSoggetto(router.getTipo(), router.getNome()));
  1781.                 }catch(Exception e){
  1782.                     throw new DriverConfigurazioneException("getRouterIdentity error: costruzione IdentificativoPorta per soggetto "+router.getTipo()+"/"+router.getNome()+" non riuscita: "+e.getMessage(),e);
  1783.                 }
  1784.             else{
  1785.                 OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  1786.                 codicePorta = properties.getIdentificativoPortaDefault(protocolFactory.getProtocol(), requestInfo);
  1787.             }
  1788.         }
  1789.         return new IDSoggetto(router.getTipo(),router.getNome(),codicePorta);
  1790.     }











  1802.     /* ********  URLPrefixRewriter  ******** */

  1804.     protected void setPDUrlPrefixRewriter(Connection connectionPdD, org.openspcoop2.core.config.Connettore connettore, IDSoggetto idSoggettoFruitore, RequestInfo requestInfo) throws DriverConfigurazioneNotFound,DriverConfigurazioneException{
  1805.         if(idSoggettoFruitore==null)
  1806.             return;
  1807.         
  1808.         Soggetto soggettoFruitore = null;
  1809.         if( requestInfo!=null && requestInfo.getRequestConfig()!=null && idSoggettoFruitore!=null) {
  1810.             if( requestInfo.getRequestConfig().getSoggettoFruitoreConfig()!=null &&
  1811.                     idSoggettoFruitore.getTipo().equals(requestInfo.getRequestConfig().getSoggettoFruitoreConfig().getTipo()) &&
  1812.                     idSoggettoFruitore.getNome().equals(requestInfo.getRequestConfig().getSoggettoFruitoreConfig().getNome())   ) {
  1813.                 soggettoFruitore = requestInfo.getRequestConfig().getSoggettoFruitoreConfig();
  1814.             }
  1815.         }
  1816.         if(soggettoFruitore==null) {
  1817.             soggettoFruitore = this.configurazionePdD.getSoggetto(connectionPdD,idSoggettoFruitore);
  1818.         }
  1819.         setUrlPrefixRewriter(soggettoFruitore.getPdUrlPrefixRewriter(),"pdUrlPrefixRewriter", connettore);
  1820.     }
  1821.     protected void setPAUrlPrefixRewriter(Connection connectionPdD, org.openspcoop2.core.config.Connettore connettore, IDSoggetto idSoggettoErogatore, RequestInfo requestInfo) throws DriverConfigurazioneNotFound,DriverConfigurazioneException{
  1822.         if(idSoggettoErogatore==null)
  1823.             return;
  1824.         
  1825.         Soggetto soggettoErogatore = null;
  1826.         if( requestInfo!=null && requestInfo.getRequestConfig()!=null && idSoggettoErogatore!=null) {
  1827.             if(requestInfo.getRequestConfig().getSoggettoErogatoreConfig()!=null &&
  1828.                     idSoggettoErogatore.getTipo().equals(requestInfo.getRequestConfig().getSoggettoErogatoreConfig().getTipo()) &&
  1829.                     idSoggettoErogatore.getNome().equals(requestInfo.getRequestConfig().getSoggettoErogatoreConfig().getNome()) ) {
  1830.                 soggettoErogatore = requestInfo.getRequestConfig().getSoggettoErogatoreConfig();
  1831.             }
  1832.         }
  1833.         if(soggettoErogatore==null) {
  1834.             if(requestInfo!=null && requestInfo.getRequestThreadContext()!=null && requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo()!=null) {
  1835.                 if(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig()!=null && idSoggettoErogatore!=null && 
  1836.                         idSoggettoErogatore.getTipo().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig().getTipo()) && 
  1837.                         idSoggettoErogatore.getNome().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig().getNome())) {
  1838.                     soggettoErogatore = requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig();
  1839.                 }
  1840.             }
  1841.         }
  1842.         if(soggettoErogatore==null) {
  1843.             if(requestInfo!=null && requestInfo.getRequestThreadContext()!=null && requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo()!=null) {
  1844.                 if(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig()!=null && idSoggettoErogatore!=null && 
  1845.                         idSoggettoErogatore.getTipo().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig().getTipo()) && 
  1846.                         idSoggettoErogatore.getNome().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig().getNome())) {
  1847.                     soggettoErogatore = requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig();
  1848.                 }
  1849.             }
  1850.         }
  1851.         if(soggettoErogatore==null) {
  1852.             soggettoErogatore = this.configurazionePdD.getSoggetto(connectionPdD,idSoggettoErogatore);
  1853.         }
  1854.         setUrlPrefixRewriter(soggettoErogatore.getPaUrlPrefixRewriter(),"paUrlPrefixRewriter", connettore);
  1855.     }
  1856.     private void setUrlPrefixRewriter(String urlPrefix,String funzione,org.openspcoop2.core.config.Connettore connettore) throws DriverConfigurazioneNotFound,DriverConfigurazioneException{

  1858.         if( (urlPrefix!=null) && (!"".equals(urlPrefix)) ){
  1859.             // search location property
  1860.             for (int i = 0; i < connettore.sizePropertyList(); i++) {
  1861.                 Property cp = connettore.getProperty(i);
  1862.                 if(cp.getNome().equalsIgnoreCase(CostantiConnettori.CONNETTORE_LOCATION)){
  1863.                     String originale = cp.getValore();
  1864.                     cp.setValore(urlPrefixRewriter(funzione,originale, urlPrefix.trim()));
  1865.                     break;
  1866.                 }
  1867.             }

  1869.         }

  1871.     }
  1872.     private String urlPrefixRewriter(String funzione,String urlOriginale, String urlPrefix) throws DriverConfigurazioneException{

  1874.         try{

  1876.             String urlFinale = urlPrefix;

  1878.             String originale = urlOriginale;
  1879.             if(originale==null){
  1880.                 throw new DriverRegistroServiziException("["+funzione+"] Url originale non fornita");
  1881.             }
  1882.             originale = originale.trim();

  1884.             // Per evitare replace multipli (in caso di risultati cachati)
  1885.             if(originale.startsWith(urlPrefix)){
  1886.                 // replace gia' effettuato
  1887.                 return originale;
  1888.             }

  1890.             this.logDebug("["+funzione+"]  Originale["+originale+"] UrlPrefix["+urlPrefix+"] ...");

  1892.             String tmp = null;
  1893.             if(originale.contains("://")){
  1894.                 tmp = originale.substring(originale.indexOf("://")+3);
  1895.             }else{
  1896.                 return urlOriginale; // url prefix effettuato solo se definito un protocollo es. http://
  1897.             }

  1899.             this.logDebug("["+funzione+"]  eliminazioneProtocollo["+tmp+"] ...");

  1901.             if(tmp.contains("/")){
  1902.                 tmp = tmp.substring(tmp.indexOf("/")+1);
  1903.                 this.logDebug("["+funzione+"]  salvataggioContesto["+tmp+"] ...");
  1904.                 if(urlFinale.endsWith("/")==false){
  1905.                     urlFinale = urlFinale + "/"; 
  1906.                 }
  1907.                 urlFinale = urlFinale + tmp;
  1908.             }
  1909.             // else sostituisco completamente tutta la url, non avendo un contesto.

  1911.             this.logDebug("["+funzione+"]  nuova url: ["+urlFinale+"]");

  1913.             return urlFinale;

  1915.         }catch(Exception e){
  1916.             this.logError("Processo di ["+funzione+"]  fallito (urlOriginale:"+urlOriginale+") (urlPrefix:"+urlPrefix+")",e);
  1917.             throw new DriverConfigurazioneException("Processo di ["+funzione+"]  fallito (urlOriginale:"+urlOriginale+") (urlPrefix:"+urlPrefix+")",e);
  1918.         }
  1919.     }










  1930.     /* ********  PORTE DELEGATE (Interfaccia)  ******** */

  1932.     public IDPortaDelegata getIDPortaDelegata(Connection connectionPdD,String nome) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1933.         return this.configurazionePdD.getIDPortaDelegata(connectionPdD, nome);
  1934.     }

  1936.     protected PortaDelegata getPortaDelegata(Connection connectionPdD,IDPortaDelegata idPD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1937.         return this.configurazionePdD.getPortaDelegata(connectionPdD,idPD);
  1938.     }

  1940.     protected PortaDelegata getPortaDelegataSafeMethod(Connection connectionPdD,IDPortaDelegata idPD)throws DriverConfigurazioneException{
  1941.         try{
  1942.             if(idPD!=null && idPD.getNome()!=null)
  1943.                 return this.getPortaDelegata(connectionPdD,idPD);
  1944.             else
  1945.                 return null;
  1946.         }catch(DriverConfigurazioneNotFound e){
  1947.             return null;
  1948.         }
  1949.     }

  1951.     protected void updateStatoPortaDelegata(Connection connectionPdD,IDPortaDelegata idPD, StatoFunzionalita stato) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1952.         this.configurazionePdD.updateStatoPortaDelegata(connectionPdD, idPD, stato);
  1953.     }
  1954.     
  1955.     protected Map<String, String> getProprietaConfigurazione(PortaDelegata pd) throws DriverConfigurazioneException {
  1956.         if (pd == null) {
  1957.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  1958.         } else if (pd.sizeProprietaList() <= 0) {
  1959.             return null;
  1960.         } else {
  1961.             Map<String, String> properties = new HashMap<>();

  1963.             for(int i = 0; i < pd.sizeProprietaList(); ++i) {
  1964.                 Proprieta p = pd.getProprieta(i);
  1965.                 properties.put(p.getNome(), p.getValore());
  1966.             }

  1968.             return properties;
  1969.         }
  1970.     }

  1972.     protected boolean identificazioneContentBased(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1973.         if(pd==null){
  1974.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  1975.         }
  1976.         if( pd.getAzione() != null  ){
  1977.             if(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_CONTENT_BASED.equals(pd.getAzione().getIdentificazione())){
  1978.                 return true;
  1979.             }else{
  1980.                 return false;
  1981.             }
  1982.         }else
  1983.             return false;
  1984.     }

  1986.     protected boolean identificazioneInputBased(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1987.         if(pd==null){
  1988.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  1989.         }
  1990.         if( pd.getAzione() != null  ){
  1991.             if(CostantiConfigurazione.PORTA_DELEGATA_AZIONE_INPUT_BASED.equals(pd.getAzione().getIdentificazione())){
  1992.                 return true;
  1993.             }else{
  1994.                 return false;
  1995.             }
  1996.         }else
  1997.             return false;
  1998.     }

  2000.     protected String getAzione(RegistroServiziManager registroServiziManager,PortaDelegata pd,URLProtocolContext urlProtocolContext,RequestInfo requestInfo,
  2001.             OpenSPCoop2Message message, OpenSPCoop2MessageSoapStreamReader soapStreamReader, HeaderIntegrazione headerIntegrazione, boolean readFirstHeaderIntegrazione,
  2002.             IProtocolFactory<?> protocolFactory) throws DriverConfigurazioneException, IdentificazioneDinamicaException { 

  2004.         try{

  2006.             if(pd==null){
  2007.                 throw new DriverConfigurazioneException("Porta Delegata non fornita");
  2008.             }
  2009.             IDSoggetto soggettoErogatore = new IDSoggetto(pd.getSoggettoErogatore().getTipo(),pd.getSoggettoErogatore().getNome());
  2010.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pd.getServizio().getTipo(),pd.getServizio().getNome(), 
  2011.                     soggettoErogatore, 
  2012.                     pd.getServizio().getVersione()); 

  2014.             String azioneHeaderIntegrazione = null;
  2015.             if(headerIntegrazione!=null && headerIntegrazione.getBusta()!=null && headerIntegrazione.getBusta().getAzione()!=null){
  2016.                 azioneHeaderIntegrazione = headerIntegrazione.getBusta().getAzione();
  2017.             }

  2019.             ModalitaIdentificazioneAzione modalitaIdentificazione = ModalitaIdentificazioneAzione.STATIC;
  2020.             String pattern = null;
  2021.             boolean forceRegistryBased = false;
  2022.             boolean forcePluginBased = false;
  2023.             if( pd.getAzione() != null  ){
  2024.                 idServizio.setAzione(pd.getAzione().getNome());
  2025.                 pattern = pd.getAzione().getPattern();
  2026.                 if( pd.getAzione().getIdentificazione() != null  ){
  2027.                     modalitaIdentificazione = ModalitaIdentificazioneAzione.convert(pd.getAzione().getIdentificazione());
  2028.                 }
  2029.                 forceRegistryBased = StatoFunzionalita.ABILITATO.equals(pd.getAzione().getForceInterfaceBased());
  2030.             }

  2032.             OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  2033.             
  2034.             boolean bufferMessageReadOnly = op2Properties.isReadByPathBufferEnabled();
  2035.             
  2036.             boolean rpcAcceptRootElementUnqualified = OpenSPCoop2Properties.getInstance().isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified();
  2037.             if(pd!=null && pd.getProprietaList()!=null && !pd.getProprietaList().isEmpty()) {
  2038.                 boolean defaultRpcAcceptRootElementUnqualified = rpcAcceptRootElementUnqualified;
  2039.                 rpcAcceptRootElementUnqualified = ValidatoreMessaggiApplicativiRest.readBooleanValueWithDefault(pd.getProprietaList(), CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_RPC_ACCEPT_ROOT_ELEMENT_UNQUALIFIED_ENABLED, defaultRpcAcceptRootElementUnqualified);
  2040.             }
  2041.             
  2042.             WSDLValidatorConfig config = new WSDLValidatorConfig();
  2043.             config.setRpcAcceptRootElementUnqualified(rpcAcceptRootElementUnqualified);
  2044.             
  2045.             String azione = OperationFinder.getAzione(registroServiziManager, urlProtocolContext, requestInfo, message, soapStreamReader, soggettoErogatore, idServizio, 
  2046.                     readFirstHeaderIntegrazione, azioneHeaderIntegrazione, protocolFactory, modalitaIdentificazione, 
  2047.                     pattern, forceRegistryBased, forcePluginBased, this.logger, false,
  2048.                     bufferMessageReadOnly, 
  2049.                     headerIntegrazione!=null ? headerIntegrazione.getIdTransazione() : null,
  2050.                     config);

  2052.             // Se non ho riconosciuto una azione a questo punto, 
  2053.             // durante il processo standard di riconoscimento viene sollevata una eccezione IdentificazioneDinamicaException

  2055.             return azione;

  2057.         }catch(IdentificazioneDinamicaException e){
  2058.             throw e;
  2059.         }
  2060.         catch(Exception e){
  2061.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2062.         }

  2064.     }

  2066.     protected MTOMProcessorConfig getMTOMProcessorForSender(PortaDelegata pd) throws DriverConfigurazioneException{

  2068.         MTOMProcessorConfig config = new MTOMProcessorConfig();
  2069.         List<MtomXomPackageInfo> list = new ArrayList<MtomXomPackageInfo>();
  2070.         config.setInfo(list);

  2072.         if(pd == null)
  2073.             return config;

  2075.         MtomProcessor mtomProcessor = pd.getMtomProcessor();
  2076.         if(mtomProcessor == null)
  2077.             return config;

  2079.         if(mtomProcessor.getRequestFlow()!=null){
  2080.             MtomProcessorFlow mtomFlow = mtomProcessor.getRequestFlow();
  2081.             config.setMtomProcessorType(mtomFlow.getMode());
  2082.             for(int i=0 ; i<mtomFlow.sizeParameterList() ; i++){
  2083.                 String nome = mtomFlow.getParameter(i).getNome();
  2084.                 if(nome!=null){
  2085.                     MtomXomPackageInfo info = new MtomXomPackageInfo();
  2086.                     info.setName(nome);
  2087.                     info.setXpathExpression(mtomFlow.getParameter(i).getPattern());
  2088.                     info.setContentType(mtomFlow.getParameter(i).getContentType());
  2089.                     info.setRequired(mtomFlow.getParameter(i).getRequired());
  2090.                     list.add(info);
  2091.                 }
  2092.             }
  2093.         }

  2095.         return config;
  2096.     }

  2098.     protected MTOMProcessorConfig getMTOMProcessorForReceiver(PortaDelegata pd) throws DriverConfigurazioneException{

  2100.         MTOMProcessorConfig config = new MTOMProcessorConfig();
  2101.         List<MtomXomPackageInfo> list = new ArrayList<MtomXomPackageInfo>();
  2102.         config.setInfo(list);

  2104.         if(pd == null)
  2105.             return config;

  2107.         MtomProcessor mtomProcessor = pd.getMtomProcessor();
  2108.         if(mtomProcessor == null)
  2109.             return config;

  2111.         if(mtomProcessor.getResponseFlow()!=null){
  2112.             MtomProcessorFlow mtomFlow = mtomProcessor.getResponseFlow();
  2113.             config.setMtomProcessorType(mtomFlow.getMode());
  2114.             for(int i=0 ; i<mtomFlow.sizeParameterList() ; i++){
  2115.                 String nome = mtomFlow.getParameter(i).getNome();
  2116.                 if(nome!=null){
  2117.                     MtomXomPackageInfo info = new MtomXomPackageInfo();
  2118.                     info.setName(nome);
  2119.                     info.setXpathExpression(mtomFlow.getParameter(i).getPattern());
  2120.                     info.setContentType(mtomFlow.getParameter(i).getContentType());
  2121.                     info.setRequired(mtomFlow.getParameter(i).getRequired());
  2122.                     list.add(info);
  2123.                 }
  2124.             }
  2125.         }

  2127.         return config;
  2128.     }

  2130.     protected MessageSecurityConfig getMessageSecurityForSender(PortaDelegata pd) throws DriverConfigurazioneException{

  2132.         MessageSecurityConfig securityConfig = new MessageSecurityConfig();
  2133.         java.util.Map<String,Object> table = new java.util.HashMap<>();
  2134.         securityConfig.setFlowParameters(table);

  2136.         if(pd == null)
  2137.             return securityConfig;

  2139.         if(pd.getStatoMessageSecurity()!=null && CostantiConfigurazione.DISABILITATO.toString().equals(pd.getStatoMessageSecurity())){
  2140.             return securityConfig;
  2141.         }

  2143.         MessageSecurity messageSecurity = pd.getMessageSecurity();
  2144.         if(messageSecurity == null)
  2145.             return securityConfig;

  2147.         if(messageSecurity.getRequestFlow()!=null){
  2148.             MessageSecurityFlow securityFlow = messageSecurity.getRequestFlow();
  2149.             if(securityFlow.getApplyToMtom()!=null){
  2150.                 securityConfig.setApplyToMtom(StatoFunzionalita.ABILITATO.equals(securityFlow.getApplyToMtom()));
  2151.             }
  2152.             for(int i=0 ; i<securityFlow.sizeParameterList() ; i++){
  2153.                 String nome = securityFlow.getParameter(i).getNome();
  2154.                 if(nome!=null){
  2155.                     String valore = securityFlow.getParameter(i).getValore();
  2156.                     if("actor".equals(nome)){
  2157.                         // patch per header senza actor (dove non si vuole che venga assunto il default=openspcoop)
  2158.                         if(valore == null)
  2159.                             valore = "";
  2160.                         else if("notDefined".equals(valore)){
  2161.                             valore = "";
  2162.                         }
  2163.                     }
  2164.                     table.put(nome,valore);
  2165.                 }
  2166.             }
  2167.         }

  2169.         return securityConfig;
  2170.     }

  2172.     protected MessageSecurityConfig getMessageSecurityForReceiver(PortaDelegata pd) throws DriverConfigurazioneException{

  2174.         MessageSecurityConfig securityConfig = new MessageSecurityConfig();
  2175.         java.util.Map<String,Object> table = new java.util.HashMap<>();
  2176.         securityConfig.setFlowParameters(table);

  2178.         if(pd == null)
  2179.             return securityConfig;

  2181.         if(pd.getStatoMessageSecurity()!=null && CostantiConfigurazione.DISABILITATO.toString().equals(pd.getStatoMessageSecurity())){
  2182.             return securityConfig;
  2183.         }

  2185.         MessageSecurity messageSecurity = pd.getMessageSecurity();
  2186.         if(messageSecurity == null)
  2187.             return securityConfig;

  2189.         if(messageSecurity.getResponseFlow()!=null){
  2190.             MessageSecurityFlow securityFlow = messageSecurity.getResponseFlow();
  2191.             if(securityFlow.getApplyToMtom()!=null){
  2192.                 securityConfig.setApplyToMtom(StatoFunzionalita.ABILITATO.equals(securityFlow.getApplyToMtom()));
  2193.             }
  2194.             for(int i=0 ; i<securityFlow.sizeParameterList() ; i++){
  2195.                 String nome = securityFlow.getParameter(i).getNome();
  2196.                 if(nome!=null){
  2197.                     String valore = securityFlow.getParameter(i).getValore();
  2198.                     if("actor".equals(nome)){
  2199.                         // patch per header senza actor (dove non si vuole che venga assunto il default=openspcoop)
  2200.                         if(valore == null)
  2201.                             valore = "";
  2202.                         else if("notDefined".equals(valore)){
  2203.                             valore = "";
  2204.                         }
  2205.                     }
  2206.                     table.put(nome,valore);
  2207.                 }
  2208.             }
  2209.         }

  2211.         return securityConfig;
  2212.     }

  2214.     protected String getAutenticazione(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  2216.         if(pd==null){
  2217.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  2218.         }

  2220.         if(pd.getAutenticazione() == null || "".equals(pd.getAutenticazione()))
  2221.             return CostantiConfigurazione.CREDENZIALE_SSL.toString();
  2222.         else
  2223.             return pd.getAutenticazione();
  2224.     }

  2226.     protected boolean isAutenticazioneOpzionale(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  2228.         if(pd==null){
  2229.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  2230.         }

  2232.         if(pd.getAutenticazioneOpzionale() == null)
  2233.             return false;
  2234.         else{
  2235.             if(StatoFunzionalita.ABILITATO.equals(pd.getAutenticazioneOpzionale())){
  2236.                 return true;
  2237.             }
  2238.             else if(StatoFunzionalita.DISABILITATO.equals(pd.getAutenticazioneOpzionale())){
  2239.                 return false;
  2240.             }
  2241.             else{
  2242.                 return false;
  2243.             }
  2244.         }

  2246.     }

  2248.     protected String getGestioneToken(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  2250.         if(pd==null){
  2251.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  2252.         }

  2254.         if(pd.getGestioneToken()!=null && pd.getGestioneToken().getPolicy()!=null) {
  2255.             return pd.getGestioneToken().getPolicy();
  2256.         }
  2257.         return null;
  2258.     }

  2260.     protected PolicyGestioneToken getPolicyGestioneToken(Connection connectionPdD, PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  2262.         if(pd==null){
  2263.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  2264.         }

  2266.         if(pd.getGestioneToken()==null || pd.getGestioneToken().getPolicy()==null) {
  2267.             throw new DriverConfigurazioneException("Porta Delegata senza una policy di gestione token");
  2268.         }

  2270.         GenericProperties gp = this.getGenericProperties(connectionPdD, org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA, pd.getGestioneToken().getPolicy());

  2272.         PolicyGestioneToken policy = null;
  2273.         try {
  2274.             policy = TokenUtilities.convertTo(gp, pd.getGestioneToken());
  2275.         }catch(Exception e) {
  2276.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2277.         }

  2279.         return policy;
  2280.     }

  2282.     protected String getAutorizzazione(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  2284.         if(pd==null){
  2285.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  2286.         }

  2288.         if(pd.getAutorizzazione() == null || "".equals(pd.getAutorizzazione()) )
  2289.             return CostantiConfigurazione.AUTORIZZAZIONE_AUTHENTICATED;
  2290.         else
  2291.             return pd.getAutorizzazione();
  2292.     }

  2294.     protected String getAutorizzazioneContenuto(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  2296.         if(pd==null){
  2297.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  2298.         }

  2300.         if(pd.getAutorizzazioneContenuto() == null || "".equals(pd.getAutorizzazioneContenuto()))
  2301.             return CostantiConfigurazione.NONE;
  2302.         else
  2303.             return pd.getAutorizzazioneContenuto();
  2304.     }

  2306.     public CorsConfigurazione getConfigurazioneCORS(Connection connectionPdD, PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  2308.         if(pd==null){
  2309.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  2310.         }

  2312.         CorsConfigurazione cors = pd.getGestioneCors();
  2313.         if(cors==null) {
  2314.             cors = this.getConfigurazioneCORS(connectionPdD);
  2315.         }
  2316.         return cors;
  2317.     }

  2319.     public ResponseCachingConfigurazione getConfigurazioneResponseCaching(Connection connectionPdD, PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  2321.         if(pd==null){
  2322.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  2323.         }

  2325.         ResponseCachingConfigurazione c = pd.getResponseCaching();
  2326.         if(c==null) {
  2327.             c = this.getConfigurazioneResponseCaching(connectionPdD);
  2328.         }
  2329.         return c;
  2330.     }

  2332.     protected boolean ricevutaAsincronaSimmetricaAbilitata(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2333.         if(pd==null)
  2334.             return true; // default Abilitata-CNIPA
  2335.         return !CostantiConfigurazione.DISABILITATO.equals(pd.getRicevutaAsincronaSimmetrica());
  2336.     }

  2338.     protected boolean ricevutaAsincronaAsimmetricaAbilitata(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2339.         if(pd==null)
  2340.             return true; // default Abilitata-CNIPA
  2341.         return !CostantiConfigurazione.DISABILITATO.equals(pd.getRicevutaAsincronaAsimmetrica());
  2342.     }

  2344.     protected ValidazioneContenutiApplicativi getTipoValidazioneContenutoApplicativo(Connection connectionPdD, PortaDelegata pd,String implementazionePdDSoggetto, boolean request) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2345.         // default in configurazione
  2346.         ValidazioneContenutiApplicativi val = this.getTipoValidazioneContenutoApplicativo(connectionPdD,implementazionePdDSoggetto);

  2348.         if( pd==null || pd.getValidazioneContenutiApplicativi() == null ){
  2349.             return val;
  2350.         }

  2352.         ValidazioneContenutiApplicativi valPD = new ValidazioneContenutiApplicativi();

  2354.         if( CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.equals(pd.getValidazioneContenutiApplicativi().getStato())  )
  2355.             valPD.setStato(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO);
  2356.         else if( CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(pd.getValidazioneContenutiApplicativi().getStato())  )
  2357.             valPD.setStato(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY);
  2358.         else if( CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO.equals(pd.getValidazioneContenutiApplicativi().getStato())  )
  2359.             valPD.setStato(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO);

  2361.         if( CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP.equals(pd.getValidazioneContenutiApplicativi().getTipo())  )
  2362.             valPD.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP);
  2363.         else if( CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(pd.getValidazioneContenutiApplicativi().getTipo())  )
  2364.             valPD.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE);
  2365.         else if( CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD.equals(pd.getValidazioneContenutiApplicativi().getTipo())  )
  2366.             valPD.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD);

  2368.         if( CostantiConfigurazione.ABILITATO.equals(pd.getValidazioneContenutiApplicativi().getAcceptMtomMessage())  )
  2369.             valPD.setAcceptMtomMessage(CostantiConfigurazione.ABILITATO);
  2370.         else if( CostantiConfigurazione.DISABILITATO.equals(pd.getValidazioneContenutiApplicativi().getAcceptMtomMessage())  )
  2371.             valPD.setAcceptMtomMessage(CostantiConfigurazione.DISABILITATO);

  2373.         refreshByProperties(pd.getProprietaList(), request, valPD);
  2374.             
  2375.         return valPD;
  2376.     }
  2377.     
  2378.     private void refreshByProperties(List<Proprieta> list, boolean request, ValidazioneContenutiApplicativi val) {
  2379.         if(list!=null && !list.isEmpty()) {
  2380.             String pName = request? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_RICHIESTA_ENABLED : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_RISPOSTA_ENABLED;
  2381.             String pNameType = request? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_RICHIESTA_TIPO : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_RISPOSTA_TIPO;
  2382.             String pNameMtom = request? CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_RICHIESTA_ACCEPT_MTOM_MESSAGE : CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_RISPOSTA_ACCEPT_MTOM_MESSAGE;
  2383.             for (Proprieta p : list) {
  2384.                 if(pName.equals(p.getNome())) {
  2385.                     if(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_ENABLED.equals(p.getValore())) {
  2386.                         val.setStato(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO);
  2387.                     }
  2388.                     else if(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_DISABLED.equals(p.getValore())) {
  2389.                         val.setStato(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO);
  2390.                     }
  2391.                     else if(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_WARNING_ONLY.equals(p.getValore())) {
  2392.                         val.setStato(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY);
  2393.                     }
  2394.                 }
  2395.                 else if(pNameType.equals(p.getNome())) {
  2396.                     if(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP.equals(p.getValore())) {
  2397.                         val.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP);
  2398.                     }
  2399.                     else if(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(p.getValore())) {
  2400.                         val.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE);
  2401.                     }
  2402.                     else if(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD.equals(p.getValore())) {
  2403.                         val.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD);
  2404.                     }
  2405.                 }
  2406.                 else if(pNameMtom.equals(p.getNome())) {
  2407.                     if(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_ENABLED.equals(p.getValore())) {
  2408.                         val.setAcceptMtomMessage(CostantiConfigurazione.ABILITATO);
  2409.                     }
  2410.                     else if(CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_VALUE_DISABLED.equals(p.getValore())) {
  2411.                         val.setAcceptMtomMessage(CostantiConfigurazione.DISABILITATO);
  2412.                     }
  2413.                 }
  2414.             }
  2415.         }
  2416.     }

  2418.     protected CorrelazioneApplicativa getCorrelazioneApplicativa(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2419.         if(pd==null){
  2420.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  2421.         }
  2422.         return pd.getCorrelazioneApplicativa();

  2424.     }

  2426.     protected CorrelazioneApplicativaRisposta getCorrelazioneApplicativaRisposta(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2427.         if(pd==null){
  2428.             throw new DriverConfigurazioneException("Porta Delegata non fornita");
  2429.         }
  2430.         return pd.getCorrelazioneApplicativaRisposta();

  2432.     }

  2434.     protected String[] getTipiIntegrazione(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 
  2435.         String[]tipi = null;
  2436.         if(pd!=null){
  2437.             if(pd.getIntegrazione() != null && ("".equals(pd.getIntegrazione())==false) ){
  2438.                 tipi = pd.getIntegrazione().trim().split(",");
  2439.             }
  2440.         }  

  2442.         return tipi;
  2443.     }

  2445.     protected boolean isGestioneManifestAttachments(Connection connectionPdD, PortaDelegata pd, IProtocolFactory<?> protocolFactory) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2446.         if(pd==null){
  2447.             try{
  2448.                 if(protocolFactory.createProtocolConfiguration().isSupportato(ServiceBinding.SOAP,FunzionalitaProtocollo.MANIFEST_ATTACHMENTS)){
  2449.                     // Bug: 286: devo usare il default della configurazione SOLO SE il protocollo lo supporta.
  2450.                     return this.isGestioneManifestAttachments(connectionPdD); //configurazione di default
  2451.                 }
  2452.                 else{
  2453.                     return false;
  2454.                 }
  2455.             }catch(Exception e){
  2456.                 throw new DriverConfigurazioneException(e.getMessage(),e);
  2457.             }
  2458.         }
  2459.         if( CostantiConfigurazione.ABILITATO.equals(pd.getGestioneManifest())  ){
  2460.             return true;
  2461.         }else if( CostantiConfigurazione.DISABILITATO.equals(pd.getGestioneManifest())  ){
  2462.             return false;
  2463.         }else{
  2464.             try{
  2465.                 if(protocolFactory.createProtocolConfiguration().isSupportato(ServiceBinding.SOAP,FunzionalitaProtocollo.MANIFEST_ATTACHMENTS)){
  2466.                     // Bug: 286: devo usare il default della configurazione SOLO SE il protocollo lo supporta.
  2467.                     return this.isGestioneManifestAttachments(connectionPdD); //configurazione di default
  2468.                 }
  2469.                 else{
  2470.                     return false;
  2471.                 }
  2472.             }catch(Exception e){
  2473.                 throw new DriverConfigurazioneException(e.getMessage(),e);
  2474.             }
  2475.         }
  2476.     }

  2478.     protected boolean isAllegaBody(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2479.         if(pd==null){
  2480.             return false; //configurazione di default
  2481.         }
  2482.         if( CostantiConfigurazione.ABILITATO.equals(pd.getAllegaBody())  )
  2483.             return true;
  2484.         else if( CostantiConfigurazione.DISABILITATO.equals(pd.getAllegaBody())  )
  2485.             return false;
  2486.         else 
  2487.             return false; //configurazione di default
  2488.     }

  2490.     protected boolean isScartaBody(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2491.         if(pd==null){
  2492.             return false; //configurazione di default
  2493.         }
  2494.         if( CostantiConfigurazione.ABILITATO.equals(pd.getScartaBody())  )
  2495.             return true;
  2496.         else if( CostantiConfigurazione.DISABILITATO.equals(pd.getScartaBody())  )
  2497.             return false;
  2498.         else 
  2499.             return false; //configurazione di default
  2500.     }

  2502.     protected boolean isModalitaStateless(PortaDelegata pd, ProfiloDiCollaborazione profiloCollaborazione) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  2504.         if(this.serverJ2EE==false){
  2505.             // Stateless obbligatorio in server di tipo web (non j2ee)
  2506.             return true;
  2507.         }

  2509.         if(pd==null){
  2510.             // configurazione di default
  2511.             if(ProfiloDiCollaborazione.ONEWAY.equals(profiloCollaborazione))
  2512.                 return CostantiConfigurazione.ABILITATO.equals(this.openspcoopProperties.getStatelessOneWay());
  2513.             else if(ProfiloDiCollaborazione.SINCRONO.equals(profiloCollaborazione))
  2514.                 return CostantiConfigurazione.ABILITATO.equals(this.openspcoopProperties.getStatelessSincrono());
  2515.             else
  2516.                 return CostantiConfigurazione.ABILITATO.equals(this.openspcoopProperties.getStatelessAsincroni());
  2517.         }

  2519.         if( CostantiConfigurazione.ABILITATO.equals(pd.getStateless())  )
  2520.             return true;
  2521.         else if( CostantiConfigurazione.DISABILITATO.equals(pd.getStateless())  )
  2522.             return false;
  2523.         else {
  2524.             //configurazione di default
  2525.             if(ProfiloDiCollaborazione.ONEWAY.equals(profiloCollaborazione))
  2526.                 return CostantiConfigurazione.ABILITATO.equals(this.openspcoopProperties.getStatelessOneWay());
  2527.             else if(ProfiloDiCollaborazione.SINCRONO.equals(profiloCollaborazione))
  2528.                 return CostantiConfigurazione.ABILITATO.equals(this.openspcoopProperties.getStatelessSincrono());
  2529.             else
  2530.                 return CostantiConfigurazione.ABILITATO.equals(this.openspcoopProperties.getStatelessAsincroni());
  2531.         }
  2532.     }

  2534.     protected boolean isLocalForwardMode(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  2536.         if(pd==null || pd.getLocalForward()==null){
  2537.             // configurazione di default
  2538.             return false;
  2539.         }

  2541.         if( CostantiConfigurazione.ABILITATO.equals(pd.getLocalForward().getStato())  )
  2542.             return true;
  2543.         else if( CostantiConfigurazione.DISABILITATO.equals(pd.getLocalForward().getStato())  )
  2544.             return false;
  2545.         else {
  2546.             //configurazione di default
  2547.             return false;
  2548.         }
  2549.     }

  2551.     protected String getLocalForwardNomePortaApplicativa(PortaDelegata pd) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  2553.         if(pd==null || pd.getLocalForward()==null){
  2554.             // configurazione di default
  2555.             return null;
  2556.         }

  2558.         return pd.getLocalForward().getPortaApplicativa();
  2559.     }

  2561.     protected boolean isPortaAbilitata(PortaDelegata pd) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{

  2563.         if(pd==null){
  2564.             //configurazione di default
  2565.             return true; 
  2566.         }

  2568.         if( CostantiConfigurazione.ABILITATO.equals(pd.getStato())  )
  2569.             return true;
  2570.         else if( CostantiConfigurazione.DISABILITATO.equals(pd.getStato())  )
  2571.             return false;
  2572.         else {
  2573.             //configurazione di default
  2574.             return true; 
  2575.         }
  2576.     }

  2578.     protected DumpConfigurazione getDumpConfigurazione(Connection connectionPdD,PortaDelegata pd) throws DriverConfigurazioneException{
  2579.         if(pd==null){
  2580.             //configurazione di default
  2581.             return getDumpConfigurazionePortaDelegata(connectionPdD);
  2582.         }

  2584.         if(pd.getDump()!=null) {
  2585.             return pd.getDump();
  2586.         }
  2587.         else {
  2588.             //configurazione di default
  2589.             return getDumpConfigurazionePortaDelegata(connectionPdD);
  2590.         }
  2591.     }
  2592.     
  2593.     protected boolean isTransazioniFileTraceEnabled(Connection connectionPdD,PortaDelegata pd) throws DriverConfigurazioneException{
  2594.         
  2595.         boolean defaultValue = this.openspcoopProperties.isTransazioniFileTraceEnabled();
  2596.         if(pd==null){
  2597.             //configurazione di default
  2598.             return defaultValue;
  2599.         }
  2600.         try {
  2601.             return CostantiProprieta.isFileTraceEnabled(pd.getProprietaList(), defaultValue);
  2602.         }catch(Exception e) {
  2603.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2604.         }

  2606.     }
  2607.     
  2608.     protected boolean isTransazioniFileTraceDumpBinarioHeadersEnabled(Connection connectionPdD,PortaDelegata pd) throws DriverConfigurazioneException{
  2609.         
  2610.         boolean defaultValue = this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPDEnabled() && this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPDHeadersEnabled();
  2611.         if(pd==null){
  2612.             //configurazione di default
  2613.             return defaultValue;
  2614.         }
  2615.         try {
  2616.             return CostantiProprieta.isFileTraceDumpBinarioHeadersEnabled(pd.getProprietaList(), defaultValue);
  2617.         }catch(Exception e) {
  2618.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2619.         }

  2621.     }
  2622.     protected boolean isTransazioniFileTraceDumpBinarioPayloadEnabled(Connection connectionPdD,PortaDelegata pd) throws DriverConfigurazioneException{
  2623.         
  2624.         boolean defaultValue = this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPDEnabled() && this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPDPayloadEnabled();
  2625.         if(pd==null){
  2626.             //configurazione di default
  2627.             return defaultValue;
  2628.         }
  2629.         try {
  2630.             return CostantiProprieta.isFileTraceDumpBinarioPayloadEnabled(pd.getProprietaList(), defaultValue);
  2631.         }catch(Exception e) {
  2632.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2633.         }

  2635.     }
  2636.     
  2637.     protected boolean isTransazioniFileTraceDumpBinarioConnettoreHeadersEnabled(Connection connectionPdD,PortaDelegata pd) throws DriverConfigurazioneException{
  2638.     
  2639.         boolean defaultValue = this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled() && this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPDConnettoreHeadersEnabled();
  2640.         if(pd==null){
  2641.             //configurazione di default
  2642.             return defaultValue;
  2643.         }
  2644.         try {
  2645.             return CostantiProprieta.isFileTraceDumpBinarioConnettoreHeadersEnabled(pd.getProprietaList(), defaultValue);
  2646.         }catch(Exception e) {
  2647.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2648.         }

  2650.     }
  2651.     protected boolean isTransazioniFileTraceDumpBinarioConnettorePayloadEnabled(Connection connectionPdD,PortaDelegata pd) throws DriverConfigurazioneException{
  2652.         
  2653.         boolean defaultValue = this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPDConnettoreEnabled() && this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPDConnettorePayloadEnabled();
  2654.         if(pd==null){
  2655.             //configurazione di default
  2656.             return defaultValue;
  2657.         }
  2658.         try {
  2659.             return CostantiProprieta.isFileTraceDumpBinarioConnettorePayloadEnabled(pd.getProprietaList(), defaultValue);
  2660.         }catch(Exception e) {
  2661.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2662.         }

  2664.     }
  2665.     
  2666.     protected File getFileTraceConfig(Connection connectionPdD,PortaDelegata pd) throws DriverConfigurazioneException{

  2668.         try {
  2669.             File defaultValue = this.openspcoopProperties.getTransazioniFileTraceConfig();
  2670.             if(pd==null){
  2671.                 //configurazione di default
  2672.                 return defaultValue;
  2673.             }
  2674.             return CostantiProprieta.getFileTraceConfig(pd.getProprietaList(), defaultValue);
  2675.         }catch(Exception e) {
  2676.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2677.         }

  2679.     }
  2680.     
  2681.     protected SoglieDimensioneMessaggi getSoglieLimitedInputStream(Connection connectionPdD,PortaDelegata pd, String azione, String idModulo,
  2682.             PdDContext pddContext, RequestInfo requestInfo, 
  2683.             IProtocolFactory<?> protocolFactory, Logger log) throws DriverConfigurazioneException{
  2684.         
  2685.         if(!this.openspcoopProperties.isControlloTrafficoEnabled()){
  2686.             return null;
  2687.         }
  2688.         
  2689.         URLProtocolContext urlProtocolContext = null;
  2690.         if(requestInfo!=null) {
  2691.             urlProtocolContext = requestInfo.getProtocolContext();
  2692.         }
  2693.         
  2694.         TipoPdD tipoPdD = null;
  2695.         String nomePorta = null;
  2696.         IDSoggetto idDominio = null;
  2697.         IDSoggetto soggettoFruitore = null;
  2698.         IDServizio idServizio = null;
  2699.         IDPortaDelegata idPD = null;
  2700.         IDPortaApplicativa idPA = null;
  2701.         if(pd!=null) {
  2702.             tipoPdD = TipoPdD.DELEGATA;
  2703.             nomePorta = pd.getNome();
  2704.             idDominio = new IDSoggetto(pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario());
  2705.             soggettoFruitore = idDominio;
  2706.             try {
  2707.                 idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pd.getServizio().getTipo(), pd.getServizio().getNome(), 
  2708.                         pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome(),
  2709.                         pd.getServizio().getVersione());
  2710.                 idServizio.setAzione(azione);
  2711.             }catch(Exception e) {
  2712.                 throw new DriverConfigurazioneException(e.getMessage(),e);
  2713.             }
  2714.             idPD = new IDPortaDelegata();
  2715.             idPD.setNome(nomePorta);
  2716.         }
  2717.         else {
  2718.             idDominio = OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(protocolFactory!=null ? protocolFactory.getProtocol() : null, requestInfo);
  2719.         }
  2720.          
  2721.         IState state = null;
  2722.         IDAccordo idAccordo = null; // viene calcolato all'interno del metodo
  2723.         String servizioApplicativoFruitore = null; 
  2724.         List<String> serviziApplicativiErogatori = null;
  2725.         try {
  2726.             DatiTransazione datiTransazione = InterceptorPolicyUtilities.readDatiTransazione(tipoPdD, idModulo, 
  2727.                     pddContext, urlProtocolContext,
  2728.                     protocolFactory, state, log,
  2729.                     idDominio, soggettoFruitore, idServizio, idAccordo,
  2730.                     idPD, idPA,
  2731.                     servizioApplicativoFruitore, serviziApplicativiErogatori);
  2732.             return DimensioneMessaggiConfigurationUtils.readSoglieDimensioneMessaggi(tipoPdD, nomePorta, datiTransazione, log, urlProtocolContext, requestInfo, pddContext, protocolFactory);
  2733.         }catch(Exception e) {
  2734.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2735.         }
  2736.     }
  2737.     
  2738.     protected boolean isConnettoriUseTimeoutInputStream(Connection connectionPdD,PortaDelegata pd) throws DriverConfigurazioneException{
  2739.         
  2740.         boolean defaultValue = this.openspcoopProperties.isConnettoriUseTimeoutInputStream();
  2741.         if(pd==null){
  2742.             //configurazione di default
  2743.             return defaultValue;
  2744.         }
  2745.         try {
  2746.             return CostantiProprieta.isConnettoriUseTimeoutInputStream(pd.getProprietaList(), defaultValue);
  2747.         }catch(Exception e) {
  2748.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2749.         }

  2751.     }
  2752.     protected SogliaReadTimeout getRequestReadTimeout(PortaDelegata pd,
  2753.             RequestInfo requestInfo, 
  2754.             IProtocolFactory<?> protocolFactory,
  2755.             Context context,
  2756.             IState state) throws DriverConfigurazioneException{

  2758.         int defaultValue = this.openspcoopProperties.getReadConnectionTimeout_ricezioneContenutiApplicativi();
  2759.         if(pd==null){
  2760.             //configurazione di default
  2761.             return ReadTimeoutConfigurationUtils.buildSogliaRequestTimeout(defaultValue, true, protocolFactory);
  2762.         }
  2763.         try {
  2764.             boolean configurazioneGlobale = !CostantiProprieta.existsConnettoriRequestTimeout(pd.getProprietaList());
  2765.             int sogliaMs = defaultValue;
  2766.             if(!configurazioneGlobale) {
  2767.                 sogliaMs = CostantiProprieta.getConnettoriRequestTimeout(pd.getProprietaList(), defaultValue);
  2768.             }
  2769.             return ReadTimeoutConfigurationUtils.buildSogliaRequestTimeout(sogliaMs, configurazioneGlobale, pd, 
  2770.                     new ReadTimeoutContextParam(requestInfo, protocolFactory, context, state));
  2771.         }catch(Exception e) {
  2772.             throw new DriverConfigurazioneException(e.getMessage(),e);
  2773.         }

  2775.     }

  2777.     protected Trasformazioni getTrasformazioni(PortaDelegata pd) throws DriverConfigurazioneException{
  2778.         if(pd!=null && pd.getTrasformazioni()!=null) {
  2779.             return pd.getTrasformazioni();
  2780.         }
  2781.         return null;
  2782.     }
  2783.     
  2784.     protected List<String> getPreInRequestHandlers(PortaDelegata pd) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2785.         List<String> list = new ArrayList<>();
  2786.         if(pd!=null && pd.getConfigurazioneHandler()!=null) {
  2787.             ConfigurazionePortaHandler confPorta = pd.getConfigurazioneHandler();
  2788.             if(confPorta.getRequest()!=null) {
  2789.                 fillListHandlers(confPorta.getRequest().getPreInList(), list);
  2790.             }
  2791.         }
  2792.         return list;
  2793.     }
  2794.     protected List<String> getInRequestHandlers(PortaDelegata pd) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2795.         List<String> list = new ArrayList<>();
  2796.         if(pd!=null && pd.getConfigurazioneHandler()!=null) {
  2797.             ConfigurazionePortaHandler confPorta = pd.getConfigurazioneHandler();
  2798.             if(confPorta.getRequest()!=null) {
  2799.                 fillListHandlers(confPorta.getRequest().getInList(), list);
  2800.             }
  2801.         }
  2802.         return list;
  2803.     }
  2804.     protected List<String> getInRequestProtocolHandlers(PortaDelegata pd) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2805.         List<String> list = new ArrayList<>();
  2806.         if(pd!=null && pd.getConfigurazioneHandler()!=null) {
  2807.             ConfigurazionePortaHandler confPorta = pd.getConfigurazioneHandler();
  2808.             if(confPorta.getRequest()!=null) {
  2809.                 fillListHandlers(confPorta.getRequest().getInProtocolInfoList(), list);
  2810.             }
  2811.         }
  2812.         return list;
  2813.     }
  2814.     protected List<String> getOutRequestHandlers(PortaDelegata pd) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2815.         List<String> list = new ArrayList<>();
  2816.         if(pd!=null && pd.getConfigurazioneHandler()!=null) {
  2817.             ConfigurazionePortaHandler confPorta = pd.getConfigurazioneHandler();
  2818.             if(confPorta.getRequest()!=null) {
  2819.                 fillListHandlers(confPorta.getRequest().getOutList(), list);
  2820.             }
  2821.         }
  2822.         return list;
  2823.     }
  2824.     protected List<String> getPostOutRequestHandlers(PortaDelegata pd) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2825.         List<String> list = new ArrayList<>();
  2826.         if(pd!=null && pd.getConfigurazioneHandler()!=null) {
  2827.             ConfigurazionePortaHandler confPorta = pd.getConfigurazioneHandler();
  2828.             if(confPorta.getRequest()!=null) {
  2829.                 fillListHandlers(confPorta.getRequest().getPostOutList(), list);
  2830.             }
  2831.         }
  2832.         return list;
  2833.     }
  2834.     protected List<String> getPreInResponseHandlers(PortaDelegata pd) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2835.         List<String> list = new ArrayList<>();
  2836.         if(pd!=null && pd.getConfigurazioneHandler()!=null) {
  2837.             ConfigurazionePortaHandler confPorta = pd.getConfigurazioneHandler();
  2838.             if(confPorta.getResponse()!=null) {
  2839.                 fillListHandlers(confPorta.getResponse().getPreInList(), list);
  2840.             }
  2841.         }
  2842.         return list;
  2843.     }
  2844.     protected List<String> getInResponseHandlers(PortaDelegata pd) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2845.         List<String> list = new ArrayList<>();
  2846.         if(pd!=null && pd.getConfigurazioneHandler()!=null) {
  2847.             ConfigurazionePortaHandler confPorta = pd.getConfigurazioneHandler();
  2848.             if(confPorta.getResponse()!=null) {
  2849.                 fillListHandlers(confPorta.getResponse().getInList(), list);
  2850.             }
  2851.         }
  2852.         return list;
  2853.     }
  2854.     protected List<String> getOutResponseHandlers(PortaDelegata pd) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2855.         List<String> list = new ArrayList<>();
  2856.         if(pd!=null && pd.getConfigurazioneHandler()!=null) {
  2857.             ConfigurazionePortaHandler confPorta = pd.getConfigurazioneHandler();
  2858.             if(confPorta.getResponse()!=null) {
  2859.                 fillListHandlers(confPorta.getResponse().getOutList(), list);
  2860.             }
  2861.         }
  2862.         return list;
  2863.     }
  2864.     protected List<String> getPostOutResponseHandlers(PortaDelegata pd) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2865.         List<String> list = new ArrayList<>();
  2866.         if(pd!=null && pd.getConfigurazioneHandler()!=null) {
  2867.             ConfigurazionePortaHandler confPorta = pd.getConfigurazioneHandler();
  2868.             if(confPorta.getResponse()!=null) {
  2869.                 fillListHandlers(confPorta.getResponse().getPostOutList(), list);
  2870.             }
  2871.         }
  2872.         return list;
  2873.     }

  2875.     protected List<Object> getExtendedInfo(PortaDelegata pd)throws DriverConfigurazioneException{

  2877.         if(pd == null || pd.sizeExtendedInfoList()<=0)
  2878.             return null;

  2880.         return pd.getExtendedInfoList();
  2881.     }

  2883.     protected Template getTemplateTrasformazioneRichiesta(Connection connectionPdD,IDPortaDelegata idPD, String nomeTrasformazione, TrasformazioneRegolaRichiesta richiesta, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2884.         return this.configurazionePdD.getTemplateTrasformazioneRichiesta(connectionPdD, idPD, nomeTrasformazione, richiesta, requestInfo);
  2885.     }
  2886.     protected Template getTemplateTrasformazioneSoapRichiesta(Connection connectionPdD,IDPortaDelegata idPD, String nomeTrasformazione, TrasformazioneRegolaRichiesta richiesta, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2887.         return this.configurazionePdD.getTemplateTrasformazioneSoapRichiesta(connectionPdD, idPD, nomeTrasformazione, richiesta, requestInfo);
  2888.     }
  2889.     protected Template getTemplateTrasformazioneRisposta(Connection connectionPdD,IDPortaDelegata idPD, String nomeTrasformazione, TrasformazioneRegolaRisposta risposta, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2890.         return this.configurazionePdD.getTemplateTrasformazioneRisposta(connectionPdD, idPD, nomeTrasformazione, risposta, requestInfo);
  2891.     }
  2892.     protected Template getTemplateTrasformazioneSoapRisposta(Connection connectionPdD,IDPortaDelegata idPD, String nomeTrasformazione, TrasformazioneRegolaRisposta risposta, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2893.         return this.configurazionePdD.getTemplateTrasformazioneSoapRisposta(connectionPdD, idPD, nomeTrasformazione, risposta, requestInfo);
  2894.     }
  2895.     
  2896.     public Template getTemplateCorrelazioneApplicativaRichiesta(Connection connectionPdD,IDPortaDelegata idPD, String nomeRegola, byte[] template, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2897.         return this.configurazionePdD.getTemplateCorrelazioneApplicativaRichiesta(connectionPdD, idPD, nomeRegola, template, requestInfo);
  2898.     }
  2899.     public Template getTemplateCorrelazioneApplicativaRisposta(Connection connectionPdD,IDPortaDelegata idPD, String nomeRegola, byte[] template, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2900.         return this.configurazionePdD.getTemplateCorrelazioneApplicativaRisposta(connectionPdD, idPD, nomeRegola, template, requestInfo);
  2901.     }
  2902.     
  2903.     protected Template getTemplateIntegrazione(Connection connectionPdD,IDPortaDelegata idPD, File file, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2904.         return this.configurazionePdD.getTemplateIntegrazione(connectionPdD, idPD, file, requestInfo);
  2905.     }











  2917.     /* ********  PORTE APPLICATIVE  (Interfaccia) ******** */

  2919.     public IDPortaApplicativa getIDPortaApplicativa(Connection connectionPdD,String nome) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2920.         return this.configurazionePdD.getIDPortaApplicativa(connectionPdD, nome);
  2921.     }

  2923.     protected Map<IDSoggetto,PortaApplicativa> getPorteApplicativeSoggettiVirtuali(Connection connectionPdD,IDServizio idServizio)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2924.         return this.configurazionePdD.getPorteApplicativeSoggettiVirtuali(connectionPdD,idServizio,null,false);
  2925.     }

  2927.     protected boolean existsPA(Connection connectionPdD,RichiestaApplicativa richiestaApplicativa) throws DriverConfigurazioneException{    

  2929.         // Se non c'e' un servizio non puo' esistere una porta applicativa
  2930.         if(richiestaApplicativa.getIDServizio()==null)
  2931.             return false;
  2932.         if( (richiestaApplicativa.getIDServizio().getNome()==null) || 
  2933.                 (richiestaApplicativa.getIDServizio().getTipo()==null) || 
  2934.                 (richiestaApplicativa.getIDServizio().getVersione()==null)  )
  2935.             return false;

  2937.         if( isSoggettoVirtuale(connectionPdD,richiestaApplicativa.getIDServizio().getSoggettoErogatore())  ){
  2938.             Map<IDSoggetto,PortaApplicativa> paConSoggetti = null;
  2939.             try{
  2940.                 paConSoggetti = this.configurazionePdD.getPorteApplicativeSoggettiVirtuali(connectionPdD,richiestaApplicativa.getIDServizio(),richiestaApplicativa.getFiltroProprietaPorteApplicative(),true);
  2941.             }catch(DriverConfigurazioneNotFound e){
  2942.                 return false;
  2943.             }
  2944.             if( paConSoggetti!=null && paConSoggetti.size()>0)
  2945.                 return true;
  2946.             else
  2947.                 return false;
  2948.         }else{
  2949.             PortaApplicativa pa = null;
  2950.             try{
  2951.                 IDPortaApplicativa idPA = richiestaApplicativa.getIdPortaApplicativa();
  2952.                 if(idPA==null){
  2953.                     return false;
  2954.                 }
  2955.                 pa = this.configurazionePdD.getPortaApplicativa(connectionPdD,idPA);
  2956.             }catch(DriverConfigurazioneNotFound e){
  2957.                 return false;
  2958.             }
  2959.             return pa!=null;
  2960.         }
  2961.     }

  2963.     protected PortaApplicativa getPortaApplicativa(Connection connectionPdD,IDPortaApplicativa idPA) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2964.         if(idPA==null){
  2965.             throw new DriverConfigurazioneException("[getPortaApplicativa]: Parametro non definito (idPA is null)");
  2966.         }
  2967.         return this.configurazionePdD.getPortaApplicativa(connectionPdD,idPA);
  2968.     }

  2970.     protected PortaApplicativa getPortaApplicativaSafeMethod(Connection connectionPdD,IDPortaApplicativa idPA)throws DriverConfigurazioneException{
  2971.         try{
  2972.             if(idPA!=null && idPA.getNome()!=null)
  2973.                 return this.getPortaApplicativa(connectionPdD,idPA);
  2974.             else
  2975.                 return null;
  2976.         }catch(DriverConfigurazioneNotFound e){
  2977.             return null;
  2978.         }
  2979.     }

  2981.     protected void updateStatoPortaApplicativa(Connection connectionPdD,IDPortaApplicativa idPA, StatoFunzionalita stato) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2982.         this.configurazionePdD.updateStatoPortaApplicativa(connectionPdD, idPA, stato);
  2983.     }
  2984.     
  2985.     protected String updateStatoConnettoreMultiplo(Connection connectionPdD,IDPortaApplicativa idPA, String nomeConnettore, StatoFunzionalita stato) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2986.         return this.configurazionePdD.updateStatoConnettoreMultiplo(connectionPdD, idPA, nomeConnettore, stato);
  2987.     }
  2988.     protected String updateStatoConnettoreMultiplo(Connection connectionPdD,IDPortaApplicativa idPA, String nomeConnettore, String user, StatoFunzionalita stato) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2989.         return this.configurazionePdD.updateStatoConnettoreMultiplo(connectionPdD, idPA, nomeConnettore, user, stato);
  2990.     }
  2991.     
  2992.     protected String updateSchedulingConnettoreMultiplo(Connection connectionPdD,IDPortaApplicativa idPA, String nomeConnettore, StatoFunzionalita stato) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2993.         return this.configurazionePdD.updateSchedulingConnettoreMultiplo(connectionPdD, idPA, nomeConnettore, stato);
  2994.     }
  2995.     protected String updateSchedulingConnettoreMultiplo(Connection connectionPdD,IDPortaApplicativa idPA, String nomeConnettore, String user, StatoFunzionalita stato) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2996.         return this.configurazionePdD.updateSchedulingConnettoreMultiplo(connectionPdD, idPA, nomeConnettore, user, stato);
  2997.     }
  2998.     
  2999.     public Map<String, String> getProprietaConfigurazione(PortaApplicativa pa) throws DriverConfigurazioneException {
  3000.         if (pa == null) {
  3001.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3002.         } else if (pa.sizeProprietaList() <= 0) {
  3003.             return null;
  3004.         } else {
  3005.             Map<String, String> properties = new HashMap<>();

  3007.             for(int i = 0; i < pa.sizeProprietaList(); ++i) {
  3008.                 Proprieta p = pa.getProprieta(i);
  3009.                 properties.put(p.getNome(), p.getValore());
  3010.             }

  3012.             return properties;
  3013.         }
  3014.     }
  3015.     
  3016.     protected boolean identificazioneContentBased(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  3017.         if(pa==null){
  3018.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3019.         }
  3020.         if( pa.getAzione() != null  ){
  3021.             if(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_CONTENT_BASED.equals(pa.getAzione().getIdentificazione())){
  3022.                 return true;
  3023.             }else{
  3024.                 return false;
  3025.             }
  3026.         }else
  3027.             return false;
  3028.     }

  3030.     protected boolean identificazioneInputBased(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  3031.         if(pa==null){
  3032.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3033.         }
  3034.         if( pa.getAzione() != null  ){
  3035.             if(CostantiConfigurazione.PORTA_APPLICATIVA_AZIONE_INPUT_BASED.equals(pa.getAzione().getIdentificazione())){
  3036.                 return true;
  3037.             }else{
  3038.                 return false;
  3039.             }
  3040.         }else
  3041.             return false;
  3042.     }

  3044.     protected String getAzione(RegistroServiziManager registroServiziManager,PortaApplicativa pa,URLProtocolContext urlProtocolContext, RequestInfo requestInfo,
  3045.             OpenSPCoop2Message message, OpenSPCoop2MessageSoapStreamReader soapStreamReader, HeaderIntegrazione headerIntegrazione, boolean readFirstHeaderIntegrazione,
  3046.             IProtocolFactory<?> protocolFactory) throws DriverConfigurazioneException, IdentificazioneDinamicaException { 

  3048.         try{

  3050.             if(pa==null){
  3051.                 throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3052.             }
  3053.             IDSoggetto soggettoErogatore = new IDSoggetto(pa.getTipoSoggettoProprietario(),pa.getNomeSoggettoProprietario());
  3054.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pa.getServizio().getTipo(),pa.getServizio().getNome(), 
  3055.                     soggettoErogatore, pa.getServizio().getVersione()); 

  3057.             String azioneHeaderIntegrazione = null;
  3058.             if(headerIntegrazione!=null && headerIntegrazione.getBusta()!=null && headerIntegrazione.getBusta().getAzione()!=null){
  3059.                 azioneHeaderIntegrazione = headerIntegrazione.getBusta().getAzione();
  3060.             }

  3062.             ModalitaIdentificazioneAzione modalitaIdentificazione = ModalitaIdentificazioneAzione.STATIC;
  3063.             String pattern = null;
  3064.             boolean forceRegistryBased = false;
  3065.             boolean forcePluginBased = true; // sulla PA si fa sempre questo controllo?
  3066.             if( pa.getAzione() != null  ){
  3067.                 idServizio.setAzione(pa.getAzione().getNome());
  3068.                 pattern = pa.getAzione().getPattern();
  3069.                 if( pa.getAzione().getIdentificazione() != null  ){
  3070.                     modalitaIdentificazione = ModalitaIdentificazioneAzione.convert(pa.getAzione().getIdentificazione());
  3071.                 }
  3072.                 forceRegistryBased = StatoFunzionalita.ABILITATO.equals(pa.getAzione().getForceInterfaceBased());
  3073.             }

  3075.             OpenSPCoop2Properties op2Properties = OpenSPCoop2Properties.getInstance();
  3076.             
  3077.             boolean bufferMessageReadOnly =  op2Properties.isReadByPathBufferEnabled();
  3078.             
  3079.             boolean rpcAcceptRootElementUnqualified = OpenSPCoop2Properties.getInstance().isValidazioneContenutiApplicativiRpcAcceptRootElementUnqualified();
  3080.             if(pa!=null && pa.getProprietaList()!=null && !pa.getProprietaList().isEmpty()) {
  3081.                 boolean defaultRpcAcceptRootElementUnqualified = rpcAcceptRootElementUnqualified;
  3082.                 rpcAcceptRootElementUnqualified = ValidatoreMessaggiApplicativiRest.readBooleanValueWithDefault(pa.getProprietaList(), CostantiProprieta.VALIDAZIONE_CONTENUTI_PROPERTY_NAME_RPC_ACCEPT_ROOT_ELEMENT_UNQUALIFIED_ENABLED, defaultRpcAcceptRootElementUnqualified);
  3083.             }
  3084.             
  3085.             WSDLValidatorConfig config = new WSDLValidatorConfig();
  3086.             config.setRpcAcceptRootElementUnqualified(rpcAcceptRootElementUnqualified);
  3087.             
  3088.             String azione = OperationFinder.getAzione(registroServiziManager, urlProtocolContext, requestInfo, message, soapStreamReader, soggettoErogatore, idServizio, 
  3089.                     readFirstHeaderIntegrazione, azioneHeaderIntegrazione, protocolFactory, modalitaIdentificazione, 
  3090.                     pattern, forceRegistryBased, forcePluginBased, this.logger, true,
  3091.                     bufferMessageReadOnly, 
  3092.                     headerIntegrazione!=null ? headerIntegrazione.getIdTransazione() : null,
  3093.                     config);

  3095.             // Se non ho riconosciuto una azione a questo punto, 
  3096.             // durante il processo standard di riconoscimento viene sollevata una eccezione IdentificazioneDinamicaException

  3098.             return azione;

  3100.         }catch(IdentificazioneDinamicaException e){
  3101.             throw e;
  3102.         }
  3103.         catch(Exception e){
  3104.             throw new DriverConfigurazioneException(e.getMessage(),e);
  3105.         }

  3107.     }

  3109.     protected String[] getServiziApplicativi(PortaApplicativa pa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  3111.         if(pa==null){
  3112.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3113.         }

  3115.         String[]sa = new String[pa.sizeServizioApplicativoList()];
  3116.         for(int i=0;i<pa.sizeServizioApplicativoList();i++){
  3117.             sa[i] = pa.getServizioApplicativo(i).getNome();
  3118.         }

  3120.         return sa;
  3121.     }

  3123.     protected SoggettoVirtuale getServiziApplicativiSoggettiVirtuali(Connection connectionPdD,RichiestaApplicativa richiestaApplicativa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  3125.         Map<IDSoggetto,PortaApplicativa> paConSoggetti = this.configurazionePdD.getPorteApplicativeSoggettiVirtuali(connectionPdD,richiestaApplicativa.getIDServizio()
  3126.                 ,richiestaApplicativa.getFiltroProprietaPorteApplicative(),true);
  3127.         if(paConSoggetti == null)
  3128.             throw new DriverConfigurazioneNotFound("PorteApplicative contenenti SoggettiVirtuali di ["+richiestaApplicativa.getIDServizio()+"] non trovate");
  3129.         if(paConSoggetti.size() ==0)
  3130.             throw new DriverConfigurazioneNotFound("PorteApplicative contenenti SoggettiVirtuali di ["+richiestaApplicativa.getIDServizio()+"] non trovate");

  3132.         java.util.List<SoggettoVirtualeServizioApplicativo> trovati = new java.util.ArrayList<SoggettoVirtualeServizioApplicativo>();

  3134.         Iterator<IDSoggetto> it = paConSoggetti.keySet().iterator();
  3135.         while (it.hasNext()) {
  3136.             IDSoggetto soggReale = (IDSoggetto) it.next();
  3137.             PortaApplicativa pa = paConSoggetti.get(soggReale);
  3138.             for(int k=0; k<pa.sizeServizioApplicativoList(); k++){

  3140.                 SoggettoVirtualeServizioApplicativo sa = new SoggettoVirtualeServizioApplicativo();
  3141.                 sa.setNomeServizioApplicativo(pa.getServizioApplicativo(k).getNome());
  3142.                 sa.setIdSoggettoReale(soggReale);
  3143.                 sa.setPortaApplicativa(pa);
  3144.                 trovati.add(sa);

  3146.             }
  3147.         }

  3149.         if(trovati.size() == 0)
  3150.             throw new DriverConfigurazioneNotFound("PorteApplicative contenenti SoggettiVirtuali di ["+richiestaApplicativa.getIDServizio()+"] non trovati soggetti virtuali");
  3151.         else{
  3152.             SoggettoVirtuale soggVirtuale = new SoggettoVirtuale();
  3153.             for (SoggettoVirtualeServizioApplicativo soggettoVirtualeServizioApplicativo : trovati) {
  3154.                 soggVirtuale.addServizioApplicativo(soggettoVirtualeServizioApplicativo);
  3155.             }
  3156.             return soggVirtuale;
  3157.         }
  3158.     }

  3160.     protected List<PortaApplicativa> getPorteApplicative(Connection connectionPdD,IDServizio idServizio, boolean ricercaPuntuale) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  3161.         return this.configurazionePdD.getPorteApplicative(connectionPdD, idServizio, ricercaPuntuale);
  3162.     }


  3165.     protected List<PortaApplicativa> getPorteApplicativeVirtuali(Connection connectionPdD,IDSoggetto idSoggettoVirtuale, IDServizio idServizio, boolean ricercaPuntuale) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  3166.         return this.configurazionePdD.getPorteApplicativeVirtuali(connectionPdD, idSoggettoVirtuale, idServizio, ricercaPuntuale);
  3167.     }

  3169.     protected MTOMProcessorConfig getMTOMProcessorForSender(PortaApplicativa pa)throws DriverConfigurazioneException{

  3171.         MTOMProcessorConfig config = new MTOMProcessorConfig();
  3172.         List<MtomXomPackageInfo> list = new ArrayList<MtomXomPackageInfo>();
  3173.         config.setInfo(list);

  3175.         if(pa == null)
  3176.             return config;

  3178.         MtomProcessor mtomProcessor = pa.getMtomProcessor();
  3179.         if(mtomProcessor == null)
  3180.             return config;

  3182.         if(mtomProcessor.getResponseFlow()!=null){
  3183.             MtomProcessorFlow mtomFlow = mtomProcessor.getResponseFlow();
  3184.             config.setMtomProcessorType(mtomFlow.getMode());
  3185.             for(int i=0 ; i<mtomFlow.sizeParameterList() ; i++){
  3186.                 String nome = mtomFlow.getParameter(i).getNome();
  3187.                 if(nome!=null){
  3188.                     MtomXomPackageInfo info = new MtomXomPackageInfo();
  3189.                     info.setName(nome);
  3190.                     info.setXpathExpression(mtomFlow.getParameter(i).getPattern());
  3191.                     info.setContentType(mtomFlow.getParameter(i).getContentType());
  3192.                     info.setRequired(mtomFlow.getParameter(i).getRequired());
  3193.                     list.add(info);
  3194.                 }
  3195.             }
  3196.         }

  3198.         return config;
  3199.     }

  3201.     protected MTOMProcessorConfig getMTOMProcessorForReceiver(PortaApplicativa pa)throws DriverConfigurazioneException{

  3203.         MTOMProcessorConfig config = new MTOMProcessorConfig();
  3204.         List<MtomXomPackageInfo> list = new ArrayList<MtomXomPackageInfo>();
  3205.         config.setInfo(list);

  3207.         if(pa == null)
  3208.             return config;

  3210.         MtomProcessor mtomProcessor = pa.getMtomProcessor();
  3211.         if(mtomProcessor == null)
  3212.             return config;

  3214.         if(mtomProcessor.getRequestFlow()!=null){
  3215.             MtomProcessorFlow mtomFlow = mtomProcessor.getRequestFlow();
  3216.             config.setMtomProcessorType(mtomFlow.getMode());
  3217.             for(int i=0 ; i<mtomFlow.sizeParameterList() ; i++){
  3218.                 String nome = mtomFlow.getParameter(i).getNome();
  3219.                 if(nome!=null){
  3220.                     MtomXomPackageInfo info = new MtomXomPackageInfo();
  3221.                     info.setName(nome);
  3222.                     info.setXpathExpression(mtomFlow.getParameter(i).getPattern());
  3223.                     info.setContentType(mtomFlow.getParameter(i).getContentType());
  3224.                     info.setRequired(mtomFlow.getParameter(i).getRequired());
  3225.                     list.add(info);
  3226.                 }
  3227.             }
  3228.         }

  3230.         return config; 
  3231.     }

  3233.     protected MessageSecurityConfig getMessageSecurityForSender(PortaApplicativa pa)throws DriverConfigurazioneException{

  3235.         MessageSecurityConfig securityConfig = new MessageSecurityConfig();
  3236.         java.util.Map<String,Object> table = new java.util.HashMap<>();
  3237.         securityConfig.setFlowParameters(table);

  3239.         if(pa == null)
  3240.             return securityConfig;

  3242.         if(pa.getStatoMessageSecurity()!=null && CostantiConfigurazione.DISABILITATO.toString().equals(pa.getStatoMessageSecurity())){
  3243.             return securityConfig;
  3244.         }

  3246.         MessageSecurity messageSecurity = pa.getMessageSecurity();
  3247.         if(messageSecurity == null)
  3248.             return securityConfig;

  3250.         if(messageSecurity.getResponseFlow()!=null){
  3251.             MessageSecurityFlow securityFlow = messageSecurity.getResponseFlow();
  3252.             if(securityFlow.getApplyToMtom()!=null){
  3253.                 securityConfig.setApplyToMtom(StatoFunzionalita.ABILITATO.equals(securityFlow.getApplyToMtom()));
  3254.             }
  3255.             for(int i=0 ; i<securityFlow.sizeParameterList() ; i++){
  3256.                 String nome = securityFlow.getParameter(i).getNome();
  3257.                 if(nome!=null){
  3258.                     String valore = securityFlow.getParameter(i).getValore();
  3259.                     if("actor".equals(nome)){
  3260.                         // patch per header senza actor (dove non si vuole che venga assunto il default=openspcoop)
  3261.                         if(valore == null)
  3262.                             valore = "";
  3263.                         else if("notDefined".equals(valore)){
  3264.                             valore = "";
  3265.                         }
  3266.                     }
  3267.                     table.put(nome,valore);
  3268.                 }
  3269.             }
  3270.         }

  3272.         return securityConfig;
  3273.     }

  3275.     protected MessageSecurityConfig getMessageSecurityForReceiver(PortaApplicativa pa)throws DriverConfigurazioneException{

  3277.         MessageSecurityConfig securityConfig = new MessageSecurityConfig();
  3278.         java.util.Map<String,Object> table = new java.util.HashMap<>();
  3279.         securityConfig.setFlowParameters(table);

  3281.         if(pa == null)
  3282.             return securityConfig;

  3284.         if(pa.getStatoMessageSecurity()!=null && CostantiConfigurazione.DISABILITATO.toString().equals(pa.getStatoMessageSecurity())){
  3285.             return securityConfig;
  3286.         }

  3288.         MessageSecurity messageSecurity = pa.getMessageSecurity();
  3289.         if(messageSecurity == null)
  3290.             return securityConfig;

  3292.         if(messageSecurity.getRequestFlow()!=null){
  3293.             MessageSecurityFlow securityFlow = messageSecurity.getRequestFlow();
  3294.             if(securityFlow.getApplyToMtom()!=null){
  3295.                 securityConfig.setApplyToMtom(StatoFunzionalita.ABILITATO.equals(securityFlow.getApplyToMtom()));
  3296.             }
  3297.             for(int i=0 ; i<securityFlow.sizeParameterList() ; i++){
  3298.                 String nome = securityFlow.getParameter(i).getNome();
  3299.                 if(nome!=null){
  3300.                     String valore = securityFlow.getParameter(i).getValore();
  3301.                     if("actor".equals(nome)){
  3302.                         // patch per header senza actor (dove non si vuole che venga assunto il default=openspcoop)
  3303.                         if(valore == null)
  3304.                             valore = "";
  3305.                         else if("notDefined".equals(valore)){
  3306.                             valore = "";
  3307.                         }
  3308.                     }
  3309.                     table.put(nome,valore);
  3310.                 }
  3311.             }
  3312.         }

  3314.         return securityConfig; 
  3315.     }


  3318.     protected String getAutenticazione(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  3320.         if(pa==null){
  3321.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3322.         }

  3324.         if(pa.getAutenticazione() == null || "".equals(pa.getAutenticazione()))
  3325.             return CostantiConfigurazione.CREDENZIALE_SSL.toString();
  3326.         else
  3327.             return pa.getAutenticazione();
  3328.     }

  3330.     protected boolean isAutenticazioneOpzionale(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  3332.         if(pa==null){
  3333.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3334.         }

  3336.         if(pa.getAutenticazioneOpzionale() == null)
  3337.             return false;
  3338.         else{
  3339.             if(StatoFunzionalita.ABILITATO.equals(pa.getAutenticazioneOpzionale())){
  3340.                 return true;
  3341.             }
  3342.             else if(StatoFunzionalita.DISABILITATO.equals(pa.getAutenticazioneOpzionale())){
  3343.                 return false;
  3344.             }
  3345.             else{
  3346.                 return false;
  3347.             }
  3348.         }

  3350.     }

  3352.     protected String getGestioneToken(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  3354.         if(pa==null){
  3355.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3356.         }

  3358.         if(pa.getGestioneToken()!=null && pa.getGestioneToken().getPolicy()!=null) {
  3359.             return pa.getGestioneToken().getPolicy();
  3360.         }
  3361.         return null;
  3362.     }

  3364.     protected PolicyGestioneToken getPolicyGestioneToken(Connection connectionPdD, PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  3366.         if(pa==null){
  3367.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3368.         }

  3370.         if(pa.getGestioneToken()==null || pa.getGestioneToken().getPolicy()==null) {
  3371.             throw new DriverConfigurazioneException("Porta Applicativa senza una policy di gestione token");
  3372.         }

  3374.         GenericProperties gp = this.getGenericProperties(connectionPdD, org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA, pa.getGestioneToken().getPolicy());

  3376.         PolicyGestioneToken policy = null;
  3377.         try {
  3378.             policy = TokenUtilities.convertTo(gp, pa.getGestioneToken());
  3379.         }catch(Exception e) {
  3380.             throw new DriverConfigurazioneException(e.getMessage(),e);
  3381.         }

  3383.         return policy;
  3384.     }

  3386.     protected String getAutorizzazione(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  3388.         if(pa==null){
  3389.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3390.         }

  3392.         if(pa.getAutorizzazione() == null || "".equals(pa.getAutorizzazione()) )
  3393.             return CostantiConfigurazione.AUTORIZZAZIONE_AUTHENTICATED;
  3394.         else
  3395.             return pa.getAutorizzazione();
  3396.     }

  3398.     protected String getAutorizzazioneContenuto(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  3400.         if(pa==null){
  3401.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3402.         }

  3404.         if(pa.getAutorizzazioneContenuto() == null || "".equals(pa.getAutorizzazioneContenuto()))
  3405.             return CostantiConfigurazione.NONE;
  3406.         else
  3407.             return pa.getAutorizzazioneContenuto();
  3408.     }

  3410.     public CorsConfigurazione getConfigurazioneCORS(Connection connectionPdD, PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  3412.         if(pa==null){
  3413.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3414.         }

  3416.         CorsConfigurazione cors = pa.getGestioneCors();
  3417.         if(cors==null) {
  3418.             cors = this.getConfigurazioneCORS(connectionPdD);
  3419.         }
  3420.         return cors;
  3421.     }

  3423.     public ResponseCachingConfigurazione getConfigurazioneResponseCaching(Connection connectionPdD, PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  3425.         if(pa==null){
  3426.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3427.         }

  3429.         ResponseCachingConfigurazione c = pa.getResponseCaching();
  3430.         if(c==null) {
  3431.             c = this.getConfigurazioneResponseCaching(connectionPdD);
  3432.         }
  3433.         return c;
  3434.     }

  3436.     protected boolean ricevutaAsincronaSimmetricaAbilitata(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  3437.         if(pa==null)
  3438.             return true; // default Abilitata-CNIPA
  3439.         return !CostantiConfigurazione.DISABILITATO.equals(pa.getRicevutaAsincronaSimmetrica());
  3440.     }

  3442.     protected boolean ricevutaAsincronaAsimmetricaAbilitata(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  3443.         if(pa==null)
  3444.             return true; // default Abilitata-CNIPA
  3445.         return !CostantiConfigurazione.DISABILITATO.equals(pa.getRicevutaAsincronaAsimmetrica());
  3446.     }

  3448.     protected ValidazioneContenutiApplicativi getTipoValidazioneContenutoApplicativo(Connection connectionPdD, PortaApplicativa pa,String implementazionePdDSoggetto, boolean request) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  3450.         // default in configurazione
  3451.         ValidazioneContenutiApplicativi val = this.getTipoValidazioneContenutoApplicativo(connectionPdD,implementazionePdDSoggetto);

  3453.         if( pa==null || pa.getValidazioneContenutiApplicativi() == null ){
  3454.             return val;
  3455.         }

  3457.         ValidazioneContenutiApplicativi valPA = new ValidazioneContenutiApplicativi();

  3459.         if( CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.equals(pa.getValidazioneContenutiApplicativi().getStato())  )
  3460.             valPA.setStato(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO);
  3461.         else if( CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(pa.getValidazioneContenutiApplicativi().getStato())  )
  3462.             valPA.setStato(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY);
  3463.         else if( CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO.equals(pa.getValidazioneContenutiApplicativi().getStato())  )
  3464.             valPA.setStato(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO);

  3466.         if( CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP.equals(pa.getValidazioneContenutiApplicativi().getTipo())  )
  3467.             valPA.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP);
  3468.         else if( CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(pa.getValidazioneContenutiApplicativi().getTipo())  )
  3469.             valPA.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE);
  3470.         else if( CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD.equals(pa.getValidazioneContenutiApplicativi().getTipo())  )
  3471.             valPA.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD);

  3473.         if( CostantiConfigurazione.ABILITATO.equals(pa.getValidazioneContenutiApplicativi().getAcceptMtomMessage())  )
  3474.             valPA.setAcceptMtomMessage(CostantiConfigurazione.ABILITATO);
  3475.         else if( CostantiConfigurazione.DISABILITATO.equals(pa.getValidazioneContenutiApplicativi().getAcceptMtomMessage())  )
  3476.             valPA.setAcceptMtomMessage(CostantiConfigurazione.DISABILITATO);

  3478.         refreshByProperties(pa.getProprietaList(), request, valPA);
  3479.         
  3480.         return valPA;
  3481.     }

  3483.     protected CorrelazioneApplicativa getCorrelazioneApplicativa(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  3484.         if(pa==null){
  3485.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3486.         }
  3487.         return pa.getCorrelazioneApplicativa();

  3489.     }

  3491.     protected CorrelazioneApplicativaRisposta getCorrelazioneApplicativaRisposta(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  3492.         if(pa==null){
  3493.             throw new DriverConfigurazioneException("Porta Applicativa non fornita");
  3494.         }
  3495.         return pa.getCorrelazioneApplicativaRisposta();

  3497.     }

  3499.     protected String[] getTipiIntegrazione(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound { 

  3501.         String[]tipi = null;
  3502.         if(pa!=null){
  3503.             if(pa.getIntegrazione() != null && ("".equals(pa.getIntegrazione())==false) ){
  3504.                 tipi = pa.getIntegrazione().trim().split(",");
  3505.             }  
  3506.         }

  3508.         return tipi;
  3509.     }

  3511.     protected boolean isGestioneManifestAttachments(Connection connectionPdD, PortaApplicativa pa, IProtocolFactory<?> protocolFactory) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  3513.         if(pa==null){
  3514.             try{
  3515.                 if(protocolFactory.createProtocolConfiguration().isSupportato(ServiceBinding.SOAP,FunzionalitaProtocollo.MANIFEST_ATTACHMENTS)){
  3516.                     // Bug: 286: devo usare il default della configurazione SOLO SE il protocollo lo supporta.
  3517.                     return this.isGestioneManifestAttachments(connectionPdD); //configurazione di default
  3518.                 }
  3519.                 else{
  3520.                     return false;
  3521.                 }
  3522.             }catch(Exception e){
  3523.                 throw new DriverConfigurazioneException(e.getMessage(),e);
  3524.             }
  3525.         }

  3527.         if( CostantiConfigurazione.ABILITATO.equals(pa.getGestioneManifest())  ){
  3528.             return true;
  3529.         }else if( CostantiConfigurazione.DISABILITATO.equals(pa.getGestioneManifest())  ){
  3530.             return false;
  3531.         }else {
  3532.             try{
  3533.                 if(protocolFactory.createProtocolConfiguration().isSupportato(ServiceBinding.SOAP,FunzionalitaProtocollo.MANIFEST_ATTACHMENTS)){
  3534.                     // Bug: 286: devo usare il default della configurazione SOLO SE il protocollo lo supporta.
  3535.                     return this.isGestioneManifestAttachments(connectionPdD); //configurazione di default
  3536.                 }
  3537.                 else{
  3538.                     return false;
  3539.                 }
  3540.             }catch(Exception e){
  3541.                 throw new DriverConfigurazioneException(e.getMessage(),e);
  3542.             }
  3543.         }
  3544.     }

  3546.     protected boolean isAllegaBody(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  3548.         if(pa==null)
  3549.             return false; //configurazione di default
  3550.         if( CostantiConfigurazione.ABILITATO.equals(pa.getAllegaBody())  )
  3551.             return true;
  3552.         else if( CostantiConfigurazione.DISABILITATO.equals(pa.getAllegaBody())  )
  3553.             return false;
  3554.         else 
  3555.             return false; //configurazione di default
  3556.     }

  3558.     protected boolean isScartaBody(PortaApplicativa pa) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  3560.         if(pa==null){
  3561.             return false; //configurazione di default
  3562.         }

  3564.         if( CostantiConfigurazione.ABILITATO.equals(pa.getScartaBody())  )
  3565.             return true;
  3566.         else if( CostantiConfigurazione.DISABILITATO.equals(pa.getScartaBody())  )
  3567.             return false;
  3568.         else 
  3569.             return false; //configurazione di default
  3570.     }

  3572.     protected boolean isModalitaStateless(PortaApplicativa pa, ProfiloDiCollaborazione profiloCollaborazione) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{

  3574.         if(this.serverJ2EE==false){
  3575.             // Stateless obbligatorio in server di tipo web (non j2ee)
  3576.             return true;
  3577.         }

  3579.         if(pa==null){
  3580.             //configurazione di default
  3581.             if(ProfiloDiCollaborazione.ONEWAY.equals(profiloCollaborazione))
  3582.                 return CostantiConfigurazione.ABILITATO.equals(this.openspcoopProperties.getStatelessOneWay());
  3583.             else if(ProfiloDiCollaborazione.SINCRONO.equals(profiloCollaborazione))
  3584.                 return CostantiConfigurazione.ABILITATO.equals(this.openspcoopProperties.getStatelessSincrono());
  3585.             else
  3586.                 return CostantiConfigurazione.ABILITATO.equals(this.openspcoopProperties.getStatelessAsincroni()); 
  3587.         }

  3589.         if( CostantiConfigurazione.ABILITATO.equals(pa.getStateless())  )
  3590.             return true;
  3591.         else if( CostantiConfigurazione.DISABILITATO.equals(pa.getStateless())  )
  3592.             return false;
  3593.         else {
  3594.             //configurazione di default
  3595.             if(ProfiloDiCollaborazione.ONEWAY.equals(profiloCollaborazione))
  3596.                 return CostantiConfigurazione.ABILITATO.equals(this.openspcoopProperties.getStatelessOneWay());
  3597.             else if(ProfiloDiCollaborazione.SINCRONO.equals(profiloCollaborazione))
  3598.                 return CostantiConfigurazione.ABILITATO.equals(this.openspcoopProperties.getStatelessSincrono());
  3599.             else
  3600.                 return CostantiConfigurazione.ABILITATO.equals(this.openspcoopProperties.getStatelessAsincroni()); 
  3601.         }
  3602.     }

  3604.     protected boolean autorizzazione(PortaApplicativa pa, IDSoggetto soggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 
  3605.         if( (pa == null) || (pa.getSoggetti()==null) )
  3606.             return false;
  3607.         if( (soggetto == null) || (soggetto.getTipo()==null) || (soggetto.getNome()==null) )
  3608.             return false;

  3610.         for(int j=0; j<pa.getSoggetti().sizeSoggettoList(); j++){
  3611.             if(soggetto.getTipo().equals(pa.getSoggetti().getSoggetto(j).getTipo()) &&
  3612.                     soggetto.getNome().equals(pa.getSoggetti().getSoggetto(j).getNome())) {
  3613.                 return true;
  3614.             }
  3615.         }

  3617.         return false;
  3618.     }

  3620.     protected boolean autorizzazione(PortaApplicativa pa, IDServizioApplicativo servizioApplicativo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 
  3621.         if( (pa == null) || (pa.getServiziApplicativiAutorizzati()==null) )
  3622.             return false;
  3623.         if( (servizioApplicativo == null) || (servizioApplicativo.getNome()==null) || 
  3624.                 (servizioApplicativo.getIdSoggettoProprietario()==null) ||
  3625.                 (servizioApplicativo.getIdSoggettoProprietario().getTipo()==null) ||
  3626.                 (servizioApplicativo.getIdSoggettoProprietario().getNome()==null) )
  3627.             return false;

  3629.         for(int j=0; j<pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList(); j++){
  3630.             if(servizioApplicativo.getNome().equals(pa.getServiziApplicativiAutorizzati().getServizioApplicativo(j).getNome()) &&
  3631.                     servizioApplicativo.getIdSoggettoProprietario().getTipo().equals(pa.getServiziApplicativiAutorizzati().getServizioApplicativo(j).getTipoSoggettoProprietario()) &&
  3632.                     servizioApplicativo.getIdSoggettoProprietario().getNome().equals(pa.getServiziApplicativiAutorizzati().getServizioApplicativo(j).getNomeSoggettoProprietario())) {
  3633.                 return true;
  3634.             }
  3635.         }

  3637.         return false;
  3638.     }

  3640.     protected boolean autorizzazioneTrasportoRoles(RegistroServiziManager registroServiziManager, 
  3641.             PortaApplicativa pa, org.openspcoop2.core.registry.Soggetto soggetto, ServizioApplicativo sa, InfoConnettoreIngresso infoConnettoreIngresso,
  3642.             PdDContext pddContext, RequestInfo requestInfo,
  3643.             boolean checkRuoloRegistro, boolean checkRuoloEsterno,
  3644.             StringBuilder details) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  3646.         if( (pa == null) || pa.getRuoli()==null || pa.getRuoli().sizeRuoloList()<=0 ){
  3647.             throw new DriverConfigurazioneNotFound("Non sono stati definiti i ruoli necessari a fruire della porta applicativa");
  3648.         }

  3650.         if(checkRuoloRegistro && !checkRuoloEsterno){
  3651.             if(soggetto==null && sa==null){
  3652.                 throw new DriverConfigurazioneException("Identità soggetto e/o applicativo non disponibile; tale informazione è richiesta dall'autorizzazione");
  3653.             }
  3654.         }

  3656.         return _autorizzazioneRoles(registroServiziManager,
  3657.                 soggetto, sa, 
  3658.                 infoConnettoreIngresso, true,
  3659.                 pddContext, requestInfo,
  3660.                 checkRuoloRegistro, checkRuoloEsterno,
  3661.                 details,
  3662.                 pa.getRuoli().getMatch(), pa.getRuoli(),
  3663.                 false);
  3664.     }
  3665.     
  3666.     protected boolean autorizzazioneTokenRoles(RegistroServiziManager registroServiziManager, 
  3667.             PortaApplicativa pa, ServizioApplicativo sa, InfoConnettoreIngresso infoConnettoreIngresso,
  3668.             PdDContext pddContext,  RequestInfo requestInfo,
  3669.             boolean checkRuoloRegistro, boolean checkRuoloEsterno,
  3670.             StringBuilder details) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  3672.         if( (pa == null) || (pa.getAutorizzazioneToken()==null) || 
  3673.                 pa.getAutorizzazioneToken().getRuoli()==null || 
  3674.                 pa.getAutorizzazioneToken().getRuoli().sizeRuoloList()<=0 ){
  3675.             throw new DriverConfigurazioneNotFound("Non sono stati definiti i ruoli necessari a fruire della porta applicativa");
  3676.         }

  3678.         if(checkRuoloRegistro && !checkRuoloEsterno){
  3679.             if(sa==null){
  3680.                 throw new DriverConfigurazioneException("Identità soggetto e/o applicativo non disponibile; tale informazione è richiesta dall'autorizzazione");
  3681.             }
  3682.         }

  3684.         return _autorizzazioneRoles(registroServiziManager,
  3685.                 null, sa, 
  3686.                 infoConnettoreIngresso, true,
  3687.                 pddContext, requestInfo,
  3688.                 checkRuoloRegistro, checkRuoloEsterno,
  3689.                 details,
  3690.                 pa.getAutorizzazioneToken().getRuoli().getMatch(), pa.getAutorizzazioneToken().getRuoli(),
  3691.                 false);
  3692.     }
  3693.     
  3694.     public static boolean _autorizzazioneRoles(RegistroServiziManager registroServiziManager,
  3695.             org.openspcoop2.core.registry.Soggetto soggetto, ServizioApplicativo sa, 
  3696.             InfoConnettoreIngresso infoConnettoreIngresso, boolean readInfoConnettoreIngresso,
  3697.             Context pddContext, RequestInfo requestInfo,
  3698.             boolean checkRuoloRegistro, boolean checkRuoloEsterno,
  3699.             StringBuilder details,
  3700.             RuoloTipoMatch ruoloMatch, AutorizzazioneRuoli autorizzazioneRuoli,
  3701.             boolean modiCheck) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  3703.         HttpServletRequest httpServletRequest = null;
  3704.         List<String> tokenRoles = null;
  3705.         if(checkRuoloEsterno){

  3707.             InformazioniToken informazioniTokenNormalizzate = null;
  3708.             Object oInformazioniTokenNormalizzate = pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  3709.             if(oInformazioniTokenNormalizzate!=null) {
  3710.                 informazioniTokenNormalizzate = (InformazioniToken) oInformazioniTokenNormalizzate;
  3711.             }
  3712.             if(informazioniTokenNormalizzate!=null) {
  3713.                 tokenRoles = informazioniTokenNormalizzate.getRoles();
  3714.             }

  3716.             if(readInfoConnettoreIngresso) {
  3717.                 if(infoConnettoreIngresso==null ||
  3718.                         infoConnettoreIngresso.getUrlProtocolContext()==null ||
  3719.                         infoConnettoreIngresso.getUrlProtocolContext().getHttpServletRequest()==null){
  3720.                     if(tokenRoles==null) {
  3721.                         throw new DriverConfigurazioneException("HttpServletRequest non disponibile; risorsa richiesta dall'autorizzazione");
  3722.                     }
  3723.                 }
  3724.                 if(infoConnettoreIngresso!=null && infoConnettoreIngresso.getUrlProtocolContext()!=null) {
  3725.                     httpServletRequest = infoConnettoreIngresso.getUrlProtocolContext().getHttpServletRequest();
  3726.                 }
  3727.             }
  3728.         }

  3730.         if(ruoloMatch==null){
  3731.             ruoloMatch = RuoloTipoMatch.ALL;
  3732.         }

  3734.         String searchIn = "";
  3735.         if(checkRuoloRegistro) {
  3736.             if(sa!=null) {
  3737.                 try {
  3738.                     if(modiCheck) {
  3739.                         searchIn = " nell'applicativo";
  3740.                     }
  3741.                     else {
  3742.                         searchIn = " in application '"+sa.getNome()+NamingUtils.LABEL_DOMINIO+NamingUtils.getLabelSoggetto(new IDSoggetto(sa.getTipoSoggettoProprietario(), sa.getNomeSoggettoProprietario()))+"'";
  3743.                     }
  3744.                 }catch(Exception t) {}
  3745.             }
  3746.         }
  3747.         if(checkRuoloEsterno) {
  3748.             if(checkRuoloRegistro && sa!=null) {
  3749.                 if(modiCheck) {
  3750.                     searchIn = searchIn + " e";
  3751.                 }
  3752.                 else {
  3753.                     searchIn = searchIn + " and";
  3754.                 }
  3755.             }
  3756.             if(modiCheck) {
  3757.                 searchIn = searchIn + " nel contesto della richiesta";
  3758.             }
  3759.             else {
  3760.                 searchIn = searchIn + " in request context";
  3761.             }
  3762.         }
  3763.         
  3764.         for(int j=0; j<autorizzazioneRuoli.sizeRuoloList(); j++){
  3765.             Ruolo ruolo = autorizzazioneRuoli.getRuolo(j);

  3767.             boolean trovato = false;

  3769.             if(checkRuoloRegistro) {
  3770.                 if(sa!=null) {
  3771.                     if(sa.getInvocazionePorta()!=null && sa.getInvocazionePorta().getRuoli()!=null){
  3772.                         ServizioApplicativoRuoli ruoliSA = sa.getInvocazionePorta().getRuoli();
  3773.                         for (int i = 0; i < ruoliSA.sizeRuoloList(); i++) {
  3774.                             if(ruolo.getNome().equals(ruoliSA.getRuolo(i).getNome())){
  3775.                                 trovato = true;
  3776.                                 break;
  3777.                             }
  3778.                         }
  3779.                     }
  3780.                 }
  3781.                 else if(soggetto!=null) {
  3782.                     if(soggetto.getRuoli()!=null){
  3783.                         RuoliSoggetto ruoliSoggetto = soggetto.getRuoli();
  3784.                         for (int i = 0; i < ruoliSoggetto.sizeRuoloList(); i++) {
  3785.                             if(ruolo.getNome().equals(ruoliSoggetto.getRuolo(i).getNome())){
  3786.                                 trovato = true;
  3787.                                 break;
  3788.                             }
  3789.                         }
  3790.                     }
  3791.                 }
  3792.             }

  3794.             if(!trovato && checkRuoloEsterno){
  3795.                 String nomeRuoloDaVerificare = ruolo.getNome();
  3796.                 try {
  3797.                     org.openspcoop2.core.registry.Ruolo ruoloRegistro = registroServiziManager.getRuolo(ruolo.getNome(), null, requestInfo);
  3798.                     if( (RuoloTipologia.ESTERNO.equals(ruoloRegistro.getTipologia()) || RuoloTipologia.QUALSIASI.equals(ruoloRegistro.getTipologia())) &&
  3799.                             ruoloRegistro.getNomeEsterno()!=null && 
  3800.                             !"".equals(ruoloRegistro.getNomeEsterno())) {
  3801.                         nomeRuoloDaVerificare = ruoloRegistro.getNomeEsterno();
  3802.                     }
  3803.                 }catch(Exception e) {
  3804.                     throw new DriverConfigurazioneException("Recupero del ruolo '"+ruolo.getNome()+"' fallito: "+e.getMessage(),e);
  3805.                 }
  3806.                 boolean foundInHttpServlet = false;
  3807.                 boolean foundInToken = false;
  3808.                 if(httpServletRequest!=null) {
  3809.                     foundInHttpServlet = httpServletRequest.isUserInRole(nomeRuoloDaVerificare);
  3810.                 }
  3811.                 if(tokenRoles!=null && tokenRoles.size()>0) {
  3812.                     foundInToken = tokenRoles.contains(nomeRuoloDaVerificare); 
  3813.                 }
  3814.                 if(foundInHttpServlet || foundInToken){
  3815.                     trovato = true;
  3816.                 }
  3817.             }

  3819.             if(trovato){
  3820.                 if(RuoloTipoMatch.ANY.equals(ruoloMatch)){
  3821.                     return true; // basta un ruolo
  3822.                 }
  3823.             }
  3824.             else{
  3825.                 if(RuoloTipoMatch.ALL.equals(ruoloMatch)){
  3826.                     if(details!=null) {
  3827.                         if(modiCheck) {
  3828.                             details.append("Ruolo '"+ruolo.getNome()+"' non trovato").append(searchIn);
  3829.                         }
  3830.                         else {
  3831.                             details.append("Role '"+ruolo.getNome()+"' not found").append(searchIn);
  3832.                         }
  3833.                     }
  3834.                     return false; // deve possedere tutti i ruoli
  3835.                 }
  3836.             }
  3837.         }

  3839.         if(RuoloTipoMatch.ANY.equals(ruoloMatch)){
  3840.             if(details!=null) {
  3841.                 if(modiCheck) {
  3842.                     details.append("Ruoli non trovati").append(searchIn);
  3843.                 }
  3844.                 else {
  3845.                     details.append("Roles not found").append(searchIn);
  3846.                 }
  3847.             }
  3848.             return false; // non è stato trovato alcun ruolo
  3849.         }
  3850.         else{
  3851.             return true; // tutti i ruoli trovati
  3852.         }

  3854.     }

  3856.     protected boolean isPortaAbilitata(PortaApplicativa pa) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{

  3858.         if(pa==null){
  3859.             //configurazione di default
  3860.             return true; 
  3861.         }

  3863.         if( CostantiConfigurazione.ABILITATO.equals(pa.getStato())  )
  3864.             return true;
  3865.         else if( CostantiConfigurazione.DISABILITATO.equals(pa.getStato())  )
  3866.             return false;
  3867.         else {
  3868.             //configurazione di default
  3869.             return true; 
  3870.         }
  3871.     }

  3873.     protected DumpConfigurazione getDumpConfigurazione(Connection connectionPdD,PortaApplicativa pa) throws DriverConfigurazioneException{
  3874.         if(pa==null){
  3875.             //configurazione di default
  3876.             return getDumpConfigurazionePortaApplicativa(connectionPdD);
  3877.         }

  3879.         if(pa.getDump()!=null) {
  3880.             return pa.getDump();
  3881.         }
  3882.         else {
  3883.             //configurazione di default
  3884.             return getDumpConfigurazionePortaApplicativa(connectionPdD);
  3885.         }
  3886.     }

  3888.     protected boolean isTransazioniFileTraceEnabled(Connection connectionPdD,PortaApplicativa pa) throws DriverConfigurazioneException{
  3889.         
  3890.         boolean defaultValue = this.openspcoopProperties.isTransazioniFileTraceEnabled();
  3891.         if(pa==null){
  3892.             //configurazione di default
  3893.             return defaultValue;
  3894.         }
  3895.         try {
  3896.             return CostantiProprieta.isFileTraceEnabled(pa.getProprietaList(), defaultValue);
  3897.         }catch(Exception e) {
  3898.             throw new DriverConfigurazioneException(e.getMessage(),e);
  3899.         }

  3901.     }
  3902.     
  3903.     protected boolean isTransazioniFileTraceDumpBinarioHeadersEnabled(Connection connectionPdD,PortaApplicativa pa) throws DriverConfigurazioneException{
  3904.         
  3905.         boolean defaultValue = this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPAEnabled() && this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPAHeadersEnabled();
  3906.         if(pa==null){
  3907.             //configurazione di default
  3908.             return defaultValue;
  3909.         }
  3910.         try {
  3911.             return CostantiProprieta.isFileTraceDumpBinarioHeadersEnabled(pa.getProprietaList(), defaultValue);
  3912.         }catch(Exception e) {
  3913.             throw new DriverConfigurazioneException(e.getMessage(),e);
  3914.         }

  3916.     }
  3917.     protected boolean isTransazioniFileTraceDumpBinarioPayloadEnabled(Connection connectionPdD,PortaApplicativa pa) throws DriverConfigurazioneException{
  3918.         
  3919.         boolean defaultValue = this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPAEnabled() && this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPAPayloadEnabled();
  3920.         if(pa==null){
  3921.             //configurazione di default
  3922.             return defaultValue;
  3923.         }
  3924.         try {
  3925.             return CostantiProprieta.isFileTraceDumpBinarioPayloadEnabled(pa.getProprietaList(), defaultValue);
  3926.         }catch(Exception e) {
  3927.             throw new DriverConfigurazioneException(e.getMessage(),e);
  3928.         }

  3930.     }

  3932.     protected boolean isTransazioniFileTraceDumpBinarioConnettoreHeadersEnabled(Connection connectionPdD,PortaApplicativa pa) throws DriverConfigurazioneException{
  3933.     
  3934.         boolean defaultValue = this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled() && this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPAConnettoreHeadersEnabled();
  3935.         if(pa==null){
  3936.             //configurazione di default
  3937.             return defaultValue;
  3938.         }
  3939.         try {
  3940.             return CostantiProprieta.isFileTraceDumpBinarioConnettoreHeadersEnabled(pa.getProprietaList(), defaultValue);
  3941.         }catch(Exception e) {
  3942.             throw new DriverConfigurazioneException(e.getMessage(),e);
  3943.         }

  3945.     }
  3946.     protected boolean isTransazioniFileTraceDumpBinarioConnettorePayloadEnabled(Connection connectionPdD,PortaApplicativa pa) throws DriverConfigurazioneException{
  3947.         
  3948.         boolean defaultValue = this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPAConnettoreEnabled() && this.openspcoopProperties.isTransazioniFileTraceDumpBinarioPAConnettorePayloadEnabled();
  3949.         if(pa==null){
  3950.             //configurazione di default
  3951.             return defaultValue;
  3952.         }
  3953.         try {
  3954.             return CostantiProprieta.isFileTraceDumpBinarioConnettorePayloadEnabled(pa.getProprietaList(), defaultValue);
  3955.         }catch(Exception e) {
  3956.             throw new DriverConfigurazioneException(e.getMessage(),e);
  3957.         }

  3959.     }
  3960.     
  3961.     protected File getFileTraceConfig(Connection connectionPdD,PortaApplicativa pa) throws DriverConfigurazioneException{

  3963.         try {
  3964.             File defaultValue = this.openspcoopProperties.getTransazioniFileTraceConfig();
  3965.             if(pa==null){
  3966.                 //configurazione di default
  3967.                 return defaultValue;
  3968.             }
  3969.             return CostantiProprieta.getFileTraceConfig(pa.getProprietaList(), defaultValue);
  3970.         }catch(Exception e) {
  3971.             throw new DriverConfigurazioneException(e.getMessage(),e);
  3972.         }

  3974.     }
  3975.     
  3976.     protected SoglieDimensioneMessaggi getSoglieLimitedInputStream(Connection connectionPdD,PortaApplicativa pa, String azione, String idModulo,
  3977.             PdDContext pddContext, RequestInfo requestInfo,
  3978.             IProtocolFactory<?> protocolFactory, Logger log) throws DriverConfigurazioneException{
  3979.         
  3980.         if(!this.openspcoopProperties.isControlloTrafficoEnabled()){
  3981.             return null;
  3982.         }
  3983.         
  3984.         URLProtocolContext urlProtocolContext = null;
  3985.         if(requestInfo!=null) {
  3986.             urlProtocolContext = requestInfo.getProtocolContext();
  3987.         }
  3988.         
  3989.         TipoPdD tipoPdD = null;
  3990.         String nomePorta = null;
  3991.         IDSoggetto idDominio = null;
  3992.         IDSoggetto soggettoFruitore = null;
  3993.         IDServizio idServizio = null;
  3994.         IDPortaDelegata idPD = null;
  3995.         IDPortaApplicativa idPA = null;
  3996.         if(pa!=null) {
  3997.             tipoPdD = TipoPdD.APPLICATIVA;
  3998.             nomePorta = pa.getNome();
  3999.             idDominio = new IDSoggetto(pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario());
  4000.             try {
  4001.                 idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(pa.getServizio().getTipo(), pa.getServizio().getNome(), 
  4002.                         pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario(), 
  4003.                         pa.getServizio().getVersione());
  4004.                 idServizio.setAzione(azione);
  4005.             }catch(Exception e) {
  4006.                 throw new DriverConfigurazioneException(e.getMessage(),e);
  4007.             }
  4008.             idPA = new IDPortaApplicativa();
  4009.             idPA.setNome(nomePorta);
  4010.         }
  4011.         else {
  4012.             idDominio = OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(protocolFactory!=null ? protocolFactory.getProtocol() : null, requestInfo);
  4013.         }
  4014.          
  4015.         IState state = null;
  4016.         IDAccordo idAccordo = null; // viene calcolato all'interno del metodo
  4017.         String servizioApplicativoFruitore = null; 
  4018.         List<String> serviziApplicativiErogatori = null;
  4019.         try {
  4020.             DatiTransazione datiTransazione = InterceptorPolicyUtilities.readDatiTransazione(tipoPdD, idModulo, 
  4021.                     pddContext, urlProtocolContext,
  4022.                     protocolFactory, state, log,
  4023.                     idDominio, soggettoFruitore, idServizio, idAccordo,
  4024.                     idPD, idPA,
  4025.                     servizioApplicativoFruitore, serviziApplicativiErogatori);
  4026.             return DimensioneMessaggiConfigurationUtils.readSoglieDimensioneMessaggi(tipoPdD, nomePorta, datiTransazione, log, urlProtocolContext, requestInfo, pddContext, protocolFactory);
  4027.         }catch(Exception e) {
  4028.             throw new DriverConfigurazioneException(e.getMessage(),e);
  4029.         }
  4030.     }
  4031.     
  4032.     protected boolean isConnettoriUseTimeoutInputStream(Connection connectionPdD,PortaApplicativa pa) throws DriverConfigurazioneException{
  4033.         
  4034.         boolean defaultValue = this.openspcoopProperties.isConnettoriUseTimeoutInputStream();
  4035.         if(pa==null){
  4036.             //configurazione di default
  4037.             return defaultValue;
  4038.         }
  4039.         try {
  4040.             return CostantiProprieta.isConnettoriUseTimeoutInputStream(pa.getProprietaList(), defaultValue);
  4041.         }catch(Exception e) {
  4042.             throw new DriverConfigurazioneException(e.getMessage(),e);
  4043.         }

  4045.     }
  4046.     protected SogliaReadTimeout getRequestReadTimeout(PortaApplicativa pa,
  4047.             RequestInfo requestInfo, 
  4048.             IProtocolFactory<?> protocolFactory,
  4049.             Context context,
  4050.             IState state) throws DriverConfigurazioneException{

  4052.         int defaultValue = this.openspcoopProperties.getReadConnectionTimeout_ricezioneBuste();
  4053.         if(pa==null){
  4054.             //configurazione di default
  4055.             return ReadTimeoutConfigurationUtils.buildSogliaRequestTimeout(defaultValue, false, protocolFactory);
  4056.         }
  4057.         try {
  4058.             boolean configurazioneGlobale = !CostantiProprieta.existsConnettoriRequestTimeout(pa.getProprietaList());
  4059.             int sogliaMs = defaultValue;
  4060.             if(!configurazioneGlobale) {
  4061.                 sogliaMs = CostantiProprieta.getConnettoriRequestTimeout(pa.getProprietaList(), defaultValue);
  4062.             }
  4063.             return ReadTimeoutConfigurationUtils.buildSogliaRequestTimeout(sogliaMs, configurazioneGlobale, pa, 
  4064.                     new ReadTimeoutContextParam(requestInfo, protocolFactory, context, state));
  4065.         }catch(Exception e) {
  4066.             throw new DriverConfigurazioneException(e.getMessage(),e);
  4067.         }

  4069.     }
  4070.     
  4071.     
  4072.     protected Trasformazioni getTrasformazioni(PortaApplicativa pa) throws DriverConfigurazioneException{
  4073.         if(pa!=null && pa.getTrasformazioni()!=null) {
  4074.             return pa.getTrasformazioni();
  4075.         }
  4076.         return null;
  4077.     }
  4078.     
  4079.     protected List<String> getPreInRequestHandlers(PortaApplicativa pa) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  4080.         List<String> list = new ArrayList<>();
  4081.         if(pa!=null && pa.getConfigurazioneHandler()!=null) {
  4082.             ConfigurazionePortaHandler confPorta = pa.getConfigurazioneHandler();
  4083.             if(confPorta.getRequest()!=null) {
  4084.                 fillListHandlers(confPorta.getRequest().getPreInList(), list);
  4085.             }
  4086.         }
  4087.         return list;
  4088.     }
  4089.     protected List<String> getInRequestHandlers(PortaApplicativa pa) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  4090.         List<String> list = new ArrayList<>();
  4091.         if(pa!=null && pa.getConfigurazioneHandler()!=null) {
  4092.             ConfigurazionePortaHandler confPorta = pa.getConfigurazioneHandler();
  4093.             if(confPorta.getRequest()!=null) {
  4094.                 fillListHandlers(confPorta.getRequest().getInList(), list);
  4095.             }
  4096.         }
  4097.         return list;
  4098.     }
  4099.     protected List<String> getInRequestProtocolHandlers(PortaApplicativa pa) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  4100.         List<String> list = new ArrayList<>();
  4101.         if(pa!=null && pa.getConfigurazioneHandler()!=null) {
  4102.             ConfigurazionePortaHandler confPorta = pa.getConfigurazioneHandler();
  4103.             if(confPorta.getRequest()!=null) {
  4104.                 fillListHandlers(confPorta.getRequest().getInProtocolInfoList(), list);
  4105.             }
  4106.         }
  4107.         return list;
  4108.     }
  4109.     protected List<String> getOutRequestHandlers(PortaApplicativa pa) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  4110.         List<String> list = new ArrayList<>();
  4111.         if(pa!=null && pa.getConfigurazioneHandler()!=null) {
  4112.             ConfigurazionePortaHandler confPorta = pa.getConfigurazioneHandler();
  4113.             if(confPorta.getRequest()!=null) {
  4114.                 fillListHandlers(confPorta.getRequest().getOutList(), list);
  4115.             }
  4116.         }
  4117.         return list;
  4118.     }
  4119.     protected List<String> getPostOutRequestHandlers(PortaApplicativa pa) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  4120.         List<String> list = new ArrayList<>();
  4121.         if(pa!=null && pa.getConfigurazioneHandler()!=null) {
  4122.             ConfigurazionePortaHandler confPorta = pa.getConfigurazioneHandler();
  4123.             if(confPorta.getRequest()!=null) {
  4124.                 fillListHandlers(confPorta.getRequest().getPostOutList(), list);
  4125.             }
  4126.         }
  4127.         return list;
  4128.     }
  4129.     protected List<String> getPreInResponseHandlers(PortaApplicativa pa) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  4130.         List<String> list = new ArrayList<>();
  4131.         if(pa!=null && pa.getConfigurazioneHandler()!=null) {
  4132.             ConfigurazionePortaHandler confPorta = pa.getConfigurazioneHandler();
  4133.             if(confPorta.getResponse()!=null) {
  4134.                 fillListHandlers(confPorta.getResponse().getPreInList(), list);
  4135.             }
  4136.         }
  4137.         return list;
  4138.     }
  4139.     protected List<String> getInResponseHandlers(PortaApplicativa pa) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  4140.         List<String> list = new ArrayList<>();
  4141.         if(pa!=null && pa.getConfigurazioneHandler()!=null) {
  4142.             ConfigurazionePortaHandler confPorta = pa.getConfigurazioneHandler();
  4143.             if(confPorta.getResponse()!=null) {
  4144.                 fillListHandlers(confPorta.getResponse().getInList(), list);
  4145.             }
  4146.         }
  4147.         return list;
  4148.     }
  4149.     protected List<String> getOutResponseHandlers(PortaApplicativa pa) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  4150.         List<String> list = new ArrayList<>();
  4151.         if(pa!=null && pa.getConfigurazioneHandler()!=null) {
  4152.             ConfigurazionePortaHandler confPorta = pa.getConfigurazioneHandler();
  4153.             if(confPorta.getResponse()!=null) {
  4154.                 fillListHandlers(confPorta.getResponse().getOutList(), list);
  4155.             }
  4156.         }
  4157.         return list;
  4158.     }
  4159.     protected List<String> getPostOutResponseHandlers(PortaApplicativa pa) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  4160.         List<String> list = new ArrayList<>();
  4161.         if(pa!=null && pa.getConfigurazioneHandler()!=null) {
  4162.             ConfigurazionePortaHandler confPorta = pa.getConfigurazioneHandler();
  4163.             if(confPorta.getResponse()!=null) {
  4164.                 fillListHandlers(confPorta.getResponse().getPostOutList(), list);
  4165.             }
  4166.         }
  4167.         return list;
  4168.     }
  4169.     
  4170.     protected List<Object> getExtendedInfo(PortaApplicativa pa)throws DriverConfigurazioneException{

  4172.         if(pa == null || pa.sizeExtendedInfoList()<=0)
  4173.             return null;

  4175.         return pa.getExtendedInfoList();
  4176.     }

  4178.     protected Template getTemplateTrasformazioneRichiesta(Connection connectionPdD,IDPortaApplicativa idPA, String nomeTrasformazione, TrasformazioneRegolaRichiesta richiesta, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4179.         return this.configurazionePdD.getTemplateTrasformazioneRichiesta(connectionPdD, idPA, nomeTrasformazione, richiesta, requestInfo);
  4180.     }
  4181.     protected Template getTemplateTrasformazioneSoapRichiesta(Connection connectionPdD,IDPortaApplicativa idPA, String nomeTrasformazione, TrasformazioneRegolaRichiesta richiesta, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4182.         return this.configurazionePdD.getTemplateTrasformazioneSoapRichiesta(connectionPdD, idPA, nomeTrasformazione, richiesta, requestInfo);
  4183.     }
  4184.     protected Template getTemplateTrasformazioneRisposta(Connection connectionPdD,IDPortaApplicativa idPA, String nomeTrasformazione, TrasformazioneRegolaRisposta risposta, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4185.         return this.configurazionePdD.getTemplateTrasformazioneRisposta(connectionPdD, idPA, nomeTrasformazione, risposta, requestInfo);
  4186.     }
  4187.     protected Template getTemplateTrasformazioneSoapRisposta(Connection connectionPdD,IDPortaApplicativa idPA, String nomeTrasformazione, TrasformazioneRegolaRisposta risposta, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4188.         return this.configurazionePdD.getTemplateTrasformazioneSoapRisposta(connectionPdD, idPA, nomeTrasformazione, risposta, requestInfo);
  4189.     }
  4190.     
  4191.     protected Template getTemplateConnettoreMultiploSticky(Connection connectionPdD,IDPortaApplicativa idPA, byte[] template, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4192.         return this.configurazionePdD.getTemplateConnettoreMultiploSticky(connectionPdD, idPA, template, requestInfo);
  4193.     }
  4194.     protected Template getTemplateConnettoreMultiploCondizionale(Connection connectionPdD,IDPortaApplicativa idPA, String nomeRegola, byte[] template, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4195.         return this.configurazionePdD.getTemplateConnettoreMultiploCondizionale(connectionPdD, idPA, nomeRegola, template, requestInfo);
  4196.     }
  4197.     
  4198.     public Template getTemplateCorrelazioneApplicativaRichiesta(Connection connectionPdD,IDPortaApplicativa idPA, String nomeRegola, byte[] template, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4199.         return this.configurazionePdD.getTemplateCorrelazioneApplicativaRichiesta(connectionPdD, idPA, nomeRegola, template, requestInfo);
  4200.     }
  4201.     public Template getTemplateCorrelazioneApplicativaRisposta(Connection connectionPdD,IDPortaApplicativa idPA, String nomeRegola, byte[] template, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4202.         return this.configurazionePdD.getTemplateCorrelazioneApplicativaRisposta(connectionPdD, idPA, nomeRegola, template, requestInfo);
  4203.     }
  4204.     
  4205.     protected Template getTemplateIntegrazione(Connection connectionPdD,IDPortaApplicativa idPA, File file, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4206.         return this.configurazionePdD.getTemplateIntegrazione(connectionPdD, idPA, file, requestInfo);
  4207.     }
  4208.     
  4209.     





  4215.     /* ********  Servizi Applicativi (Interfaccia)  ******** */

  4217.     protected boolean existsServizioApplicativo(Connection connectionPdD,IDServizioApplicativo idSA) throws DriverConfigurazioneException{ 

  4219.         ServizioApplicativo servizioApplicativo = null;
  4220.         try{
  4221.             servizioApplicativo = this.configurazionePdD.getServizioApplicativo(connectionPdD,idSA);
  4222.         }catch(DriverConfigurazioneNotFound e){
  4223.             return false;
  4224.         }

  4226.         return servizioApplicativo!=null;

  4228.     }

  4230.     protected ServizioApplicativo getServizioApplicativo(Connection connectionPdD,IDServizioApplicativo idSA) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4231.         return this.configurazionePdD.getServizioApplicativo(connectionPdD, idSA);
  4232.     }

  4234.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiBasic(Connection connectionPdD,String aUser,String aPassword, CryptConfig config) throws DriverConfigurazioneException{
  4235.         return getIdServizioApplicativoByCredenzialiBasic(connectionPdD, aUser, aPassword, config, null);
  4236.     }
  4237.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiBasic(Connection connectionPdD,String aUser,String aPassword, CryptConfig config,
  4238.             List<String> tipiSoggetto) throws DriverConfigurazioneException{
  4239.         ServizioApplicativo servizioApplicativo = null;
  4240.         try{
  4241.             if(tipiSoggetto!=null) {
  4242.                 servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiBasic(connectionPdD, aUser, aPassword, config, tipiSoggetto);
  4243.             }
  4244.             else {
  4245.                 servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiBasic(connectionPdD, aUser, aPassword, config);
  4246.             }
  4247.         }catch(DriverConfigurazioneNotFound e){
  4248.             /**this.logDebug("autenticazioneHTTP (not found): "+e.getMessage());*/
  4249.         }

  4251.         if(servizioApplicativo!=null){
  4252.             IDServizioApplicativo idSA = new IDServizioApplicativo();
  4253.             idSA.setNome(servizioApplicativo.getNome());
  4254.             if(servizioApplicativo.getTipoSoggettoProprietario()!=null && servizioApplicativo.getNomeSoggettoProprietario()!=null){
  4255.                 idSA.setIdSoggettoProprietario(new IDSoggetto(servizioApplicativo.getTipoSoggettoProprietario(), servizioApplicativo.getNomeSoggettoProprietario()));
  4256.             }
  4257.             return idSA;
  4258.         }
  4259.         else
  4260.             return null;
  4261.     }
  4262.     
  4263.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiApiKey(Connection connectionPdD,String aUser,String aPassword, boolean appId, CryptConfig config) throws DriverConfigurazioneException{
  4264.         return getIdServizioApplicativoByCredenzialiApiKey(connectionPdD, aUser, aPassword, appId, config, null);
  4265.     }
  4266.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiApiKey(Connection connectionPdD,String aUser,String aPassword, boolean appId, CryptConfig config,
  4267.             List<String> tipiSoggetto) throws DriverConfigurazioneException{
  4268.         ServizioApplicativo servizioApplicativo = null;
  4269.         try{
  4270.             if(tipiSoggetto!=null) {
  4271.                 servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiApiKey(connectionPdD, aUser, aPassword, appId, config, tipiSoggetto);
  4272.             }
  4273.             else {
  4274.                 servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiApiKey(connectionPdD, aUser, aPassword, appId, config);
  4275.             }
  4276.         }catch(DriverConfigurazioneNotFound e){
  4277.             /**this.logDebug("autenticazioneHTTP (not found): "+e.getMessage());*/
  4278.         }

  4280.         if(servizioApplicativo!=null){
  4281.             IDServizioApplicativo idSA = new IDServizioApplicativo();
  4282.             idSA.setNome(servizioApplicativo.getNome());
  4283.             if(servizioApplicativo.getTipoSoggettoProprietario()!=null && servizioApplicativo.getNomeSoggettoProprietario()!=null){
  4284.                 idSA.setIdSoggettoProprietario(new IDSoggetto(servizioApplicativo.getTipoSoggettoProprietario(), servizioApplicativo.getNomeSoggettoProprietario()));
  4285.             }
  4286.             return idSA;
  4287.         }
  4288.         else
  4289.             return null;
  4290.     }

  4292.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiSsl(Connection connectionPdD,String aSubject, String aIssuer) throws DriverConfigurazioneException{
  4293.         return getIdServizioApplicativoByCredenzialiSsl(connectionPdD, aSubject, aIssuer, 
  4294.                 null);
  4295.     }
  4296.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiSsl(Connection connectionPdD,String aSubject, String aIssuer,
  4297.             List<String> tipiSoggetto) throws DriverConfigurazioneException{
  4298.         return getIdServizioApplicativoByCredenzialiSsl(connectionPdD, aSubject, aIssuer, 
  4299.                 tipiSoggetto,
  4300.                 false, false, false);
  4301.     }
  4302.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiSsl(Connection connectionPdD,String aSubject, String aIssuer,
  4303.             List<String> tipiSoggetto, 
  4304.             boolean includiApplicativiNonModI, boolean includiApplicativiModIEsterni, boolean includiApplicativiModIInterni) throws DriverConfigurazioneException{
  4305.         ServizioApplicativo servizioApplicativo = null;
  4306.         try{
  4307.             if(tipiSoggetto!=null) {
  4308.                 if(includiApplicativiNonModI || includiApplicativiModIEsterni || includiApplicativiModIInterni) {
  4309.                     servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiSsl(connectionPdD, aSubject, aIssuer, tipiSoggetto, 
  4310.                             includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
  4311.                 }
  4312.                 else {
  4313.                     servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiSsl(connectionPdD, aSubject, aIssuer, tipiSoggetto);
  4314.                 }
  4315.             }
  4316.             else {
  4317.                 servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiSsl(connectionPdD, aSubject, aIssuer);
  4318.             }
  4319.         }catch(DriverConfigurazioneNotFound e){
  4320.             /**this.logDebug("autenticazioneHTTP (not found): "+e.getMessage());*/
  4321.         }

  4323.         if(servizioApplicativo!=null){
  4324.             IDServizioApplicativo idSA = new IDServizioApplicativo();
  4325.             idSA.setNome(servizioApplicativo.getNome());
  4326.             if(servizioApplicativo.getTipoSoggettoProprietario()!=null && servizioApplicativo.getNomeSoggettoProprietario()!=null){
  4327.                 idSA.setIdSoggettoProprietario(new IDSoggetto(servizioApplicativo.getTipoSoggettoProprietario(), servizioApplicativo.getNomeSoggettoProprietario()));
  4328.             }
  4329.             return idSA;
  4330.         }
  4331.         else
  4332.             return null;
  4333.     }

  4335.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiSsl(Connection connectionPdD,CertificateInfo certificate, boolean strictVerifier) throws DriverConfigurazioneException{
  4336.         return getIdServizioApplicativoByCredenzialiSsl(connectionPdD, certificate, strictVerifier, 
  4337.                 null);
  4338.     }
  4339.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiSsl(Connection connectionPdD,CertificateInfo certificate, boolean strictVerifier,
  4340.             List<String> tipiSoggetto) throws DriverConfigurazioneException{
  4341.         return getIdServizioApplicativoByCredenzialiSsl(connectionPdD, certificate, strictVerifier, 
  4342.                 tipiSoggetto,
  4343.                 false, false, false);
  4344.     }
  4345.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiSsl(Connection connectionPdD,CertificateInfo certificate, boolean strictVerifier,
  4346.             List<String> tipiSoggetto, 
  4347.             boolean includiApplicativiNonModI, boolean includiApplicativiModIEsterni, boolean includiApplicativiModIInterni) throws DriverConfigurazioneException{
  4348.         ServizioApplicativo servizioApplicativo = null;
  4349.         try{
  4350.             if(tipiSoggetto!=null) {
  4351.                 if(includiApplicativiNonModI || includiApplicativiModIEsterni || includiApplicativiModIInterni) {
  4352.                     servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiSsl(connectionPdD, certificate, strictVerifier, tipiSoggetto, 
  4353.                             includiApplicativiNonModI, includiApplicativiModIEsterni, includiApplicativiModIInterni);
  4354.                 }
  4355.                 else {
  4356.                     servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiSsl(connectionPdD, certificate, strictVerifier, tipiSoggetto);
  4357.                 }
  4358.             }
  4359.             else {
  4360.                 servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiSsl(connectionPdD, certificate, strictVerifier);
  4361.             }
  4362.         }catch(DriverConfigurazioneNotFound e){
  4363.             /**this.logDebug("autenticazioneHTTP (not found): "+e.getMessage());*/
  4364.         }

  4366.         if(servizioApplicativo!=null){
  4367.             IDServizioApplicativo idSA = new IDServizioApplicativo();
  4368.             idSA.setNome(servizioApplicativo.getNome());
  4369.             if(servizioApplicativo.getTipoSoggettoProprietario()!=null && servizioApplicativo.getNomeSoggettoProprietario()!=null){
  4370.                 idSA.setIdSoggettoProprietario(new IDSoggetto(servizioApplicativo.getTipoSoggettoProprietario(), servizioApplicativo.getNomeSoggettoProprietario()));
  4371.             }
  4372.             return idSA;
  4373.         }
  4374.         else
  4375.             return null;
  4376.     }

  4378.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiPrincipal(Connection connectionPdD,String principal) throws DriverConfigurazioneException{
  4379.         return getIdServizioApplicativoByCredenzialiPrincipal(connectionPdD, principal, null);
  4380.     }
  4381.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiPrincipal(Connection connectionPdD,String principal,
  4382.             List<String> tipiSoggetto) throws DriverConfigurazioneException{
  4383.         ServizioApplicativo servizioApplicativo = null;
  4384.         try{
  4385.             if(tipiSoggetto!=null) {
  4386.                 servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiPrincipal(connectionPdD, principal, tipiSoggetto);
  4387.             }
  4388.             else {
  4389.                 servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiPrincipal(connectionPdD, principal);
  4390.             }
  4391.         }catch(DriverConfigurazioneNotFound e){
  4392.             /**this.logDebug("autenticazioneHTTP (not found): "+e.getMessage());*/
  4393.         }

  4395.         if(servizioApplicativo!=null){
  4396.             IDServizioApplicativo idSA = new IDServizioApplicativo();
  4397.             idSA.setNome(servizioApplicativo.getNome());
  4398.             if(servizioApplicativo.getTipoSoggettoProprietario()!=null && servizioApplicativo.getNomeSoggettoProprietario()!=null){
  4399.                 idSA.setIdSoggettoProprietario(new IDSoggetto(servizioApplicativo.getTipoSoggettoProprietario(), servizioApplicativo.getNomeSoggettoProprietario()));
  4400.             }
  4401.             return idSA;
  4402.         }
  4403.         else
  4404.             return null;
  4405.     }
  4406.     
  4407.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiToken(Connection connectionPdD,String tokenPolicy, String tokenClientId) throws DriverConfigurazioneException{
  4408.         return getIdServizioApplicativoByCredenzialiToken(connectionPdD, tokenPolicy, tokenClientId, null);
  4409.     }
  4410.     protected IDServizioApplicativo getIdServizioApplicativoByCredenzialiToken(Connection connectionPdD,String tokenPolicy, String tokenClientId,
  4411.             List<String> tipiSoggetto) throws DriverConfigurazioneException{
  4412.         ServizioApplicativo servizioApplicativo = null;
  4413.         try{
  4414.             if(tipiSoggetto!=null) {
  4415.                 servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiToken(connectionPdD, tokenPolicy, tokenClientId, tipiSoggetto);
  4416.             }
  4417.             else {
  4418.                 servizioApplicativo = this.configurazionePdD.getServizioApplicativoByCredenzialiToken(connectionPdD, tokenPolicy, tokenClientId);
  4419.             }
  4420.         }catch(DriverConfigurazioneNotFound e){
  4421.             /**this.logDebug("autenticazioneHTTP (not found): "+e.getMessage());*/
  4422.         }

  4424.         if(servizioApplicativo!=null){
  4425.             IDServizioApplicativo idSA = new IDServizioApplicativo();
  4426.             idSA.setNome(servizioApplicativo.getNome());
  4427.             if(servizioApplicativo.getTipoSoggettoProprietario()!=null && servizioApplicativo.getNomeSoggettoProprietario()!=null){
  4428.                 idSA.setIdSoggettoProprietario(new IDSoggetto(servizioApplicativo.getTipoSoggettoProprietario(), servizioApplicativo.getNomeSoggettoProprietario()));
  4429.             }
  4430.             return idSA;
  4431.         }
  4432.         else
  4433.             return null;
  4434.     }

  4436.     protected boolean autorizzazione(PortaDelegata pd, String servizioApplicativo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  4438.         if( (pd == null) || (servizioApplicativo==null) )
  4439.             return false;

  4441.         for(int j=0; j<pd.sizeServizioApplicativoList(); j++){
  4442.             if(servizioApplicativo.equals(pd.getServizioApplicativo(j).getNome()))
  4443.                 return true;
  4444.         }

  4446.         return false;

  4448.     }

  4450.     protected boolean autorizzazioneTrasportoRoles(RegistroServiziManager registroServiziManager, 
  4451.             PortaDelegata pd, ServizioApplicativo sa, InfoConnettoreIngresso infoConnettoreIngresso,
  4452.             PdDContext pddContext, RequestInfo requestInfo,
  4453.             boolean checkRuoloRegistro, boolean checkRuoloEsterno,
  4454.             StringBuilder details) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{ 

  4456.         if( (pd == null) || pd.getRuoli()==null || pd.getRuoli().sizeRuoloList()<=0 ){
  4457.             throw new DriverConfigurazioneNotFound("Non sono stati definiti i ruoli necessari a fruire della porta delegata");
  4458.         }

  4460.         if(checkRuoloRegistro && !checkRuoloEsterno){
  4461.             if(sa==null){
  4462.                 throw new DriverConfigurazioneException("Identità servizio applicativo non disponibile; tale informazione è richiesta dall'autorizzazione");
  4463.             }
  4464.         }
  4465.         
  4466.         return _autorizzazioneRoles(registroServiziManager,
  4467.                 null, sa, 
  4468.                 infoConnettoreIngresso, true,
  4469.                 pddContext, requestInfo,
  4470.                 checkRuoloRegistro, checkRuoloEsterno,
  4471.                 details,
  4472.                 pd.getRuoli().getMatch(), pd.getRuoli(),
  4473.                 false);

  4475.     }
  4476.     
  4477.     protected boolean autorizzazioneTokenRoles(RegistroServiziManager registroServiziManager, 
  4478.             PortaDelegata pd, ServizioApplicativo sa, InfoConnettoreIngresso infoConnettoreIngresso,
  4479.             PdDContext pddContext, RequestInfo requestInfo,
  4480.             boolean checkRuoloRegistro, boolean checkRuoloEsterno,
  4481.             StringBuilder details) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{ 

  4483.         if( (pd == null) || pd.getAutorizzazioneToken()==null || 
  4484.                 pd.getAutorizzazioneToken().getRuoli()==null || 
  4485.                 pd.getAutorizzazioneToken().getRuoli().sizeRuoloList()<=0 ){
  4486.             throw new DriverConfigurazioneNotFound("Non sono stati definiti i ruoli necessari a fruire della porta delegata");
  4487.         }

  4489.         if(checkRuoloRegistro && !checkRuoloEsterno){
  4490.             if(sa==null){
  4491.                 throw new DriverConfigurazioneException("Identità servizio applicativo non disponibile; tale informazione è richiesta dall'autorizzazione");
  4492.             }
  4493.         }
  4494.         
  4495.         return _autorizzazioneRoles(registroServiziManager,
  4496.                 null, sa, 
  4497.                 infoConnettoreIngresso, true,
  4498.                 pddContext, requestInfo,
  4499.                 checkRuoloRegistro, checkRuoloEsterno,
  4500.                 details,
  4501.                 pd.getAutorizzazioneToken().getRuoli().getMatch(), pd.getAutorizzazioneToken().getRuoli(),
  4502.                 false);

  4504.     }

  4506.     protected void aggiornaProprietaGestioneErrorePD(ProprietaErroreApplicativo gestioneErrore, ServizioApplicativo sa) throws DriverConfigurazioneException {

  4508.         if(sa==null)
  4509.             return;
  4510.         if(sa.getInvocazionePorta()==null)
  4511.             return;
  4512.         if(sa.getInvocazionePorta().getGestioneErrore()==null)
  4513.             return;
  4514.         InvocazionePortaGestioneErrore proprietaSA = sa.getInvocazionePorta().getGestioneErrore();


  4517.         // Aggiornamento proprieta
  4518.         // tipo di fault xml/soap
  4519.         if(CostantiConfigurazione.ERRORE_APPLICATIVO_SOAP.equals(proprietaSA.getFault()))
  4520.             gestioneErrore.setFaultAsXML(false);
  4521.         else if(CostantiConfigurazione.ERRORE_APPLICATIVO_XML.equals(proprietaSA.getFault()))
  4522.             gestioneErrore.setFaultAsXML(true);
  4523.         // fault actor
  4524.         if(proprietaSA.getFaultActor()!=null && StringUtils.isNotEmpty(proprietaSA.getFaultActor()))
  4525.             gestioneErrore.setFaultActor(proprietaSA.getFaultActor());
  4526.         // fault generic code abilitato/disabilitato
  4527.         if(CostantiConfigurazione.ABILITATO.equals(proprietaSA.getGenericFaultCode()))
  4528.             gestioneErrore.setFaultAsGenericCode(true);
  4529.         else if(CostantiConfigurazione.DISABILITATO.equals(proprietaSA.getGenericFaultCode()))
  4530.             gestioneErrore.setFaultAsGenericCode(false);
  4531.         // fault prefix code
  4532.         if(proprietaSA.getPrefixFaultCode()!=null && StringUtils.isNotEmpty(proprietaSA.getPrefixFaultCode()))
  4533.             gestioneErrore.setFaultPrefixCode(proprietaSA.getPrefixFaultCode());

  4535.         return;
  4536.     }

  4538.     protected boolean invocazionePortaDelegataPerRiferimento(ServizioApplicativo sa) throws DriverConfigurazioneException{
  4539.         if(sa==null)
  4540.             return false;
  4541.         if(sa.getInvocazionePorta()==null)
  4542.             return false;
  4543.         return CostantiConfigurazione.ABILITATO.equals(sa.getInvocazionePorta().getInvioPerRiferimento());
  4544.     }

  4546.     protected boolean invocazionePortaDelegataSbustamentoInformazioniProtocollo(ServizioApplicativo sa) throws DriverConfigurazioneException{
  4547.         if(sa==null)
  4548.             return true;
  4549.         if(sa.getInvocazionePorta()==null)
  4550.             return true;
  4551.         return !CostantiConfigurazione.DISABILITATO.equals(sa.getInvocazionePorta().getSbustamentoInformazioniProtocollo());
  4552.     }

  4554.     public List<String> getServiziApplicativiConsegnaNotifichePrioritarie(Connection connectionPdD, String queue) throws DriverConfigurazioneException{
  4555.         try {
  4556.             List<IDConnettore> list = this.configurazionePdD.getConnettoriConsegnaNotifichePrioritarie(connectionPdD, queue);
  4557.             if(list==null || list.isEmpty()) {
  4558.                 throw new DriverConfigurazioneNotFound();
  4559.             }
  4560.             List<String> l = new ArrayList<>();
  4561.             for (IDServizioApplicativo idSA : list) {
  4562.                 if(l.contains(idSA.getNome())==false) {
  4563.                     l.add(idSA.getNome());
  4564.                 }
  4565.             }
  4566.             return l;
  4567.         }catch(DriverConfigurazioneNotFound notFound) {
  4568.             return new ArrayList<>();
  4569.         }
  4570.     }
  4571.     
  4572.     public List<IDConnettore> getConnettoriConsegnaNotifichePrioritarie(Connection connectionPdD, String queue) throws DriverConfigurazioneException{
  4573.         try {
  4574.             return this.configurazionePdD.getConnettoriConsegnaNotifichePrioritarie(connectionPdD, queue);
  4575.         }catch(DriverConfigurazioneNotFound notFound) {
  4576.             return new ArrayList<IDConnettore>();
  4577.         }
  4578.     }
  4579.     
  4580.     public void resetConnettoriConsegnaNotifichePrioritarie(Connection connectionPdD, String queue) throws DriverConfigurazioneException{
  4581.         this.configurazionePdD.resetConnettoriConsegnaNotifichePrioritarie(connectionPdD, queue);
  4582.     }
  4583.     
  4584.     public Map<String, String> getProprietaConfigurazione(ServizioApplicativo sa) throws DriverConfigurazioneException {
  4585.         if (sa == null) {
  4586.             throw new DriverConfigurazioneException("ServizioApplicativo non fornito");
  4587.         } else if (sa.sizeProprietaList() <= 0) {
  4588.             return null;
  4589.         } else {
  4590.             Map<String, String> properties = new HashMap<>();

  4592.             for(int i = 0; i < sa.sizeProprietaList(); ++i) {
  4593.                 Proprieta p = sa.getProprieta(i);
  4594.                 properties.put(p.getNome(), p.getValore());
  4595.             }

  4597.             return properties;
  4598.         }
  4599.     }










  4610.     // INVOCAZIONE SERVIZIO

  4612.     protected boolean invocazioneServizioConGetMessage(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4613.         // Servizio applicativo
  4614.         if(sa==null)
  4615.             return false;
  4616.         if(sa.getInvocazioneServizio()==null)
  4617.             return false;
  4618.         InvocazioneServizio serv = sa.getInvocazioneServizio();
  4619.         return CostantiConfigurazione.ABILITATO.equals(serv.getGetMessage());
  4620.     }

  4622.     protected boolean invocazioneServizioConSbustamento(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4623.         // Servizio applicativo
  4624.         if(sa==null)
  4625.             return false;
  4626.         if(sa.getInvocazioneServizio()==null)
  4627.             return false;
  4628.         InvocazioneServizio serv = sa.getInvocazioneServizio();
  4629.         return CostantiConfigurazione.ABILITATO.equals(serv.getSbustamentoSoap());
  4630.     }

  4632.     protected boolean invocazioneServizioConSbustamentoInformazioniProtocollo(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4633.         // Servizio applicativo
  4634.         if(sa==null)
  4635.             return true;
  4636.         if(sa.getInvocazioneServizio()==null)
  4637.             return true;
  4638.         InvocazioneServizio serv = sa.getInvocazioneServizio();
  4639.         return !CostantiConfigurazione.DISABILITATO.equals(serv.getSbustamentoInformazioniProtocollo());
  4640.     }

  4642.     protected boolean invocazioneServizioConConnettore(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4643.         // Servizio applicativo
  4644.         if(sa==null)
  4645.             return false;
  4646.         if(sa.getInvocazioneServizio()==null)
  4647.             return false;

  4649.         InvocazioneServizio serv = sa.getInvocazioneServizio();
  4650.         Connettore connettore = serv.getConnettore();
  4651.         if(connettore!=null && 
  4652.                 !CostantiConfigurazione.NONE.equals(connettore.getTipo()) &&
  4653.                 !CostantiConfigurazione.DISABILITATO.equals(connettore.getTipo()))
  4654.             return true;
  4655.         else
  4656.             return false;
  4657.     }

  4659.     protected ConnettoreMsg getInvocazioneServizio(Connection connectionPdD,ServizioApplicativo sa,RichiestaApplicativa richiestaApplicativa, RequestInfo requestInfo)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  4661.         // Servizio applicativo
  4662.         if(sa.getInvocazioneServizio()==null)
  4663.             throw new DriverConfigurazioneNotFound("Servizio applicativo ["+richiestaApplicativa.getServizioApplicativo()+"] del soggetto["+richiestaApplicativa.getIDServizio().getSoggettoErogatore()+"] non possieder l'elemento invocazione servizio");
  4664.         InvocazioneServizio serv = sa.getInvocazioneServizio();


  4667.         // Soggetto Erogatore
  4668.         IDSoggetto aSoggetto = richiestaApplicativa.getIDServizio().getSoggettoErogatore();
  4669.         Soggetto soggetto = null;
  4670.         if( requestInfo!=null && requestInfo.getRequestConfig()!=null && aSoggetto!=null) {
  4671.             if(requestInfo.getRequestConfig().getSoggettoErogatoreConfig()!=null &&
  4672.                     aSoggetto.getTipo().equals(requestInfo.getRequestConfig().getSoggettoErogatoreConfig().getTipo()) &&
  4673.                     aSoggetto.getNome().equals(requestInfo.getRequestConfig().getSoggettoErogatoreConfig().getNome())   ) {
  4674.                 soggetto = requestInfo.getRequestConfig().getSoggettoErogatoreConfig();
  4675.             }
  4676.             else if( requestInfo.getRequestConfig().getSoggettoFruitoreConfig()!=null &&
  4677.                     aSoggetto.getTipo().equals(requestInfo.getRequestConfig().getSoggettoFruitoreConfig().getTipo()) &&
  4678.                     aSoggetto.getNome().equals(requestInfo.getRequestConfig().getSoggettoFruitoreConfig().getNome())    ) {
  4679.                 soggetto = requestInfo.getRequestConfig().getSoggettoFruitoreConfig();
  4680.             }
  4681.         }
  4682.         if(soggetto==null) {
  4683.             if(requestInfo!=null && requestInfo.getRequestThreadContext()!=null && requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo()!=null) {
  4684.                 if(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig()!=null && aSoggetto!=null && 
  4685.                         aSoggetto.getTipo().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig().getTipo()) && 
  4686.                         aSoggetto.getNome().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig().getNome())) {
  4687.                     soggetto = requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig();
  4688.                 }
  4689.             }
  4690.         }
  4691.         if(soggetto==null) {
  4692.             if(requestInfo!=null && requestInfo.getRequestThreadContext()!=null && requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo()!=null) {
  4693.                 if(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig()!=null && aSoggetto!=null && 
  4694.                         aSoggetto.getTipo().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig().getTipo()) && 
  4695.                         aSoggetto.getNome().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig().getNome())) {
  4696.                     soggetto = requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig();
  4697.                 }
  4698.             }
  4699.         }
  4700.         if(soggetto==null) {
  4701.             soggetto = this.configurazionePdD.getSoggetto(connectionPdD,aSoggetto);
  4702.         }
  4703.         if(soggetto==null)
  4704.             throw new DriverConfigurazioneNotFound("[getInvocazioneServizio] Soggetto erogatore non trovato");


  4707.         // Porta Applicativa
  4708.         PortaApplicativa pa = null;
  4709.         if(requestInfo!=null && requestInfo.getRequestConfig()!=null && richiestaApplicativa.getIdPortaApplicativa()!=null && richiestaApplicativa.getIdPortaApplicativa().getNome()!=null) {
  4710.             if( requestInfo.getRequestConfig().getPortaApplicativa()!=null && richiestaApplicativa.getIdPortaApplicativa().getNome().equals(requestInfo.getRequestConfig().getPortaApplicativa().getNome())) {
  4711.                 pa = requestInfo.getRequestConfig().getPortaApplicativa();
  4712.             }
  4713.             else if( requestInfo.getRequestConfig().getPortaApplicativaDefault()!=null && richiestaApplicativa.getIdPortaApplicativa().getNome().equals(requestInfo.getRequestConfig().getPortaApplicativaDefault().getNome())) {
  4714.                 pa = requestInfo.getRequestConfig().getPortaApplicativaDefault();
  4715.             }
  4716.         }
  4717.         if(pa==null) {
  4718.             pa = this.configurazionePdD.getPortaApplicativa(connectionPdD,richiestaApplicativa.getIdPortaApplicativa());
  4719.         }


  4722.         // CONNETTORE
  4723.         Connettore connettore = serv.getConnettore();
  4724.         java.util.Map<String,String> properties = null;
  4725.         if(connettore != null && CostantiConfigurazione.DISABILITATO.equals(connettore.getTipo())==false){
  4726.             String nome = connettore.getNome();
  4727.             if(connettore.getTipo() == null){
  4728.                 // la definizione nel servizio applicativo e' un puntatore, lo cerca nel soggetto.
  4729.                 for(int i=0;i<soggetto.sizeConnettoreList();i++){
  4730.                     if(nome.equals(soggetto.getConnettore(i).getNome())){
  4731.                         connettore = soggetto.getConnettore(i);
  4732.                         break;
  4733.                     }
  4734.                 }
  4735.             }

  4737.             // urlPrefixRewriter
  4738.             setPAUrlPrefixRewriter(connectionPdD,connettore, aSoggetto, requestInfo);

  4740.             // Properties connettore
  4741.             properties = new java.util.HashMap<>();
  4742.             for(int i=0;i<connettore.sizePropertyList();i++){
  4743.                 properties.put(connettore.getProperty(i).getNome(),connettore.getProperty(i).getValore());
  4744.             }
  4745.         }


  4748.         // PROTOCOL-PROPERTIES
  4749.         Map<String, List<String>> protocol_properties = new HashMap<>();
  4750.         for(int i=0;i<pa.sizeProprietaList();i++){
  4751.             TransportUtils.put(protocol_properties, pa.getProprieta(i).getNome(),pa.getProprieta(i).getValore(), false);
  4752.         }

  4754.         // Autenticazione
  4755.         String autenticazione = CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_NONE.toString();
  4756.         String tmp = null;
  4757.         if(serv.getAutenticazione()!=null){
  4758.             tmp = serv.getAutenticazione().toString();
  4759.         }
  4760.         if(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.toString().equalsIgnoreCase(tmp)){
  4761.             autenticazione = CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.toString();
  4762.         }


  4765.         // Credenziali
  4766.         InvocazioneCredenziali credenziali = null;
  4767.         if(serv.getCredenziali()!=null){
  4768.             credenziali = new InvocazioneCredenziali();
  4769.             credenziali.setUser(serv.getCredenziali().getUser());
  4770.             credenziali.setPassword(serv.getCredenziali().getPassword());
  4771.         }

  4773.         // Costruisco connettoreMsg
  4774.         ConnettoreMsg connettoreMsg = null;
  4775.         if(connettore != null){
  4776.             connettoreMsg = new ConnettoreMsg();
  4777.             connettoreMsg.setTipoConnettore(connettore.getTipo());
  4778.             connettoreMsg.setConnectorProperties(properties);
  4779.             connettoreMsg.setSbustamentoSOAP(CostantiConfigurazione.ABILITATO.equals(serv.getSbustamentoSoap()));
  4780.             connettoreMsg.setSbustamentoInformazioniProtocollo(!CostantiConfigurazione.DISABILITATO.equals(serv.getSbustamentoInformazioniProtocollo()));
  4781.             connettoreMsg.setPropertiesTrasporto(protocol_properties);
  4782.             connettoreMsg.setPropertiesUrlBased(protocol_properties);
  4783.             connettoreMsg.setAutenticazione(autenticazione);
  4784.             connettoreMsg.setCredenziali(credenziali);
  4785.         }


  4788.         return connettoreMsg;
  4789.     }

  4791.     protected GestioneErrore getGestioneErroreConnettoreInvocazioneServizio(IProtocolFactory<?> protocolFactory, ServiceBinding serviceBinding, Connection connectionPdD,ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  4793.         //  Servizio applicativo
  4794.         if(sa.getInvocazioneServizio()==null || 
  4795.                 sa.getInvocazioneServizio().getGestioneErrore()==null)
  4796.             return getGestioneErroreConnettoreComponenteIntegrazione(protocolFactory, serviceBinding, connectionPdD);
  4797.         InvocazioneServizio invocazione = sa.getInvocazioneServizio();
  4798.         return invocazione.getGestioneErrore();
  4799.     }

  4801.     protected boolean invocazioneServizioPerRiferimento(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4802.         //    Servizio applicativo
  4803.         if(sa==null)
  4804.             return false;
  4805.         if(sa.getInvocazioneServizio()==null)
  4806.             return false;
  4807.         return CostantiConfigurazione.ABILITATO.equals(sa.getInvocazioneServizio().getInvioPerRiferimento());
  4808.     }

  4810.     protected boolean invocazioneServizioRispostaPerRiferimento(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4811.         //        Servizio applicativo
  4812.         if(sa==null)
  4813.             return false;
  4814.         if(sa.getInvocazioneServizio()==null)
  4815.             return false;
  4816.         return CostantiConfigurazione.ABILITATO.equals(sa.getInvocazioneServizio().getRispostaPerRiferimento());
  4817.     }








  4826.     // RICEZIONE RISPOSTA ASINCRONA

  4828.     protected boolean existsConsegnaRispostaAsincrona(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound { 

  4830.         if(sa==null)
  4831.             return false;
  4832.         if(sa.getRispostaAsincrona()==null)
  4833.             return false;

  4835.         if(CostantiConfigurazione.ABILITATO.equals(sa.getRispostaAsincrona().getGetMessage()))
  4836.             return true;
  4837.         if( sa.getRispostaAsincrona().getConnettore()!=null 
  4838.                 && !CostantiConfigurazione.DISABILITATO.equals(sa.getRispostaAsincrona().getConnettore().getTipo()) )
  4839.             return true;

  4841.         return false;

  4843.     }

  4845.     protected boolean consegnaRispostaAsincronaConGetMessage(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4846.         // Servizio applicativo
  4847.         if(sa==null)
  4848.             return false;
  4849.         if(sa.getRispostaAsincrona()==null)
  4850.             return false;
  4851.         RispostaAsincrona serv = sa.getRispostaAsincrona();
  4852.         return CostantiConfigurazione.ABILITATO.equals(serv.getGetMessage());
  4853.     }

  4855.     protected boolean consegnaRispostaAsincronaConSbustamento(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4856.         // Servizio applicativo
  4857.         if(sa==null)
  4858.             return false;
  4859.         if(sa.getRispostaAsincrona()==null)
  4860.             return false;
  4861.         RispostaAsincrona serv = sa.getRispostaAsincrona();
  4862.         return CostantiConfigurazione.ABILITATO.equals(serv.getSbustamentoSoap());
  4863.     }

  4865.     protected boolean consegnaRispostaAsincronaConSbustamentoInformazioniProtocollo(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4866.         // Servizio applicativo
  4867.         if(sa==null)
  4868.             return true;
  4869.         if(sa.getRispostaAsincrona()==null)
  4870.             return true;
  4871.         RispostaAsincrona serv = sa.getRispostaAsincrona();
  4872.         return !CostantiConfigurazione.DISABILITATO.equals(serv.getSbustamentoInformazioniProtocollo());
  4873.     }

  4875.     protected boolean consegnaRispostaAsincronaConConnettore(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  4876.         // Servizio applicativo
  4877.         if(sa==null)
  4878.             return false;
  4879.         if(sa.getRispostaAsincrona()==null)
  4880.             return false;
  4881.         RispostaAsincrona serv = sa.getRispostaAsincrona();
  4882.         Connettore connettore = serv.getConnettore();
  4883.         if(connettore!=null && 
  4884.                 !CostantiConfigurazione.NONE.equals(connettore.getTipo()) &&
  4885.                 !CostantiConfigurazione.DISABILITATO.equals(connettore.getTipo()))
  4886.             return true;
  4887.         else
  4888.             return false;
  4889.     }

  4891.     protected ConnettoreMsg getConsegnaRispostaAsincrona(Connection connectionPdD,ServizioApplicativo sa,RichiestaDelegata idPD, RequestInfo requestInfo)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  4893.         // Servizio applicativo
  4894.         if(sa.getRispostaAsincrona()==null)
  4895.             throw new DriverConfigurazioneNotFound("Servizio applicativo ["+idPD.getServizioApplicativo()+"] del soggetto["+idPD.getIdSoggettoFruitore()+"] non possiede una risposta Asincrona");
  4896.         RispostaAsincrona serv = sa.getRispostaAsincrona();


  4899.         // Soggetto che possiede il connettore
  4900.         IDSoggetto aSoggetto = idPD.getIdSoggettoFruitore();
  4901.         Soggetto soggetto = null;
  4902.         if( requestInfo!=null && requestInfo.getRequestConfig()!=null && aSoggetto!=null) {
  4903.             if(requestInfo.getRequestConfig().getSoggettoErogatoreConfig()!=null &&
  4904.                     aSoggetto.getTipo().equals(requestInfo.getRequestConfig().getSoggettoErogatoreConfig().getTipo()) &&
  4905.                     aSoggetto.getNome().equals(requestInfo.getRequestConfig().getSoggettoErogatoreConfig().getNome())   ) {
  4906.                 soggetto = requestInfo.getRequestConfig().getSoggettoErogatoreConfig();
  4907.             }
  4908.             else if( requestInfo.getRequestConfig().getSoggettoFruitoreConfig()!=null &&
  4909.                     aSoggetto.getTipo().equals(requestInfo.getRequestConfig().getSoggettoFruitoreConfig().getTipo()) &&
  4910.                     aSoggetto.getNome().equals(requestInfo.getRequestConfig().getSoggettoFruitoreConfig().getNome())    ) {
  4911.                 soggetto = requestInfo.getRequestConfig().getSoggettoFruitoreConfig();
  4912.             }
  4913.         }
  4914.         if(soggetto==null) {
  4915.             if(requestInfo!=null && requestInfo.getRequestThreadContext()!=null && requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo()!=null) {
  4916.                 if(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig()!=null && aSoggetto!=null && 
  4917.                         aSoggetto.getTipo().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig().getTipo()) && 
  4918.                         aSoggetto.getNome().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig().getNome())) {
  4919.                     soggetto = requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig();
  4920.                 }
  4921.             }
  4922.         }
  4923.         if(soggetto==null) {
  4924.             if(requestInfo!=null && requestInfo.getRequestThreadContext()!=null && requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo()!=null) {
  4925.                 if(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig()!=null && aSoggetto!=null && 
  4926.                         aSoggetto.getTipo().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig().getTipo()) && 
  4927.                         aSoggetto.getNome().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig().getNome())) {
  4928.                     soggetto = requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig();
  4929.                 }
  4930.             }
  4931.         }
  4932.         if(soggetto==null) {
  4933.             soggetto = this.configurazionePdD.getSoggetto(connectionPdD,aSoggetto);
  4934.         }
  4935.         if(soggetto==null)
  4936.             throw new DriverConfigurazioneNotFound("[getConsegnaRispostaAsincrona] Soggetto non trovato");


  4939.         // CONNETTORE
  4940.         Connettore connettore = serv.getConnettore();
  4941.         java.util.Map<String,String> properties = null;
  4942.         if(connettore != null && CostantiConfigurazione.DISABILITATO.equals(connettore.getTipo())==false){
  4943.             String nome = connettore.getNome();
  4944.             if(connettore.getTipo() == null){
  4945.                 // la definizione nel servizio applicativo e' un puntatore, lo cerca nel soggetto.
  4946.                 for(int i=0;i<soggetto.sizeConnettoreList();i++){
  4947.                     if(nome.equals(soggetto.getConnettore(i).getNome())){
  4948.                         connettore = soggetto.getConnettore(i);
  4949.                         break;
  4950.                     }
  4951.                 }
  4952.             }

  4954.             // urlPrefixRewriter
  4955.             setPAUrlPrefixRewriter(connectionPdD,connettore, aSoggetto, requestInfo);

  4957.             // set properties
  4958.             properties = new java.util.HashMap<>();
  4959.             for(int i=0;i<connettore.sizePropertyList();i++){
  4960.                 properties.put(connettore.getProperty(i).getNome(),connettore.getProperty(i).getValore());
  4961.             }
  4962.         }


  4965.         // Autenticazione
  4966.         String autenticazione = CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_NONE.toString();
  4967.         String tmp = null;
  4968.         if(serv.getAutenticazione()!=null){
  4969.             tmp = serv.getAutenticazione().toString();
  4970.         }
  4971.         if(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.toString().equalsIgnoreCase(tmp))
  4972.             autenticazione = CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.toString();


  4975.         // Credenziali
  4976.         InvocazioneCredenziali credenziali = null;
  4977.         if(serv.getCredenziali()!=null){
  4978.             credenziali = new InvocazioneCredenziali();
  4979.             credenziali.setUser(serv.getCredenziali().getUser());
  4980.             credenziali.setPassword(serv.getCredenziali().getPassword());
  4981.         }

  4983.         // Costruisco connettoreMsg
  4984.         ConnettoreMsg connettoreMsg = null;
  4985.         if(connettore != null){
  4986.             connettoreMsg = new ConnettoreMsg();
  4987.             connettoreMsg.setTipoConnettore(connettore.getTipo());
  4988.             connettoreMsg.setConnectorProperties(properties);

  4990.             connettoreMsg.setSbustamentoSOAP(CostantiConfigurazione.ABILITATO.equals(serv.getSbustamentoSoap()));
  4991.             connettoreMsg.setSbustamentoInformazioniProtocollo(!CostantiConfigurazione.DISABILITATO.equals(serv.getSbustamentoInformazioniProtocollo()));
  4992.             connettoreMsg.setAutenticazione(autenticazione);
  4993.             connettoreMsg.setCredenziali(credenziali);
  4994.         }


  4997.         return connettoreMsg;
  4998.     }

  5000.     protected ConnettoreMsg getConsegnaRispostaAsincrona(Connection connectionPdD,ServizioApplicativo sa,RichiestaApplicativa richiestaApplicativa, RequestInfo requestInfo)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  5002.         //       Servizio applicativo
  5003.         if(sa.getRispostaAsincrona()==null)
  5004.             throw new DriverConfigurazioneNotFound("Servizio applicativo ["+richiestaApplicativa.getServizioApplicativo()+"] del soggetto["+richiestaApplicativa.getSoggettoFruitore()+"] non possiede l'elemento invocazione servizio");
  5005.         RispostaAsincrona serv = sa.getRispostaAsincrona();


  5008.         // Soggetto che contiene il connettore
  5009.         IDSoggetto aSoggetto = richiestaApplicativa.getIDServizio().getSoggettoErogatore();
  5010.         Soggetto soggetto = null;
  5011.         if( requestInfo!=null && requestInfo.getRequestConfig()!=null && aSoggetto!=null) {
  5012.             if(requestInfo.getRequestConfig().getSoggettoErogatoreConfig()!=null &&
  5013.                     aSoggetto.getTipo().equals(requestInfo.getRequestConfig().getSoggettoErogatoreConfig().getTipo()) &&
  5014.                     aSoggetto.getNome().equals(requestInfo.getRequestConfig().getSoggettoErogatoreConfig().getNome())   ) {
  5015.                 soggetto = requestInfo.getRequestConfig().getSoggettoErogatoreConfig();
  5016.             }
  5017.             else if( requestInfo.getRequestConfig().getSoggettoFruitoreConfig()!=null &&
  5018.                     aSoggetto.getTipo().equals(requestInfo.getRequestConfig().getSoggettoFruitoreConfig().getTipo()) &&
  5019.                     aSoggetto.getNome().equals(requestInfo.getRequestConfig().getSoggettoFruitoreConfig().getNome())    ) {
  5020.                 soggetto = requestInfo.getRequestConfig().getSoggettoFruitoreConfig();
  5021.             }
  5022.         }
  5023.         if(soggetto==null) {
  5024.             if(requestInfo!=null && requestInfo.getRequestThreadContext()!=null && requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo()!=null) {
  5025.                 if(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig()!=null && aSoggetto!=null && 
  5026.                         aSoggetto.getTipo().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig().getTipo()) && 
  5027.                         aSoggetto.getNome().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig().getNome())) {
  5028.                     soggetto = requestInfo.getRequestThreadContext().getRequestFruitoreTrasportoInfo().getSoggettoFruitoreConfig();
  5029.                 }
  5030.             }
  5031.         }
  5032.         if(soggetto==null) {
  5033.             if(requestInfo!=null && requestInfo.getRequestThreadContext()!=null && requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo()!=null) {
  5034.                 if(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig()!=null && aSoggetto!=null && 
  5035.                         aSoggetto.getTipo().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig().getTipo()) && 
  5036.                         aSoggetto.getNome().equals(requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig().getNome())) {
  5037.                     soggetto = requestInfo.getRequestThreadContext().getRequestFruitoreTokenInfo().getSoggettoFruitoreConfig();
  5038.                 }
  5039.             }
  5040.         }
  5041.         if(soggetto==null) {
  5042.             soggetto = this.configurazionePdD.getSoggetto(connectionPdD,aSoggetto);
  5043.         }
  5044.         if(soggetto==null)
  5045.             throw new DriverConfigurazioneNotFound("[getConsegnaRispostaAsincrona] Soggetto non trovato");


  5048.         // Porta Applicativa
  5049.         PortaApplicativa pa = null;
  5050.         if(requestInfo!=null && requestInfo.getRequestConfig()!=null && richiestaApplicativa.getIdPortaApplicativa()!=null && richiestaApplicativa.getIdPortaApplicativa().getNome()!=null) {
  5051.             if( requestInfo.getRequestConfig().getPortaApplicativa()!=null && richiestaApplicativa.getIdPortaApplicativa().getNome().equals(requestInfo.getRequestConfig().getPortaApplicativa().getNome())) {
  5052.                 pa = requestInfo.getRequestConfig().getPortaApplicativa();
  5053.             }
  5054.             else if( requestInfo.getRequestConfig().getPortaApplicativaDefault()!=null && richiestaApplicativa.getIdPortaApplicativa().getNome().equals(requestInfo.getRequestConfig().getPortaApplicativaDefault().getNome())) {
  5055.                 pa = requestInfo.getRequestConfig().getPortaApplicativaDefault();
  5056.             }
  5057.         }
  5058.         if(pa==null) {
  5059.             pa = this.configurazionePdD.getPortaApplicativa(connectionPdD,richiestaApplicativa.getIdPortaApplicativa());
  5060.         }


  5063.         // CONNETTORE
  5064.         Connettore connettore = serv.getConnettore();
  5065.         java.util.Map<String,String> properties = null;
  5066.         if(connettore != null && CostantiConfigurazione.DISABILITATO.equals(connettore.getTipo())==false){
  5067.             String nome = connettore.getNome();
  5068.             if(connettore.getTipo() == null){
  5069.                 // la definizione nel servizio applicativo e' un puntatore, lo cerca nel soggetto.
  5070.                 for(int i=0;i<soggetto.sizeConnettoreList();i++){
  5071.                     if(nome.equals(soggetto.getConnettore(i).getNome())){
  5072.                         connettore = soggetto.getConnettore(i);
  5073.                         break;
  5074.                     }
  5075.                 }
  5076.             }

  5078.             // urlPrefixRewriter
  5079.             setPAUrlPrefixRewriter(connectionPdD,connettore, aSoggetto, requestInfo);

  5081.             // Properties connettore
  5082.             properties = new java.util.HashMap<>();
  5083.             for(int i=0;i<connettore.sizePropertyList();i++){
  5084.                 properties.put(connettore.getProperty(i).getNome(),connettore.getProperty(i).getValore());
  5085.             }
  5086.         }


  5089.         // PROTOCOL-PROPERTIES
  5090.         Map<String, List<String>> protocol_properties = new HashMap<>();
  5091.         for(int i=0;i<pa.sizeProprietaList();i++){
  5092.             TransportUtils.put(protocol_properties, pa.getProprieta(i).getNome(),pa.getProprieta(i).getValore(), false);
  5093.         }

  5095.         // Autenticazione
  5096.         String autenticazione = CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_NONE.toString();
  5097.         String tmp = null;
  5098.         if(serv.getAutenticazione()!=null){
  5099.             tmp = serv.getAutenticazione().toString();
  5100.         }
  5101.         if(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.toString().equalsIgnoreCase(tmp))
  5102.             autenticazione = CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.toString();


  5105.         // Credenziali
  5106.         InvocazioneCredenziali credenziali = null;
  5107.         if(serv.getCredenziali()!=null){
  5108.             credenziali = new InvocazioneCredenziali();
  5109.             credenziali.setUser(serv.getCredenziali().getUser());
  5110.             credenziali.setPassword(serv.getCredenziali().getPassword());
  5111.         }

  5113.         // Costruisco connettoreMsg
  5114.         ConnettoreMsg connettoreMsg = null;
  5115.         if(connettore != null){
  5116.             connettoreMsg = new ConnettoreMsg();
  5117.             connettoreMsg.setTipoConnettore(connettore.getTipo());
  5118.             connettoreMsg.setConnectorProperties(properties);
  5119.             connettoreMsg.setSbustamentoSOAP(CostantiConfigurazione.ABILITATO.equals(serv.getSbustamentoSoap()));
  5120.             connettoreMsg.setSbustamentoInformazioniProtocollo(!CostantiConfigurazione.DISABILITATO.equals(serv.getSbustamentoInformazioniProtocollo()));
  5121.             connettoreMsg.setPropertiesTrasporto(protocol_properties);
  5122.             connettoreMsg.setPropertiesUrlBased(protocol_properties);
  5123.             connettoreMsg.setAutenticazione(autenticazione);
  5124.             connettoreMsg.setCredenziali(credenziali);
  5125.         }


  5128.         return connettoreMsg;
  5129.     }

  5131.     protected GestioneErrore getGestioneErroreConnettoreRispostaAsincrona(IProtocolFactory<?> protocolFactory, ServiceBinding serviceBinding, Connection connectionPdD,ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  5133.         //  Servizio applicativo
  5134.         if(sa.getRispostaAsincrona()==null ||
  5135.                 sa.getRispostaAsincrona().getGestioneErrore()==null )
  5136.             return getGestioneErroreConnettoreComponenteIntegrazione(protocolFactory, serviceBinding, connectionPdD);
  5137.         RispostaAsincrona asincrona = sa.getRispostaAsincrona();
  5138.         return asincrona.getGestioneErrore();

  5140.     }

  5142.     protected boolean consegnaRispostaAsincronaPerRiferimento(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  5143.         //    Servizio applicativo
  5144.         if(sa==null)
  5145.             return false;
  5146.         if(sa.getRispostaAsincrona()==null)
  5147.             return false;
  5148.         return CostantiConfigurazione.ABILITATO.equals(sa.getRispostaAsincrona().getInvioPerRiferimento());
  5149.     }

  5151.     protected boolean consegnaRispostaAsincronaRispostaPerRiferimento(ServizioApplicativo sa)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  5152.         // Servizio applicativo
  5153.         if(sa==null)
  5154.             return false;
  5155.         if(sa.getRispostaAsincrona()==null)
  5156.             return false;
  5157.         return CostantiConfigurazione.ABILITATO.equals(sa.getRispostaAsincrona().getRispostaPerRiferimento());
  5158.     }





  5164.     // CHECK CERTIFICATI
  5165.     
  5166.     protected CertificateCheck checkCertificatoApplicativo(Connection connectionPdD,boolean useCache,
  5167.             long idSA, int sogliaWarningGiorni, 
  5168.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  5169.         
  5170.         if(useCache) {
  5171.             throw new DriverConfigurazioneException("Not Implemented");
  5172.         }
  5173.         
  5174.         ServizioApplicativo sa = null;
  5175.         IDriverConfigurazioneGet driver = this.configurazionePdD.getDriverConfigurazionePdD();
  5176.         if(driver instanceof DriverConfigurazioneDB) {
  5177.             DriverConfigurazioneDB driverDB = (DriverConfigurazioneDB) driver;
  5178.             sa = driverDB.getServizioApplicativo(idSA);
  5179.         }
  5180.         else {
  5181.             throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  5182.         }
  5183.         return checkCertificatoApplicativo(sa,sogliaWarningGiorni, 
  5184.                 addCertificateDetails, separator, newLine,
  5185.                 this.logger);
  5186.     }
  5187.     protected CertificateCheck checkCertificatoApplicativo(Connection connectionPdD,boolean useCache,
  5188.             IDServizioApplicativo idSA, int sogliaWarningGiorni, 
  5189.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  5190.         
  5191.         ServizioApplicativo sa = null;
  5192.         if(useCache) {
  5193.             sa = this.configurazionePdD.getServizioApplicativo(connectionPdD, idSA);
  5194.         }
  5195.         else {
  5196.             sa = this.configurazionePdD.getDriverConfigurazionePdD().getServizioApplicativo(idSA);
  5197.         }
  5198.         return checkCertificatoApplicativo(sa, sogliaWarningGiorni, 
  5199.                 addCertificateDetails, separator, newLine,
  5200.                 this.logger);
  5201.     }
  5202.     public static CertificateCheck checkCertificatoApplicativo(ServizioApplicativo sa, int sogliaWarningGiorni, 
  5203.             boolean addCertificateDetails, String separator, String newLine,
  5204.             Logger log) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  5205.         
  5206.         if(sa==null) {
  5207.             throw new DriverConfigurazioneException("Applicativo non fornito");
  5208.         }
  5209.         if(sa.getInvocazionePorta()==null || sa.getInvocazionePorta().sizeCredenzialiList()<=0) {
  5210.             throw new DriverConfigurazioneException("Nessuna credenziale risulta associata all'applicativo");
  5211.         }
  5212.         List<byte[]> certs = new ArrayList<>();
  5213.         List<Boolean> strictValidation = new ArrayList<>();
  5214.         for (int i = 0; i < sa.getInvocazionePorta().sizeCredenzialiList(); i++) {
  5215.             Credenziali c = sa.getInvocazionePorta().getCredenziali(i);
  5216.             if(!org.openspcoop2.core.config.constants.CredenzialeTipo.SSL.equals(c.getTipo())) {
  5217.                 throw new DriverConfigurazioneException("La credenziale ("+c.getTipo()+") associata all'applicativo non è un certificato x509");
  5218.             }
  5219.             if(c.getCertificate()!=null) {
  5220.                 certs.add(c.getCertificate());
  5221.                 strictValidation.add(c.isCertificateStrictVerification());
  5222.             }
  5223.         }
  5224.         if(certs.isEmpty()) {
  5225.             throw new DriverConfigurazioneException("Nessun certificato risulta associata all'applicativo");
  5226.         }
  5227.         else {
  5228.             try {
  5229.                 return CertificateUtils.checkCertificateClient(certs, strictValidation, sogliaWarningGiorni,  
  5230.                         addCertificateDetails, separator, newLine,
  5231.                         log);
  5232.             }catch(Exception t) {
  5233.                 throw new DriverConfigurazioneException(t.getMessage(),t);
  5234.             }
  5235.         }

  5237.     }

  5239.     protected CertificateCheck checkCertificatoModiApplicativo(Connection connectionPdD,boolean useCache,
  5240.             long idSA, int sogliaWarningGiorni, 
  5241.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  5242.         
  5243.         if(useCache) {
  5244.             throw new DriverConfigurazioneException("Not Implemented");
  5245.         }
  5246.         
  5247.         ServizioApplicativo sa = null;
  5248.         IDriverConfigurazioneGet driver = this.configurazionePdD.getDriverConfigurazionePdD();
  5249.         if(driver instanceof DriverConfigurazioneDB) {
  5250.             DriverConfigurazioneDB driverDB = (DriverConfigurazioneDB) driver;
  5251.             sa = driverDB.getServizioApplicativo(idSA);
  5252.         }
  5253.         else {
  5254.             throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  5255.         }
  5256.         return checkCertificatoModiApplicativo(sa,sogliaWarningGiorni, 
  5257.                 addCertificateDetails, separator, newLine,
  5258.                 this.logger);
  5259.     }
  5260.     protected CertificateCheck checkCertificatoModiApplicativo(Connection connectionPdD,boolean useCache,
  5261.             IDServizioApplicativo idSA, int sogliaWarningGiorni, 
  5262.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  5263.         
  5264.         ServizioApplicativo sa = null;
  5265.         if(useCache) {
  5266.             sa = this.configurazionePdD.getServizioApplicativo(connectionPdD, idSA);
  5267.         }
  5268.         else {
  5269.             sa = this.configurazionePdD.getDriverConfigurazionePdD().getServizioApplicativo(idSA);
  5270.         }
  5271.         return checkCertificatoModiApplicativo(sa, sogliaWarningGiorni, 
  5272.                 addCertificateDetails, separator, newLine,
  5273.                 this.logger);
  5274.     }
  5275.     public static CertificateCheck checkCertificatoModiApplicativo(ServizioApplicativo sa, int sogliaWarningGiorni, 
  5276.             boolean addCertificateDetails, String separator, String newLine,
  5277.             Logger log) throws DriverConfigurazioneException {
  5278.         
  5279.         String protocollo = null;
  5280.         try {
  5281.             protocollo = ProtocolFactoryManager.getInstance().getProtocolByOrganizationType(sa.getTipoSoggettoProprietario());
  5282.         }catch(Exception e) {
  5283.             throw new DriverConfigurazioneException(e.getMessage(),e);
  5284.         }
  5285.         boolean modi = CostantiLabel.MODIPA_PROTOCOL_NAME.equals(protocollo);
  5286.         if(!modi) {
  5287.             throw new DriverConfigurazioneException("Il profilo di interoperabilità dell'applicativo non è "+CostantiLabel.MODIPA_PROTOCOL_LABEL);
  5288.         }
  5289.         
  5290.         KeystoreParams keystoreParams = ModIUtils.getApplicativoKeystoreParams(sa.getProtocolPropertyList());
  5291.         if(keystoreParams==null) {
  5292.             throw new DriverConfigurazioneException("Non risulta alcun keystore, da utilizzare per la firma "+CostantiLabel.MODIPA_PROTOCOL_LABEL+", associato all'applicativo");
  5293.         }
  5294.         
  5295.         CertificateCheck check = null;
  5296.         boolean classpathSupported = false;
  5297.         try {
  5298.             if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  5299.                 IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  5300.                 
  5301.                 check = CertificateUtils.checkKeyPair(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyPairPublicKeyPath(), keystoreParams.getKeyPassword(), keystoreParams.getKeyPairAlgorithm(),
  5302.                         byokUnwrapManager,
  5303.                         false, //addCertificateDetails,  
  5304.                         separator, newLine);
  5305.             }
  5306.             else if(SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  5307.                 throw new DriverConfigurazioneException("Nell'Applicativo "+sa.getNome()+" la configurazione ModI utilizza un keystore "+SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_LABEL+" non compatibile la firma dei messaggi");
  5308.             }
  5309.             else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  5310.                 IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  5311.                 
  5312.                 check = CertificateUtils.checkKeystoreJWKs(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyAlias(), byokUnwrapManager,
  5313.                         false, //addCertificateDetails,  
  5314.                         separator, newLine);
  5315.             }
  5316.             else {
  5317.                 IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  5318.                 
  5319.                 if(keystoreParams.getStore()!=null) {
  5320.                     check = CertificateUtils.checkKeyStore(CostantiLabel.STORE_CARICATO_BASEDATI, keystoreParams.getStore(), keystoreParams.getType(), keystoreParams.getPassword(), 
  5321.                             byokUnwrapManager,
  5322.                             keystoreParams.getKeyAlias(), keystoreParams.getKeyPassword(),
  5323.                             sogliaWarningGiorni, 
  5324.                             addCertificateDetails, separator, newLine,
  5325.                             log);
  5326.                 }
  5327.                 else {
  5328.                     check = CertificateUtils.checkKeyStore(keystoreParams.getPath(), classpathSupported, keystoreParams.getType(), keystoreParams.getPassword(), 
  5329.                             byokUnwrapManager,
  5330.                             keystoreParams.getKeyAlias(), keystoreParams.getKeyPassword(),
  5331.                             sogliaWarningGiorni, 
  5332.                             addCertificateDetails, separator, newLine,
  5333.                             log);
  5334.                 }
  5335.             }
  5336.         }catch(Exception t) {
  5337.             throw new DriverConfigurazioneException(t.getMessage(),t);
  5338.         }

  5340.         if(check==null || StatoCheck.OK.equals(check.getStatoCheck())) {
  5341.             byte[] cert = ModIUtils.getApplicativoKeystoreCertificate(sa.getProtocolPropertyList());
  5342.             if(cert!=null && cert.length>0) {
  5343.                 try {
  5344.                     return CertificateUtils.checkSingleCertificate("Certificato associato al keystore ModI", cert, 
  5345.                             sogliaWarningGiorni, 
  5346.                             separator, newLine);
  5347.                 }catch(Exception t) {
  5348.                     throw new DriverConfigurazioneException(t.getMessage(),t);
  5349.                 }
  5350.             }
  5351.         }
  5352.         
  5353.         return check;
  5354.     }

  5356.     
  5357.     protected CertificateCheck checkCertificatiConnettoreHttpsById(Connection connectionPdD,boolean useCache,
  5358.             long idConnettore, int sogliaWarningGiorni, 
  5359.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  5360.         
  5361.         if(connectionPdD!=null) {
  5362.             // nop
  5363.         }
  5364.         
  5365.         if(useCache) {
  5366.             throw new DriverConfigurazioneException("Not Implemented");
  5367.         }
  5368.         
  5369.         Connettore connettore = null;
  5370.         IDriverConfigurazioneGet driver = this.configurazionePdD.getDriverConfigurazionePdD();
  5371.         if(driver instanceof DriverConfigurazioneDB) {
  5372.             DriverConfigurazioneDB driverDB = (DriverConfigurazioneDB) driver;
  5373.             connettore = driverDB.getConnettore(idConnettore);
  5374.         }
  5375.         else {
  5376.             throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  5377.         }
  5378.         return checkCertificatiConnettoreHttpsById(connettore,sogliaWarningGiorni, 
  5379.                 addCertificateDetails, separator, newLine,
  5380.                 this.logger);
  5381.     }
  5382.     public static CertificateCheck checkCertificatiConnettoreHttpsById(Connettore connettore, int sogliaWarningGiorni, 
  5383.             boolean addCertificateDetails, String separator, String newLine,
  5384.             Logger log) throws DriverConfigurazioneException {
  5385.         
  5386.         TipiConnettore tipo = TipiConnettore.toEnumFromName(connettore.getTipo());
  5387.         if( !TipiConnettore.HTTPS.equals(tipo)) {
  5388.             throw new DriverConfigurazioneException("Il connettore indicato non è di tipo https");
  5389.         }
  5390.         
  5391.         SSLConfig httpsProp = null;
  5392.         Map<String,Object> dynamicMap = null;
  5393.         try {
  5394.             httpsProp = ConnettoreHTTPSProperties.readProperties(connettore.getProperties());
  5395.             dynamicMap = DynamicMapBuilderUtils.buildDynamicMap(null, null, null, 
  5396.                     log);
  5397.             httpsProp.setDynamicMap(dynamicMap);
  5398.         }catch(Exception t) {
  5399.             throw new DriverConfigurazioneException(t.getMessage(),t);
  5400.         }
  5401.         CertificateCheck check = null;
  5402.         boolean classpathSupported = false;
  5403.                 
  5404.         String storeDetails = null; // per evitare duplicazione
  5405.         
  5406.         if(httpsProp.getKeyStoreLocation()!=null) {
  5407.             try {
  5408.                 IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapPolicyUtilities.getBYOKUnwrapManager(httpsProp.getKeyStoreBYOKPolicy(), dynamicMap);
  5409.                 
  5410.                 check = CertificateUtils.checkKeyStore(httpsProp.getKeyStoreLocation(), classpathSupported, httpsProp.getKeyStoreType(), 
  5411.                         httpsProp.getKeyStorePassword(), 
  5412.                         byokUnwrapManager,
  5413.                         httpsProp.getKeyAlias(), httpsProp.getKeyPassword(),
  5414.                         sogliaWarningGiorni, 
  5415.                         false, //addCertificateDetails,  
  5416.                         separator, newLine,
  5417.                         log);
  5418.                 
  5419.                 if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5420.                     storeDetails = CertificateUtils.toStringKeyStore(httpsProp.getKeyStoreLocation(), httpsProp.getKeyStoreType(),
  5421.                             httpsProp.getKeyStoreBYOKPolicy(),
  5422.                             httpsProp.getKeyAlias(), 
  5423.                             separator, newLine);
  5424.                 }
  5425.             }catch(Exception t) {
  5426.                 throw new DriverConfigurazioneException(t.getMessage(),t);
  5427.             }
  5428.         }
  5429.         
  5430.         if(check==null || StatoCheck.OK.equals(check.getStatoCheck())) {
  5431.             if(!httpsProp.isTrustAllCerts() && httpsProp.getTrustStoreLocation()!=null) {
  5432.                 try {
  5433.                     check = CertificateUtils.checkTrustStore(httpsProp.getTrustStoreLocation(), classpathSupported, httpsProp.getTrustStoreType(), 
  5434.                             httpsProp.getTrustStorePassword(), httpsProp.getTrustStoreCRLsLocation(), httpsProp.getTrustStoreOCSPPolicy(),
  5435.                             sogliaWarningGiorni, 
  5436.                             false, //addCertificateDetails, 
  5437.                             separator, newLine,
  5438.                             log);
  5439.                     
  5440.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5441.                         storeDetails = CertificateUtils.toStringTrustStore(httpsProp.getTrustStoreLocation(), httpsProp.getTrustStoreType(),
  5442.                                 httpsProp.getTrustStoreCRLsLocation(), httpsProp.getTrustStoreOCSPPolicy(),
  5443.                                 separator, newLine);
  5444.                     }
  5445.                 }catch(Exception t) {
  5446.                     throw new DriverConfigurazioneException(t.getMessage(),t);
  5447.                 }
  5448.             }
  5449.         }
  5450.         
  5451.         if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5452.             String id = RegistroServiziReader.ID_CONFIGURAZIONE_CONNETTORE_HTTPS;
  5453.             if(addCertificateDetails && storeDetails!=null) {
  5454.                 id = id + newLine + storeDetails;
  5455.             }
  5456.             check.setConfigurationId(id);   
  5457.         }   
  5458.         
  5459.         if(check==null) {
  5460.             // connettore https con truststore 'all' senza client autentication
  5461.             check = new CertificateCheck();
  5462.             check.setStatoCheck(StatoCheck.OK);
  5463.         }
  5464.         
  5465.         return check;
  5466.     }

  5468.     public CertificateCheck checkCertificatiJvm(int sogliaWarningGiorni, 
  5469.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException{
  5470.         return checkCertificatiJvm(sogliaWarningGiorni, 
  5471.                 addCertificateDetails, separator, newLine,
  5472.                 this.logger);
  5473.     }
  5474.     
  5475.     public static CertificateCheck checkCertificatiJvm(int sogliaWarningGiorni, 
  5476.             boolean addCertificateDetails, String separator, String newLine,
  5477.             Logger log) throws DriverConfigurazioneException {
  5478.         
  5479.         CertificateCheck check = null;
  5480.         boolean classpathSupported = false;
  5481.         
  5482.         String storeDetails = null; // per evitare duplicazione
  5483.         
  5484.         KeystoreParams keystoreParams = CertificateUtils.readKeyStoreParamsJVM();
  5485.         KeystoreParams truststoreParams = CertificateUtils.readTrustStoreParamsJVM();
  5486.         
  5487.         if(keystoreParams!=null) {
  5488.             try {
  5489.                 IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  5490.                 
  5491.                 check = CertificateUtils.checkKeyStore(keystoreParams.getPath(), classpathSupported, keystoreParams.getType(),
  5492.                         keystoreParams.getPassword(), 
  5493.                         byokUnwrapManager,
  5494.                         keystoreParams.getKeyAlias(), keystoreParams.getKeyPassword(),
  5495.                         sogliaWarningGiorni, 
  5496.                         false, //addCertificateDetails,  
  5497.                         separator, newLine,
  5498.                         log);
  5499.                 
  5500.                 if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5501.                     storeDetails = CertificateUtils.toStringKeyStore(keystoreParams, 
  5502.                             separator, newLine);
  5503.                 }
  5504.             }catch(Exception t) {
  5505.                 throw new DriverConfigurazioneException(t.getMessage(),t);
  5506.             }
  5507.         }
  5508.         
  5509.         if(check==null || StatoCheck.OK.equals(check.getStatoCheck())) {
  5510.             if(truststoreParams!=null) {
  5511.                 try {
  5512.                     check = CertificateUtils.checkTrustStore(truststoreParams.getPath(), classpathSupported, truststoreParams.getType(), 
  5513.                             truststoreParams.getPassword(), truststoreParams.getCrls(), truststoreParams.getOcspPolicy(),
  5514.                             sogliaWarningGiorni, 
  5515.                             false, //addCertificateDetails, 
  5516.                             separator, newLine,
  5517.                             log);
  5518.                     
  5519.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5520.                         storeDetails = CertificateUtils.toStringTrustStore(truststoreParams,
  5521.                                 separator, newLine);
  5522.                     }
  5523.                 }catch(Exception t) {
  5524.                     throw new DriverConfigurazioneException(t.getMessage(),t);
  5525.                 }
  5526.             }
  5527.         }
  5528.         
  5529.         if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5530.             /**String id = "Configurazione https della JVM";*/
  5531.             String id = "";
  5532.             if(addCertificateDetails && storeDetails!=null) {
  5533.                 id = id + newLine + storeDetails;
  5534.             }
  5535.             check.setConfigurationId(id);   
  5536.         }   
  5537.         
  5538.         if(check==null) {
  5539.             // connettore https con truststore 'all' senza client autentication
  5540.             check = new CertificateCheck();
  5541.             check.setStatoCheck(StatoCheck.OK);
  5542.         }
  5543.         
  5544.         return check;
  5545.     }
  5546.     
  5547.     protected CertificateCheck checkCertificatiConnettoreHttpsTokenPolicyValidazione(Connection connectionPdD,boolean useCache,
  5548.             String nome, String tipo, int sogliaWarningGiorni, 
  5549.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  5550.         
  5551.         if(connectionPdD!=null) {
  5552.             // nop
  5553.         }
  5554.         if(useCache) {
  5555.             throw new DriverConfigurazioneException("Not Implemented");
  5556.         }
  5557.         
  5558.         GenericProperties gp = null;
  5559.         IDriverConfigurazioneGet driver = this.configurazionePdD.getDriverConfigurazionePdD();
  5560.         if(driver instanceof DriverConfigurazioneDB) {
  5561.             DriverConfigurazioneDB driverDB = (DriverConfigurazioneDB) driver;
  5562.             gp = driverDB.getGenericProperties(org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA, nome);
  5563.         }
  5564.         else {
  5565.             throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  5566.         }
  5567.         return checkCertificatiConnettoreHttpsTokenPolicyValidazione(gp, tipo, sogliaWarningGiorni, 
  5568.                 addCertificateDetails, separator, newLine,
  5569.                 this.logger);
  5570.     }
  5571.     public static CertificateCheck checkCertificatiConnettoreHttpsTokenPolicyValidazione(GenericProperties gp, String tipo, int sogliaWarningGiorni, 
  5572.             boolean addCertificateDetails, String separator, String newLine,
  5573.             Logger log) throws DriverConfigurazioneException {
  5574.         
  5575.         GestioneToken gestioneToken = new GestioneToken();
  5576.         List<org.openspcoop2.core.config.Connettore> listConnettori = null;
  5577.         try {
  5578.             PolicyGestioneToken policy = TokenUtilities.convertTo(gp, gestioneToken);
  5579.             
  5580.             if( !policy.isEndpointHttps() ) {
  5581.                 throw new DriverConfigurazioneException("La configurazione della policy "+gp.getNome()+" non utilizza un connettore di tipo https");
  5582.             }
  5583.             
  5584.             listConnettori = ConnettoreCheck.convertTokenPolicyValidazioneToConnettore(gp, log);
  5585.         }catch(Exception t) {
  5586.             throw new DriverConfigurazioneException(t.getMessage(),t);
  5587.         }
  5588.         
  5589.         CertificateCheck check = _checkConnettori(listConnettori, tipo, sogliaWarningGiorni, 
  5590.                 addCertificateDetails, separator, newLine,
  5591.                 log);
  5592.         if(check!=null) {
  5593.             return check;
  5594.         }
  5595.         
  5596.         throw new DriverConfigurazioneException("Nella policy "+gp.getNome()+" non risulta configurato un connettore per la funzionalità '"+tipo+"'");
  5597.         
  5598.     }
  5599.     
  5600.     protected CertificateCheck checkCertificatiValidazioneJwtTokenPolicyValidazione(Connection connectionPdD,boolean useCache,
  5601.             String nome, int sogliaWarningGiorni, 
  5602.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  5603.         
  5604.         if(connectionPdD!=null) {
  5605.             // nop
  5606.         }
  5607.         
  5608.         if(useCache) {
  5609.             throw new DriverConfigurazioneException("Not Implemented");
  5610.         }
  5611.         
  5612.         GenericProperties gp = null;
  5613.         IDriverConfigurazioneGet driver = this.configurazionePdD.getDriverConfigurazionePdD();
  5614.         if(driver instanceof DriverConfigurazioneDB) {
  5615.             DriverConfigurazioneDB driverDB = (DriverConfigurazioneDB) driver;
  5616.             gp = driverDB.getGenericProperties(org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA, nome);
  5617.         }
  5618.         else {
  5619.             throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  5620.         }
  5621.         return checkCertificatiValidazioneJwtTokenPolicyValidazione(gp, sogliaWarningGiorni, 
  5622.                 addCertificateDetails, separator, newLine,
  5623.                 this.logger);
  5624.     }
  5625.     public static final String ID_CONFIGURAZIONE_TOKEN_VALIDAZIONE_JWT = "Configurazione Validazione JWT";
  5626.     public static CertificateCheck checkCertificatiValidazioneJwtTokenPolicyValidazione(GenericProperties gp, int sogliaWarningGiorni, 
  5627.             boolean addCertificateDetails, String separator, String newLine,
  5628.             Logger log) throws DriverConfigurazioneException {
  5629.         
  5630.         GestioneToken gestioneToken = new GestioneToken();
  5631.         KeystoreParams keystoreParams = null;
  5632.         KeystoreParams truststoreParams = null;
  5633.         PolicyGestioneToken policy = null;
  5634.         try {
  5635.             policy = TokenUtilities.convertTo(gp, gestioneToken);
  5636.             if(!TokenUtilities.isValidazioneEnabled(gp)) {
  5637.                 throw new DriverConfigurazioneException("La configurazione nella policy "+gp.getNome()+" non utilizza la funzionalità di validazione JWT");
  5638.             }
  5639.             String tokenType = policy.getTipoToken();
  5640.             if(org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_TYPE_JWS.equals(tokenType)) {
  5641.                 // JWS Compact              
  5642.                 truststoreParams = TokenUtilities.getValidazioneJwtKeystoreParams(policy);
  5643.             }
  5644.             else if(org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_TYPE_JWE.equals(tokenType)) {
  5645.                 // JWE Compact
  5646.                 keystoreParams = TokenUtilities.getValidazioneJwtKeystoreParams(policy);
  5647.             }
  5648.         }catch(Exception t) {
  5649.             throw new DriverConfigurazioneException(t.getMessage(),t);
  5650.         }
  5651.         
  5652.         CertificateCheck check = null;
  5653.         boolean classpathSupported = true;
  5654.                 
  5655.         String storeDetails = null; // per evitare duplicazione
  5656.         
  5657.         if(keystoreParams!=null) {
  5658.             try {
  5659.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  5660.                     throw new DriverConfigurazioneException("Nella configurazione della policy "+gp.getNome()+" la funzionalità di validazione JWT utilizza un keystore "+SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_LABEL+" non compatibile con il criterio di validazione dei certificati");
  5661.                 }
  5662.                 else if(SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  5663.                     throw new DriverConfigurazioneException("Nella configurazione della policy "+gp.getNome()+" la funzionalità di validazione JWT utilizza un keystore "+SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_LABEL+" non compatibile con il criterio di validazione dei certificati");
  5664.                     
  5665.                 }
  5666.                 else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  5667.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  5668.                     
  5669.                     if(keystoreParams.getPath().startsWith(JOSEUtils.HTTP_PROTOCOL) || keystoreParams.getPath().startsWith(JOSEUtils.HTTPS_PROTOCOL)) {
  5670.                         byte [] store = getStoreCertificatiTokenPolicy(policy, keystoreParams, log);
  5671.                         check = CertificateUtils.checkKeystoreJWKs(keystoreParams.getPath(), new String(store), keystoreParams.getKeyAlias(), 
  5672.                                 byokUnwrapManager,
  5673.                                 false, //addCertificateDetails,  
  5674.                                 separator, newLine);
  5675.                     }
  5676.                     else{
  5677.                         check = CertificateUtils.checkKeystoreJWKs(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyAlias(), 
  5678.                                 byokUnwrapManager,
  5679.                                 false, //addCertificateDetails,  
  5680.                                 separator, newLine);
  5681.                     }
  5682.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5683.                         storeDetails = CertificateUtils.toStringKeystoreJWKs(keystoreParams, 
  5684.                                 separator, newLine);
  5685.                     }
  5686.                 }
  5687.                 else {  
  5688.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  5689.                     
  5690.                     if(keystoreParams.getPath().startsWith(JOSEUtils.HTTP_PROTOCOL) || keystoreParams.getPath().startsWith(JOSEUtils.HTTPS_PROTOCOL)) {
  5691.                         byte [] store = getStoreCertificatiTokenPolicy(policy, keystoreParams, log);
  5692.                         check = CertificateUtils.checkKeyStore(keystoreParams.getPath(), store, keystoreParams.getType(),
  5693.                                 keystoreParams.getPassword(), 
  5694.                                 byokUnwrapManager,
  5695.                                 keystoreParams.getKeyAlias(), keystoreParams.getKeyPassword(),
  5696.                                 sogliaWarningGiorni, 
  5697.                                 false, //addCertificateDetails,  
  5698.                                 separator, newLine,
  5699.                                 log);
  5700.                     }
  5701.                     else {
  5702.                         check = CertificateUtils.checkKeyStore(keystoreParams.getPath(), classpathSupported, keystoreParams.getType(),
  5703.                                 keystoreParams.getPassword(), 
  5704.                                 byokUnwrapManager,
  5705.                                 keystoreParams.getKeyAlias(), keystoreParams.getKeyPassword(),
  5706.                                 sogliaWarningGiorni, 
  5707.                                 false, //addCertificateDetails,  
  5708.                                 separator, newLine,
  5709.                                 log);
  5710.                     }
  5711.                     
  5712.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5713.                         storeDetails = CertificateUtils.toStringKeyStore(keystoreParams, 
  5714.                                 separator, newLine);
  5715.                     }
  5716.                 }
  5717.             }catch(Exception t) {
  5718.                 throw new DriverConfigurazioneException(t.getMessage(),t);
  5719.             }
  5720.         }
  5721.         
  5722.         if( (check==null || StatoCheck.OK.equals(check.getStatoCheck())) &&
  5723.             truststoreParams!=null
  5724.             ) {
  5725.             try {
  5726.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(truststoreParams.getType())) {
  5727.                     throw new DriverConfigurazioneException("Nella configurazione della policy "+gp.getNome()+" la funzionalità di validazione JWT utilizza un keystore "+SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_LABEL+" non compatibile con il criterio di validazione dei certificati");
  5728.                 }
  5729.                 else if(SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(truststoreParams.getType())) {
  5730.                     if(truststoreParams.getPath().startsWith(JOSEUtils.HTTP_PROTOCOL) || truststoreParams.getPath().startsWith(JOSEUtils.HTTPS_PROTOCOL)) {
  5731.                         byte [] store = getStoreCertificatiTokenPolicy(policy, truststoreParams, log);
  5732.                         check = CertificateUtils.checkPublicKey(truststoreParams.getPath(), store, truststoreParams.getKeyPairAlgorithm(),
  5733.                                 false, //addCertificateDetails,  
  5734.                                 separator, newLine);
  5735.                     }
  5736.                     else {
  5737.                         check = CertificateUtils.checkPublicKey(classpathSupported, truststoreParams.getPath(), truststoreParams.getKeyPairAlgorithm(),
  5738.                                 false, //addCertificateDetails,  
  5739.                                 separator, newLine);
  5740.                     }
  5741.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5742.                         storeDetails = CertificateUtils.toStringPublicKey(truststoreParams, 
  5743.                                 separator, newLine);
  5744.                     }
  5745.                 }
  5746.                 else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(truststoreParams.getType())) {
  5747.                     if(truststoreParams.getPath().startsWith(JOSEUtils.HTTP_PROTOCOL) || truststoreParams.getPath().startsWith(JOSEUtils.HTTPS_PROTOCOL)) {
  5748.                         byte [] store = getStoreCertificatiTokenPolicy(policy, truststoreParams, log);
  5749.                         check = CertificateUtils.checkTruststoreJWKs(truststoreParams.getPath(), new String(store), truststoreParams.getKeyAlias(), 
  5750.                                 false, //addCertificateDetails,  
  5751.                                 separator, newLine);
  5752.                     }
  5753.                     else {
  5754.                         check = CertificateUtils.checkTruststoreJWKs(classpathSupported, truststoreParams.getPath(), truststoreParams.getKeyAlias(), 
  5755.                                 false, //addCertificateDetails,  
  5756.                                 separator, newLine);
  5757.                     }
  5758.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5759.                         storeDetails = CertificateUtils.toStringTruststoreJWKs(truststoreParams, 
  5760.                                 separator, newLine);
  5761.                     }
  5762.                 }
  5763.                 else {      
  5764.                     String alias = truststoreParams.getKeyAlias();
  5765.                     if(alias!=null && 
  5766.                             (
  5767.                                     alias.equals(Costanti.POLICY_VALIDAZIONE_SPECIAL_CASE_USE_X5C)
  5768.                                     ||
  5769.                                     alias.equals(Costanti.POLICY_VALIDAZIONE_SPECIAL_CASE_USE_X5T)
  5770.                                     ||
  5771.                                     alias.equals(Costanti.POLICY_VALIDAZIONE_SPECIAL_CASE_USE_X5C_X5T)
  5772.                             )
  5773.                         ) {
  5774.                         alias=null; // special case, valido tutti i certificati nel truststore con cui validero' il certificato presente in x5c o x5t
  5775.                     }
  5776.                     
  5777.                     if(truststoreParams.getPath().startsWith(JOSEUtils.HTTP_PROTOCOL) || truststoreParams.getPath().startsWith(JOSEUtils.HTTPS_PROTOCOL)) {
  5778.                         byte [] store = getStoreCertificatiTokenPolicy(policy, truststoreParams, log);
  5779.                         check = CertificateUtils.checkTrustStore(truststoreParams.getPath(), store, truststoreParams.getType(), 
  5780.                                 truststoreParams.getPassword(), truststoreParams.getCrls(), truststoreParams.getOcspPolicy(),
  5781.                                 alias,
  5782.                                 sogliaWarningGiorni, 
  5783.                                 false, //addCertificateDetails, 
  5784.                                 separator, newLine,
  5785.                                 log);
  5786.                     }
  5787.                     else {
  5788.                         check = CertificateUtils.checkTrustStore(truststoreParams.getPath(), classpathSupported, truststoreParams.getType(), 
  5789.                                 truststoreParams.getPassword(), truststoreParams.getCrls(), truststoreParams.getOcspPolicy(),
  5790.                                 alias,
  5791.                                 sogliaWarningGiorni, 
  5792.                                 false, //addCertificateDetails, 
  5793.                                 separator, newLine,
  5794.                                 log);
  5795.                     }
  5796.                     
  5797.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5798.                         storeDetails = CertificateUtils.toStringTrustStore(truststoreParams,
  5799.                                 separator, newLine);
  5800.                     }
  5801.                 }
  5802.             }catch(Exception t) {
  5803.                 throw new DriverConfigurazioneException(t.getMessage(),t);
  5804.             }
  5805.         }
  5806.         
  5807.         if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5808.             String id = ID_CONFIGURAZIONE_TOKEN_VALIDAZIONE_JWT;
  5809.             if(addCertificateDetails && storeDetails!=null) {
  5810.                 id = id + newLine + storeDetails;
  5811.             }
  5812.             check.setConfigurationId(id);   
  5813.         }   
  5814.         
  5815.         if(check==null) {
  5816.             // connettore https con truststore 'all' senza client autentication
  5817.             check = new CertificateCheck();
  5818.             check.setStatoCheck(StatoCheck.OK);
  5819.         }
  5820.         
  5821.         return check;
  5822.     }
  5823.     
  5824.     
  5825.     private static byte[] getStoreCertificatiTokenPolicy(AbstractPolicyToken policy,KeystoreParams truststoreParams, Logger log) throws TokenException, SecurityException {
  5826.         Properties p = new Properties();
  5827.         p.put(SecurityConstants.JOSE_KEYSTORE_FILE, truststoreParams.getPath());
  5828.         p.put(SecurityConstants.JOSE_KEYSTORE_TYPE, truststoreParams.getType());
  5829.         if(truststoreParams.getPassword()!=null) {
  5830.             p.put(SecurityConstants.JOSE_KEYSTORE_PSWD, truststoreParams.getPassword());
  5831.         }
  5832.         TokenUtilities.injectJOSEConfigSsl(p, policy,
  5833.                 null, null);
  5834.         boolean throwError = true;
  5835.         boolean forceNoCache = true;
  5836.         return JOSEUtils.readHttpStore(p, null, truststoreParams.getPath(), log, throwError, forceNoCache);
  5837.     }
  5838.     
  5839.     
  5840.     protected CertificateCheck checkCertificatiForwardToJwtTokenPolicyValidazione(Connection connectionPdD,boolean useCache,
  5841.             String nome, int sogliaWarningGiorni, 
  5842.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  5843.         
  5844.         if(connectionPdD!=null) {
  5845.             // nop
  5846.         }
  5847.         
  5848.         if(useCache) {
  5849.             throw new DriverConfigurazioneException("Not Implemented");
  5850.         }
  5851.         
  5852.         GenericProperties gp = null;
  5853.         IDriverConfigurazioneGet driver = this.configurazionePdD.getDriverConfigurazionePdD();
  5854.         if(driver instanceof DriverConfigurazioneDB) {
  5855.             DriverConfigurazioneDB driverDB = (DriverConfigurazioneDB) driver;
  5856.             gp = driverDB.getGenericProperties(org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA, nome);
  5857.         }
  5858.         else {
  5859.             throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  5860.         }
  5861.         return checkCertificatiForwardToJwtTokenPolicyValidazione(gp, sogliaWarningGiorni, 
  5862.                 addCertificateDetails, separator, newLine,
  5863.                 this.logger);
  5864.     }
  5865.     public static final String ID_CONFIGURAZIONE_TOKEN_VALIDAZIONE_FORWARD_TO_JWT = "Configurazione ForwardTo JWT";
  5866.     public static CertificateCheck checkCertificatiForwardToJwtTokenPolicyValidazione(GenericProperties gp, int sogliaWarningGiorni, 
  5867.             boolean addCertificateDetails, String separator, String newLine,
  5868.             Logger log) throws DriverConfigurazioneException {
  5869.         
  5870.         GestioneToken gestioneToken = new GestioneToken();
  5871.         KeystoreParams keystoreParams = null;
  5872.         KeystoreParams truststoreParams = null;
  5873.         try {
  5874.             PolicyGestioneToken policy = TokenUtilities.convertTo(gp, gestioneToken);
  5875.             if(!TokenUtilities.isTokenForwardEnabled(gp) || !policy.isForwardTokenInformazioniRaccolte()) {
  5876.                 throw new DriverConfigurazioneException("La configurazione nella policy "+gp.getNome()+" non utilizza la funzionalità di forward delle informazioni raccolte del token");
  5877.             }
  5878.             String forwardInformazioniRaccolteMode = policy.getForwardTokenInformazioniRaccolteMode();
  5879.             
  5880.             if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_OP2_JWS.equals(forwardInformazioniRaccolteMode) ||
  5881.                     Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWS.equals(forwardInformazioniRaccolteMode)) {
  5882.                 // JWS Compact              
  5883.                 keystoreParams = TokenUtilities.getForwardToJwtKeystoreParams(policy);
  5884.             }
  5885.             else if(Costanti.POLICY_TOKEN_FORWARD_INFO_RACCOLTE_MODE_JWE.equals(forwardInformazioniRaccolteMode)) {
  5886.                 // JWE Compact
  5887.                 truststoreParams = TokenUtilities.getForwardToJwtKeystoreParams(policy);
  5888.                 keystoreParams = TokenUtilities.getForwardToJwtKeystoreParams(policy); // verifico con keystoreParams per adesso poichè cifro con chiave privata
  5889.                 if(keystoreParams!=null) {
  5890.                     truststoreParams=null;
  5891.                 }
  5892.             }
  5893.         }catch(Exception t) {
  5894.             throw new DriverConfigurazioneException(t.getMessage(),t);
  5895.         }
  5896.         
  5897.         CertificateCheck check = null;
  5898.         boolean classpathSupported = true;
  5899.         
  5900.         String storeDetails = null; // per evitare duplicazione
  5901.         
  5902.         if(keystoreParams!=null) {
  5903.             try {
  5904.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  5905.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  5906.                     
  5907.                     check = CertificateUtils.checkKeyPair(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyPairPublicKeyPath(), keystoreParams.getKeyPassword(), keystoreParams.getKeyPairAlgorithm(),
  5908.                             byokUnwrapManager,
  5909.                             false, //addCertificateDetails,  
  5910.                             separator, newLine);
  5911.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5912.                         storeDetails = CertificateUtils.toStringKeyPair(keystoreParams, 
  5913.                                 separator, newLine);
  5914.                     }
  5915.                 }
  5916.                 else if(SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  5917.                     throw new DriverConfigurazioneException("Nella configurazione della policy "+gp.getNome()+" la funzionalità di forward delle informazioni raccolte come JWT utilizza un keystore "+SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_LABEL+" non compatibile con il criterio di validazione dei certificati");
  5918.                     
  5919.                 }
  5920.                 else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  5921.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  5922.                     
  5923.                     check = CertificateUtils.checkKeystoreJWKs(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyAlias(),
  5924.                             byokUnwrapManager,
  5925.                             false, //addCertificateDetails,  
  5926.                             separator, newLine);
  5927.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5928.                         storeDetails = CertificateUtils.toStringKeystoreJWKs(keystoreParams, 
  5929.                                 separator, newLine);
  5930.                     }
  5931.                 }
  5932.                 else {
  5933.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  5934.                     
  5935.                     check = CertificateUtils.checkKeyStore(keystoreParams.getPath(), classpathSupported, keystoreParams.getType(),
  5936.                             keystoreParams.getPassword(), 
  5937.                             byokUnwrapManager,
  5938.                             keystoreParams.getKeyAlias(), keystoreParams.getKeyPassword(),
  5939.                             sogliaWarningGiorni, 
  5940.                             false, //addCertificateDetails,  
  5941.                             separator, newLine,
  5942.                             log);
  5943.                     
  5944.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5945.                         storeDetails = CertificateUtils.toStringKeyStore(keystoreParams, 
  5946.                                 separator, newLine);
  5947.                     }
  5948.                 }
  5949.             }catch(Exception t) {
  5950.                 throw new DriverConfigurazioneException(t.getMessage(),t);
  5951.             }
  5952.         }
  5953.         
  5954.         if( (check==null || StatoCheck.OK.equals(check.getStatoCheck())) &&
  5955.             truststoreParams!=null
  5956.             ) {
  5957.             try {
  5958.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(truststoreParams.getType())) {
  5959.                     throw new DriverConfigurazioneException("Nella configurazione della policy "+gp.getNome()+" la funzionalità di forward delle informazioni raccolte come JWT utilizza un keystore "+SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_LABEL+" non compatibile con il criterio di validazione dei certificati");
  5960.                 }
  5961.                 else if(SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(truststoreParams.getType())) {
  5962.                     check = CertificateUtils.checkPublicKey(classpathSupported, truststoreParams.getPath(), truststoreParams.getKeyPairAlgorithm(),
  5963.                             false, //addCertificateDetails,  
  5964.                             separator, newLine);
  5965.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5966.                         storeDetails = CertificateUtils.toStringPublicKey(truststoreParams, 
  5967.                                 separator, newLine);
  5968.                     }
  5969.                 }
  5970.                 else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(truststoreParams.getType())) {
  5971.                     check = CertificateUtils.checkTruststoreJWKs(classpathSupported, truststoreParams.getPath(), truststoreParams.getKeyAlias(), 
  5972.                             false, //addCertificateDetails,  
  5973.                             separator, newLine);
  5974.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5975.                         storeDetails = CertificateUtils.toStringTruststoreJWKs(truststoreParams, 
  5976.                                 separator, newLine);
  5977.                     }
  5978.                 }
  5979.                 else {      
  5980.                     check = CertificateUtils.checkTrustStore(truststoreParams.getPath(), classpathSupported, truststoreParams.getType(), 
  5981.                             truststoreParams.getPassword(), truststoreParams.getCrls(), truststoreParams.getOcspPolicy(),
  5982.                             truststoreParams.getKeyAlias(),
  5983.                             sogliaWarningGiorni, 
  5984.                             false, //addCertificateDetails, 
  5985.                             separator, newLine,
  5986.                             log);
  5987.                     
  5988.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5989.                         storeDetails = CertificateUtils.toStringTrustStore(truststoreParams,
  5990.                                 separator, newLine);
  5991.                     }
  5992.                 }
  5993.             }catch(Exception t) {
  5994.                 throw new DriverConfigurazioneException(t.getMessage(),t);
  5995.             }
  5996.         }
  5997.         
  5998.         if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  5999.             String id = ID_CONFIGURAZIONE_TOKEN_VALIDAZIONE_FORWARD_TO_JWT;
  6000.             if(addCertificateDetails && storeDetails!=null) {
  6001.                 id = id + newLine + storeDetails;
  6002.             }
  6003.             check.setConfigurationId(id);   
  6004.         }   
  6005.         
  6006.         if(check==null) {
  6007.             // connettore https con truststore 'all' senza client autentication
  6008.             check = new CertificateCheck();
  6009.             check.setStatoCheck(StatoCheck.OK);
  6010.         }
  6011.         
  6012.         return check;
  6013.     }


  6016.     protected CertificateCheck checkCertificatiConnettoreHttpsTokenPolicyNegoziazione(Connection connectionPdD,boolean useCache,
  6017.             String nome, int sogliaWarningGiorni, 
  6018.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  6019.         
  6020.         if(connectionPdD!=null) {
  6021.             // nop
  6022.         }
  6023.         
  6024.         if(useCache) {
  6025.             throw new DriverConfigurazioneException("Not Implemented");
  6026.         }
  6027.         
  6028.         GenericProperties gp = null;
  6029.         IDriverConfigurazioneGet driver = this.configurazionePdD.getDriverConfigurazionePdD();
  6030.         if(driver instanceof DriverConfigurazioneDB) {
  6031.             DriverConfigurazioneDB driverDB = (DriverConfigurazioneDB) driver;
  6032.             gp = driverDB.getGenericProperties(org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA_RETRIEVE, nome);
  6033.         }
  6034.         else {
  6035.             throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  6036.         }
  6037.         return checkCertificatiConnettoreHttpsTokenPolicyNegoziazione(gp, sogliaWarningGiorni, 
  6038.                 addCertificateDetails, separator, newLine,
  6039.                 this.logger);
  6040.     }
  6041.     public static CertificateCheck checkCertificatiConnettoreHttpsTokenPolicyNegoziazione(GenericProperties gp, int sogliaWarningGiorni, 
  6042.             boolean addCertificateDetails, String separator, String newLine,
  6043.             Logger log) throws DriverConfigurazioneException {
  6044.         
  6045.         List<org.openspcoop2.core.config.Connettore> listConnettori = null;
  6046.         try {
  6047.             PolicyNegoziazioneToken policy = TokenUtilities.convertTo(gp);
  6048.             
  6049.             if( !policy.isEndpointHttps() ) {
  6050.                 throw new DriverConfigurazioneException("La configurazione della policy "+gp.getNome()+" non utilizza un connettore di tipo https");
  6051.             }
  6052.             
  6053.             listConnettori = ConnettoreCheck.convertTokenPolicyNegoziazioneToConnettore(gp, log); // sarà solo uno
  6054.         }catch(Exception t) {
  6055.             throw new DriverConfigurazioneException(t.getMessage(),t);
  6056.         }
  6057.         
  6058.         CertificateCheck check = _checkConnettori(listConnettori, null, sogliaWarningGiorni, 
  6059.                 addCertificateDetails, separator, newLine,
  6060.                 log);
  6061.         if(check!=null) {
  6062.             return check;
  6063.         }
  6064.         throw new DriverConfigurazioneException("Nella policy "+gp.getNome()+" non risulta configurato un connettore https");
  6065.         
  6066.     }
  6067.     
  6068.     protected CertificateCheck checkCertificatiSignedJwtTokenPolicyNegoziazione(Connection connectionPdD,boolean useCache,
  6069.             String nome, int sogliaWarningGiorni, 
  6070.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  6071.         
  6072.         if(connectionPdD!=null) {
  6073.             // nop
  6074.         }
  6075.         
  6076.         if(useCache) {
  6077.             throw new DriverConfigurazioneException("Not Implemented");
  6078.         }
  6079.         
  6080.         GenericProperties gp = null;
  6081.         IDriverConfigurazioneGet driver = this.configurazionePdD.getDriverConfigurazionePdD();
  6082.         if(driver instanceof DriverConfigurazioneDB) {
  6083.             DriverConfigurazioneDB driverDB = (DriverConfigurazioneDB) driver;
  6084.             gp = driverDB.getGenericProperties(org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA_RETRIEVE, nome);
  6085.         }
  6086.         else {
  6087.             throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  6088.         }
  6089.         return checkCertificatiSignedJwtTokenPolicyNegoziazione(gp, sogliaWarningGiorni, 
  6090.                 addCertificateDetails, separator, newLine,
  6091.                 this.logger);
  6092.     }
  6093.     public static final String ID_CONFIGURAZIONE_TOKEN_NEGOZIAZIONE_SIGNED_JWT = "Configurazione SignedJWT";
  6094.     public static CertificateCheck checkCertificatiSignedJwtTokenPolicyNegoziazione(GenericProperties gp, int sogliaWarningGiorni, 
  6095.             boolean addCertificateDetails, String separator, String newLine,
  6096.             Logger log) throws DriverConfigurazioneException {
  6097.         
  6098.         KeystoreParams keystoreParams = null;
  6099.         try {
  6100.             PolicyNegoziazioneToken policy = TokenUtilities.convertTo(gp);
  6101.             if(!policy.isRfc7523x509Grant()) {
  6102.                 throw new DriverConfigurazioneException("La configurazione nella policy "+gp.getNome()+" non utilizza la funzionalità SignedJWT (RFC 7523)");
  6103.             }
  6104.             // JWS Compact              
  6105.             keystoreParams = TokenUtilities.getSignedJwtKeystoreParams(policy);
  6106.         }catch(Exception t) {
  6107.             throw new DriverConfigurazioneException(t.getMessage(),t);
  6108.         }
  6109.         
  6110.         CertificateCheck check = null;
  6111.         boolean classpathSupported = true;
  6112.         
  6113.         String storeDetails = null; // per evitare duplicazione
  6114.         
  6115.         if(keystoreParams!=null) {
  6116.             try {

  6118.                 if(Costanti.KEYSTORE_TYPE_APPLICATIVO_MODI_VALUE.equalsIgnoreCase(keystoreParams.getPath())) {
  6119.                     throw new DriverConfigurazioneException("Nella configurazione della policy "+gp.getNome()+" la funzionalità di SignedJWT utilizza la modalità '"+Costanti.KEYSTORE_TYPE_APPLICATIVO_MODI_LABEL+"'; la validazione dei certificati verrà effettuata su ogni singolo applicativo");
  6120.                 }
  6121.                 if(Costanti.KEYSTORE_TYPE_FRUIZIONE_MODI_VALUE.equalsIgnoreCase(keystoreParams.getPath())) {
  6122.                     throw new DriverConfigurazioneException("Nella configurazione della policy "+gp.getNome()+" la funzionalità di SignedJWT utilizza la modalità '"+Costanti.KEYSTORE_TYPE_FRUIZIONE_MODI_LABEL+"'; la validazione dei certificati verrà effettuata sulla fruizione");
  6123.                 }
  6124.                 
  6125.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  6126.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  6127.                     
  6128.                     check = CertificateUtils.checkKeyPair(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyPairPublicKeyPath(), keystoreParams.getKeyPassword(), keystoreParams.getKeyPairAlgorithm(),
  6129.                             byokUnwrapManager,
  6130.                             false, //addCertificateDetails,  
  6131.                             separator, newLine);
  6132.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6133.                         storeDetails = CertificateUtils.toStringKeyPair(keystoreParams, 
  6134.                                 separator, newLine);
  6135.                     }
  6136.                 }
  6137.                 else if(SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  6138.                     throw new DriverConfigurazioneException("Nella configurazione della policy "+gp.getNome()+" la funzionalità di SignedJWT utilizza un keystore "+SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_LABEL+" non compatibile con il criterio di validazione dei certificati");
  6139.                 }
  6140.                 else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  6141.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  6142.                     
  6143.                     check = CertificateUtils.checkKeystoreJWKs(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyAlias(), 
  6144.                             byokUnwrapManager,
  6145.                             false, //addCertificateDetails,  
  6146.                             separator, newLine);
  6147.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6148.                         storeDetails = CertificateUtils.toStringKeystoreJWKs(keystoreParams, 
  6149.                                 separator, newLine);
  6150.                     }
  6151.                 }
  6152.                 else {
  6153.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  6154.                     
  6155.                     check = CertificateUtils.checkKeyStore(keystoreParams.getPath(), classpathSupported, keystoreParams.getType(),
  6156.                             keystoreParams.getPassword(), 
  6157.                             byokUnwrapManager,
  6158.                             keystoreParams.getKeyAlias(), keystoreParams.getKeyPassword(),
  6159.                             sogliaWarningGiorni, 
  6160.                             false, //addCertificateDetails,  
  6161.                             separator, newLine,
  6162.                             log);
  6163.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6164.                         storeDetails = CertificateUtils.toStringKeyStore(keystoreParams, 
  6165.                                 separator, newLine);
  6166.                     }
  6167.                 }
  6168.                 
  6169.             }catch(Exception t) {
  6170.                 throw new DriverConfigurazioneException(t.getMessage(),t);
  6171.             }
  6172.         }
  6173.         
  6174.         if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6175.             String id = ID_CONFIGURAZIONE_TOKEN_NEGOZIAZIONE_SIGNED_JWT;
  6176.             if(addCertificateDetails && storeDetails!=null) {
  6177.                 id = id + newLine + storeDetails;
  6178.             }
  6179.             check.setConfigurationId(id);   
  6180.         }   
  6181.         
  6182.         if(check==null) {
  6183.             // connettore https con truststore 'all' senza client autentication
  6184.             check = new CertificateCheck();
  6185.             check.setStatoCheck(StatoCheck.OK);
  6186.         }
  6187.         
  6188.         return check;
  6189.     }


  6192.     protected CertificateCheck checkCertificatiConnettoreHttpsAttributeAuthority(Connection connectionPdD,boolean useCache,
  6193.             String nome, int sogliaWarningGiorni, 
  6194.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  6195.         
  6196.         if(connectionPdD!=null) {
  6197.             // nop
  6198.         }
  6199.         
  6200.         if(useCache) {
  6201.             throw new DriverConfigurazioneException("Not Implemented");
  6202.         }
  6203.         
  6204.         GenericProperties gp = null;
  6205.         IDriverConfigurazioneGet driver = this.configurazionePdD.getDriverConfigurazionePdD();
  6206.         if(driver instanceof DriverConfigurazioneDB) {
  6207.             DriverConfigurazioneDB driverDB = (DriverConfigurazioneDB) driver;
  6208.             gp = driverDB.getGenericProperties(org.openspcoop2.pdd.core.token.Costanti.ATTRIBUTE_AUTHORITY, nome);
  6209.         }
  6210.         else {
  6211.             throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  6212.         }
  6213.         return checkCertificatiConnettoreHttpsAttributeAuthority(gp, sogliaWarningGiorni, 
  6214.                 addCertificateDetails, separator, newLine,
  6215.                 this.logger);
  6216.     }
  6217.     public static CertificateCheck checkCertificatiConnettoreHttpsAttributeAuthority(GenericProperties gp, int sogliaWarningGiorni, 
  6218.             boolean addCertificateDetails, String separator, String newLine,
  6219.             Logger log) throws DriverConfigurazioneException {
  6220.         
  6221.         List<org.openspcoop2.core.config.Connettore> listConnettori = null;
  6222.         try {
  6223.             PolicyAttributeAuthority policy = AttributeAuthorityUtilities.convertTo(gp);
  6224.             
  6225.             if( !policy.isEndpointHttps() ) {
  6226.                 throw new DriverConfigurazioneException("La configurazione della policy "+gp.getNome()+" non utilizza un connettore di tipo https");
  6227.             }
  6228.             
  6229.             listConnettori = ConnettoreCheck.convertAttributeAuthorityToConnettore(gp, log); // sarà solo uno
  6230.         }catch(Exception t) {
  6231.             throw new DriverConfigurazioneException(t.getMessage(),t);
  6232.         }
  6233.         
  6234.         CertificateCheck check = _checkConnettori(listConnettori, null, sogliaWarningGiorni, 
  6235.                 addCertificateDetails, separator, newLine,
  6236.                 log);
  6237.         if(check!=null) {
  6238.             return check;
  6239.         }
  6240.         throw new DriverConfigurazioneException("Nell'AttributeAuthority "+gp.getNome()+" non risulta configurato un connettore https");
  6241.         
  6242.     }
  6243.         
  6244.     protected CertificateCheck checkCertificatiAttributeAuthorityJwtRichiesta(Connection connectionPdD,boolean useCache,
  6245.             String nome, int sogliaWarningGiorni, 
  6246.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  6247.         
  6248.         if(connectionPdD!=null) {
  6249.             // nop
  6250.         }
  6251.         
  6252.         if(useCache) {
  6253.             throw new DriverConfigurazioneException("Not Implemented");
  6254.         }
  6255.         
  6256.         GenericProperties gp = null;
  6257.         IDriverConfigurazioneGet driver = this.configurazionePdD.getDriverConfigurazionePdD();
  6258.         if(driver instanceof DriverConfigurazioneDB) {
  6259.             DriverConfigurazioneDB driverDB = (DriverConfigurazioneDB) driver;
  6260.             gp = driverDB.getGenericProperties(org.openspcoop2.pdd.core.token.Costanti.ATTRIBUTE_AUTHORITY, nome);
  6261.         }
  6262.         else {
  6263.             throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  6264.         }
  6265.         return checkCertificatiAttributeAuthorityJwtRichiesta(gp, sogliaWarningGiorni, 
  6266.                 addCertificateDetails, separator, newLine,
  6267.                 this.logger);
  6268.     }
  6269.     public static final String ID_CONFIGURAZIONE_ATTRIBUTE_AUTHORITY_JWT_RICHIESTA = "Configurazione JWS Richiesta";
  6270.     public static CertificateCheck checkCertificatiAttributeAuthorityJwtRichiesta(GenericProperties gp, int sogliaWarningGiorni, 
  6271.             boolean addCertificateDetails, String separator, String newLine,
  6272.             Logger log) throws DriverConfigurazioneException {
  6273.         
  6274.         KeystoreParams keystoreParams = null;
  6275.         try {
  6276.             PolicyAttributeAuthority policy = AttributeAuthorityUtilities.convertTo(gp);
  6277.             if(!policy.isRequestJws()) {
  6278.                 throw new DriverConfigurazioneException("La configurazione nell'AttributeAuthority "+gp.getNome()+" non definisce il tipo di richiesta come JWS");
  6279.             }
  6280.             // JWS Compact              
  6281.             keystoreParams = AttributeAuthorityUtilities.getRequestJwsKeystoreParams(policy);
  6282.         }catch(Exception t) {
  6283.             throw new DriverConfigurazioneException(t.getMessage(),t);
  6284.         }
  6285.         
  6286.         CertificateCheck check = null;
  6287.         boolean classpathSupported = true;
  6288.         
  6289.         String storeDetails = null; // per evitare duplicazione
  6290.         
  6291.         if(keystoreParams!=null) {
  6292.             try {
  6293.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  6294.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  6295.                     
  6296.                     check = CertificateUtils.checkKeyPair(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyPairPublicKeyPath(), keystoreParams.getKeyPassword(), keystoreParams.getKeyPairAlgorithm(),
  6297.                             byokUnwrapManager,
  6298.                             false, //addCertificateDetails,  
  6299.                             separator, newLine);
  6300.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6301.                         storeDetails = CertificateUtils.toStringKeyPair(keystoreParams, 
  6302.                                 separator, newLine);
  6303.                     }
  6304.                 }
  6305.                 else if(SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  6306.                     throw new DriverConfigurazioneException("Nell'Attribute Authority "+gp.getNome()+" la configurazione della richiesta JWS utilizza un keystore "+SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_LABEL+" non compatibile con il criterio di validazione dei certificati");
  6307.                 }
  6308.                 else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  6309.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  6310.                     
  6311.                     check = CertificateUtils.checkKeystoreJWKs(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyAlias(), 
  6312.                             byokUnwrapManager,
  6313.                             false, //addCertificateDetails,  
  6314.                             separator, newLine);
  6315.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6316.                         storeDetails = CertificateUtils.toStringKeystoreJWKs(keystoreParams, 
  6317.                                 separator, newLine);
  6318.                     }
  6319.                 }
  6320.                 else {
  6321.                     
  6322.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  6323.                     
  6324.                     check = CertificateUtils.checkKeyStore(keystoreParams.getPath(), classpathSupported, keystoreParams.getType(),
  6325.                             keystoreParams.getPassword(), 
  6326.                             byokUnwrapManager,
  6327.                             keystoreParams.getKeyAlias(), keystoreParams.getKeyPassword(),
  6328.                             sogliaWarningGiorni, 
  6329.                             false, //addCertificateDetails,  
  6330.                             separator, newLine,
  6331.                             log);
  6332.                     
  6333.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6334.                         storeDetails = CertificateUtils.toStringKeyStore(keystoreParams, 
  6335.                                 separator, newLine);
  6336.                     }
  6337.                 }
  6338.             }catch(Exception t) {
  6339.                 throw new DriverConfigurazioneException(t.getMessage(),t);
  6340.             }
  6341.         }
  6342.         
  6343.         if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6344.             String id = ID_CONFIGURAZIONE_ATTRIBUTE_AUTHORITY_JWT_RICHIESTA;
  6345.             if(addCertificateDetails && storeDetails!=null) {
  6346.                 id = id + newLine + storeDetails;
  6347.             }
  6348.             check.setConfigurationId(id);   
  6349.         }   
  6350.         
  6351.         if(check==null) {
  6352.             // connettore https con truststore 'all' senza client autentication
  6353.             check = new CertificateCheck();
  6354.             check.setStatoCheck(StatoCheck.OK);
  6355.         }
  6356.         
  6357.         return check;
  6358.     }
  6359.     
  6360.     public static final String ID_CONFIGURAZIONE_ATTRIBUTE_AUTHORITY_JWT_RISPOSTA = "Configurazione JWS Risposta";
  6361.     protected CertificateCheck checkCertificatiAttributeAuthorityJwtRisposta(Connection connectionPdD,boolean useCache,
  6362.             String nome, int sogliaWarningGiorni, 
  6363.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  6364.         
  6365.         if(connectionPdD!=null) {
  6366.             // nop
  6367.         }
  6368.         
  6369.         if(useCache) {
  6370.             throw new DriverConfigurazioneException("Not Implemented");
  6371.         }
  6372.         
  6373.         GenericProperties gp = null;
  6374.         IDriverConfigurazioneGet driver = this.configurazionePdD.getDriverConfigurazionePdD();
  6375.         if(driver instanceof DriverConfigurazioneDB) {
  6376.             DriverConfigurazioneDB driverDB = (DriverConfigurazioneDB) driver;
  6377.             gp = driverDB.getGenericProperties(org.openspcoop2.pdd.core.token.Costanti.ATTRIBUTE_AUTHORITY, nome);
  6378.         }
  6379.         else {
  6380.             throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  6381.         }
  6382.         return checkCertificatiAttributeAuthorityJwtRisposta(gp, sogliaWarningGiorni, 
  6383.                 addCertificateDetails, separator, newLine,
  6384.                 this.logger);
  6385.     }
  6386.     public static CertificateCheck checkCertificatiAttributeAuthorityJwtRisposta(GenericProperties gp, int sogliaWarningGiorni, 
  6387.             boolean addCertificateDetails, String separator, String newLine,
  6388.             Logger log) throws DriverConfigurazioneException {
  6389.         
  6390.         KeystoreParams keystoreParams = null;
  6391.         PolicyAttributeAuthority policy = null;
  6392.         try {
  6393.             policy = AttributeAuthorityUtilities.convertTo(gp);
  6394.             if(!policy.isResponseJws()) {
  6395.                 throw new DriverConfigurazioneException("La configurazione nell'AttributeAuthority "+gp.getNome()+" non definisce il tipo di risposta come JWS");
  6396.             }
  6397.             // JWS Compact              
  6398.             keystoreParams = AttributeAuthorityUtilities.getResponseJwsKeystoreParams(policy);
  6399.         }catch(Exception t) {
  6400.             throw new DriverConfigurazioneException(t.getMessage(),t);
  6401.         }
  6402.         
  6403.         CertificateCheck check = null;
  6404.         boolean classpathSupported = true;
  6405.         
  6406.         String storeDetails = null; // per evitare duplicazione
  6407.         
  6408.         if(keystoreParams!=null) {
  6409.             try {
  6410.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  6411.                     throw new DriverConfigurazioneException("Nell'Attribute Authority "+gp.getNome()+" la configurazione della risposta JWS utilizza un keystore "+SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_LABEL+" non compatibile con il criterio di validazione dei certificati");
  6412.                 }
  6413.                 else if(SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  6414.                     if(keystoreParams.getPath().startsWith(JOSEUtils.HTTP_PROTOCOL) || keystoreParams.getPath().startsWith(JOSEUtils.HTTPS_PROTOCOL)) {
  6415.                         byte [] store = getStoreCertificatiTokenPolicy(policy, keystoreParams, log);
  6416.                         check = CertificateUtils.checkPublicKey(keystoreParams.getPath(), store, keystoreParams.getKeyPairAlgorithm(),
  6417.                                 false, //addCertificateDetails,  
  6418.                                 separator, newLine);
  6419.                     }
  6420.                     else {
  6421.                         check = CertificateUtils.checkPublicKey(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyPairAlgorithm(),
  6422.                                 false, //addCertificateDetails,  
  6423.                                 separator, newLine);
  6424.                     }
  6425.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6426.                         storeDetails = CertificateUtils.toStringPublicKey(keystoreParams, 
  6427.                                 separator, newLine);
  6428.                     }
  6429.                 }
  6430.                 else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  6431.                     if(keystoreParams.getPath().startsWith(JOSEUtils.HTTP_PROTOCOL) || keystoreParams.getPath().startsWith(JOSEUtils.HTTPS_PROTOCOL)) {
  6432.                         byte [] store = getStoreCertificatiTokenPolicy(policy, keystoreParams, log);
  6433.                         check = CertificateUtils.checkTruststoreJWKs(keystoreParams.getPath(), new String(store), keystoreParams.getKeyAlias(), 
  6434.                                 false, //addCertificateDetails,  
  6435.                                 separator, newLine);
  6436.                     }
  6437.                     else {
  6438.                         check = CertificateUtils.checkTruststoreJWKs(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyAlias(), 
  6439.                                 false, //addCertificateDetails,  
  6440.                                 separator, newLine);
  6441.                     }
  6442.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6443.                         storeDetails = CertificateUtils.toStringTruststoreJWKs(keystoreParams, 
  6444.                                 separator, newLine);
  6445.                     }
  6446.                 }
  6447.                 else {  
  6448.                     if(keystoreParams.getPath().startsWith(JOSEUtils.HTTP_PROTOCOL) || keystoreParams.getPath().startsWith(JOSEUtils.HTTPS_PROTOCOL)) {
  6449.                         byte [] store = getStoreCertificatiTokenPolicy(policy, keystoreParams, log);
  6450.                         check = CertificateUtils.checkTrustStore(keystoreParams.getPath(), store, keystoreParams.getType(), 
  6451.                                 keystoreParams.getPassword(), keystoreParams.getCrls(), keystoreParams.getOcspPolicy(),keystoreParams.getKeyAlias(),
  6452.                                 sogliaWarningGiorni, 
  6453.                                 false, //addCertificateDetails, 
  6454.                                 separator, newLine,
  6455.                                 log);
  6456.                     }
  6457.                     else {
  6458.                         check = CertificateUtils.checkTrustStore(keystoreParams.getPath(), classpathSupported, keystoreParams.getType(), 
  6459.                                 keystoreParams.getPassword(), keystoreParams.getCrls(), keystoreParams.getOcspPolicy(),keystoreParams.getKeyAlias(),
  6460.                                 sogliaWarningGiorni, 
  6461.                                 false, //addCertificateDetails, 
  6462.                                 separator, newLine,
  6463.                                 log);
  6464.                     }
  6465.                     
  6466.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6467.                         storeDetails = CertificateUtils.toStringKeyStore(keystoreParams, 
  6468.                                 separator, newLine);
  6469.                     }
  6470.                 }
  6471.             }catch(Exception t) {
  6472.                 throw new DriverConfigurazioneException(t.getMessage(),t);
  6473.             }
  6474.         }
  6475.         
  6476.         if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6477.             String id = ID_CONFIGURAZIONE_ATTRIBUTE_AUTHORITY_JWT_RISPOSTA;
  6478.             if(addCertificateDetails && storeDetails!=null) {
  6479.                 id = id + newLine + storeDetails;
  6480.             }
  6481.             check.setConfigurationId(id);   
  6482.         }   
  6483.         
  6484.         if(check==null) {
  6485.             // connettore https con truststore 'all' senza client autentication
  6486.             check = new CertificateCheck();
  6487.             check.setStatoCheck(StatoCheck.OK);
  6488.         }
  6489.         
  6490.         return check;
  6491.     }
  6492.     
  6493.     public static final String ID_CONFIGURAZIONE_RICHIESTA_MESSAGE_SECURITY = "Configurazione Richiesta 'Message Security'";
  6494.     public static final String ID_CONFIGURAZIONE_RISPOSTA_MESSAGE_SECURITY = "Configurazione Risposta 'Message Security'";
  6495.     protected CertificateCheck checkCertificatiMessageSecurityErogazioneById(Connection connectionPdD,boolean useCache,
  6496.             long idAsps, int sogliaWarningGiorni, 
  6497.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  6498.         
  6499.         if(connectionPdD!=null) {
  6500.             // nop
  6501.         }
  6502.         
  6503.         if(useCache) {
  6504.             throw new DriverConfigurazioneException("Not Implemented");
  6505.         }
  6506.         
  6507.         AccordoServizioParteSpecifica asps = null;
  6508.         IDServizio idServizio = null;
  6509.         for (IDriverRegistroServiziGet driver : RegistroServiziReader.getDriverRegistroServizi().values()) {
  6510.             if(driver instanceof DriverRegistroServiziDB) {
  6511.                 try {
  6512.                     DriverRegistroServiziDB driverDB = (DriverRegistroServiziDB) driver;
  6513.                     asps = driverDB.getAccordoServizioParteSpecifica(idAsps);
  6514.                     idServizio = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);
  6515.                 }catch(Exception e) {
  6516.                     throw new DriverConfigurazioneException(e.getMessage(),e);
  6517.                 }
  6518.                 break;
  6519.             }
  6520.             else {
  6521.                 throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  6522.             }
  6523.         }
  6524.         
  6525.         DriverConfigurazioneDB driver = null;
  6526.         if(this.configurazionePdD.getDriverConfigurazionePdD() instanceof DriverConfigurazioneDB) {
  6527.             driver = (DriverConfigurazioneDB) this.configurazionePdD.getDriverConfigurazionePdD();
  6528.         }
  6529.         else {
  6530.             throw new DriverConfigurazioneException("Not Implemented with driver '"+this.configurazionePdD.getDriverConfigurazionePdD().getClass().getName()+"'");
  6531.         }
  6532.         
  6533.         List<MappingErogazionePortaApplicativa> list = this.configurazionePdD._getMappingErogazionePortaApplicativaList(idServizio, connectionPdD); // usa direttamente, senza cache, DriverConfigurazioneDB
  6534.         List<PortaApplicativa> listPorta = new ArrayList<>();
  6535.         if(list!=null && !list.isEmpty()) {
  6536.             for (MappingErogazionePortaApplicativa mappingErogazionePortaApplicativa : list) {
  6537.                 listPorta.add(driver.getPortaApplicativa(mappingErogazionePortaApplicativa.getIdPortaApplicativa()));
  6538.             }
  6539.         }
  6540.         
  6541.         return checkCertificatiMessageSecurityErogazioneById(list, listPorta,
  6542.                 sogliaWarningGiorni, 
  6543.                 addCertificateDetails, separator, newLine,
  6544.                 this.logger);
  6545.     }
  6546.     public static CertificateCheck checkCertificatiMessageSecurityErogazioneById(List<MappingErogazionePortaApplicativa> listMapping, List<PortaApplicativa> listPorta, 
  6547.             int sogliaWarningGiorni,
  6548.             boolean addCertificateDetails, String separator, String newLine,
  6549.             Logger log) throws DriverConfigurazioneException {
  6550.                 
  6551.         if(listPorta==null || listPorta.isEmpty()) {
  6552.             throw new DriverConfigurazioneException("Param listPorta is null or empty");
  6553.         }
  6554.         if(listMapping==null || listMapping.isEmpty()) {
  6555.             throw new DriverConfigurazioneException("Param listMapping is null or empty");
  6556.         }
  6557.         if(listMapping.size()!=listPorta.size()) {
  6558.             throw new DriverConfigurazioneException("Param listPorta and listMapping are different");
  6559.         }
  6560.         
  6561.         CertificateCheck check = null;
  6562.         
  6563.         for (int i = 0; i < listPorta.size(); i++) {
  6564.             PortaApplicativa portaApplicativa = listPorta.get(i);
  6565.             MappingErogazionePortaApplicativa mapping = listMapping.get(i);
  6566.             
  6567.             List<KeystoreParams> listKeystoreParams = SecurityUtils.readRequestKeystoreParams(portaApplicativa);
  6568.             check = checkCertificatiMessageSecurityErogazioneById(true, mapping, listKeystoreParams, 
  6569.                     sogliaWarningGiorni,
  6570.                     addCertificateDetails, separator, newLine,
  6571.                     log);
  6572.             if(check!=null) {
  6573.                 return check;
  6574.             }
  6575.             
  6576.             listKeystoreParams = SecurityUtils.readResponseKeystoreParams(portaApplicativa);
  6577.             check = checkCertificatiMessageSecurityErogazioneById(false, mapping, listKeystoreParams, 
  6578.                     sogliaWarningGiorni,
  6579.                     addCertificateDetails, separator, newLine,
  6580.                     log);
  6581.             if(check!=null) {
  6582.                 return check;
  6583.             }
  6584.             
  6585.         }
  6586.                 
  6587.         check = new CertificateCheck();
  6588.         check.setStatoCheck(StatoCheck.OK);
  6589.         
  6590.         return check;
  6591.     }
  6592.     public static CertificateCheck checkCertificatiMessageSecurityErogazioneById(boolean request, MappingErogazionePortaApplicativa mapping, List<KeystoreParams> listKeystoreParams, 
  6593.             int sogliaWarningGiorni,
  6594.             boolean addCertificateDetails, String separator, String newLine,
  6595.             Logger log) throws DriverConfigurazioneException {
  6596.         
  6597.         CertificateCheck check = null;
  6598.         
  6599.         if(listKeystoreParams!=null && !listKeystoreParams.isEmpty()) {
  6600.             for (KeystoreParams keystoreParams : listKeystoreParams) {
  6601.                 
  6602.                 String descrizioneGruppo = null;
  6603.                 if(!mapping.isDefault() || (mapping.getDescrizione()!=null && StringUtils.isNotEmpty(mapping.getDescrizione()) )) {
  6604.                     descrizioneGruppo = mapping.getDescrizione();
  6605.                 }
  6606.                 
  6607.                 check = checkCertificatiMessageSecurity(request, descrizioneGruppo, keystoreParams, 
  6608.                         sogliaWarningGiorni,
  6609.                         addCertificateDetails, separator, newLine,
  6610.                         log);
  6611.                 if(check!=null) {
  6612.                     return check;
  6613.                 }
  6614.             }
  6615.         }
  6616.         
  6617.         return null;
  6618.     }
  6619.     
  6620.     protected CertificateCheck checkCertificatiMessageSecurityFruizioneById(Connection connectionPdD,boolean useCache,
  6621.             long idFruitore, 
  6622.             int sogliaWarningGiorni, 
  6623.             boolean addCertificateDetails, String separator, String newLine) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  6624.         
  6625.         if(connectionPdD!=null) {
  6626.             // nop
  6627.         }
  6628.         
  6629.         if(useCache) {
  6630.             throw new DriverConfigurazioneException("Not Implemented");
  6631.         }
  6632.         
  6633.         IDServizio idServizio = null;
  6634.         AccordoServizioParteSpecifica asps = null;
  6635.         IDSoggetto idFruitoreObject = null;
  6636.         Fruitore fruitore = null;
  6637.         for (IDriverRegistroServiziGet driver : RegistroServiziReader.getDriverRegistroServizi().values()) {
  6638.             if(driver instanceof DriverRegistroServiziDB) {
  6639.                 try {
  6640.                     DriverRegistroServiziDB driverDB = (DriverRegistroServiziDB) driver;
  6641.                     fruitore = driverDB.getServizioFruitore(idFruitore);
  6642.                     idFruitoreObject = new IDSoggetto(fruitore.getTipo(), fruitore.getNome());
  6643.                     asps = driverDB.getAccordoServizioParteSpecifica(fruitore.getIdServizio());
  6644.                     idServizio = IDServizioFactory.getInstance().getIDServizioFromAccordo(asps);        
  6645.                 }catch(Exception e) {
  6646.                     throw new DriverConfigurazioneException(e.getMessage(),e);
  6647.                 }
  6648.                 break;
  6649.             }
  6650.             else {
  6651.                 throw new DriverConfigurazioneException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  6652.             }
  6653.         }
  6654.         if(fruitore==null) {
  6655.             throw new DriverConfigurazioneException("Fruitore con id '"+idFruitore+"' non trovato");
  6656.         }
  6657.         
  6658.         DriverConfigurazioneDB driver = null;
  6659.         if(this.configurazionePdD.getDriverConfigurazionePdD() instanceof DriverConfigurazioneDB) {
  6660.             driver = (DriverConfigurazioneDB) this.configurazionePdD.getDriverConfigurazionePdD();
  6661.         }
  6662.         else {
  6663.             throw new DriverConfigurazioneException("Not Implemented with driver '"+this.configurazionePdD.getDriverConfigurazionePdD().getClass().getName()+"'");
  6664.         }
  6665.         
  6666.         List<MappingFruizionePortaDelegata> list = this.configurazionePdD._getMappingFruizionePortaDelegataList(idFruitoreObject, idServizio, connectionPdD); // usa direttamente, senza cache, DriverConfigurazioneDB
  6667.         List<PortaDelegata> listPorta = new ArrayList<>();
  6668.         if(list!=null && !list.isEmpty()) {
  6669.             for (MappingFruizionePortaDelegata mappingFruizionePortaDelegata : list) {
  6670.                 listPorta.add(driver.getPortaDelegata(mappingFruizionePortaDelegata.getIdPortaDelegata()));
  6671.             }
  6672.         }
  6673.         
  6674.         return checkCertificatiMessageSecurityFruizioneById(list, listPorta,
  6675.                 sogliaWarningGiorni, 
  6676.                 addCertificateDetails, separator, newLine,
  6677.                 this.logger);
  6678.     }
  6679.     public static CertificateCheck checkCertificatiMessageSecurityFruizioneById(List<MappingFruizionePortaDelegata> listMapping, List<PortaDelegata> listPorta,
  6680.             int sogliaWarningGiorni,
  6681.             boolean addCertificateDetails, String separator, String newLine,
  6682.             Logger log) throws DriverConfigurazioneException {
  6683.                 
  6684.         if(listPorta==null || listPorta.isEmpty()) {
  6685.             throw new DriverConfigurazioneException("Param listPorta is null or empty");
  6686.         }
  6687.         if(listMapping==null || listMapping.isEmpty()) {
  6688.             throw new DriverConfigurazioneException("Param listMapping is null or empty");
  6689.         }
  6690.         if(listMapping.size()!=listPorta.size()) {
  6691.             throw new DriverConfigurazioneException("Param listPorta and listMapping are different");
  6692.         }
  6693.         
  6694.         CertificateCheck check = null;
  6695.         
  6696.         for (int i = 0; i < listPorta.size(); i++) {
  6697.             PortaDelegata portaDelegata = listPorta.get(i);
  6698.             MappingFruizionePortaDelegata mapping = listMapping.get(i);
  6699.             
  6700.             List<KeystoreParams> listKeystoreParams = SecurityUtils.readRequestKeystoreParams(portaDelegata);
  6701.             check = checkCertificatiMessageSecurityFruizioneById(true, mapping, listKeystoreParams, 
  6702.                     sogliaWarningGiorni,
  6703.                     addCertificateDetails, separator, newLine,
  6704.                     log);
  6705.             if(check!=null) {
  6706.                 return check;
  6707.             }
  6708.             
  6709.             listKeystoreParams = SecurityUtils.readResponseKeystoreParams(portaDelegata);
  6710.             check = checkCertificatiMessageSecurityFruizioneById(false, mapping, listKeystoreParams, 
  6711.                     sogliaWarningGiorni,
  6712.                     addCertificateDetails, separator, newLine,
  6713.                     log);
  6714.             if(check!=null) {
  6715.                 return check;
  6716.             }
  6717.             
  6718.         }
  6719.                 
  6720.         check = new CertificateCheck();
  6721.         check.setStatoCheck(StatoCheck.OK);
  6722.         
  6723.         return check;
  6724.     }
  6725.     public static CertificateCheck checkCertificatiMessageSecurityFruizioneById(boolean request, MappingFruizionePortaDelegata mapping, List<KeystoreParams> listKeystoreParams, 
  6726.             int sogliaWarningGiorni,
  6727.             boolean addCertificateDetails, String separator, String newLine,
  6728.             Logger log) throws DriverConfigurazioneException {
  6729.         
  6730.         CertificateCheck check = null;
  6731.         
  6732.         if(listKeystoreParams!=null && !listKeystoreParams.isEmpty()) {
  6733.             for (KeystoreParams keystoreParams : listKeystoreParams) {
  6734.                 
  6735.                 String descrizioneGruppo = null;
  6736.                 if(!mapping.isDefault() || (mapping.getDescrizione()!=null && StringUtils.isNotEmpty(mapping.getDescrizione()) )) {
  6737.                     descrizioneGruppo = mapping.getDescrizione();
  6738.                 }
  6739.                 
  6740.                 check = checkCertificatiMessageSecurity(request, descrizioneGruppo, keystoreParams, 
  6741.                         sogliaWarningGiorni,
  6742.                         addCertificateDetails, separator, newLine,
  6743.                         log);
  6744.                 if(check!=null) {
  6745.                     return check;
  6746.                 }
  6747.             }
  6748.         }
  6749.         
  6750.         return null;
  6751.     }
  6752.         
  6753.     
  6754.     
  6755.     private static CertificateCheck checkCertificatiMessageSecurity(boolean request, String descrizioneGruppo, KeystoreParams keystoreParams, 
  6756.             int sogliaWarningGiorni,
  6757.             boolean addCertificateDetails, String separator, String newLine,
  6758.             Logger log) throws DriverConfigurazioneException {
  6759.         
  6760.         boolean classpathSupported = true;
  6761.         
  6762.         String storeDetails = null;
  6763.         
  6764.         if(keystoreParams!=null) {
  6765.             try {
  6766.                 CertificateCheck check = null;
  6767.                 if(SecurityConstants.KEYSTORE_TYPE_KEY_PAIR_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  6768.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  6769.                     
  6770.                     check = CertificateUtils.checkKeyPair(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyPairPublicKeyPath(), keystoreParams.getKeyPassword(), keystoreParams.getKeyPairAlgorithm(),
  6771.                             byokUnwrapManager,
  6772.                             false, //addCertificateDetails,  
  6773.                             separator, newLine);
  6774.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6775.                         storeDetails = CertificateUtils.toStringKeyPair(keystoreParams, 
  6776.                                 separator, newLine);
  6777.                     }
  6778.                 }
  6779.                 else if(SecurityConstants.KEYSTORE_TYPE_PUBLIC_KEY_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  6780.                     check = CertificateUtils.checkPublicKey(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyPairAlgorithm(),
  6781.                                 false, //addCertificateDetails,  
  6782.                                 separator, newLine);
  6783.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6784.                         storeDetails = CertificateUtils.toStringPublicKey(keystoreParams, 
  6785.                                 separator, newLine);
  6786.                     }
  6787.                 }
  6788.                 else if(SecurityConstants.KEYSTORE_TYPE_JWK_VALUE.equalsIgnoreCase(keystoreParams.getType())) {
  6789.                     
  6790.                     IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  6791.                     
  6792.                     check = CertificateUtils.checkKeystoreJWKs(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyAlias(),
  6793.                             byokUnwrapManager,
  6794.                             false, //addCertificateDetails,  
  6795.                             separator, newLine);
  6796.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6797.                         storeDetails = CertificateUtils.toStringTruststoreJWKs(keystoreParams, 
  6798.                                 separator, newLine);
  6799.                     }
  6800.                 }
  6801.                 else {  
  6802.                     if(keystoreParams.getKeyPassword()!=null) {
  6803.                         IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapFactory.getBYOKUnwrapManager(keystoreParams.getByokPolicy(), log);
  6804.                         
  6805.                         check = CertificateUtils.checkKeyStore(keystoreParams.getPath(), classpathSupported, keystoreParams.getType(),
  6806.                                 keystoreParams.getPassword(), 
  6807.                                 byokUnwrapManager,
  6808.                                 keystoreParams.getKeyAlias(), keystoreParams.getKeyPassword(),
  6809.                                 sogliaWarningGiorni, 
  6810.                                 false, //addCertificateDetails,  
  6811.                                 separator, newLine,
  6812.                                 log);
  6813.                     }
  6814.                     else {
  6815.                         check = CertificateUtils.checkTrustStore(keystoreParams.getPath(), classpathSupported, keystoreParams.getType(), 
  6816.                                 keystoreParams.getPassword(), keystoreParams.getCrls(), keystoreParams.getOcspPolicy(),keystoreParams.getKeyAlias(),
  6817.                                 sogliaWarningGiorni, 
  6818.                                 false, //addCertificateDetails, 
  6819.                                 separator, newLine,
  6820.                                 log);
  6821.                     }
  6822.                     
  6823.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6824.                         storeDetails = CertificateUtils.toStringKeyStore(keystoreParams, 
  6825.                                 separator, newLine);
  6826.                     }
  6827.                 }
  6828.                 
  6829.                 if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6830.                     String id = request ? ID_CONFIGURAZIONE_RICHIESTA_MESSAGE_SECURITY : ID_CONFIGURAZIONE_RISPOSTA_MESSAGE_SECURITY;
  6831.                     if(descrizioneGruppo!=null && !org.openspcoop2.core.constants.Costanti.MAPPING_DESCRIZIONE_DEFAULT.equals(descrizioneGruppo)) {
  6832.                         id = id + " (" +descrizioneGruppo+")";
  6833.                     }
  6834.                     if(keystoreParams.getDescription()!=null && StringUtils.isNotEmpty(keystoreParams.getDescription())) {
  6835.                         id = id + " - " +keystoreParams.getDescription();
  6836.                     }
  6837.                     if(addCertificateDetails && storeDetails!=null) {
  6838.                         id = id + newLine + storeDetails;
  6839.                     }
  6840.                     check.setConfigurationId(id);   
  6841.                     
  6842.                     return check;
  6843.                 }   
  6844.                 
  6845.             }catch(Exception t) {
  6846.                 throw new DriverConfigurazioneException(t.getMessage(),t);
  6847.             }
  6848.         }
  6849.         
  6850.         return null;
  6851.     }

  6853.     
  6854.     private static CertificateCheck _checkConnettori(List<org.openspcoop2.core.config.Connettore> listConnettori, String tipo, int sogliaWarningGiorni, 
  6855.             boolean addCertificateDetails, String separator, String newLine,
  6856.             Logger log) throws DriverConfigurazioneException {

  6858.         boolean classpathSupported = true;
  6859.         
  6860.         if(listConnettori!=null && !listConnettori.isEmpty()) {
  6861.             for (org.openspcoop2.core.config.Connettore connettore : listConnettori) {
  6862.                     
  6863.                 String tipoC = ConnettoreCheck.getPropertyValue(connettore, ConnettoreCheck.POLICY_TIPO_ENDPOINT);
  6864.                 if(tipo==null || tipo.equalsIgnoreCase(tipoC)) {
  6865.                 
  6866.                     SSLConfig httpsProp = null;
  6867.                     Map<String,Object> dynamicMap = null;
  6868.                     try {
  6869.                         httpsProp = ConnettoreHTTPSProperties.readProperties(connettore.getProperties());
  6870.                         dynamicMap = DynamicMapBuilderUtils.buildDynamicMap(null, null, null, 
  6871.                                 log);
  6872.                         httpsProp.setDynamicMap(dynamicMap);
  6873.                     }catch(Exception t) {
  6874.                         throw new DriverConfigurazioneException(t.getMessage(),t);
  6875.                     }
  6876.                     CertificateCheck check = null;
  6877.                             
  6878.                     String storeDetails = null; // per evitare duplicazione
  6879.                     
  6880.                     if(httpsProp.getKeyStoreLocation()!=null) {
  6881.                         try {
  6882.                             IBYOKUnwrapManager byokUnwrapManager = BYOKUnwrapPolicyUtilities.getBYOKUnwrapManager(httpsProp.getKeyStoreBYOKPolicy(), dynamicMap);
  6883.                             
  6884.                             check = CertificateUtils.checkKeyStore(httpsProp.getKeyStoreLocation(), classpathSupported, httpsProp.getKeyStoreType(), 
  6885.                                     httpsProp.getKeyStorePassword(), 
  6886.                                     byokUnwrapManager,
  6887.                                     httpsProp.getKeyAlias(), httpsProp.getKeyPassword(),
  6888.                                     sogliaWarningGiorni, 
  6889.                                     false, //addCertificateDetails,  
  6890.                                     separator, newLine,
  6891.                                     log);
  6892.                             
  6893.                             if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6894.                                 storeDetails = CertificateUtils.toStringKeyStore(httpsProp.getKeyStoreLocation(), httpsProp.getKeyStoreType(),
  6895.                                         httpsProp.getKeyStoreBYOKPolicy(),
  6896.                                         httpsProp.getKeyAlias(), 
  6897.                                         separator, newLine);
  6898.                             }
  6899.                         }catch(Exception t) {
  6900.                             throw new DriverConfigurazioneException(t.getMessage(),t);
  6901.                         }
  6902.                     }
  6903.                     
  6904.                     if(check==null || StatoCheck.OK.equals(check.getStatoCheck())) {
  6905.                         if(!httpsProp.isTrustAllCerts() && httpsProp.getTrustStoreLocation()!=null) {
  6906.                             try {
  6907.                                 check = CertificateUtils.checkTrustStore(httpsProp.getTrustStoreLocation(), classpathSupported, httpsProp.getTrustStoreType(), 
  6908.                                         httpsProp.getTrustStorePassword(), httpsProp.getTrustStoreCRLsLocation(), httpsProp.getTrustStoreOCSPPolicy(),
  6909.                                         sogliaWarningGiorni, 
  6910.                                         false, //addCertificateDetails, 
  6911.                                         separator, newLine,
  6912.                                         log);
  6913.                                 
  6914.                                 if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6915.                                     storeDetails = CertificateUtils.toStringTrustStore(httpsProp.getTrustStoreLocation(), httpsProp.getTrustStoreType(),
  6916.                                             httpsProp.getTrustStoreCRLsLocation(), httpsProp.getTrustStoreOCSPPolicy(),
  6917.                                             separator, newLine);
  6918.                                 }
  6919.                             }catch(Exception t) {
  6920.                                 throw new DriverConfigurazioneException(t.getMessage(),t);
  6921.                             }
  6922.                         }
  6923.                     }
  6924.                     
  6925.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  6926.                         String id = RegistroServiziReader.ID_CONFIGURAZIONE_CONNETTORE_HTTPS;
  6927.                         if(addCertificateDetails && storeDetails!=null) {
  6928.                             id = id + newLine + storeDetails;
  6929.                         }
  6930.                         check.setConfigurationId(id);   
  6931.                     }   
  6932.                     
  6933.                     if(check==null) {
  6934.                         // connettore https con truststore 'all' senza client autentication
  6935.                         check = new CertificateCheck();
  6936.                         check.setStatoCheck(StatoCheck.OK);
  6937.                     }
  6938.                     
  6939.                     return check;
  6940.                 }
  6941.                     
  6942.             }
  6943.         }
  6944.         return null;
  6945.     }



  6949.     /* ********  CONFIGURAZIONE  ******** */

  6951.     /**
  6952.      * Restituisce le informazioni necessarie alla porta di dominio per accedere ai registri di servizio.
  6953.      *
  6954.      * @return informazioni sui registri di servizio.
  6955.      * 
  6956.      */
  6957.     private static AccessoRegistro accessoRegistroServizi = null;
  6958.     private static Boolean accessoRegistroServiziLetto = false;
  6959.     public static void setAccessoRegistroServizi(AccessoRegistro accessoRegistroServizi) {
  6960.         ConfigurazionePdDReader.accessoRegistroServizi = accessoRegistroServizi;
  6961.     }
  6962.     public static void setAccessoRegistroServiziLetto(Boolean accessoRegistroServiziLetto) {
  6963.         ConfigurazionePdDReader.accessoRegistroServiziLetto = accessoRegistroServiziLetto;
  6964.     }
  6965.     protected AccessoRegistro getAccessoRegistroServizi(Connection connectionPdD){

  6967.         if( this.configurazioneDinamica || !ConfigurazionePdDReader.accessoRegistroServiziLetto.booleanValue()){
  6968.             AccessoRegistro configRegistro = null;
  6969.             try{
  6970.                 configRegistro = this.configurazionePdD.getAccessoRegistro(connectionPdD);
  6971.             }catch(DriverConfigurazioneNotFound e){
  6972.                 this.logDebug("getAccessoRegistroServizi (not found): "+e.getMessage());
  6973.             }catch(Exception e){
  6974.                 this.logError("getAccessoRegistroServizi",e);
  6975.             }

  6977.             ConfigurazionePdDReader.setAccessoRegistroServizi(configRegistro);
  6978.             ConfigurazionePdDReader.setAccessoRegistroServiziLetto(true);
  6979.         }

  6981.         /**
  6982.         if(ConfigurazionePdDReader.accessoRegistroServizi.getCache()==null){
  6983.             System.out.println("REGISTRO CACHE DISABILITATA");
  6984.         }else{
  6985.             System.out.println("REGISTRO CACHE ABILITATA");
  6986.             System.out.println("REGISTRO CACHE ALGORITMO: "+ConfigurazionePdDReader.accessoRegistroServizi.getCache().getAlgoritmo());
  6987.             System.out.println("REGISTRO CACHE DIMENSIONE: "+ConfigurazionePdDReader.accessoRegistroServizi.getCache().getDimensione());
  6988.             System.out.println("REGISTRO CACHE ITEM IDLE: "+ConfigurazionePdDReader.accessoRegistroServizi.getCache().getItemIdleTime());
  6989.             System.out.println("REGISTRO CACHE ITEM LIFE SECOND: "+ConfigurazionePdDReader.accessoRegistroServizi.getCache().getItemLifeSecond());
  6990.         }

  6992.         for(int i=0; i<ConfigurazionePdDReader.accessoRegistroServizi.sizeRegistroList(); i++){
  6993.             System.out.println("REGISTRO ["+i+"] NOME ["+ConfigurazionePdDReader.accessoRegistroServizi.getRegistro(i).getNome()+"]");
  6994.             System.out.println("REGISTRO ["+i+"] TIPO ["+ConfigurazionePdDReader.accessoRegistroServizi.getRegistro(i).getTipo()+"]");
  6995.             System.out.println("REGISTRO ["+i+"] LOCATION ["+ConfigurazionePdDReader.accessoRegistroServizi.getRegistro(i).getLocation()+"]");
  6996.             System.out.println("REGISTRO ["+i+"] USER ["+ConfigurazionePdDReader.accessoRegistroServizi.getRegistro(i).getUser()+"]");
  6997.             System.out.println("REGISTRO ["+i+"] PASSWORD ["+ConfigurazionePdDReader.accessoRegistroServizi.getRegistro(i).getPassword()+"]");
  6998.         }*/

  7000.         return ConfigurazionePdDReader.accessoRegistroServizi;
  7001.     }

  7003.     /**
  7004.      * Restituisce le informazioni necessarie alla porta di dominio per accedere alla configurazione
  7005.      *
  7006.      * @return informazioni
  7007.      * 
  7008.      */
  7009.     private static AccessoConfigurazione accessoConfigurazione = null;
  7010.     private static Boolean accessoConfigurazioneLetto = false;
  7011.     public static void setAccessoConfigurazione(AccessoConfigurazione accessoConfigurazione) {
  7012.         ConfigurazionePdDReader.accessoConfigurazione = accessoConfigurazione;
  7013.     }
  7014.     public static void setAccessoConfigurazioneLetto(Boolean accessoConfigurazioneLetto) {
  7015.         ConfigurazionePdDReader.accessoConfigurazioneLetto = accessoConfigurazioneLetto;
  7016.     }
  7017.     protected AccessoConfigurazione getAccessoConfigurazione(Connection connectionPdD){

  7019.         if( this.configurazioneDinamica || !ConfigurazionePdDReader.accessoConfigurazioneLetto.booleanValue()){
  7020.             AccessoConfigurazione tmp = null;
  7021.             try{
  7022.                 tmp = this.configurazionePdD.getAccessoConfigurazione(connectionPdD);
  7023.             }catch(DriverConfigurazioneNotFound e){
  7024.                 this.logDebug("getAccessoConfigurazione (not found): "+e.getMessage());
  7025.             }catch(Exception e){
  7026.                 this.logError("getAccessoConfigurazione",e);
  7027.             }

  7029.             ConfigurazionePdDReader.setAccessoConfigurazione(tmp);
  7030.             ConfigurazionePdDReader.setAccessoConfigurazioneLetto(true);
  7031.         }

  7033.         /**
  7034.         if(ConfigurazionePdDReader.accessoConfigurazione.getCache()==null){
  7035.             System.out.println("ACCESSO_CONFIG CACHE DISABILITATA");
  7036.         }else{
  7037.             System.out.println("ACCESSO_CONFIG CACHE ABILITATA");
  7038.             System.out.println("ACCESSO_CONFIG CACHE ALGORITMO: "+ConfigurazionePdDReader.accessoConfigurazione.getCache().getAlgoritmo());
  7039.             System.out.println("ACCESSO_CONFIG CACHE DIMENSIONE: "+ConfigurazionePdDReader.accessoConfigurazione.getCache().getDimensione());
  7040.             System.out.println("ACCESSO_CONFIG CACHE ITEM IDLE: "+ConfigurazionePdDReader.accessoConfigurazione.getCache().getItemIdleTime());
  7041.             System.out.println("ACCESSO_CONFIG CACHE ITEM LIFE SECOND: "+ConfigurazionePdDReader.accessoConfigurazione.getCache().getItemLifeSecond());
  7042.         }
  7043.          */

  7045.         return ConfigurazionePdDReader.accessoConfigurazione;
  7046.     }

  7048.     /**
  7049.      * Restituisce le informazioni necessarie alla porta di dominio per accedere ai dati di autorizzazione
  7050.      *
  7051.      * @return informazioni
  7052.      * 
  7053.      */
  7054.     private static AccessoDatiAutorizzazione accessoDatiAutorizzazione = null;
  7055.     private static Boolean accessoDatiAutorizzazioneLetto = false;
  7056.     public static void setAccessoDatiAutorizzazione(AccessoDatiAutorizzazione accessoDatiAutorizzazione) {
  7057.         ConfigurazionePdDReader.accessoDatiAutorizzazione = accessoDatiAutorizzazione;
  7058.     }
  7059.     public static void setAccessoDatiAutorizzazioneLetto(Boolean accessoDatiAutorizzazioneLetto) {
  7060.         ConfigurazionePdDReader.accessoDatiAutorizzazioneLetto = accessoDatiAutorizzazioneLetto;
  7061.     }
  7062.     protected AccessoDatiAutorizzazione getAccessoDatiAutorizzazione(Connection connectionPdD){

  7064.         if( this.configurazioneDinamica || !ConfigurazionePdDReader.accessoDatiAutorizzazioneLetto.booleanValue()){
  7065.             AccessoDatiAutorizzazione tmp = null;
  7066.             try{
  7067.                 tmp = this.configurazionePdD.getAccessoDatiAutorizzazione(connectionPdD);
  7068.             }catch(DriverConfigurazioneNotFound e){
  7069.                 this.logDebug("getAccessoDatiAutorizzazione (not found): "+e.getMessage());
  7070.             }catch(Exception e){
  7071.                 this.logError("getAccessoDatiAutorizzazione",e);
  7072.             }

  7074.             ConfigurazionePdDReader.setAccessoDatiAutorizzazione(tmp);
  7075.             ConfigurazionePdDReader.setAccessoDatiAutorizzazioneLetto(true);
  7076.         }

  7078.         /**
  7079.         if(ConfigurazionePdDReader.accessoDatiAutorizzazione.getCache()==null){
  7080.             System.out.println("ACCESSO_DATI_AUTH CACHE DISABILITATA");
  7081.         }else{
  7082.             System.out.println("ACCESSO_DATI_AUTH CACHE ABILITATA");
  7083.             System.out.println("ACCESSO_DATI_AUTH CACHE ALGORITMO: "+ConfigurazionePdDReader.accessoDatiAutorizzazione.getCache().getAlgoritmo());
  7084.             System.out.println("ACCESSO_DATI_AUTH CACHE DIMENSIONE: "+ConfigurazionePdDReader.accessoDatiAutorizzazione.getCache().getDimensione());
  7085.             System.out.println("ACCESSO_DATI_AUTH CACHE ITEM IDLE: "+ConfigurazionePdDReader.accessoDatiAutorizzazione.getCache().getItemIdleTime());
  7086.             System.out.println("ACCESSO_DATI_AUTH CACHE ITEM LIFE SECOND: "+ConfigurazionePdDReader.accessoDatiAutorizzazione.getCache().getItemLifeSecond());
  7087.         }
  7088.          */

  7090.         return ConfigurazionePdDReader.accessoDatiAutorizzazione;
  7091.     }

  7093.     /**
  7094.      * Restituisce le informazioni necessarie alla porta di dominio per accedere ai dati di autorizzazione
  7095.      *
  7096.      * @return informazioni
  7097.      * 
  7098.      */
  7099.     private static AccessoDatiAutenticazione accessoDatiAutenticazione = null;
  7100.     private static Boolean accessoDatiAutenticazioneLetto = false;
  7101.     public static void setAccessoDatiAutenticazione(AccessoDatiAutenticazione accessoDatiAutenticazione) {
  7102.         ConfigurazionePdDReader.accessoDatiAutenticazione = accessoDatiAutenticazione;
  7103.     }
  7104.     public static void setAccessoDatiAutenticazioneLetto(Boolean accessoDatiAutenticazioneLetto) {
  7105.         ConfigurazionePdDReader.accessoDatiAutenticazioneLetto = accessoDatiAutenticazioneLetto;
  7106.     }
  7107.     protected AccessoDatiAutenticazione getAccessoDatiAutenticazione(Connection connectionPdD){

  7109.         if( this.configurazioneDinamica || !ConfigurazionePdDReader.accessoDatiAutenticazioneLetto.booleanValue()){
  7110.             AccessoDatiAutenticazione tmp = null;
  7111.             try{
  7112.                 tmp = this.configurazionePdD.getAccessoDatiAutenticazione(connectionPdD);
  7113.             }catch(DriverConfigurazioneNotFound e){
  7114.                 this.logDebug("getAccessoDatiAutenticazione (not found): "+e.getMessage());
  7115.             }catch(Exception e){
  7116.                 this.logError("getAccessoDatiAutenticazione",e);
  7117.             }

  7119.             ConfigurazionePdDReader.setAccessoDatiAutenticazione(tmp);
  7120.             ConfigurazionePdDReader.setAccessoDatiAutenticazioneLetto(true);
  7121.         }

  7123.         /**
  7124.         if(ConfigurazionePdDReader.accessoDatiAutenticazione.getCache()==null){
  7125.             System.out.println("ACCESSO_DATI_AUTHN CACHE DISABILITATA");
  7126.         }else{
  7127.             System.out.println("ACCESSO_DATI_AUTHN CACHE ABILITATA");
  7128.             System.out.println("ACCESSO_DATI_AUTHN CACHE ALGORITMO: "+ConfigurazionePdDReader.accessoDatiAutenticazione.getCache().getAlgoritmo());
  7129.             System.out.println("ACCESSO_DATI_AUTHN CACHE DIMENSIONE: "+ConfigurazionePdDReader.accessoDatiAutenticazione.getCache().getDimensione());
  7130.             System.out.println("ACCESSO_DATI_AUTHN CACHE ITEM IDLE: "+ConfigurazionePdDReader.accessoDatiAutenticazione.getCache().getItemIdleTime());
  7131.             System.out.println("ACCESSO_DATI_AUTHN CACHE ITEM LIFE SECOND: "+ConfigurazionePdDReader.accessoDatiAutenticazione.getCache().getItemLifeSecond());
  7132.         }
  7133.          */

  7135.         return ConfigurazionePdDReader.accessoDatiAutenticazione;
  7136.     }

  7138.     /**
  7139.      * Restituisce le informazioni necessarie alla porta di dominio per accedere ai dati di gestione dei token
  7140.      *
  7141.      * @return informazioni
  7142.      * 
  7143.      */
  7144.     private static AccessoDatiGestioneToken accessoDatiGestioneToken = null;
  7145.     private static Boolean accessoDatiGestioneTokenLetto = false;
  7146.     public static void setAccessoDatiGestioneToken(AccessoDatiGestioneToken accessoDatiGestioneToken) {
  7147.         ConfigurazionePdDReader.accessoDatiGestioneToken = accessoDatiGestioneToken;
  7148.     }
  7149.     public static void setAccessoDatiGestioneTokenLetto(Boolean accessoDatiGestioneTokenLetto) {
  7150.         ConfigurazionePdDReader.accessoDatiGestioneTokenLetto = accessoDatiGestioneTokenLetto;
  7151.     }
  7152.     protected AccessoDatiGestioneToken getAccessoDatiGestioneToken(Connection connectionPdD){

  7154.         if( this.configurazioneDinamica || !ConfigurazionePdDReader.accessoDatiGestioneTokenLetto.booleanValue()){
  7155.             AccessoDatiGestioneToken tmp = null;
  7156.             try{
  7157.                 tmp = this.configurazionePdD.getAccessoDatiGestioneToken(connectionPdD);
  7158.             }catch(DriverConfigurazioneNotFound e){
  7159.                 this.logDebug("getAccessoDatiGestioneToken (not found): "+e.getMessage());
  7160.             }catch(Exception e){
  7161.                 this.logError("getAccessoDatiGestioneToken",e);
  7162.             }

  7164.             ConfigurazionePdDReader.setAccessoDatiGestioneToken(tmp);
  7165.             ConfigurazionePdDReader.setAccessoDatiGestioneTokenLetto(true);
  7166.         }

  7168.         /**
  7169.         if(ConfigurazionePdDReader.accessoDatiGestioneToken.getCache()==null){
  7170.             System.out.println("ACCESSO_DATI_TOKEN CACHE DISABILITATA");
  7171.         }else{
  7172.             System.out.println("ACCESSO_DATI_TOKEN CACHE ABILITATA");
  7173.             System.out.println("ACCESSO_DATI_TOKEN CACHE ALGORITMO: "+ConfigurazionePdDReader.accessoDatiGestioneToken.getCache().getAlgoritmo());
  7174.             System.out.println("ACCESSO_DATI_TOKEN CACHE DIMENSIONE: "+ConfigurazionePdDReader.accessoDatiGestioneToken.getCache().getDimensione());
  7175.             System.out.println("ACCESSO_DATI_TOKEN CACHE ITEM IDLE: "+ConfigurazionePdDReader.accessoDatiGestioneToken.getCache().getItemIdleTime());
  7176.             System.out.println("ACCESSO_DATI_TOKEN CACHE ITEM LIFE SECOND: "+ConfigurazionePdDReader.accessoDatiGestioneToken.getCache().getItemLifeSecond());
  7177.         }
  7178.          */

  7180.         return ConfigurazionePdDReader.accessoDatiGestioneToken;
  7181.     }
  7182.     
  7183.     /**
  7184.      * Restituisce le informazioni necessarie alla porta di dominio per accedere ai dati raccolti via attribute authority
  7185.      *
  7186.      * @return informazioni
  7187.      * 
  7188.      */
  7189.     private static AccessoDatiAttributeAuthority accessoDatiAttributeAuthority = null;
  7190.     private static Boolean accessoDatiAttributeAuthorityLetto = false;
  7191.     public static void setAccessoDatiAttributeAuthority(AccessoDatiAttributeAuthority accessoDatiAttributeAuthority) {
  7192.         ConfigurazionePdDReader.accessoDatiAttributeAuthority = accessoDatiAttributeAuthority;
  7193.     }
  7194.     public static void setAccessoDatiAttributeAuthorityLetto(Boolean accessoDatiAttributeAuthorityLetto) {
  7195.         ConfigurazionePdDReader.accessoDatiAttributeAuthorityLetto = accessoDatiAttributeAuthorityLetto;
  7196.     }
  7197.     protected AccessoDatiAttributeAuthority getAccessoDatiAttributeAuthority(Connection connectionPdD){

  7199.         if( this.configurazioneDinamica || !ConfigurazionePdDReader.accessoDatiAttributeAuthorityLetto.booleanValue()){
  7200.             AccessoDatiAttributeAuthority tmp = null;
  7201.             try{
  7202.                 tmp = this.configurazionePdD.getAccessoDatiAttributeAuthority(connectionPdD);
  7203.             }catch(DriverConfigurazioneNotFound e){
  7204.                 this.logDebug("getAccessoDatiAttributeAuthority (not found): "+e.getMessage());
  7205.             }catch(Exception e){
  7206.                 this.logError("getAccessoDatiAttributeAuthority",e);
  7207.             }

  7209.             ConfigurazionePdDReader.setAccessoDatiAttributeAuthority(tmp);
  7210.             ConfigurazionePdDReader.setAccessoDatiAttributeAuthorityLetto(true);
  7211.         }

  7213.         /**
  7214.         if(ConfigurazionePdDReader.accessoDatiAttributeAuthority.getCache()==null){
  7215.             System.out.println("ACCESSO_DATI_ATTRIBUTE_AUTHORITY CACHE DISABILITATA");
  7216.         }else{
  7217.             System.out.println("ACCESSO_DATI_ATTRIBUTE_AUTHORITY CACHE ABILITATA");
  7218.             System.out.println("ACCESSO_DATI_ATTRIBUTE_AUTHORITY CACHE ALGORITMO: "+ConfigurazionePdDReader.accessoDatiAttributeAuthority.getCache().getAlgoritmo());
  7219.             System.out.println("ACCESSO_DATI_ATTRIBUTE_AUTHORITY CACHE DIMENSIONE: "+ConfigurazionePdDReader.accessoDatiAttributeAuthority.getCache().getDimensione());
  7220.             System.out.println("ACCESSO_DATI_ATTRIBUTE_AUTHORITY CACHE ITEM IDLE: "+ConfigurazionePdDReader.accessoDatiAttributeAuthority.getCache().getItemIdleTime());
  7221.             System.out.println("ACCESSO_DATI_ATTRIBUTE_AUTHORITY CACHE ITEM LIFE SECOND: "+ConfigurazionePdDReader.accessoDatiAttributeAuthority.getCache().getItemLifeSecond());
  7222.         }
  7223.          */

  7225.         return ConfigurazionePdDReader.accessoDatiAttributeAuthority;
  7226.     }

  7228.     /**
  7229.      * Restituisce le informazioni necessarie alla porta di dominio per accedere ai dati di gestione dei keystore
  7230.      *
  7231.      * @return informazioni
  7232.      * 
  7233.      */
  7234.     private static AccessoDatiKeystore accessoDatiKeystore = null;
  7235.     private static Boolean accessoDatiKeystoreLetto = false;
  7236.     public static void setAccessoDatiKeystore(AccessoDatiKeystore accessoDatiKeystore) {
  7237.         ConfigurazionePdDReader.accessoDatiKeystore = accessoDatiKeystore;
  7238.     }
  7239.     public static void setAccessoDatiKeystoreLetto(Boolean accessoDatiKeystoreLetto) {
  7240.         ConfigurazionePdDReader.accessoDatiKeystoreLetto = accessoDatiKeystoreLetto;
  7241.     }
  7242.     protected AccessoDatiKeystore getAccessoDatiKeystore(Connection connectionPdD){

  7244.         if( this.configurazioneDinamica || !ConfigurazionePdDReader.accessoDatiKeystoreLetto.booleanValue()){
  7245.             AccessoDatiKeystore tmp = null;
  7246.             try{
  7247.                 tmp = this.configurazionePdD.getAccessoDatiKeystore(connectionPdD);
  7248.             }catch(DriverConfigurazioneNotFound e){
  7249.                 this.logDebug("getAccessoDatiKeystore (not found): "+e.getMessage());
  7250.             }catch(Exception e){
  7251.                 this.logError("getAccessoDatiKeystore",e);
  7252.             }

  7254.             ConfigurazionePdDReader.setAccessoDatiKeystore(tmp);
  7255.             ConfigurazionePdDReader.setAccessoDatiKeystoreLetto(true);
  7256.         }

  7258.         /**
  7259.         if(ConfigurazionePdDReader.accessoDatiKeystore.getCache()==null){
  7260.             System.out.println("ACCESSO_DATI_KEYSTORE CACHE DISABILITATA");
  7261.         }else{
  7262.             System.out.println("ACCESSO_DATI_KEYSTORE CACHE ABILITATA");
  7263.             System.out.println("ACCESSO_DATI_KEYSTORE CACHE ALGORITMO: "+ConfigurazionePdDReader.accessoDatiKeystore.getCache().getAlgoritmo());
  7264.             System.out.println("ACCESSO_DATI_KEYSTORE CACHE DIMENSIONE: "+ConfigurazionePdDReader.accessoDatiKeystore.getCache().getDimensione());
  7265.             System.out.println("ACCESSO_DATI_KEYSTORE CACHE ITEM IDLE: "+ConfigurazionePdDReader.accessoDatiKeystore.getCache().getItemIdleTime());
  7266.             System.out.println("ACCESSO_DATI_KEYSTORE CACHE ITEM LIFE SECOND: "+ConfigurazionePdDReader.accessoDatiKeystore.getCache().getItemLifeSecond());
  7267.             System.out.println("ACCESSO_DATI_KEYSTORE CACHE ITEM LIFE SECOND: "+ConfigurazionePdDReader.accessoDatiKeystore.getCrlItemLifeSecond());
  7268.         }
  7269.          */

  7271.         return ConfigurazionePdDReader.accessoDatiKeystore;
  7272.     }
  7273.     
  7274.     /**
  7275.      * Restituisce le informazioni necessarie alla porta di dominio per accedere ai dati di gestione delle richieste
  7276.      *
  7277.      * @return informazioni
  7278.      * 
  7279.      */
  7280.     private static AccessoDatiRichieste accessoDatiRichieste = null;
  7281.     private static Boolean accessoDatiRichiesteLetto = false;
  7282.     public static void setAccessoDatiRichieste(AccessoDatiRichieste accessoDatiRichieste) {
  7283.         ConfigurazionePdDReader.accessoDatiRichieste = accessoDatiRichieste;
  7284.     }
  7285.     public static void setAccessoDatiRichiesteLetto(Boolean accessoDatiRichiesteLetto) {
  7286.         ConfigurazionePdDReader.accessoDatiRichiesteLetto = accessoDatiRichiesteLetto;
  7287.     }
  7288.     protected AccessoDatiRichieste getAccessoDatiRichieste(Connection connectionPdD){

  7290.         if( this.configurazioneDinamica || !ConfigurazionePdDReader.accessoDatiRichiesteLetto.booleanValue()){
  7291.             AccessoDatiRichieste tmp = null;
  7292.             try{
  7293.                 tmp = this.configurazionePdD.getAccessoDatiRichieste(connectionPdD);
  7294.             }catch(DriverConfigurazioneNotFound e){
  7295.                 this.logDebug("getAccessoDatiRichieste (not found): "+e.getMessage());
  7296.             }catch(Exception e){
  7297.                 this.logError("getAccessoDatiRichieste",e);
  7298.             }

  7300.             ConfigurazionePdDReader.setAccessoDatiRichieste(tmp);
  7301.             ConfigurazionePdDReader.setAccessoDatiRichiesteLetto(true);
  7302.         }

  7304.         /**
  7305.         if(ConfigurazionePdDReader.accessoDatiRichieste.getCache()==null){
  7306.             System.out.println("ACCESSO_DATI_RICHIESTE CACHE DISABILITATA");
  7307.         }else{
  7308.             System.out.println("ACCESSO_DATI_RICHIESTE CACHE ABILITATA");
  7309.             System.out.println("ACCESSO_DATI_RICHIESTE CACHE ALGORITMO: "+ConfigurazionePdDReader.accessoDatiRichieste.getCache().getAlgoritmo());
  7310.             System.out.println("ACCESSO_DATI_RICHIESTE CACHE DIMENSIONE: "+ConfigurazionePdDReader.accessoDatiRichieste.getCache().getDimensione());
  7311.             System.out.println("ACCESSO_DATI_RICHIESTE CACHE ITEM IDLE: "+ConfigurazionePdDReader.accessoDatiRichieste.getCache().getItemIdleTime());
  7312.             System.out.println("ACCESSO_DATI_RICHIESTE CACHE ITEM LIFE SECOND: "+ConfigurazionePdDReader.accessoDatiRichieste.getCache().getItemLifeSecond());
  7313.             System.out.println("ACCESSO_DATI_RICHIESTE CACHE ITEM LIFE SECOND: "+ConfigurazionePdDReader.accessoDatiRichieste.getCrlItemLifeSecond());
  7314.         }
  7315.          */

  7317.         return ConfigurazionePdDReader.accessoDatiRichieste;
  7318.     }

  7320.     /**
  7321.      * Restituisce il tipo di validazione richiesta alla porta di dominio.
  7322.      * Se un valore non viene impostato, il tipo ritornato sara' 'attivo'.
  7323.      *
  7324.      * @return la validazione richiesta a OpenSPCoop.
  7325.      * 
  7326.      */
  7327.     private static StatoFunzionalitaConWarning tipoValidazione = null;
  7328.     protected StatoFunzionalitaConWarning getTipoValidazione(Connection connectionPdD,String implementazionePdDSoggetto){

  7330.         // ovverriding per implementazione porta di dominio
  7331.         String tipo = this.pddProperties.getValidazioneBuste_Stato(implementazionePdDSoggetto);
  7332.         if(tipo!=null && ( 
  7333.                 CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.toString().equals(tipo) || 
  7334.                 CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO.toString().equals(tipo) || 
  7335.                 CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.toString().equals(tipo) ) 
  7336.                 ){
  7337.             if(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.toString().equals(tipo))
  7338.                 return CostantiConfigurazione.STATO_CON_WARNING_ABILITATO;
  7339.             else if(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO.toString().equals(tipo))
  7340.                 return CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO;
  7341.             else 
  7342.                 return CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY;
  7343.         }

  7345.         if( this.configurazioneDinamica || ConfigurazionePdDReader.tipoValidazione==null){

  7347.             Configurazione configurazione = null;
  7348.             try{
  7349.                 configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);

  7351.                 /*if(configurazione.getValidazioneBuste()!=null){
  7352.                     System.out.println("VALIDAZIONE tipo["+configurazione.getValidazioneBuste().getStato()+"] Controllo["+
  7353.                             configurazione.getValidazioneBuste().getControllo()+"] Profilo["+
  7354.                             configurazione.getValidazioneBuste().getProfiloCollaborazione()+"] Manifest["+
  7355.                             configurazione.getValidazioneBuste().getManifestAttachments()+"]");
  7356.                 }*/


  7359.             }catch(DriverConfigurazioneNotFound e){
  7360.                 this.logDebug("getTipoValidazione (not found): "+e.getMessage());
  7361.             }catch(Exception e){
  7362.                 this.logError("getTipoValidazione",e);
  7363.             }
  7364.             if( configurazione  == null || configurazione.getValidazioneBuste()==null){
  7365.                 ConfigurazionePdDReader.tipoValidazione = CostantiConfigurazione.STATO_CON_WARNING_ABILITATO;
  7366.             }else if( CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.equals(configurazione.getValidazioneBuste().getStato())  )
  7367.                 ConfigurazionePdDReader.tipoValidazione = CostantiConfigurazione.STATO_CON_WARNING_ABILITATO;
  7368.             else if( CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO.equals(configurazione.getValidazioneBuste().getStato())  )
  7369.                 ConfigurazionePdDReader.tipoValidazione = CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO;
  7370.             else if( CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(configurazione.getValidazioneBuste().getStato())  )
  7371.                 ConfigurazionePdDReader.tipoValidazione = CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY;
  7372.             else
  7373.                 ConfigurazionePdDReader.tipoValidazione = CostantiConfigurazione.STATO_CON_WARNING_ABILITATO;

  7375.         }

  7377.         return ConfigurazionePdDReader.tipoValidazione;
  7378.     }

  7380.     /**
  7381.      * Restituisce true se il livello di validazione richiesta alla porta di dominio e' normale.
  7382.      * False se il livello di validazione e' rigido.
  7383.      * Se un valore non e' stato impostato, il livello scelto sara' 'normale' (return true).
  7384.      *
  7385.      * @return true se il livello di validazione richiesta a OpenSPCoop e 'normale'.
  7386.      * 
  7387.      */
  7388.     private static Boolean isLivelloValidazioneNormale = null;
  7389.     protected boolean isLivelloValidazioneNormale(Connection connectionPdD,String implementazionePdDSoggetto){

  7391.         // ovverriding per implementazione porta di dominio
  7392.         String value = this.pddProperties.getValidazioneBuste_Controllo(implementazionePdDSoggetto);
  7393.         if(value!=null && ( 
  7394.                 CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_NORMALE.toString().equalsIgnoreCase(value) || 
  7395.                 CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_RIGIDO.toString().equalsIgnoreCase(value) ) 
  7396.                 ){
  7397.             if(CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_NORMALE.toString().equalsIgnoreCase(value))
  7398.                 return true;
  7399.             else 
  7400.                 return false;
  7401.         }

  7403.         if( this.configurazioneDinamica || ConfigurazionePdDReader.isLivelloValidazioneNormale==null){

  7405.             Configurazione configurazione = null;
  7406.             try{
  7407.                 configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  7408.             }catch(DriverConfigurazioneNotFound e){
  7409.                 this.logDebug("isLivelloValidazioneNormale (not found): "+e.getMessage());
  7410.             }catch(Exception e){
  7411.                 this.logError("isLivelloValidazioneNormale",e);
  7412.             }
  7413.             if( configurazione  == null  || configurazione.getValidazioneBuste()==null){
  7414.                 ConfigurazionePdDReader.isLivelloValidazioneNormale = true; // default is normale
  7415.             }else if( CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_NORMALE.equals(configurazione.getValidazioneBuste().getControllo())  )
  7416.                 ConfigurazionePdDReader.isLivelloValidazioneNormale = true;
  7417.             else 
  7418.                 ConfigurazionePdDReader.isLivelloValidazioneNormale = false;        

  7420.         }

  7422.         return ConfigurazionePdDReader.isLivelloValidazioneNormale;

  7424.     }

  7426.     /**
  7427.      * Restituisce true se il livello di validazione richiesta alla porta di dominio e' rigido.
  7428.      * False se il livello di validazione e' normale.
  7429.      * Se un valore non e' stato impostato, il livello scelto sara' 'normale' (return false).
  7430.      *
  7431.      * @return true se il livello di validazione richiesta a OpenSPCoop e 'rigido'.
  7432.      * 
  7433.      */
  7434.     private static Boolean isLivelloValidazioneRigido = null;
  7435.     protected boolean isLivelloValidazioneRigido(Connection connectionPdD, String implementazionePdDSoggetto){

  7437.         // ovverriding per implementazione porta di dominio
  7438.         String value = this.pddProperties.getValidazioneBuste_Controllo(implementazionePdDSoggetto);
  7439.         if(value!=null && ( 
  7440.                 CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_NORMALE.toString().equalsIgnoreCase(value) || 
  7441.                 CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_RIGIDO.toString().equalsIgnoreCase(value) ) 
  7442.                 ){
  7443.             if(CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_RIGIDO.toString().equalsIgnoreCase(value))
  7444.                 return true;
  7445.             else 
  7446.                 return false;
  7447.         }

  7449.         if( this.configurazioneDinamica || ConfigurazionePdDReader.isLivelloValidazioneRigido==null){

  7451.             Configurazione configurazione = null;
  7452.             try{
  7453.                 configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  7454.             }catch(DriverConfigurazioneNotFound e){
  7455.                 this.logDebug("isLivelloValidazioneRigido (not found): "+e.getMessage());
  7456.             }catch(Exception e){
  7457.                 this.logError("isLivelloValidazioneRigido",e);
  7458.             }
  7459.             if( configurazione  == null  || configurazione.getValidazioneBuste()==null){
  7460.                 ConfigurazionePdDReader.isLivelloValidazioneRigido = false; // default is normale
  7461.             }else if( CostantiConfigurazione.VALIDAZIONE_PROTOCOL_LIVELLO_RIGIDO.equals(configurazione.getValidazioneBuste().getControllo())  )
  7462.                 ConfigurazionePdDReader.isLivelloValidazioneRigido = true;
  7463.             else
  7464.                 ConfigurazionePdDReader.isLivelloValidazioneRigido = false;

  7466.         }

  7468.         return ConfigurazionePdDReader.isLivelloValidazioneRigido;
  7469.     }

  7471.     /**
  7472.      * Restituisce l'indicazione se il profilo di collaborazione deve essere validato controllando
  7473.      * il profilo registrato nel registro.
  7474.      * Se un valore non viene impostato, il tipo ritornato sara' 'disabilitato'.
  7475.      *
  7476.      * @return la validazione del profilo di collaborazione richiesta a OpenSPCoop.
  7477.      * 
  7478.      */
  7479.     private static Boolean validazioneProfiloCollaborazione = null;
  7480.     protected boolean isValidazioneProfiloCollaborazione(Connection connectionPdD, String implementazionePdDSoggetto){

  7482.         // ovverriding per implementazione porta di dominio
  7483.         String value = this.pddProperties.getValidazioneBuste_ProfiloCollaborazione(implementazionePdDSoggetto);
  7484.         if(value!=null && ( 
  7485.                 CostantiConfigurazione.ABILITATO.toString().equalsIgnoreCase(value) || 
  7486.                 CostantiConfigurazione.DISABILITATO.toString().equalsIgnoreCase(value) ) 
  7487.                 ){
  7488.             if(CostantiConfigurazione.ABILITATO.toString().equalsIgnoreCase(value))
  7489.                 return true;
  7490.             else 
  7491.                 return false;
  7492.         }

  7494.         if( this.configurazioneDinamica || ConfigurazionePdDReader.validazioneProfiloCollaborazione==null){

  7496.             Configurazione configurazione = null;
  7497.             try{
  7498.                 configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  7499.             }catch(DriverConfigurazioneNotFound e){
  7500.                 this.logDebug("isValidazioneProfiloCollaborazione (not found): "+e.getMessage());
  7501.             }catch(Exception e){
  7502.                 this.logError("isValidazioneProfiloCollaborazione",e);
  7503.             }
  7504.             if(configurazione == null || configurazione.getValidazioneBuste()==null)
  7505.                 ConfigurazionePdDReader.validazioneProfiloCollaborazione = false; //default: CostantiConfigurazione.DISABILITATO;
  7506.             else if(CostantiConfigurazione.ABILITATO.equals(configurazione.getValidazioneBuste().getProfiloCollaborazione()))
  7507.                 ConfigurazionePdDReader.validazioneProfiloCollaborazione = true;
  7508.             else
  7509.                 ConfigurazionePdDReader.validazioneProfiloCollaborazione = false; //default: CostantiConfigurazione.DISABILITATO;

  7511.         }

  7513.         return ConfigurazionePdDReader.validazioneProfiloCollaborazione;
  7514.     }

  7516.     /**
  7517.      * Restituisce true se la porta di dominio deve validare il manifest di eventuali messaggi con attachments. 
  7518.      *
  7519.      * @return Restituisce true se la porta di dominio deve validare il manifest di eventuali messaggi con attachments. 
  7520.      * 
  7521.      */
  7522.     private static Boolean validazioneManifestAttachments = null;
  7523.     protected boolean isValidazioneManifestAttachments(Connection connectionPdD, String implementazionePdDSoggetto){

  7525.         // ovverriding per implementazione porta di dominio
  7526.         String value = this.pddProperties.getValidazioneBuste_ManifestAttachments(implementazionePdDSoggetto);
  7527.         if(value!=null && ( 
  7528.                 CostantiConfigurazione.ABILITATO.toString().equalsIgnoreCase(value) || 
  7529.                 CostantiConfigurazione.DISABILITATO.toString().equalsIgnoreCase(value) ) 
  7530.                 ){
  7531.             if(CostantiConfigurazione.ABILITATO.toString().equalsIgnoreCase(value))
  7532.                 return true;
  7533.             else 
  7534.                 return false;
  7535.         }

  7537.         if( this.configurazioneDinamica || ConfigurazionePdDReader.validazioneManifestAttachments==null){

  7539.             Configurazione configurazione = null;
  7540.             try{
  7541.                 configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  7542.             }catch(DriverConfigurazioneNotFound e){
  7543.                 this.logDebug("isValidazioneManifestAttachments (not found): "+e.getMessage());
  7544.             }catch(Exception e){
  7545.                 this.logDebug("isValidazioneManifestAttachments",e);
  7546.             }
  7547.             if(configurazione == null || configurazione.getValidazioneBuste()==null)
  7548.                 ConfigurazionePdDReader.validazioneManifestAttachments = true; //default: CostantiConfigurazione.ABILITATO;
  7549.             else if(CostantiConfigurazione.DISABILITATO.equals(configurazione.getValidazioneBuste().getManifestAttachments()))
  7550.                 ConfigurazionePdDReader.validazioneManifestAttachments = false;
  7551.             else
  7552.                 ConfigurazionePdDReader.validazioneManifestAttachments = true; //default: CostantiConfigurazione.ABILITATO;

  7554.         }

  7556.         return ConfigurazionePdDReader.validazioneManifestAttachments;
  7557.     }

  7559.     /**
  7560.      * Restituisce l'indicazione sulla connettivita' della PdD, in particolar modo sulla modalita' 
  7561.      * di invio di risposte, la quale puo' variare da invio
  7562.      * nella reply della connessione (return false) o su di una nuova connessione (return true)
  7563.      *
  7564.      * @return true se viene utilizzata una nuova connessione per effettuare l'invio di eventuali risposte.
  7565.      * 
  7566.      */
  7567.     private static Boolean newConnectionForResponse = null;
  7568.     protected boolean newConnectionForResponse(Connection connectionPdD){

  7570.         if( this.configurazioneDinamica || ConfigurazionePdDReader.newConnectionForResponse==null){
  7571.             Configurazione configurazione = null;
  7572.             try{
  7573.                 configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);

  7575.                 /*if(configurazione.getRisposte()!=null){
  7576.                     System.out.println("NEW CONNECTION FOR RESPONSE ["+configurazione.getRisposte().getConnessione()+"]");
  7577.                 }*/

  7579.             }catch(DriverConfigurazioneNotFound e){
  7580.                 this.logDebug("newConnectionForResponse (not found): "+e.getMessage());
  7581.             }catch(Exception e){
  7582.                 this.logError("newConnectionForResponse",e);
  7583.             }
  7584.             if(configurazione == null || configurazione.getRisposte()==null)
  7585.                 ConfigurazionePdDReader.newConnectionForResponse = false; //default: CostantiConfigurazione.CONNECTION_REPLY;
  7586.             else if(CostantiConfigurazione.NEW_CONNECTION.equals(configurazione.getRisposte().getConnessione()))
  7587.                 ConfigurazionePdDReader.newConnectionForResponse = true;
  7588.             else
  7589.                 ConfigurazionePdDReader.newConnectionForResponse = false; //default: CostantiConfigurazione.CONNECTION_REPLY;
  7590.         }

  7592.         return ConfigurazionePdDReader.newConnectionForResponse;
  7593.     }

  7595.     /**
  7596.      * Restituisce true se la porta di dominio deve utilizzare eventuali indirizzi telematici presenti nelle buste ricevute. 
  7597.      *
  7598.      * @return true se la porta di dominio deve utilizzare eventuali indirizzi telematici presenti nelle buste.
  7599.      * 
  7600.      */
  7601.     private static Boolean utilizzoIndirizzoRisposta = null;
  7602.     protected boolean isUtilizzoIndirizzoTelematico(Connection connectionPdD){

  7604.         if( this.configurazioneDinamica || ConfigurazionePdDReader.utilizzoIndirizzoRisposta==null){
  7605.             Configurazione configurazione = null;
  7606.             try{
  7607.                 configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);

  7609.                 /*if(configurazione.getIndirizzoRisposta()!=null){
  7610.                     System.out.println("INDIRIZZO TELEMATICO ["+configurazione.getIndirizzoRisposta().getUtilizzo()+"]");
  7611.                 }*/

  7613.             }catch(DriverConfigurazioneNotFound e){
  7614.                 this.logDebug("isUtilizzoIndirizzoRisposta (not found): "+e.getMessage());
  7615.             }catch(Exception e){
  7616.                 this.logError("isUtilizzoIndirizzoRisposta",e);
  7617.             }
  7618.             if(configurazione == null || configurazione.getIndirizzoRisposta() == null)
  7619.                 ConfigurazionePdDReader.utilizzoIndirizzoRisposta = false; //default: CostantiConfigurazione.DISABILITATO;
  7620.             else if(CostantiConfigurazione.ABILITATO.equals(configurazione.getIndirizzoRisposta().getUtilizzo()))
  7621.                 ConfigurazionePdDReader.utilizzoIndirizzoRisposta = true;
  7622.             else
  7623.                 ConfigurazionePdDReader.utilizzoIndirizzoRisposta = false; //default: CostantiConfigurazione.DISABILITATO;
  7624.         }

  7626.         return ConfigurazionePdDReader.utilizzoIndirizzoRisposta;
  7627.     }

  7629.     /**
  7630.      * Restituisce true se la porta di dominio deve gestire (creare/eliminare) manifest di eventuali messaggi con attachments. 
  7631.      *
  7632.      * @return Restituisce true se la porta di dominio deve gestire (creare/eliminare) manifest di eventuali messaggi con attachments. 
  7633.      * 
  7634.      */
  7635.     private static Boolean gestioneManifestAttachments = null;
  7636.     protected boolean isGestioneManifestAttachments(Connection connectionPdD){

  7638.         if( this.configurazioneDinamica || ConfigurazionePdDReader.gestioneManifestAttachments==null){
  7639.             Configurazione configurazione = null;
  7640.             try{
  7641.                 configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);

  7643.                 /*if(configurazione.getAttachments()!=null){
  7644.                     System.out.println("GESTIONE MANIFEST ["+configurazione.getAttachments().getGestioneManifest()+"]");
  7645.                 }*/

  7647.             }catch(DriverConfigurazioneNotFound e){
  7648.                 this.logDebug("isGestioneManifestAttachments (not found): "+e.getMessage());
  7649.             }catch(Exception e){
  7650.                 this.logError("isGestioneManifestAttachments",e);
  7651.             }
  7652.             if(configurazione == null || configurazione.getAttachments()==null)
  7653.                 ConfigurazionePdDReader.gestioneManifestAttachments = false;  //default: CostantiConfigurazione.DISABILITATO;
  7654.             else if(CostantiConfigurazione.ABILITATO.equals(configurazione.getAttachments().getGestioneManifest()))
  7655.                 ConfigurazionePdDReader.gestioneManifestAttachments = true;
  7656.             else
  7657.                 ConfigurazionePdDReader.gestioneManifestAttachments = false;  //default: CostantiConfigurazione.DISABILITATO;
  7658.         }

  7660.         return ConfigurazionePdDReader.gestioneManifestAttachments;
  7661.     }

  7663.     /**
  7664.      * Restituisce i minuti dopo i quali una busta non riscontrata sara' rispedita.
  7665.      * (nel caso in cui nella busta sia richiesto una confermaRicezione) 
  7666.      *
  7667.      * @return timeout riscontro.
  7668.      * 
  7669.      */
  7670.     private static Long timeoutRiscontro = null;
  7671.     protected long getTimeoutRiscontro(Connection connectionPdD){

  7673.         if( this.configurazioneDinamica || ConfigurazionePdDReader.timeoutRiscontro==null){
  7674.             Configurazione configurazione = null;
  7675.             try{
  7676.                 configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);

  7678.                 /*if(configurazione.getInoltroBusteNonRiscontrate()!=null){
  7679.                     System.out.println("RISCONTRI ["+configurazione.getInoltroBusteNonRiscontrate().getCadenza()+"]");
  7680.                 }*/

  7682.             }catch(DriverConfigurazioneNotFound e){
  7683.                 this.logDebug("getTimeoutRiscontro (not found): "+e.getMessage());
  7684.             }catch(Exception e){
  7685.                 this.logError("getTimeoutRiscontro",e);
  7686.             }
  7687.             if(configurazione == null || configurazione.getInoltroBusteNonRiscontrate()==null)
  7688.                 ConfigurazionePdDReader.timeoutRiscontro = -1L;
  7689.             else if(configurazione.getInoltroBusteNonRiscontrate().getCadenza() == null)
  7690.                 ConfigurazionePdDReader.timeoutRiscontro = -1L;
  7691.             else{
  7692.                 Long longValue = null;
  7693.                 try{
  7694.                     longValue = Long.valueOf(configurazione.getInoltroBusteNonRiscontrate().getCadenza());
  7695.                 }catch(Exception e){
  7696.                     //  Conversione fallita
  7697.                 }

  7699.                 if(longValue == null)
  7700.                     ConfigurazionePdDReader.timeoutRiscontro = -1L;
  7701.                 else
  7702.                     ConfigurazionePdDReader.timeoutRiscontro = longValue;
  7703.             }
  7704.         }

  7706.         return ConfigurazionePdDReader.timeoutRiscontro;
  7707.     }


  7710.     /**
  7711.      * Restituisce il Livello per il logger dei messaggi diagnostici. 
  7712.      *
  7713.      * @return Il livello di Log4J per il logger dei messaggi diagnostici (di default ritorna ALL). 
  7714.      * 
  7715.      */
  7716.     private static Level livelloMessaggiDiagnostici = null;
  7717.     public static Level livelloMessaggiDiagnosticiJMX = null;
  7718.     protected Level getLivelloMessaggiDiagnostici(Connection connectionPdD){

  7720.         if(ConfigurazionePdDReader.livelloMessaggiDiagnosticiJMX!=null)
  7721.             return ConfigurazionePdDReader.livelloMessaggiDiagnosticiJMX;

  7723.         if( this.configurazioneDinamica || ConfigurazionePdDReader.livelloMessaggiDiagnostici==null){
  7724.             try{
  7725.                 Configurazione configurazione = null;
  7726.                 try{
  7727.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);                   
  7728.                 }catch(DriverConfigurazioneNotFound e){
  7729.                     this.logDebug("getLivelloMessaggiDiagnostici (not found): "+e.getMessage());
  7730.                 }catch(Exception e){
  7731.                     this.logError("getLivelloMessaggiDiagnostici",e);
  7732.                 }

  7734.                 if(configurazione!=null && configurazione.getMessaggiDiagnostici()!=null){
  7735.                     String readLevel = configurazione.getMessaggiDiagnostici().getSeverita().toString();       
  7736.                     ConfigurazionePdDReader.livelloMessaggiDiagnostici = LogLevels.toLog4J(readLevel);
  7737.                 }else{
  7738.                     ConfigurazionePdDReader.livelloMessaggiDiagnostici = LogLevels.LOG_LEVEL_INFO_PROTOCOL;
  7739.                 }

  7741.             }catch(Exception e){
  7742.                 ConfigurazionePdDReader.livelloMessaggiDiagnostici = LogLevels.LOG_LEVEL_INFO_PROTOCOL;
  7743.             }
  7744.         }

  7746.         return ConfigurazionePdDReader.livelloMessaggiDiagnostici;
  7747.     }

  7749.     /**
  7750.      * Restituisce il Livello per il logger dei messaggi diagnostici in stile 'openspcoop'. 
  7751.      *
  7752.      * @return Il livello di Log4J per il logger dei messaggi diagnostici 'openspcoop' (di default ritorna OFF). 
  7753.      * 
  7754.      */
  7755.     private static Level livelloLog4JMessaggiDiagnostici = null;
  7756.     public static Level livelloLog4JMessaggiDiagnosticiJMX = null;
  7757.     protected Level getLivelloLog4JMessaggiDiagnostici(Connection connectionPdD){

  7759.         if(ConfigurazionePdDReader.livelloLog4JMessaggiDiagnosticiJMX!=null){
  7760.             return ConfigurazionePdDReader.livelloLog4JMessaggiDiagnosticiJMX;
  7761.         }

  7763.         if( this.configurazioneDinamica || ConfigurazionePdDReader.livelloLog4JMessaggiDiagnostici==null){
  7764.             try{
  7765.                 Configurazione configurazione = null;
  7766.                 try{
  7767.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  7768.                 }catch(DriverConfigurazioneNotFound e){
  7769.                     this.logDebug("getLivelloLog4JMessaggiDiagnostici (not found): "+e.getMessage());
  7770.                 }catch(Exception e){
  7771.                     this.logError("getLivelloLog4JMessaggiDiagnostici",e);
  7772.                 }

  7774.                 if(configurazione!=null && configurazione.getMessaggiDiagnostici()!=null){
  7775.                     String readLevel =  configurazione.getMessaggiDiagnostici().getSeveritaLog4j().toString();     
  7776.                     ConfigurazionePdDReader.livelloLog4JMessaggiDiagnostici = LogLevels.toLog4J(readLevel);
  7777.                 }else{
  7778.                     ConfigurazionePdDReader.livelloLog4JMessaggiDiagnostici = LogLevels.LOG_LEVEL_INFO_PROTOCOL;
  7779.                 }

  7781.             }catch(Exception e){
  7782.                 ConfigurazionePdDReader.livelloLog4JMessaggiDiagnostici = LogLevels.LOG_LEVEL_INFO_PROTOCOL;
  7783.             }
  7784.         }

  7786.         return ConfigurazionePdDReader.livelloLog4JMessaggiDiagnostici;
  7787.     }

  7789.     /**
  7790.      * Restituisce il Livello per il logger dei messaggi diagnostici . 
  7791.      *
  7792.      * @return Il livello per il logger dei messaggi diagnostici  (di default ritorna ALL). 
  7793.      * 
  7794.      */
  7795.     private static Integer severitaMessaggiDiagnostici = null;
  7796.     public static Integer severitaMessaggiDiagnosticiJMX = null;
  7797.     protected int getSeveritaMessaggiDiagnostici(Connection connectionPdD){

  7799.         if(ConfigurazionePdDReader.severitaMessaggiDiagnosticiJMX!=null){
  7800.             return ConfigurazionePdDReader.severitaMessaggiDiagnosticiJMX;
  7801.         }

  7803.         if( this.configurazioneDinamica || ConfigurazionePdDReader.severitaMessaggiDiagnostici==null){
  7804.             try{
  7805.                 Configurazione configurazione = null;
  7806.                 try{
  7807.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);

  7809.                 }catch(DriverConfigurazioneNotFound e){
  7810.                     this.logDebug("getSeveritaMessaggiDiagnostici (not found): "+e.getMessage());
  7811.                 }catch(Exception e){
  7812.                     this.logError("getSeveritaMessaggiDiagnostici",e);
  7813.                 }

  7815.                 if(configurazione!=null && configurazione.getMessaggiDiagnostici()!=null){
  7816.                     String readLevel = configurazione.getMessaggiDiagnostici().getSeverita().toString();       
  7817.                     ConfigurazionePdDReader.severitaMessaggiDiagnostici = LogLevels.toOpenSPCoop2(readLevel);
  7818.                 }else{
  7819.                     ConfigurazionePdDReader.severitaMessaggiDiagnostici = LogLevels.SEVERITA_INFO_PROTOCOL;
  7820.                 }

  7822.             }catch(Exception e){
  7823.                 ConfigurazionePdDReader.severitaMessaggiDiagnostici = LogLevels.SEVERITA_INFO_PROTOCOL;
  7824.             }
  7825.         }

  7827.         return ConfigurazionePdDReader.severitaMessaggiDiagnostici;
  7828.     }

  7830.     /**
  7831.      * Restituisce il Livello per il logger dei messaggi diagnostici che finiscono su log4j
  7832.      *
  7833.      * @return Il livello per il logger dei messaggi diagnostici che finiscono su log4j (di default ritorna OFF). 
  7834.      * 
  7835.      */
  7836.     private static Integer severitaLog4JMessaggiDiagnostici = null;
  7837.     public static Integer severitaLog4JMessaggiDiagnosticiJMX = null;
  7838.     public static Integer getSeveritaLog4JMessaggiDiagnosticiJMX() {
  7839.         return severitaLog4JMessaggiDiagnosticiJMX;
  7840.     }
  7841.     public static void setSeveritaLog4JMessaggiDiagnosticiJMX(
  7842.             Integer severitaLog4JMessaggiDiagnosticiJMX) {
  7843.         ConfigurazionePdDReader.severitaLog4JMessaggiDiagnosticiJMX = severitaLog4JMessaggiDiagnosticiJMX;
  7844.     }
  7845.     protected int getSeveritaLog4JMessaggiDiagnostici(Connection connectionPdD){

  7847.         if(ConfigurazionePdDReader.severitaLog4JMessaggiDiagnosticiJMX!=null){
  7848.             return ConfigurazionePdDReader.severitaLog4JMessaggiDiagnosticiJMX;
  7849.         }

  7851.         if( this.configurazioneDinamica || ConfigurazionePdDReader.severitaLog4JMessaggiDiagnostici==null){
  7852.             try{

  7854.                 Configurazione configurazione = null;
  7855.                 try{
  7856.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  7857.                 }catch(DriverConfigurazioneNotFound e){
  7858.                     this.logDebug("getSeveritaLog4JMessaggiDiagnostici (not found): "+e.getMessage());
  7859.                 }catch(Exception e){
  7860.                     this.logError("getSeveritaLog4JMessaggiDiagnostici",e);
  7861.                 }

  7863.                 if(configurazione!=null && configurazione.getMessaggiDiagnostici()!=null){
  7864.                     String readLevel = configurazione.getMessaggiDiagnostici().getSeveritaLog4j().toString();      
  7865.                     ConfigurazionePdDReader.severitaLog4JMessaggiDiagnostici = LogLevels.toOpenSPCoop2(readLevel);
  7866.                 }else{
  7867.                     ConfigurazionePdDReader.severitaLog4JMessaggiDiagnostici = LogLevels.SEVERITA_INFO_PROTOCOL;
  7868.                 }

  7870.             }catch(Exception e){
  7871.                 ConfigurazionePdDReader.severitaLog4JMessaggiDiagnostici = LogLevels.SEVERITA_INFO_PROTOCOL;
  7872.             }
  7873.         }

  7875.         return ConfigurazionePdDReader.severitaLog4JMessaggiDiagnostici;
  7876.     }

  7878.     /**
  7879.      * Restituisce gli appender personalizzati per la registrazione dei messaggi diagnostici. 
  7880.      *
  7881.      * @return Restituisce gli appender personalizzati per la registrazione dei messaggi diagnostici. 
  7882.      */
  7883.     private static MessaggiDiagnostici openSPCoopAppenderMessaggiDiagnostici = null;
  7884.     private static Boolean openSPCoopAppenderMessaggiDiagnosticiLetto = false;
  7885.     protected MessaggiDiagnostici getOpenSPCoopAppenderMessaggiDiagnostici(Connection connectionPdD){

  7887.         if( this.configurazioneDinamica || !ConfigurazionePdDReader.openSPCoopAppenderMessaggiDiagnosticiLetto){
  7888.             try{

  7890.                 Configurazione configurazione = null;
  7891.                 try{
  7892.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  7893.                 }catch(DriverConfigurazioneNotFound e){
  7894.                     this.logDebug("getOpenSPCoopAppenderMessaggiDiagnostici (not found): "+e.getMessage());
  7895.                 }catch(Exception e){
  7896.                     this.logError("getOpenSPCoopAppenderMessaggiDiagnostici",e);
  7897.                 }
  7898.                 if(configurazione!=null)
  7899.                     ConfigurazionePdDReader.openSPCoopAppenderMessaggiDiagnostici = configurazione.getMessaggiDiagnostici();
  7900.                 else
  7901.                     ConfigurazionePdDReader.openSPCoopAppenderMessaggiDiagnostici = null;

  7903.             }catch(Exception e){
  7904.                 ConfigurazionePdDReader.openSPCoopAppenderMessaggiDiagnostici = null;
  7905.             }
  7906.             ConfigurazionePdDReader.openSPCoopAppenderMessaggiDiagnosticiLetto = true;
  7907.         }

  7909.         return ConfigurazionePdDReader.openSPCoopAppenderMessaggiDiagnostici;
  7910.     }


  7913.     public static Boolean tracciamentoBusteJMX = null;
  7914.     private static Boolean tracciamentoBuste = null;
  7915.     /**
  7916.      * Restituisce l'indicazione se effettuare o meno il tracciamento delle buste. 
  7917.      *
  7918.      * @return Restituisce l'indicazione se effettuare o meno il tracciamento delle buste.  (di default ritorna 'abilitato'). 
  7919.      * 
  7920.      */
  7921.     protected boolean tracciamentoBuste(Connection connectionPdD){

  7923.         if(ConfigurazionePdDReader.tracciamentoBusteJMX!=null)
  7924.             return ConfigurazionePdDReader.tracciamentoBusteJMX;

  7926.         if( this.configurazioneDinamica || ConfigurazionePdDReader.tracciamentoBuste==null){
  7927.             try{

  7929.                 Configurazione configurazione = null;
  7930.                 try{
  7931.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);

  7933.                     /*if(configurazione.getTracciamento()!=null){
  7934.                         System.out.println("TRACCIAMENTO BUSTE ["+configurazione.getTracciamento().getBuste()+"]");
  7935.                         System.out.println("TRACCIAMENTO DUMP ["+configurazione.getTracciamento().getDump()+"]");
  7936.                         for(int i=0;i<configurazione.getTracciamento().sizeOpenspcoopAppenderList();i++){
  7937.                             System.out.println("TRACCIAMENTO APPENDER ["+i+"] tipo["+configurazione.getTracciamento().getOpenspcoopAppender(i).getTipo()+"]");
  7938.                             List<org.openspcoop2.core.config.Property> properties = configurazione.getTracciamento().getOpenspcoopAppender(i).getPropertyList();
  7939.                             if(properties!=null){
  7940.                                 for (int j = 0; j < properties.size(); j++) {
  7941.                                     System.out.println("TRACCIAMENTO APPENDER ["+i+"] NOME["+properties.get(j).getNome()+"]=VALORE["+properties.get(j).getValore()+"]");
  7942.                                 }
  7943.                             }
  7944.                         }
  7945.                     }*/

  7947.                 }catch(DriverConfigurazioneNotFound e){
  7948.                     this.logDebug("tracciamentoBuste (not found): "+e.getMessage());
  7949.                 }catch(Exception e){
  7950.                     this.logError("tracciamentoBuste",e);
  7951.                 }

  7953.                 if(configurazione!=null && configurazione.getTracciamento()!=null){
  7954.                     StatoFunzionalita read = configurazione.getTracciamento().getStato();      
  7955.                     if(CostantiConfigurazione.DISABILITATO.equals(read))
  7956.                         ConfigurazionePdDReader.tracciamentoBuste = false;
  7957.                     else
  7958.                         ConfigurazionePdDReader.tracciamentoBuste = true;
  7959.                 }else{
  7960.                     ConfigurazionePdDReader.tracciamentoBuste = true; // default ConfigReader.ABILITATO
  7961.                 }
  7962.             }catch(Exception e){
  7963.                 ConfigurazionePdDReader.tracciamentoBuste = true; // default ConfigReader.ABILITATO
  7964.             }
  7965.         }

  7967.         return ConfigurazionePdDReader.tracciamentoBuste;
  7968.     }

  7970.     /**
  7971.      * Restituisce gli appender personalizzati per la registrazione delle buste. 
  7972.      *
  7973.      * @return Restituisce gli appender personalizzati per la registrazione delle buste. 
  7974.      */
  7975.     private static Tracciamento openSPCoopAppenderTracciamento = null;
  7976.     private static Boolean openSPCoopAppenderTracciamentoLetto = false;
  7977.     protected Tracciamento getOpenSPCoopAppenderTracciamento(Connection connectionPdD){

  7979.         if( this.configurazioneDinamica || ConfigurazionePdDReader.openSPCoopAppenderTracciamentoLetto==false){
  7980.             try{

  7982.                 Configurazione configurazione = null;
  7983.                 try{
  7984.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  7985.                 }catch(DriverConfigurazioneNotFound e){
  7986.                     this.logDebug("getOpenSPCoopAppenderTracciamento (not found): "+e.getMessage());
  7987.                 }catch(Exception e){
  7988.                     this.logError("getOpenSPCoopAppenderTracciamento",e);
  7989.                 }

  7991.                 if(configurazione!=null)
  7992.                     ConfigurazionePdDReader.openSPCoopAppenderTracciamento = configurazione.getTracciamento();     

  7994.             }catch(Exception e){
  7995.                 ConfigurazionePdDReader.openSPCoopAppenderTracciamento = null;
  7996.             }
  7997.             ConfigurazionePdDReader.openSPCoopAppenderTracciamentoLetto = true;
  7998.         }

  8000.         return ConfigurazionePdDReader.openSPCoopAppenderTracciamento;
  8001.     }


  8004.     private static Transazioni transazioniConfigurazione = null;
  8005.     public Transazioni getTransazioniConfigurazione(Connection connectionPdD) {

  8007.         if( this.configurazioneDinamica || ConfigurazionePdDReader.transazioniConfigurazione==null){
  8008.             try{
  8009.                 Configurazione configurazione = null;
  8010.                 try{
  8011.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  8012.                 }catch(DriverConfigurazioneNotFound e){
  8013.                     this.logDebug("getTransazioniConfigurazione (not found): "+e.getMessage());
  8014.                 }catch(Exception e){
  8015.                     this.logError("getTransazioniConfigurazione",e);
  8016.                 }

  8018.                 if(configurazione!=null && configurazione.getTransazioni()!=null){
  8019.                     ConfigurazionePdDReader.transazioniConfigurazione = configurazione.getTransazioni();
  8020.                 }else{
  8021.                     ConfigurazionePdDReader.transazioniConfigurazione = new Transazioni(); // default
  8022.                 }

  8024.             }catch(Exception e){
  8025.                 ConfigurazionePdDReader.transazioniConfigurazione = new Transazioni(); // default
  8026.             }
  8027.         }

  8029.         return ConfigurazionePdDReader.transazioniConfigurazione;

  8031.     }

  8033.     private static DumpConfigurazione dumpConfigurazionePortaApplicativa = null;
  8034.     public DumpConfigurazione getDumpConfigurazionePortaApplicativa(Connection connectionPdD) {

  8036.         if( this.configurazioneDinamica || ConfigurazionePdDReader.dumpConfigurazionePortaApplicativa==null){
  8037.             try{
  8038.                 Configurazione configurazione = null;
  8039.                 try{
  8040.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  8041.                 }catch(DriverConfigurazioneNotFound e){
  8042.                     this.logDebug("getDumpConfigurazione (not found): "+e.getMessage());
  8043.                 }catch(Exception e){
  8044.                     this.logError("getDumpConfigurazione",e);
  8045.                 }

  8047.                 if(configurazione!=null && configurazione.getDump()!=null){
  8048.                     ConfigurazionePdDReader.dumpConfigurazionePortaApplicativa = configurazione.getDump().getConfigurazionePortaApplicativa();
  8049.                 }else{
  8050.                     ConfigurazionePdDReader.dumpConfigurazionePortaApplicativa = new DumpConfigurazione(); // default tutto abilitato
  8051.                 }

  8053.             }catch(Exception e){
  8054.                 ConfigurazionePdDReader.dumpConfigurazionePortaApplicativa = new DumpConfigurazione(); // default tutto abilitato
  8055.             }
  8056.         }

  8058.         return ConfigurazionePdDReader.dumpConfigurazionePortaApplicativa;

  8060.     }
  8061.     
  8062.     private static DumpConfigurazione dumpConfigurazionePortaDelegata = null;
  8063.     public DumpConfigurazione getDumpConfigurazionePortaDelegata(Connection connectionPdD) {

  8065.         if( this.configurazioneDinamica || ConfigurazionePdDReader.dumpConfigurazionePortaDelegata==null){
  8066.             try{
  8067.                 Configurazione configurazione = null;
  8068.                 try{
  8069.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  8070.                 }catch(DriverConfigurazioneNotFound e){
  8071.                     this.logDebug("getDumpConfigurazione (not found): "+e.getMessage());
  8072.                 }catch(Exception e){
  8073.                     this.logError("getDumpConfigurazione",e);
  8074.                 }

  8076.                 if(configurazione!=null && configurazione.getDump()!=null){
  8077.                     ConfigurazionePdDReader.dumpConfigurazionePortaDelegata = configurazione.getDump().getConfigurazionePortaDelegata();
  8078.                 }else{
  8079.                     ConfigurazionePdDReader.dumpConfigurazionePortaDelegata = new DumpConfigurazione(); // default tutto abilitato
  8080.                 }

  8082.             }catch(Exception e){
  8083.                 ConfigurazionePdDReader.dumpConfigurazionePortaDelegata = new DumpConfigurazione(); // default tutto abilitato
  8084.             }
  8085.         }

  8087.         return ConfigurazionePdDReader.dumpConfigurazionePortaDelegata;

  8089.     }

  8091.     private static Boolean dumpBinarioPD = null;
  8092.     public static Boolean dumpBinarioPDJMX = null;
  8093.     protected boolean dumpBinarioPD(Connection connectionPdD){

  8095.         if(ConfigurazionePdDReader.dumpBinarioPDJMX!=null)
  8096.             return ConfigurazionePdDReader.dumpBinarioPDJMX;

  8098.         if( this.configurazioneDinamica || ConfigurazionePdDReader.dumpBinarioPD==null){
  8099.             try{
  8100.                 Configurazione configurazione = null;
  8101.                 try{
  8102.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  8103.                 }catch(DriverConfigurazioneNotFound e){
  8104.                     this.logDebug("dumpBinarioPD (not found): "+e.getMessage());
  8105.                 }catch(Exception e){
  8106.                     this.logError("dumpBinarioPD",e);
  8107.                 }

  8109.                 if(configurazione!=null && configurazione.getDump()!=null){
  8110.                     StatoFunzionalita read = configurazione.getDump().getDumpBinarioPortaDelegata();       
  8111.                     if(CostantiConfigurazione.ABILITATO.equals(read))
  8112.                         ConfigurazionePdDReader.dumpBinarioPD = true;
  8113.                     else
  8114.                         ConfigurazionePdDReader.dumpBinarioPD = false;
  8115.                 }else{
  8116.                     ConfigurazionePdDReader.dumpBinarioPD = false; // default CostantiConfigurazione.DISABILITATO
  8117.                 }

  8119.             }catch(Exception e){
  8120.                 ConfigurazionePdDReader.dumpBinarioPD = false; // default CostantiConfigurazione.DISABILITATO
  8121.             }
  8122.         }

  8124.         return ConfigurazionePdDReader.dumpBinarioPD;
  8125.     }


  8128.     private static Boolean dumpBinarioPA = null;
  8129.     public static Boolean dumpBinarioPAJMX = null;
  8130.     protected boolean dumpBinarioPA(Connection connectionPdD){

  8132.         if(ConfigurazionePdDReader.dumpBinarioPAJMX!=null)
  8133.             return ConfigurazionePdDReader.dumpBinarioPAJMX;

  8135.         if( this.configurazioneDinamica || ConfigurazionePdDReader.dumpBinarioPA==null){
  8136.             try{
  8137.                 Configurazione configurazione = null;
  8138.                 try{
  8139.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  8140.                 }catch(DriverConfigurazioneNotFound e){
  8141.                     this.logDebug("dumpBinarioPA (not found): "+e.getMessage());
  8142.                 }catch(Exception e){
  8143.                     this.logError("dumpBinarioPA",e);
  8144.                 }

  8146.                 if(configurazione!=null && configurazione.getDump()!=null){
  8147.                     StatoFunzionalita read = configurazione.getDump().getDumpBinarioPortaApplicativa();    
  8148.                     if(CostantiConfigurazione.ABILITATO.equals(read))
  8149.                         ConfigurazionePdDReader.dumpBinarioPA = true;
  8150.                     else
  8151.                         ConfigurazionePdDReader.dumpBinarioPA = false;
  8152.                 }else{
  8153.                     ConfigurazionePdDReader.dumpBinarioPA = false; // default CostantiConfigurazione.DISABILITATO
  8154.                 }

  8156.             }catch(Exception e){
  8157.                 ConfigurazionePdDReader.dumpBinarioPA = false; // default CostantiConfigurazione.DISABILITATO
  8158.             }
  8159.         }

  8161.         return ConfigurazionePdDReader.dumpBinarioPA;
  8162.     }

  8164.     /**
  8165.      * Restituisce gli appender personalizzati per la registrazione dei contenuti
  8166.      *
  8167.      * @return Restituisce gli appender personalizzati per la registrazione dei contenuti
  8168.      */
  8169.     private static Dump openSPCoopAppenderDump = null;
  8170.     private static Boolean openSPCoopAppenderDumpLetto = false;
  8171.     protected Dump getOpenSPCoopAppenderDump(Connection connectionPdD){

  8173.         if( this.configurazioneDinamica || ConfigurazionePdDReader.openSPCoopAppenderDumpLetto==false){
  8174.             try{

  8176.                 Configurazione configurazione = null;
  8177.                 try{
  8178.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  8179.                 }catch(DriverConfigurazioneNotFound e){
  8180.                     this.logDebug("getOpenSPCoopAppenderDump (not found): "+e.getMessage());
  8181.                 }catch(Exception e){
  8182.                     this.logError("getOpenSPCoopAppenderDump",e);
  8183.                 }

  8185.                 if(configurazione!=null)
  8186.                     ConfigurazionePdDReader.openSPCoopAppenderDump = configurazione.getDump();     

  8188.             }catch(Exception e){
  8189.                 ConfigurazionePdDReader.openSPCoopAppenderDump = null;
  8190.             }
  8191.             ConfigurazionePdDReader.openSPCoopAppenderDumpLetto = true;
  8192.         }

  8194.         return ConfigurazionePdDReader.openSPCoopAppenderDump;
  8195.     }

  8197.     /**
  8198.      * Restituisce la politica di gestione della consegna tramite connettore per il componente di cooperazione
  8199.      *
  8200.      * @return la politica di gestione della consegna tramite connettore per il componente di cooperazione
  8201.      * 
  8202.      */
  8203.     private static HashMap<String, GestioneErrore> gestioneErroreConnettoreComponenteCooperazioneMap = new HashMap<>();
  8204.     private static org.openspcoop2.utils.Semaphore semaphore_erroreConnettoreCooperazione = new org.openspcoop2.utils.Semaphore("ConfigurazionePdDReader_erroreConnettoreCooperazione");
  8205.     protected GestioneErrore getGestioneErroreConnettoreComponenteCooperazione(IProtocolFactory<?> protocolFactory, ServiceBinding serviceBinding, Connection connectionPdD){

  8207.         String key = protocolFactory.getProtocol()+"_"+serviceBinding;
  8208.         
  8209.         if( this.configurazioneDinamica || !ConfigurazionePdDReader.gestioneErroreConnettoreComponenteCooperazioneMap.containsKey(key)){
  8210.             GestioneErrore gestione = null;
  8211.             try{
  8212.                 try{
  8213.                     gestione = this.configurazionePdD.getGestioneErroreComponenteCooperazione(connectionPdD);

  8215.                     /*if(gestione!=null){
  8216.                         System.out.println("GESTIONE COOPERAZIONE PRESENTE");
  8217.                         System.out.println("COMPORTAMENTO: "+gestione.getComportamento());      
  8218.                         System.out.println("CADENZA: "+gestione.getCadenzaRispedizione());
  8219.                         for(int i=0;i<gestione.sizeCodiceTrasportoList();i++){
  8220.                             System.out.println("TRASPORTO MIN["+gestione.getCodiceTrasporto(i).getValoreMinimo()
  8221.                                     +"] MAX["+gestione.getCodiceTrasporto(i).getValoreMassimo()
  8222.                                     +"] COMPORTMANETO["+gestione.getCodiceTrasporto(i).getComportamento()
  8223.                                     +"] CADENZA["+gestione.getCodiceTrasporto(i).getCadenzaRispedizione()
  8224.                                     +"]" );
  8225.                         }
  8226.                         for(int i=0;i<gestione.sizeSoapFaultList();i++){
  8227.                             System.out.println("SOAP CODE["+gestione.getSoapFault(i).getFaultCode()
  8228.                                     +"] ACTOR["+gestione.getSoapFault(i).getFaultActor()
  8229.                                     +"] STRING["+gestione.getSoapFault(i).getFaultString()
  8230.                                     +"] COMPORTMANETO["+gestione.getSoapFault(i).getComportamento()
  8231.                                     +"] CADENZA["+gestione.getSoapFault(i).getCadenzaRispedizione()
  8232.                                     +"]" );
  8233.                         }
  8234.                     }*/

  8236.                 }catch(DriverConfigurazioneNotFound e){
  8237.                     this.logDebug("getGestioneErroreConnettoreComponenteCooperazione (not found): "+e.getMessage());
  8238.                 }catch(Exception e){
  8239.                     this.logError("getGestioneErroreConnettoreComponenteCooperazione",e);
  8240.                 }
  8241.                 if(gestione == null)
  8242.                     gestione = GestoreErroreConnettore.getGestioneErroreDefaultComponenteCooperazione(protocolFactory, serviceBinding);
  8243.                 
  8244.             }catch(Exception e){
  8245.                 gestione = GestoreErroreConnettore.getGestioneErroreDefaultComponenteCooperazione(protocolFactory, serviceBinding);
  8246.             } 
  8247.             
  8248.             if(this.configurazioneDinamica) {
  8249.                 return gestione;
  8250.             }
  8251.             else {
  8252.                 //synchronized (ConfigurazionePdDReader.gestioneErroreConnettoreComponenteCooperazioneMap) {
  8253.                 SemaphoreLock lock = semaphore_erroreConnettoreCooperazione.acquireThrowRuntime("getGestioneErroreConnettoreComponenteCooperazione");
  8254.                 try {               
  8255.                     if(!ConfigurazionePdDReader.gestioneErroreConnettoreComponenteCooperazioneMap.containsKey(key)) {
  8256.                         ConfigurazionePdDReader.gestioneErroreConnettoreComponenteCooperazioneMap.put(key, gestione);
  8257.                     }
  8258.                 }finally {
  8259.                     semaphore_erroreConnettoreCooperazione.release(lock, "getGestioneErroreConnettoreComponenteCooperazione");
  8260.                 }
  8261.             }
  8262.             
  8263.         }

  8265.         return ConfigurazionePdDReader.gestioneErroreConnettoreComponenteCooperazioneMap.get(key);

  8267.     }

  8269.     /**
  8270.      * Restituisce la politica di gestione della consegna tramite connettore per il componente di integrazione
  8271.      *
  8272.      * @return la politica di gestione della consegna tramite connettore per il componente di integrazione
  8273.      * 
  8274.      */
  8275.     private static HashMap<String, GestioneErrore> gestioneErroreConnettoreComponenteIntegrazioneMap = new HashMap<>();
  8276.     private static org.openspcoop2.utils.Semaphore semaphore_erroreConnettoreIntegrazione = new org.openspcoop2.utils.Semaphore("ConfigurazionePdDReader_erroreConnettoreIntegrazione");
  8277.     protected GestioneErrore getGestioneErroreConnettoreComponenteIntegrazione(IProtocolFactory<?> protocolFactory, ServiceBinding serviceBinding, Connection connectionPdD){

  8279.         String key = protocolFactory.getProtocol()+"_"+serviceBinding;
  8280.         
  8281.         if( this.configurazioneDinamica || !ConfigurazionePdDReader.gestioneErroreConnettoreComponenteIntegrazioneMap.containsKey(key)){
  8282.             GestioneErrore gestione = null;
  8283.             try{
  8284.                 try{
  8285.                     gestione = this.configurazionePdD.getGestioneErroreComponenteIntegrazione(connectionPdD);

  8287.                     /*if(gestione!=null){
  8288.                         System.out.println("GESTIONE INTEGRAZIONE PRESENTE");
  8289.                         System.out.println("COMPORTAMENTO: "+gestione.getComportamento());      
  8290.                         System.out.println("CADENZA: "+gestione.getCadenzaRispedizione());
  8291.                         for(int i=0;i<gestione.sizeCodiceTrasportoList();i++){
  8292.                             System.out.println("TRASPORTO MIN["+gestione.getCodiceTrasporto(i).getValoreMinimo()
  8293.                                     +"] MAX["+gestione.getCodiceTrasporto(i).getValoreMassimo()
  8294.                                     +"] COMPORTMANETO["+gestione.getCodiceTrasporto(i).getComportamento()
  8295.                                     +"] CADENZA["+gestione.getCodiceTrasporto(i).getCadenzaRispedizione()
  8296.                                     +"]" );
  8297.                         }
  8298.                         for(int i=0;i<gestione.sizeSoapFaultList();i++){
  8299.                             System.out.println("SOAP CODE["+gestione.getSoapFault(i).getFaultCode()
  8300.                                     +"] ACTOR["+gestione.getSoapFault(i).getFaultActor()
  8301.                                     +"] STRING["+gestione.getSoapFault(i).getFaultString()
  8302.                                     +"] COMPORTMANETO["+gestione.getSoapFault(i).getComportamento()
  8303.                                     +"] CADENZA["+gestione.getSoapFault(i).getCadenzaRispedizione()
  8304.                                     +"]" );
  8305.                         }
  8306.                     }*/

  8308.                 }catch(DriverConfigurazioneNotFound e){
  8309.                     this.logDebug("getGestioneErroreConnettoreComponenteIntegrazione (not found): "+e.getMessage());
  8310.                 }catch(Exception e){
  8311.                     this.logError("getGestioneErroreConnettoreComponenteIntegrazione",e);
  8312.                 }
  8313.                 if(gestione == null)
  8314.                     gestione = GestoreErroreConnettore.getGestioneErroreDefaultComponenteIntegrazione(protocolFactory, serviceBinding);

  8316.             }catch(Exception e){
  8317.                 gestione = GestoreErroreConnettore.getGestioneErroreDefaultComponenteIntegrazione(protocolFactory, serviceBinding);
  8318.             }
  8319.             
  8320.             if(this.configurazioneDinamica) {
  8321.                 return gestione;
  8322.             }
  8323.             else {
  8324.                 //synchronized (ConfigurazionePdDReader.gestioneErroreConnettoreComponenteIntegrazioneMap) {
  8325.                 SemaphoreLock lock = semaphore_erroreConnettoreIntegrazione.acquireThrowRuntime("getGestioneErroreConnettoreComponenteIntegrazione");
  8326.                 try {
  8327.                     if(!ConfigurazionePdDReader.gestioneErroreConnettoreComponenteIntegrazioneMap.containsKey(key)) {
  8328.                         ConfigurazionePdDReader.gestioneErroreConnettoreComponenteIntegrazioneMap.put(key, gestione);
  8329.                     }
  8330.                 }finally {
  8331.                     semaphore_erroreConnettoreIntegrazione.release(lock, "getGestioneErroreConnettoreComponenteIntegrazione");
  8332.                 }
  8333.             }
  8334.         }

  8336.         return ConfigurazionePdDReader.gestioneErroreConnettoreComponenteIntegrazioneMap.get(key);

  8338.     }



  8342.     /**
  8343.      * Restituisce il tipo di autenticazione associato al servizio IntegrationManager
  8344.      *
  8345.      * @return Restituisce il tipo di autenticazione associato al servizio IntegrationManager (di default ritorna 'ssl'). 
  8346.      * 
  8347.      */
  8348.     private static String[] integrationManagerAuthentication = null;
  8349.     protected String[] getIntegrationManagerAuthentication(Connection connectionPdD){

  8351.         if( this.configurazioneDinamica || ConfigurazionePdDReader.integrationManagerAuthentication==null){
  8352.             try{
  8353.                 Configurazione configurazione = null;
  8354.                 try{
  8355.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);

  8357.                     /*if(configurazione.getIntegrationManager()!=null){
  8358.                         System.out.println("IM ["+configurazione.getIntegrationManager().getAutenticazione()+"]");
  8359.                     }*/

  8361.                 }catch(DriverConfigurazioneNotFound e){
  8362.                     this.logDebug("getIntegrationManagerAuthentication (not found): "+e.getMessage());
  8363.                 }catch(Exception e){
  8364.                     this.logError("getIntegrationManagerAuthentication",e);
  8365.                 }
  8366.                 if(configurazione == null || configurazione.getIntegrationManager()==null || configurazione.getIntegrationManager().getAutenticazione()==null){
  8367.                     ConfigurazionePdDReader.integrationManagerAuthentication = new String [] { CostantiConfigurazione.CREDENZIALE_BASIC.toString(),
  8368.                             CostantiConfigurazione.CREDENZIALE_SSL.toString() };
  8369.                 }else {

  8371.                     String [] values =  configurazione.getIntegrationManager().getAutenticazione().split(",");
  8372.                     List<String> v = new ArrayList<>();
  8373.                     ClassNameProperties classNameProperties = ClassNameProperties.getInstance();
  8374.                     for(int i=0; i<values.length; i++){
  8375.                         values[i] = values[i].trim();
  8376.                         if(classNameProperties.getAutenticazionePortaDelegata(values[i])==null){
  8377.                             this.logError("Meccanismo di autenticazione ["+values[i]+"] non registrato in GovWay");
  8378.                         }else{
  8379.                             v.add(values[i]);
  8380.                         }
  8381.                     }
  8382.                     if(v.size()>0)
  8383.                         ConfigurazionePdDReader.integrationManagerAuthentication = v.toArray(new String[1]);
  8384.                     else
  8385.                         throw new Exception("Nessun meccanismo di autenticazione valido tra quelli esistenti");
  8386.                 }

  8388.             }catch(Exception e){
  8389.                 this.logError("Errore durante la lettura del tipo di autenticazione associato al servizio di IntegrationManager: "+e.getMessage());
  8390.                 ConfigurazionePdDReader.integrationManagerAuthentication = new String [] { CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_BASIC.toString(),
  8391.                         CostantiConfigurazione.CREDENZIALE_SSL.toString() };
  8392.             }
  8393.         }

  8395.         return ConfigurazionePdDReader.integrationManagerAuthentication;

  8397.     }


  8400.     /**
  8401.      * Restituisce il tipo di validazione xsd  attiva nella porta
  8402.      * 
  8403.      * @return Restituisce il tipo di validazione xsd attiva nella porta
  8404.      * 
  8405.      */
  8406.     private static ValidazioneContenutiApplicativi validazioneContenutiApplicativi = null;
  8407.     protected ValidazioneContenutiApplicativi getTipoValidazioneContenutoApplicativo(Connection connectionPdD, String implementazionePdDSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  8409.         ValidazioneContenutiApplicativi valDefault = new ValidazioneContenutiApplicativi();
  8410.         valDefault.setStato(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO);
  8411.         valDefault.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD);

  8413.         // ovverriding per implementazione porta di dominio
  8414.         String stato = this.pddProperties.getValidazioneContenutiApplicativi_Stato(implementazionePdDSoggetto);
  8415.         String tipo = this.pddProperties.getValidazioneContenutiApplicativi_Tipo(implementazionePdDSoggetto);
  8416.         String acceptMtomMessage = this.pddProperties.getValidazioneContenutiApplicativi_AcceptMtomMessage(implementazionePdDSoggetto);
  8417.         boolean pddPropertiesPresente = false;
  8418.         if(stato!=null  && ( 
  8419.                 CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.toString().equalsIgnoreCase(stato) || 
  8420.                 CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO.toString().equalsIgnoreCase(stato) || 
  8421.                 CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.toString().equalsIgnoreCase(stato) ) ){
  8422.             if(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.toString().equalsIgnoreCase(stato))
  8423.                 valDefault.setStato(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO);
  8424.             else if(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO.toString().equalsIgnoreCase(stato))
  8425.                 valDefault.setStato(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO);
  8426.             else
  8427.                 valDefault.setStato(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY);
  8428.             pddPropertiesPresente = true;
  8429.         }
  8430.         if(tipo!=null  && ( 
  8431.                 CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.toString().equalsIgnoreCase(stato) || 
  8432.                 CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD.toString().equalsIgnoreCase(stato) || 
  8433.                 CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP.toString().equalsIgnoreCase(stato) ) ){
  8434.             if(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.toString().equalsIgnoreCase(stato))
  8435.                 valDefault.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE);
  8436.             else if(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD.toString().equalsIgnoreCase(stato))
  8437.                 valDefault.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD);
  8438.             else
  8439.                 valDefault.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP);
  8440.             pddPropertiesPresente = true;
  8441.         }
  8442.         if(acceptMtomMessage!=null  && ( 
  8443.                 CostantiConfigurazione.ABILITATO.toString().equalsIgnoreCase(acceptMtomMessage) || 
  8444.                 CostantiConfigurazione.DISABILITATO.toString().equalsIgnoreCase(acceptMtomMessage) ) ){
  8445.             if(CostantiConfigurazione.ABILITATO.toString().equalsIgnoreCase(stato))
  8446.                 valDefault.setAcceptMtomMessage(CostantiConfigurazione.ABILITATO);
  8447.             else if(CostantiConfigurazione.DISABILITATO.toString().equalsIgnoreCase(stato))
  8448.                 valDefault.setAcceptMtomMessage(CostantiConfigurazione.DISABILITATO);
  8449.             else
  8450.                 valDefault.setAcceptMtomMessage(CostantiConfigurazione.DISABILITATO);
  8451.             pddPropertiesPresente = true;
  8452.         }
  8453.         if(pddPropertiesPresente)
  8454.             return valDefault;


  8457.         if( this.configurazioneDinamica || ConfigurazionePdDReader.validazioneContenutiApplicativi==null){

  8459.             try{
  8460.                 Configurazione configurazione = null;
  8461.                 try{
  8462.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);

  8464.                     /*if(configurazione.getValidazioneContenutiApplicativi()!=null){
  8465.                         System.out.println("VALIDAZIONE CONTENUTI STATO["+configurazione.getValidazioneContenutiApplicativi().getStato()+"]");
  8466.                         System.out.println("VALIDAZIONE CONTENUTI TIPO["+configurazione.getValidazioneContenutiApplicativi().getTipo()+"]");
  8467.                     }*/

  8469.                 }catch(DriverConfigurazioneNotFound e){
  8470.                     this.logDebug("getTipoValidazioneContenutoApplicativo (not found): "+e.getMessage());
  8471.                 }catch(Exception e){
  8472.                     this.logError("getTipoValidazioneContenutoApplicativo",e);
  8473.                 }
  8474.                 if(configurazione == null || configurazione.getValidazioneContenutiApplicativi()==null){
  8475.                     ConfigurazionePdDReader.validazioneContenutiApplicativi = valDefault;
  8476.                 }else{
  8477.                     ValidazioneContenutiApplicativi val = new ValidazioneContenutiApplicativi();
  8478.                     // Stato
  8479.                     if(configurazione.getValidazioneContenutiApplicativi().getStato()==null){
  8480.                         val.setStato(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO);
  8481.                     }else if(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.equals(configurazione.getValidazioneContenutiApplicativi().getStato())){
  8482.                         val.setStato(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO);
  8483.                     }else if(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(configurazione.getValidazioneContenutiApplicativi().getStato())){
  8484.                         val.setStato(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY);
  8485.                     }else{
  8486.                         val.setStato(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO);
  8487.                     }
  8488.                     // Tipo
  8489.                     if(configurazione.getValidazioneContenutiApplicativi().getTipo()==null){
  8490.                         val.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD);
  8491.                     }else if(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(configurazione.getValidazioneContenutiApplicativi().getTipo())){
  8492.                         val.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE);
  8493.                     }else if(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP.equals(configurazione.getValidazioneContenutiApplicativi().getTipo())){
  8494.                         val.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP);
  8495.                     }else{
  8496.                         val.setTipo(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD);
  8497.                     }
  8498.                     // AcceptMtomMessage
  8499.                     if(configurazione.getValidazioneContenutiApplicativi().getAcceptMtomMessage()==null){
  8500.                         val.setAcceptMtomMessage(CostantiConfigurazione.DISABILITATO);
  8501.                     }else if(CostantiConfigurazione.ABILITATO.equals(configurazione.getValidazioneContenutiApplicativi().getAcceptMtomMessage())){
  8502.                         val.setAcceptMtomMessage(CostantiConfigurazione.ABILITATO);
  8503.                     }else if(CostantiConfigurazione.DISABILITATO.equals(configurazione.getValidazioneContenutiApplicativi().getAcceptMtomMessage())){
  8504.                         val.setAcceptMtomMessage(CostantiConfigurazione.DISABILITATO);
  8505.                     }else{
  8506.                         val.setAcceptMtomMessage(CostantiConfigurazione.DISABILITATO);
  8507.                     }

  8509.                     ConfigurazionePdDReader.validazioneContenutiApplicativi = val;
  8510.                 }
  8511.             }catch(Throwable e){
  8512.                 ConfigurazionePdDReader.validazioneContenutiApplicativi = valDefault;
  8513.             }
  8514.         }
  8515.         return ConfigurazionePdDReader.validazioneContenutiApplicativi;
  8516.     }




  8521.     /**
  8522.      * Restituisce l'indicazione se il servizio porta delegata e' attivo
  8523.      *
  8524.      * @return Restituisce l'indicazione se il servizio porta delegata e' attivo
  8525.      * 
  8526.      */
  8527.     private static Boolean isPDServiceActive = null;
  8528.     protected Boolean isPDServiceActive(){

  8530.         if( this.configurazioneDinamica || ConfigurazionePdDReader.isPDServiceActive==null){
  8531.             try{
  8532.                 StatoServiziPdd stato = null;
  8533.                 try{
  8534.                     stato = this.configurazionePdD.getStatoServiziPdD();
  8535.                 }catch(DriverConfigurazioneNotFound e){
  8536.                     this.logDebug("isPDServiceActive (not found): "+e.getMessage());
  8537.                 }catch(Exception e){
  8538.                     this.logError("isPDServiceActive",e);
  8539.                 }
  8540.                 if(stato == null || stato.getPortaDelegata()==null || stato.getPortaDelegata().getStato()==null){
  8541.                     ConfigurazionePdDReader.isPDServiceActive = true;
  8542.                 }else {                 
  8543.                     ConfigurazionePdDReader.isPDServiceActive = !CostantiConfigurazione.DISABILITATO.equals(stato.getPortaDelegata().getStato());
  8544.                 }

  8546.             }catch(Exception e){
  8547.                 this.logError("Errore durante la lettura dell'indicazione se il servizio porta delegata e' attivo: "+e.getMessage());
  8548.                 ConfigurazionePdDReader.isPDServiceActive = false;
  8549.             }
  8550.         }

  8552.         return ConfigurazionePdDReader.isPDServiceActive;

  8554.     }

  8556.     private static List<TipoFiltroAbilitazioneServizi> getFiltriAbilitazionePDService = null;
  8557.     protected List<TipoFiltroAbilitazioneServizi> getFiltriAbilitazionePDService(){

  8559.         if( this.configurazioneDinamica || ConfigurazionePdDReader.isPDServiceActive==null){
  8560.             try{
  8561.                 StatoServiziPdd stato = null;
  8562.                 try{
  8563.                     stato = this.configurazionePdD.getStatoServiziPdD();
  8564.                 }catch(DriverConfigurazioneNotFound e){
  8565.                     this.logDebug("getFiltriAbilitazionePDService (not found): "+e.getMessage());
  8566.                 }catch(Exception e){
  8567.                     this.logError("getFiltriAbilitazionePDService",e);
  8568.                 }
  8569.                 if(stato == null || stato.getPortaDelegata()==null || stato.getPortaDelegata().sizeFiltroAbilitazioneList()<=0){
  8570.                     ConfigurazionePdDReader.getFiltriAbilitazionePDService = new ArrayList<TipoFiltroAbilitazioneServizi>();
  8571.                 }else {                 
  8572.                     ConfigurazionePdDReader.getFiltriAbilitazionePDService = stato.getPortaDelegata().getFiltroAbilitazioneList();
  8573.                 }

  8575.             }catch(Exception e){
  8576.                 this.logError("Errore durante la raccolta dei filtri di abilitazione PD: "+e.getMessage());
  8577.                 ConfigurazionePdDReader.getFiltriAbilitazionePDService = new ArrayList<TipoFiltroAbilitazioneServizi>();
  8578.             }
  8579.         }

  8581.         return ConfigurazionePdDReader.getFiltriAbilitazionePDService;

  8583.     }

  8585.     private static List<TipoFiltroAbilitazioneServizi> getFiltriDisabilitazionePDService = null;
  8586.     protected List<TipoFiltroAbilitazioneServizi> getFiltriDisabilitazionePDService(){

  8588.         if( this.configurazioneDinamica || ConfigurazionePdDReader.isPDServiceActive==null){
  8589.             try{
  8590.                 StatoServiziPdd stato = null;
  8591.                 try{
  8592.                     stato = this.configurazionePdD.getStatoServiziPdD();
  8593.                 }catch(DriverConfigurazioneNotFound e){
  8594.                     this.logDebug("getFiltriDisabilitazionePDService (not found): "+e.getMessage());
  8595.                 }catch(Exception e){
  8596.                     this.logError("getFiltriDisabilitazionePDService",e);
  8597.                 }
  8598.                 if(stato == null || stato.getPortaDelegata()==null || stato.getPortaDelegata().sizeFiltroDisabilitazioneList()<=0){
  8599.                     ConfigurazionePdDReader.getFiltriDisabilitazionePDService = new ArrayList<TipoFiltroAbilitazioneServizi>();
  8600.                 }else {                 
  8601.                     ConfigurazionePdDReader.getFiltriDisabilitazionePDService = stato.getPortaDelegata().getFiltroDisabilitazioneList();
  8602.                 }

  8604.             }catch(Exception e){
  8605.                 this.logError("Errore durante la raccolta dei filtri di disabilitazione PD: "+e.getMessage());
  8606.                 ConfigurazionePdDReader.getFiltriDisabilitazionePDService = new ArrayList<TipoFiltroAbilitazioneServizi>();
  8607.             }
  8608.         }

  8610.         return ConfigurazionePdDReader.getFiltriDisabilitazionePDService;

  8612.     }



  8616.     /**
  8617.      * Restituisce l'indicazione se il servizio porta applicativa e' attivo
  8618.      *
  8619.      * @return Restituisce l'indicazione se il servizio porta applicativa e' attivo
  8620.      * 
  8621.      */
  8622.     private static Boolean isPAServiceActive = null;
  8623.     protected Boolean isPAServiceActive(){

  8625.         if( this.configurazioneDinamica || ConfigurazionePdDReader.isPAServiceActive==null){
  8626.             try{
  8627.                 StatoServiziPdd stato = null;
  8628.                 try{
  8629.                     stato = this.configurazionePdD.getStatoServiziPdD();
  8630.                 }catch(DriverConfigurazioneNotFound e){
  8631.                     this.logDebug("isPAServiceActive (not found): "+e.getMessage());
  8632.                 }catch(Exception e){
  8633.                     this.logError("isPAServiceActive",e);
  8634.                 }
  8635.                 if(stato == null || stato.getPortaApplicativa()==null || stato.getPortaApplicativa().getStato()==null){
  8636.                     ConfigurazionePdDReader.isPAServiceActive = true;
  8637.                 }else {                 
  8638.                     ConfigurazionePdDReader.isPAServiceActive = !CostantiConfigurazione.DISABILITATO.equals(stato.getPortaApplicativa().getStato());
  8639.                 }

  8641.             }catch(Exception e){
  8642.                 this.logError("Errore durante la lettura dell'indicazione se il servizio porta applicativa e' attivo: "+e.getMessage());
  8643.                 ConfigurazionePdDReader.isPAServiceActive = false;
  8644.             }
  8645.         }

  8647.         return ConfigurazionePdDReader.isPAServiceActive;

  8649.     }

  8651.     private static List<TipoFiltroAbilitazioneServizi> getFiltriAbilitazionePAService = null;
  8652.     protected List<TipoFiltroAbilitazioneServizi> getFiltriAbilitazionePAService(){

  8654.         if( this.configurazioneDinamica || ConfigurazionePdDReader.isPAServiceActive==null){
  8655.             try{
  8656.                 StatoServiziPdd stato = null;
  8657.                 try{
  8658.                     stato = this.configurazionePdD.getStatoServiziPdD();
  8659.                 }catch(DriverConfigurazioneNotFound e){
  8660.                     this.logDebug("getFiltriAbilitazionePAService (not found): "+e.getMessage());
  8661.                 }catch(Exception e){
  8662.                     this.logError("getFiltriAbilitazionePAService",e);
  8663.                 }
  8664.                 if(stato == null || stato.getPortaApplicativa()==null || stato.getPortaApplicativa().sizeFiltroAbilitazioneList()<=0){
  8665.                     ConfigurazionePdDReader.getFiltriAbilitazionePAService = new ArrayList<TipoFiltroAbilitazioneServizi>();
  8666.                 }else {                 
  8667.                     ConfigurazionePdDReader.getFiltriAbilitazionePAService = stato.getPortaApplicativa().getFiltroAbilitazioneList();
  8668.                 }

  8670.             }catch(Exception e){
  8671.                 this.logError("Errore durante la raccolta dei filtri di abilitazione PA: "+e.getMessage());
  8672.                 ConfigurazionePdDReader.getFiltriAbilitazionePAService = new ArrayList<TipoFiltroAbilitazioneServizi>();
  8673.             }
  8674.         }

  8676.         return ConfigurazionePdDReader.getFiltriAbilitazionePAService;

  8678.     }

  8680.     private static List<TipoFiltroAbilitazioneServizi> getFiltriDisabilitazionePAService = null;
  8681.     protected List<TipoFiltroAbilitazioneServizi> getFiltriDisabilitazionePAService(){

  8683.         if( this.configurazioneDinamica || ConfigurazionePdDReader.isPAServiceActive==null){
  8684.             try{
  8685.                 StatoServiziPdd stato = null;
  8686.                 try{
  8687.                     stato = this.configurazionePdD.getStatoServiziPdD();
  8688.                 }catch(DriverConfigurazioneNotFound e){
  8689.                     this.logDebug("getFiltriDisabilitazionePAService (not found): "+e.getMessage());
  8690.                 }catch(Exception e){
  8691.                     this.logError("getFiltriDisabilitazionePAService",e);
  8692.                 }
  8693.                 if(stato == null || stato.getPortaApplicativa()==null || stato.getPortaApplicativa().sizeFiltroDisabilitazioneList()<=0){
  8694.                     ConfigurazionePdDReader.getFiltriDisabilitazionePAService = new ArrayList<TipoFiltroAbilitazioneServizi>();
  8695.                 }else {                 
  8696.                     ConfigurazionePdDReader.getFiltriDisabilitazionePAService = stato.getPortaApplicativa().getFiltroDisabilitazioneList();
  8697.                 }

  8699.             }catch(Exception e){
  8700.                 this.logError("Errore durante la raccolta dei filtri di disabilitazione PA: "+e.getMessage());
  8701.                 ConfigurazionePdDReader.getFiltriDisabilitazionePAService = new ArrayList<TipoFiltroAbilitazioneServizi>();
  8702.             }
  8703.         }

  8705.         return ConfigurazionePdDReader.getFiltriDisabilitazionePAService;

  8707.     }


  8710.     /**
  8711.      * Restituisce l'indicazione se il servizio integration manager e' attivo
  8712.      *
  8713.      * @return Restituisce l'indicazione se il servizio integration manager e' attivo
  8714.      * 
  8715.      */
  8716.     private static Boolean isIMServiceActive = null;
  8717.     protected Boolean isIMServiceActive(){

  8719.         if( this.configurazioneDinamica || ConfigurazionePdDReader.isIMServiceActive==null){
  8720.             try{
  8721.                 StatoServiziPdd stato = null;
  8722.                 try{
  8723.                     stato = this.configurazionePdD.getStatoServiziPdD();
  8724.                 }catch(DriverConfigurazioneNotFound e){
  8725.                     this.logDebug("isIMServiceActive (not found): "+e.getMessage());
  8726.                 }catch(Exception e){
  8727.                     this.logError("isIMServiceActive",e);
  8728.                 }
  8729.                 if(stato == null || stato.getIntegrationManager()==null || stato.getIntegrationManager().getStato()==null){
  8730.                     ConfigurazionePdDReader.isIMServiceActive = true;
  8731.                 }else {                 
  8732.                     ConfigurazionePdDReader.isIMServiceActive = !CostantiConfigurazione.DISABILITATO.equals(stato.getIntegrationManager().getStato());
  8733.                 }

  8735.             }catch(Exception e){
  8736.                 this.logError("Errore durante la lettura dell'indicazione se il servizio porta applicativa e' attivo: "+e.getMessage());
  8737.                 ConfigurazionePdDReader.isIMServiceActive = false;
  8738.             }
  8739.         }

  8741.         return ConfigurazionePdDReader.isIMServiceActive;

  8743.     }





  8749.     protected StatoServiziPdd getStatoServiziPdD() throws DriverConfigurazioneException{
  8750.         try{
  8751.             return this.configurazionePdD.getStatoServiziPdD();
  8752.         }catch(DriverConfigurazioneNotFound dNot){
  8753.             return null;
  8754.         }
  8755.     }

  8757.     protected void updateStatoServiziPdD(StatoServiziPdd servizi) throws DriverConfigurazioneException{
  8758.         this.configurazionePdD.updateStatoServiziPdD(servizi);
  8759.     }



  8763.     protected PolicyNegoziazioneToken getPolicyNegoziazioneToken(Connection connectionPdD, boolean forceNoCache, String policyName) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  8765.         if(policyName==null){
  8766.             throw new DriverConfigurazioneException("Policy non fornita");
  8767.         }

  8769.         GenericProperties gp = this.configurazionePdD.getGenericProperties(connectionPdD, forceNoCache, org.openspcoop2.pdd.core.token.Costanti.TIPOLOGIA_RETRIEVE, policyName);

  8771.         PolicyNegoziazioneToken policy = null;
  8772.         try {
  8773.             policy = TokenUtilities.convertTo(gp);
  8774.         }catch(Exception e) {
  8775.             throw new DriverConfigurazioneException(e.getMessage(),e);
  8776.         }

  8778.         return policy;
  8779.     }
  8780.     
  8781.     protected PolicyAttributeAuthority getPolicyAttributeAuthority(Connection connectionPdD, boolean forceNoCache, String policyName) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  8783.         if(policyName==null){
  8784.             throw new DriverConfigurazioneException("Policy non fornita");
  8785.         }

  8787.         GenericProperties gp = this.configurazionePdD.getGenericProperties(connectionPdD, forceNoCache, org.openspcoop2.pdd.core.token.Costanti.ATTRIBUTE_AUTHORITY, policyName);

  8789.         PolicyAttributeAuthority policy = null;
  8790.         try {
  8791.             policy = AttributeAuthorityUtilities.convertTo(gp);
  8792.         }catch(Exception e) {
  8793.             throw new DriverConfigurazioneException(e.getMessage(),e);
  8794.         }

  8796.         return policy;
  8797.     }

  8799.     public GenericProperties getGenericProperties(Connection connectionPdD, String tipologia, String nome) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  8801.         return this.configurazionePdD.getGenericProperties(connectionPdD, tipologia, nome);

  8803.     }

  8805.     public List<GenericProperties> getGenericProperties(Connection connectionPdD, String tipologia) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  8807.         return this.configurazionePdD.getGenericProperties(connectionPdD, tipologia);

  8809.     }

  8811.     protected SystemProperties getSystemPropertiesPdDCached(Connection connectionPdD) throws DriverConfigurazioneException{
  8812.         try{
  8813.             return this.configurazionePdD.getSystemPropertiesPdDCached(connectionPdD);
  8814.         }catch(DriverConfigurazioneNotFound dNot){
  8815.             return null;
  8816.         }
  8817.     }

  8819.     protected List<String> getEncryptedSystemPropertiesPdD() throws DriverConfigurazioneException{
  8820.         return this.configurazionePdD.getEncryptedSystemPropertiesPdD();
  8821.     }
  8822.     protected SystemProperties getSystemPropertiesPdD(boolean forceDisableBYOKUse) throws DriverConfigurazioneException{
  8823.         try{
  8824.             return this.configurazionePdD.getSystemPropertiesPdD(forceDisableBYOKUse);
  8825.         }catch(DriverConfigurazioneNotFound dNot){
  8826.             return null;
  8827.         }
  8828.     }

  8830.     protected void updateSystemPropertiesPdD(SystemProperties systemProperties) throws DriverConfigurazioneException{
  8831.         this.configurazionePdD.updateSystemPropertiesPdD(systemProperties);
  8832.     }



  8836.     public CorsConfigurazione getConfigurazioneCORS(Connection connectionPdD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 
  8837.         CorsConfigurazione cors = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getGestioneCors();
  8838.         if(cors==null) {
  8839.             return new CorsConfigurazione();
  8840.         }
  8841.         return cors;
  8842.     }

  8844.     public ConfigurazioneMultitenant getConfigurazioneMultitenant(Connection connectionPdD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 
  8845.         ConfigurazioneMultitenant conf = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getMultitenant();
  8846.         if(conf==null) {
  8847.             return new ConfigurazioneMultitenant();
  8848.         }
  8849.         return conf;
  8850.     }

  8852.     public ResponseCachingConfigurazione getConfigurazioneResponseCaching(Connection connectionPdD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 
  8853.         ResponseCachingConfigurazioneGenerale c = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getResponseCaching();
  8854.         if(c==null) {
  8855.             c = new ResponseCachingConfigurazioneGenerale();
  8856.         }
  8857.         if(c.getConfigurazione()==null) {
  8858.             c.setConfigurazione(new ResponseCachingConfigurazione());
  8859.         }
  8860.         return c.getConfigurazione();
  8861.     }

  8863.     public Cache getConfigurazioneResponseCachingCache(Connection connectionPdD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 
  8864.         ResponseCachingConfigurazioneGenerale c = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getResponseCaching();
  8865.         if(c==null) {
  8866.             c = new ResponseCachingConfigurazioneGenerale();
  8867.         }
  8868.         return c.getCache();
  8869.     }

  8871.     public Cache getConfigurazioneConsegnaApplicativiCache(Connection connectionPdD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 
  8872.         AccessoDatiConsegnaApplicativi c = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getAccessoDatiConsegnaApplicativi();
  8873.         if(c==null) {
  8874.             c = new AccessoDatiConsegnaApplicativi();
  8875.         }
  8876.         return c.getCache();
  8877.     }

  8879.     public CanaliConfigurazione getCanaliConfigurazione(Connection connectionPdD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 
  8880.         CanaliConfigurazione c = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getGestioneCanali();
  8881.         if(c==null) {
  8882.             c = new CanaliConfigurazione();
  8883.             c.setStato(StatoFunzionalita.DISABILITATO);
  8884.         }
  8885.         return c;
  8886.     }
  8887.     
  8888.     public ConfigurazioneCanaliNodo getConfigurazioneCanaliNodo(Connection connectionPdD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 
  8889.         CanaliConfigurazione c = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getGestioneCanali();
  8890.         boolean isEnabled = (c!=null && StatoFunzionalita.ABILITATO.equals(c.getStato()));
  8891.         
  8892.         ConfigurazioneCanaliNodo ccn = new ConfigurazioneCanaliNodo();
  8893.         ccn.setEnabled(isEnabled);
  8894.         if(isEnabled) {
  8895.             OpenSPCoop2Properties op2Prop = OpenSPCoop2Properties.getInstance();
  8896.             String idNodo = null;
  8897.             if(op2Prop.isClusterDinamico()) {
  8898.                 idNodo = op2Prop.getGroupId(false);
  8899.             }
  8900.             else {
  8901.                 idNodo = op2Prop.getClusterId(false);
  8902.             }
  8903.             ccn.setIdNodo(idNodo);
  8904.             
  8905.             if(c.sizeCanaleList()<=0) {
  8906.                 throw new DriverConfigurazioneException("Non risultano canali registrati nella configurazione"); 
  8907.             }
  8908.             for (CanaleConfigurazione canale : c.getCanaleList()) {
  8909.                 if(canale.isCanaleDefault()) {
  8910.                     ccn.setCanaleDefault(canale.getNome());
  8911.                     break;
  8912.                 }
  8913.             }
  8914.             if(ccn.getCanaleDefault()==null || "".equals(ccn.getCanaleDefault())) {
  8915.                 throw new DriverConfigurazioneException("Non risulta definito un canale di default"); 
  8916.             }
  8917.             
  8918.             List<String> canaliNodo = new ArrayList<>();
  8919.             if(ccn.getIdNodo()==null || "".equals(ccn.getIdNodo())) {
  8920.                 canaliNodo.add(ccn.getCanaleDefault());
  8921.             }
  8922.             else if(c.sizeNodoList()<=0) {
  8923.                 canaliNodo.add(ccn.getCanaleDefault());
  8924.             }
  8925.             else {
  8926.                 for (CanaleConfigurazioneNodo nodo : c.getNodoList()) {
  8927.                     if(ccn.getIdNodo().equals(nodo.getNome())) {
  8928.                         if(nodo.sizeCanaleList()<=0) {
  8929.                             throw new DriverConfigurazioneException("Non risultano canali associati al nodo '"+ccn.getIdNodo()+"'"); 
  8930.                         }
  8931.                         for (String canale : nodo.getCanaleList()) {
  8932.                             canaliNodo.add(canale);
  8933.                         }
  8934.                         break;
  8935.                     }
  8936.                 }
  8937.                 if(canaliNodo.isEmpty()) {
  8938.                     canaliNodo.add(ccn.getCanaleDefault());
  8939.                 }
  8940.             }
  8941.             ccn.setCanaliNodo(canaliNodo);
  8942.         }
  8943.         
  8944.         return ccn;
  8945.     }
  8946.     
  8947.     public UrlInvocazioneAPI getConfigurazioneUrlInvocazione(Connection connectionPdD, 
  8948.             IProtocolFactory<?> protocolFactory, RuoloContesto ruolo, ServiceBinding serviceBinding, String interfaceName, IDSoggetto soggettoOperativo,
  8949.             AccordoServizioParteComune aspc,
  8950.             RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  8951.         
  8952.         List<String> tags = new ArrayList<>();
  8953.         if(aspc!=null && aspc.getGruppi()!=null && aspc.getGruppi().sizeGruppoList()>0) {
  8954.             for (int i = 0; i < aspc.getGruppi().sizeGruppoList(); i++) {
  8955.                 tags.add(aspc.getGruppi().getGruppo(i).getNome());
  8956.             }
  8957.         }
  8958.         
  8959.         String canaleApi = null;
  8960.         if(aspc!=null) {
  8961.             canaleApi = aspc.getCanale();
  8962.         }

  8964.         return getConfigurazioneUrlInvocazione(connectionPdD, protocolFactory, ruolo, serviceBinding, interfaceName, soggettoOperativo, tags, canaleApi, requestInfo);
  8965.     }   
  8966.     public UrlInvocazioneAPI getConfigurazioneUrlInvocazione(Connection connectionPdD, 
  8967.             IProtocolFactory<?> protocolFactory, RuoloContesto ruolo, ServiceBinding serviceBinding, String interfaceName, IDSoggetto soggettoOperativo,
  8968.             List<String> tags, 
  8969.             String canaleApi,
  8970.             RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  8972.         Configurazione config = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);

  8974.         ConfigurazioneUrlInvocazione configurazioneUrlInvocazione = null;
  8975.         if(config!=null && config.getUrlInvocazione()!=null) {
  8976.             configurazioneUrlInvocazione = config.getUrlInvocazione();
  8977.         }

  8979.         String canale = null;
  8980.         if(config!=null && config.getGestioneCanali()!=null && StatoFunzionalita.ABILITATO.equals(config.getGestioneCanali().getStato()) && config.getGestioneCanali().sizeCanaleList()>0) {
  8981.             if(RuoloContesto.PORTA_APPLICATIVA.equals(ruolo)) {
  8982.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  8983.                 idPA.setNome(interfaceName);
  8984.                 PortaApplicativa pa = null;
  8985.                 if(requestInfo!=null && requestInfo.getRequestConfig()!=null && interfaceName!=null) {
  8986.                     if( requestInfo.getRequestConfig().getPortaApplicativa()!=null && idPA.getNome().equals(requestInfo.getRequestConfig().getPortaApplicativa().getNome())) {
  8987.                         pa = requestInfo.getRequestConfig().getPortaApplicativa();
  8988.                     }
  8989.                     else if( requestInfo.getRequestConfig().getPortaApplicativaDefault()!=null && idPA.getNome().equals(requestInfo.getRequestConfig().getPortaApplicativaDefault().getNome())) {
  8990.                         pa = requestInfo.getRequestConfig().getPortaApplicativaDefault();
  8991.                     }
  8992.                 }
  8993.                 if(pa==null) {
  8994.                     try {
  8995.                         pa = this.configurazionePdD.getPortaApplicativa(connectionPdD, idPA);
  8996.                     }catch(DriverConfigurazioneNotFound notFound) {}
  8997.                 }
  8998.                 canale = CanaliUtils.getCanale(config.getGestioneCanali(), canaleApi, pa);
  8999.             }
  9000.             else {
  9001.                 IDPortaDelegata idPD = new IDPortaDelegata();
  9002.                 idPD.setNome(interfaceName);
  9003.                 PortaDelegata pd = null;
  9004.                 if(requestInfo!=null && requestInfo.getRequestConfig()!=null && interfaceName!=null) {
  9005.                     if( requestInfo.getRequestConfig().getPortaDelegata()!=null && idPD.getNome().equals(requestInfo.getRequestConfig().getPortaDelegata().getNome())) {
  9006.                         pd = requestInfo.getRequestConfig().getPortaDelegata();
  9007.                     }
  9008.                     else if( requestInfo.getRequestConfig().getPortaDelegataDefault()!=null && idPD.getNome().equals(requestInfo.getRequestConfig().getPortaDelegata().getNome())) {
  9009.                         pd = requestInfo.getRequestConfig().getPortaDelegata();
  9010.                     }
  9011.                 }
  9012.                 if(pd==null) {
  9013.                     try {
  9014.                         pd = this.configurazionePdD.getPortaDelegata(connectionPdD, idPD);
  9015.                     }catch(DriverConfigurazioneNotFound notFound) {}
  9016.                 }
  9017.                 canale = CanaliUtils.getCanale(config.getGestioneCanali(), canaleApi, pd);
  9018.             }
  9019.         }
  9020.         
  9021.         return UrlInvocazioneAPI.getConfigurazioneUrlInvocazione(configurazioneUrlInvocazione, protocolFactory, ruolo, serviceBinding, interfaceName, soggettoOperativo,
  9022.                 tags, canale);
  9023.     }

  9025.     protected List<PolicyGroupByActiveThreadsType> getTipiGestoreRateLimiting(Connection connectionPdD) throws DriverConfigurazioneException {
  9026.         
  9027.         List<PolicyGroupByActiveThreadsType> list = new ArrayList<PolicyGroupByActiveThreadsType>();
  9028.         try {
  9029.             PolicyConfiguration pc = this.configurazionePdD.getConfigurazionePolicyRateLimitingGlobali(connectionPdD); 
  9030.             list.add(pc.getType()); // default
  9031.         }catch(Exception e) {
  9032.             throw new DriverConfigurazioneException(e.getMessage(),e);
  9033.         }
  9034.         if(this.configurazionePdD.getDriverConfigurazionePdD() instanceof DriverConfigurazioneDB) {
  9035.             DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.configurazionePdD.getDriverConfigurazionePdD();
  9036.             
  9037.             List<String> listPD =  driver.porteDelegateRateLimitingValoriUnivoci(org.openspcoop2.core.controllo_traffico.constants.Costanti.GESTORE);
  9038.             if(listPD!=null && !listPD.isEmpty()) {
  9039.                 for (String type : listPD) {
  9040.                     PolicyGroupByActiveThreadsType typeE = PolicyGroupByActiveThreadsType.valueOf(type);
  9041.                     if(!list.contains(typeE)) {
  9042.                         list.add(typeE);
  9043.                     }
  9044.                 }
  9045.             }
  9046.             
  9047.             List<String> listPA =  driver.porteApplicativeRateLimitingValoriUnivoci(org.openspcoop2.core.controllo_traffico.constants.Costanti.GESTORE);
  9048.             if(listPA!=null && !listPA.isEmpty()) {
  9049.                 for (String type : listPA) {
  9050.                     PolicyGroupByActiveThreadsType typeE = null;
  9051.                     // per backward
  9052.                     if(org.openspcoop2.core.controllo_traffico.constants.Costanti.GESTORE_HAZELCAST_MAP_BACKWARD_COMPATIBILITY.equalsIgnoreCase(type)) {
  9053.                         typeE = PolicyGroupByActiveThreadsType.HAZELCAST_MAP;
  9054.                     }
  9055.                     else {
  9056.                         typeE = PolicyGroupByActiveThreadsType.valueOf(type);
  9057.                     }
  9058.                     if(!list.contains(typeE)) {
  9059.                         list.add(typeE);
  9060.                     }
  9061.                 }
  9062.             }
  9063.         }
  9064.         
  9065.         return list;
  9066.     }
  9067.     
  9068.     protected List<String> getInitHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9069.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9070.         List<String> list = new ArrayList<>();
  9071.         if(confGenerale!=null && confGenerale.getService()!=null) {
  9072.             fillListHandlers(confGenerale.getService().getInitList(), list);
  9073.         }
  9074.         return list;
  9075.     }
  9076.     protected List<String> getExitHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9077.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9078.         List<String> list = new ArrayList<>();
  9079.         if(confGenerale!=null && confGenerale.getService()!=null) {
  9080.             fillListHandlers(confGenerale.getService().getExitList(), list);
  9081.         }
  9082.         return list;
  9083.     }
  9084.     protected List<String> getIntegrationManagerRequestHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9085.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9086.         List<String> list = new ArrayList<>();
  9087.         if(confGenerale!=null && confGenerale.getService()!=null) {
  9088.             fillListHandlers(confGenerale.getService().getIntegrationManagerRequestList(), list);
  9089.         }
  9090.         return list;
  9091.     }
  9092.     protected List<String> getIntegrationManagerResponseHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9093.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9094.         List<String> list = new ArrayList<>();
  9095.         if(confGenerale!=null && confGenerale.getService()!=null) {
  9096.             fillListHandlers(confGenerale.getService().getIntegrationManagerResponseList(), list);
  9097.         }
  9098.         return list;
  9099.     }
  9100.     
  9101.     protected List<String> getPreInRequestHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9102.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9103.         List<String> list = new ArrayList<>();
  9104.         if(confGenerale!=null && confGenerale.getRequest()!=null) {
  9105.             fillListHandlers(confGenerale.getRequest().getPreInList(), list);
  9106.         }
  9107.         return list;
  9108.     }
  9109.     protected List<String> getInRequestHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9110.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9111.         List<String> list = new ArrayList<>();
  9112.         if(confGenerale!=null && confGenerale.getRequest()!=null) {
  9113.             fillListHandlers(confGenerale.getRequest().getInList(), list);
  9114.         }
  9115.         return list;
  9116.     }
  9117.     protected List<String> getInRequestProtocolHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9118.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9119.         List<String> list = new ArrayList<>();
  9120.         if(confGenerale!=null && confGenerale.getRequest()!=null) {
  9121.             fillListHandlers(confGenerale.getRequest().getInProtocolInfoList(), list);
  9122.         }
  9123.         return list;
  9124.     }
  9125.     protected List<String> getOutRequestHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9126.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9127.         List<String> list = new ArrayList<>();
  9128.         if(confGenerale!=null && confGenerale.getRequest()!=null) {
  9129.             fillListHandlers(confGenerale.getRequest().getOutList(), list);
  9130.         }
  9131.         return list;
  9132.     }
  9133.     protected List<String> getPostOutRequestHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9134.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9135.         List<String> list = new ArrayList<>();
  9136.         if(confGenerale!=null && confGenerale.getRequest()!=null) {
  9137.             fillListHandlers(confGenerale.getRequest().getPostOutList(), list);
  9138.         }
  9139.         return list;
  9140.     }
  9141.     protected List<String> getPreInResponseHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9142.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9143.         List<String> list = new ArrayList<>();
  9144.         if(confGenerale!=null && confGenerale.getResponse()!=null) {
  9145.             fillListHandlers(confGenerale.getResponse().getPreInList(), list);
  9146.         }
  9147.         return list;
  9148.     }
  9149.     protected List<String> getInResponseHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9150.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9151.         List<String> list = new ArrayList<>();
  9152.         if(confGenerale!=null && confGenerale.getResponse()!=null) {
  9153.             fillListHandlers(confGenerale.getResponse().getInList(), list);
  9154.         }
  9155.         return list;
  9156.     }
  9157.     protected List<String> getOutResponseHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9158.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9159.         List<String> list = new ArrayList<>();
  9160.         if(confGenerale!=null && confGenerale.getResponse()!=null) {
  9161.             fillListHandlers(confGenerale.getResponse().getOutList(), list);
  9162.         }
  9163.         return list;
  9164.     }
  9165.     protected List<String> getPostOutResponseHandlers(Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9166.         ConfigurazioneGeneraleHandler confGenerale = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD).getConfigurazioneHandler();
  9167.         List<String> list = new ArrayList<>();
  9168.         if(confGenerale!=null && confGenerale.getResponse()!=null) {
  9169.             fillListHandlers(confGenerale.getResponse().getPostOutList(), list);
  9170.         }
  9171.         return list;
  9172.     }

  9174.     private void fillListHandlers(List<ConfigurazioneHandler> handlers, List<String> list) {
  9175.         if(handlers!=null && !handlers.isEmpty()) {
  9176.             for (ConfigurazioneHandler handler : handlers) {
  9177.                 if(StatoFunzionalita.ABILITATO.equals(handler.getStato())){
  9178.                     list.add(handler.getTipo());
  9179.                 }
  9180.             }
  9181.         }
  9182.     }


  9185.     // Per la configurazione realizzo due versioni.
  9186.     //
  9187.     // Il metodo 'getExtendedInfoConfigurazione' e 'getSingleExtendedInfoConfigurazione' implementa la logica classica della configurazione della PdD
  9188.     // dove le informazioni sulla policy vengono lette solamente all'avvio della PdD (se la configurazione non è dinamica)
  9189.     //
  9190.     // Il metodo 'getExtendedInfoConfigurazioneFromCache' e 'getSingleExtendedInfoConfigurazioneFromCache' implementa la logica di prelieve sempre dalla cache

  9192.     private static List<Object> getExtendedInfoConfigurazione = null;
  9193.     protected List<Object> getExtendedInfoConfigurazione(Connection connectionPdD) throws DriverConfigurazioneException{

  9195.         if( this.configurazioneDinamica || ConfigurazionePdDReader.getExtendedInfoConfigurazione==null){
  9196.             try{
  9197.                 Configurazione configurazione = null;
  9198.                 try{
  9199.                     configurazione = this.configurazionePdD.getConfigurazioneGenerale(connectionPdD);
  9200.                 }catch(DriverConfigurazioneNotFound e){
  9201.                     this.logDebug("getExtendedInfoConfigurazione (not found): "+e.getMessage());
  9202.                 }
  9203.                 //              }catch(Exception e){
  9204.                 //                  this.logError("getExtendedInfoConfigurazione",e);
  9205.                 //              }
  9206.                 if(configurazione!=null) {
  9207.                     ConfigurazionePdDReader.getExtendedInfoConfigurazione = configurazione.getExtendedInfoList();
  9208.                 }

  9210.             }catch(Exception e){
  9211.                 this.logError("Errore durante la lettura delle informazioni extra della configurazione: "+e.getMessage(),e);
  9212.                 throw new DriverConfigurazioneException("Errore durante la lettura delle informazioni extra della configurazione: "+e.getMessage(),e);
  9213.             }
  9214.         }

  9216.         return ConfigurazionePdDReader.getExtendedInfoConfigurazione;

  9218.     }

  9220.     private static Map<String, Object> getSingleExtendedInfoConfigurazione = new ConcurrentHashMap<String, Object>(); 
  9221.     protected Object getSingleExtendedInfoConfigurazione(String id, Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{

  9223.         if( this.configurazioneDinamica || ConfigurazionePdDReader.getSingleExtendedInfoConfigurazione.containsKey(id)==false){
  9224.             try{
  9225.                 Object result = null;
  9226.                 try{
  9227.                     result = this.configurazionePdD.getSingleExtendedInfoConfigurazione(id, connectionPdD);
  9228.                 }catch(DriverConfigurazioneNotFound e){
  9229.                     this.logDebug("getSingleExtendedInfoConfigurazione (not found): "+e.getMessage());
  9230.                 }
  9231.                 //              }catch(Exception e){
  9232.                 //                  this.logError("getExtendedInfoConfigurazione",e);
  9233.                 //              }

  9235.                 if(result!=null){
  9236.                     ConfigurazionePdDReader.getSingleExtendedInfoConfigurazione.put(id, result);
  9237.                 }

  9239.             }catch(Exception e){
  9240.                 this.logError("Errore durante la lettura delle informazioni extra con id '"+id+"' della configurazione: "+e.getMessage(),e);
  9241.                 throw new DriverConfigurazioneException("Errore durante la lettura delle informazioni extra con id '"+id+"' della configurazione: "+e.getMessage(),e);
  9242.             }
  9243.         }

  9245.         return ConfigurazionePdDReader.getSingleExtendedInfoConfigurazione.get(id);

  9247.     }

  9249.     protected List<Object> getExtendedInfoConfigurazioneFromCache(Connection connectionPdD) throws DriverConfigurazioneException{
  9250.         try{
  9251.             Configurazione configurazione = null;
  9252.             try{
  9253.                 configurazione = this.configurazionePdD.getConfigurazioneWithOnlyExtendedInfo(connectionPdD);
  9254.             }catch(DriverConfigurazioneNotFound e){
  9255.                 this.logDebug("getConfigurazioneWithOnlyExtendedInfo (not found): "+e.getMessage());
  9256.             }
  9257.             //          }catch(Exception e){
  9258.             //              this.logError("getExtendedInfoConfigurazione",e);
  9259.             //          }
  9260.             if(configurazione!=null) {
  9261.                 return configurazione.getExtendedInfoList();
  9262.             }
  9263.             return null;

  9265.         }catch(Exception e){
  9266.             this.logError("Errore durante la lettura delle informazioni extra della configurazione (via cache): "+e.getMessage(),e);
  9267.             throw new DriverConfigurazioneException("Errore durante la lettura delle informazioni extra della configurazione  (via cache): "+e.getMessage(),e);
  9268.         }
  9269.     }

  9271.     protected Object getSingleExtendedInfoConfigurazioneFromCache(String id, Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9272.         try{
  9273.             Object result = null;
  9274.             try{
  9275.                 result = this.configurazionePdD.getSingleExtendedInfoConfigurazione(id, connectionPdD);
  9276.             }catch(DriverConfigurazioneNotFound e){
  9277.                 this.logDebug("getSingleExtendedInfoConfigurazioneFromCache (not found): "+e.getMessage());
  9278.             }
  9279.             //          }catch(Exception e){
  9280.             //              this.logError("getExtendedInfoConfigurazione",e);
  9281.             //          }
  9282.             return result;

  9284.         }catch(Exception e){
  9285.             this.logError("Errore durante la lettura delle informazioni extra con id '"+id+"' della configurazione (via cache): "+e.getMessage(),e);
  9286.             throw new DriverConfigurazioneException("Errore durante la lettura delle informazioni extra con id '"+id+"' della configurazione  (via cache): "+e.getMessage(),e);
  9287.         }
  9288.     }

  9290.     protected Template getTemplatePolicyNegoziazioneRequest(Connection connectionPdD, String policyName, byte[] template, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9291.         return this.configurazionePdD.getTemplatePolicyNegoziazioneRequest(connectionPdD, policyName, template, requestInfo);
  9292.     }
  9293.     
  9294.     protected Template getTemplateAttributeAuthorityRequest(Connection connectionPdD, String attributeAuthorityName, byte[] template, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9295.         return this.configurazionePdD.getTemplateAttributeAuthorityRequest(connectionPdD, attributeAuthorityName, template, requestInfo);
  9296.     }
  9297.     
  9298.     protected Template getTemplateIntegrazione(Connection connectionPdD,File file, RequestInfo requestInfo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9299.         return this.configurazionePdD.getTemplateIntegrazione(connectionPdD, file, requestInfo);
  9300.     }



  9304.     /* ********  R I C E R C A  I D   E L E M E N T I   P R I M I T I V I  ******** */

  9306.     public List<IDPortaDelegata> getAllIdPorteDelegate(FiltroRicercaPorteDelegate filtroRicerca,Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9307.         return this.configurazionePdD.getAllIdPorteDelegate(filtroRicerca,connectionPdD);
  9308.     }

  9310.     public List<IDPortaApplicativa> getAllIdPorteApplicative(FiltroRicercaPorteApplicative filtroRicerca,Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9311.         return this.configurazionePdD.getAllIdPorteApplicative(filtroRicerca,connectionPdD);
  9312.     }

  9314.     public List<IDServizioApplicativo> getAllIdServiziApplicativi(FiltroRicercaServiziApplicativi filtroRicerca,Connection connectionPdD) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  9315.         return this.configurazionePdD.getAllIdServiziApplicativi(filtroRicerca,connectionPdD);
  9316.     }


  9319.     /* ******** CONTROLLO TRAFFICO ******** */

  9321.     public ConfigurazioneGenerale getConfigurazioneControlloTraffico(Connection connectionPdD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9322.         return this.configurazionePdD.getConfigurazioneControlloTraffico(connectionPdD);
  9323.     }

  9325.     public PolicyConfiguration getConfigurazionePolicyRateLimitingGlobali(Connection connectionPdD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9326.         return this.configurazionePdD.getConfigurazionePolicyRateLimitingGlobali(connectionPdD);
  9327.     }
  9328.     
  9329.     public Map<TipoRisorsaPolicyAttiva, ElencoIdPolicyAttive> getElencoIdPolicyAttiveAPI(Connection connectionPdD, boolean useCache, TipoPdD tipoPdD, String nomePorta) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9330.         return this.configurazionePdD.getElencoIdPolicyAttiveAPI(connectionPdD, useCache, tipoPdD, nomePorta);
  9331.     }

  9333.     public Map<TipoRisorsaPolicyAttiva, ElencoIdPolicyAttive> getElencoIdPolicyAttiveGlobali(Connection connectionPdD, boolean useCache) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9334.         return this.configurazionePdD.getElencoIdPolicyAttiveGlobali(connectionPdD, useCache);
  9335.     }
  9336.     
  9337.     public Map<TipoRisorsaPolicyAttiva, ElencoIdPolicyAttive> getElencoIdPolicyAttiveAPIDimensioneMessaggio(Connection connectionPdD, boolean useCache, TipoPdD tipoPdD, String nomePorta) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9338.         return this.configurazionePdD.getElencoIdPolicyAttiveAPIDimensioneMessaggio(connectionPdD, useCache, tipoPdD, nomePorta);
  9339.     }

  9341.     public Map<TipoRisorsaPolicyAttiva, ElencoIdPolicyAttive> getElencoIdPolicyAttiveGlobaliDimensioneMessaggio(Connection connectionPdD, boolean useCache) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9342.         return this.configurazionePdD.getElencoIdPolicyAttiveGlobaliDimensioneMessaggio(connectionPdD, useCache);
  9343.     }

  9345.     public AttivazionePolicy getAttivazionePolicy(Connection connectionPdD, boolean useCache, String id) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9346.         return this.configurazionePdD.getAttivazionePolicy(connectionPdD, useCache, id);
  9347.     }

  9349.     public ElencoIdPolicy getElencoIdPolicy(Connection connectionPdD, boolean useCache) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9350.         return this.configurazionePdD.getElencoIdPolicy(connectionPdD, useCache);
  9351.     }

  9353.     public ConfigurazionePolicy getConfigurazionePolicy(Connection connectionPdD, boolean useCache, String id) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9354.         return this.configurazionePdD.getConfigurazionePolicy(connectionPdD, useCache, id);
  9355.     }
  9356.     
  9357.     
  9358.     /* ******** PLUGINS ******** */
  9359.     
  9360.     public IRegistroPluginsReader getRegistroPluginsReader() {
  9361.         return this.configurazionePdD.getRegistroPluginsReader();
  9362.     }
  9363.     
  9364.     public String getPluginClassName(Connection connectionPdD, String tipoPlugin, String tipo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9365.         return this.configurazionePdD.getPluginClassName(connectionPdD, tipoPlugin, tipo);
  9366.     }
  9367.     public String getPluginClassNameByFilter(Connection connectionPdD, String tipoPlugin, String tipo, NameValue ... filtri) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9368.         return this.configurazionePdD.getPluginClassNameByFilter(connectionPdD, tipoPlugin, tipo, filtri);
  9369.     }
  9370.     public String getPluginTipo(Connection connectionPdD, String tipoPlugin, String className) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9371.         return this.configurazionePdD.getPluginTipo(connectionPdD, tipoPlugin, className);
  9372.     }
  9373.     public String getPluginTipoByFilter(Connection connectionPdD, String tipoPlugin, String className, NameValue ... filtri) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  9374.         return this.configurazionePdD.getPluginTipoByFilter(connectionPdD, tipoPlugin, className, filtri);
  9375.     }
  9376.     
  9377.     
  9378.     /* ******** ALLARMI ******** */

  9380.     public Allarme getAllarme(Connection connectionPdD, String nomeAllarme, boolean searchInCache) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  9381.         return this.configurazionePdD.getAllarme(connectionPdD, nomeAllarme, searchInCache);
  9382.     }
  9383.     public List<Allarme> searchAllarmi(Connection connectionPdD, FiltroRicercaAllarmi filtroRicerca, boolean searchInCache) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  9384.         return this.configurazionePdD.searchAllarmi(connectionPdD, filtroRicerca, searchInCache);
  9385.     }
  9386.     public List<IAlarm> instanceAllarmi(Connection connectionPdD, List<Allarme> listAllarmi) throws DriverConfigurazioneException {
  9387.         return this.configurazionePdD.instanceAllarmi(connectionPdD, listAllarmi);
  9388.     }
  9389.     public void changeStatus(Connection connectionPdD, IAlarm alarm, AlarmStatus nuovoStatoAllarme) throws DriverConfigurazioneException {
  9390.         this.configurazionePdD.changeStatus(connectionPdD, alarm, nuovoStatoAllarme);
  9391.     }


  9394.     /* ******** MAPPING ******** */

  9396.     public List<MappingErogazionePortaApplicativa> getMappingErogazionePortaApplicativaList(IDServizio idServizio,Connection connectionPdD) throws DriverConfigurazioneException{
  9397.         return this.configurazionePdD.getMappingErogazionePortaApplicativaList(idServizio, connectionPdD);
  9398.     } 
  9399.     public List<MappingFruizionePortaDelegata> getMappingFruizionePortaDelegataList(IDSoggetto idFruitore, IDServizio idServizio,Connection connectionPdD) throws DriverConfigurazioneException{
  9400.         return this.configurazionePdD.getMappingFruizionePortaDelegataList(idFruitore, idServizio, connectionPdD);
  9401.     }
  9402.     
  9403.     
  9404.     /* ******** FORWARD PROXY ******** */
  9405.     
  9406.     public boolean isForwardProxyEnabled() {
  9407.         return this.configurazionePdD.isForwardProxyEnabled();
  9408.     }
  9409.     public ForwardProxy getForwardProxyConfigFruizione(IDSoggetto dominio, IDServizio idServizio, IDGenericProperties policy, RequestInfo requestInfo) throws DriverConfigurazioneException{
  9410.         return this.configurazionePdD.getForwardProxyConfigFruizione(dominio, idServizio, policy, requestInfo);
  9411.     }
  9412.     public ForwardProxy getForwardProxyConfigErogazione(IDSoggetto dominio, IDServizio idServizio, IDGenericProperties policy, RequestInfo requestInfo) throws DriverConfigurazioneException{
  9413.         return this.configurazionePdD.getForwardProxyConfigErogazione(dominio, idServizio, policy, requestInfo);
  9414.     }
  9415.     
  9416.     
  9417.     /* ********  GENERIC FILE  ******** */

  9419.     public ContentFile getContentFile(File file) throws DriverConfigurazioneException{
  9420.         return this.configurazionePdD.getContentFile(file);
  9421.     }

  9423. }
Created with JaCoCo 0.8.8.202204050719