RegistroServiziReader.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.  */



  20. package org.openspcoop2.protocol.registry;

  21. import java.io.Serializable;
  22. import java.sql.Connection;
  23. import java.util.ArrayList;
  24. import java.util.Date;
  25. import java.util.HashMap;
  26. import java.util.List;
  27. import java.util.Map;

  28. import org.openspcoop2.core.byok.IDriverBYOK;
  29. import org.openspcoop2.core.commons.ConnettoreHTTPSProperties;
  30. import org.openspcoop2.core.commons.CoreException;
  31. import org.openspcoop2.core.commons.IMonitoraggioRisorsa;
  32. import org.openspcoop2.core.config.AccessoRegistro;
  33. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  34. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  35. import org.openspcoop2.core.constants.CostantiDB;
  36. import org.openspcoop2.core.constants.CostantiLabel;
  37. import org.openspcoop2.core.constants.StatoCheck;
  38. import org.openspcoop2.core.constants.TipiConnettore;
  39. import org.openspcoop2.core.id.IDAccordo;
  40. import org.openspcoop2.core.id.IDAccordoAzione;
  41. import org.openspcoop2.core.id.IDAccordoCooperazione;
  42. import org.openspcoop2.core.id.IDFruizione;
  43. import org.openspcoop2.core.id.IDGruppo;
  44. import org.openspcoop2.core.id.IDPortType;
  45. import org.openspcoop2.core.id.IDPortTypeAzione;
  46. import org.openspcoop2.core.id.IDResource;
  47. import org.openspcoop2.core.id.IDRuolo;
  48. import org.openspcoop2.core.id.IDScope;
  49. import org.openspcoop2.core.id.IDServizio;
  50. import org.openspcoop2.core.id.IDSoggetto;
  51. import org.openspcoop2.core.registry.AccordoCooperazione;
  52. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  53. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  54. import org.openspcoop2.core.registry.Azione;
  55. import org.openspcoop2.core.registry.ConfigurazioneServizioAzione;
  56. import org.openspcoop2.core.registry.Connettore;
  57. import org.openspcoop2.core.registry.CredenzialiSoggetto;
  58. import org.openspcoop2.core.registry.Documento;
  59. import org.openspcoop2.core.registry.Fruitore;
  60. import org.openspcoop2.core.registry.Operation;
  61. import org.openspcoop2.core.registry.PortaDominio;
  62. import org.openspcoop2.core.registry.Proprieta;
  63. import org.openspcoop2.core.registry.Ruolo;
  64. import org.openspcoop2.core.registry.Scope;
  65. import org.openspcoop2.core.registry.Soggetto;
  66. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  67. import org.openspcoop2.core.registry.constants.ProfiloCollaborazione;
  68. import org.openspcoop2.core.registry.constants.ServiceBinding;
  69. import org.openspcoop2.core.registry.constants.StatoFunzionalita;
  70. import org.openspcoop2.core.registry.constants.TipiDocumentoLivelloServizio;
  71. import org.openspcoop2.core.registry.constants.TipiDocumentoSemiformale;
  72. import org.openspcoop2.core.registry.constants.TipiDocumentoSicurezza;
  73. import org.openspcoop2.core.registry.constants.TipologiaServizio;
  74. import org.openspcoop2.core.registry.driver.BeanUtilities;
  75. import org.openspcoop2.core.registry.driver.DriverRegistroServiziAzioneNotFound;
  76. import org.openspcoop2.core.registry.driver.DriverRegistroServiziCorrelatoNotFound;
  77. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  78. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  79. import org.openspcoop2.core.registry.driver.DriverRegistroServiziPortTypeNotFound;
  80. import org.openspcoop2.core.registry.driver.DriverRegistroServiziServizioNotFound;
  81. import org.openspcoop2.core.registry.driver.FiltroRicerca;
  82. import org.openspcoop2.core.registry.driver.FiltroRicercaAccordi;
  83. import org.openspcoop2.core.registry.driver.FiltroRicercaAzioni;
  84. import org.openspcoop2.core.registry.driver.FiltroRicercaFruizioniServizio;
  85. import org.openspcoop2.core.registry.driver.FiltroRicercaGruppi;
  86. import org.openspcoop2.core.registry.driver.FiltroRicercaOperations;
  87. import org.openspcoop2.core.registry.driver.FiltroRicercaPortTypes;
  88. import org.openspcoop2.core.registry.driver.FiltroRicercaResources;
  89. import org.openspcoop2.core.registry.driver.FiltroRicercaRuoli;
  90. import org.openspcoop2.core.registry.driver.FiltroRicercaScope;
  91. import org.openspcoop2.core.registry.driver.FiltroRicercaServizi;
  92. import org.openspcoop2.core.registry.driver.FiltroRicercaSoggetti;
  93. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  94. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  95. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  96. import org.openspcoop2.core.registry.driver.IDriverRegistroServiziGet;
  97. import org.openspcoop2.core.registry.driver.ValidazioneSemantica;
  98. import org.openspcoop2.core.registry.driver.db.DriverRegistroServiziDB;
  99. import org.openspcoop2.core.registry.driver.xml.DriverRegistroServiziXML;
  100. import org.openspcoop2.core.registry.utils.RegistroServiziUtils;
  101. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  102. import org.openspcoop2.protocol.sdk.Servizio;
  103. import org.openspcoop2.protocol.sdk.constants.InformationApiSource;
  104. import org.openspcoop2.protocol.sdk.constants.Inoltro;
  105. import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
  106. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  107. import org.openspcoop2.protocol.utils.ModISecurityUtils;
  108. import org.openspcoop2.protocol.utils.ModIUtils;
  109. import org.openspcoop2.utils.LoggerWrapperFactory;
  110. import org.openspcoop2.utils.cache.CacheType;
  111. import org.openspcoop2.utils.certificate.CertificateInfo;
  112. import org.openspcoop2.utils.certificate.CertificateUtils;
  113. import org.openspcoop2.utils.certificate.KeystoreParams;
  114. import org.openspcoop2.utils.certificate.PrincipalType;
  115. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  116. import org.openspcoop2.utils.crypt.CryptConfig;
  117. import org.openspcoop2.utils.date.DateManager;
  118. import org.openspcoop2.utils.transport.http.IBYOKUnwrapFactory;
  119. import org.openspcoop2.utils.transport.http.IBYOKUnwrapManager;
  120. import org.openspcoop2.utils.transport.http.SSLConfig;
  121. import org.slf4j.Logger;

  122. /**
  123.  * Classe utilizzata per ottenere informazioni che interessano ad OpenSPCoop
  124.  *
  125.  * @author Poli Andrea (apoli@link.it)
  126.  * @author Lezza Aldo (lezza@openspcoop.org)
  127.  * @author $Author$
  128.  * @version $Rev$, $Date$
  129.  */
  130. public class RegistroServiziReader {

  131.     /* istanza di RegistroServiziReader */
  132.     private static  RegistroServiziReader registroServiziReader;
  133.     /* informazione sull'inizializzazione dell'istanza */
  134.     private static boolean initialize = false;

  135.     /* Registro dei Servizi */
  136.     private RegistroServizi registroServizi;

  137.     /** Logger utilizzato per debug. */
  138.     private Logger log = null;
  139.    
  140.     // Factory
  141.     private IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();

  142.     /* --------------- Reset Cache --------------------*/
  143.     public static boolean isCacheAbilitata() throws DriverRegistroServiziException{
  144.         try{
  145.             RegistroServiziReader registroServiziReader = org.openspcoop2.protocol.registry.RegistroServiziReader.getInstance();
  146.             if(registroServiziReader!=null && registroServiziReader.registroServizi!=null){
  147.                 return registroServiziReader.registroServizi.isCacheAbilitata();
  148.             }
  149.             return false;
  150.         }catch(Exception e){
  151.             throw new DriverRegistroServiziException("IsCacheAbilitata, recupero informazione della cache del registri dei servizi non riuscita: "+e.getMessage(),e);
  152.         }
  153.     }
  154.     public static void resetCache() throws DriverRegistroServiziException{
  155.         try{
  156.             RegistroServiziReader registroServiziReader = org.openspcoop2.protocol.registry.RegistroServiziReader.getInstance();
  157.             if(registroServiziReader!=null && registroServiziReader.registroServizi!=null){
  158.                 registroServiziReader.registroServizi.resetCache();
  159.             }
  160.         }catch(Exception e){
  161.             throw new DriverRegistroServiziException("Reset della cache di accesso ai registri dei servizi non riuscita: "+e.getMessage(),e);
  162.         }
  163.     }
  164.     public static void prefillCache(CryptConfig cryptConfigSoggetti) throws DriverRegistroServiziException{
  165.         try{
  166.             RegistroServiziReader registroServiziReader = org.openspcoop2.protocol.registry.RegistroServiziReader.getInstance();
  167.             if(registroServiziReader!=null && registroServiziReader.registroServizi!=null){
  168.                 registroServiziReader.registroServizi.prefillCache(null, registroServiziReader.log, cryptConfigSoggetti);
  169.             }
  170.         }catch(Exception e){
  171.             throw new DriverRegistroServiziException("Prefill della cache di accesso ai registri dei servizi non riuscita: "+e.getMessage(),e);
  172.         }
  173.     }
  174.     public static String printStatsCache(String separator) throws DriverRegistroServiziException{
  175.         try{
  176.             RegistroServiziReader registroServiziReader = org.openspcoop2.protocol.registry.RegistroServiziReader.getInstance();
  177.             if(registroServiziReader!=null && registroServiziReader.registroServizi!=null){
  178.                 return registroServiziReader.registroServizi.printStatsCache(separator);
  179.             }
  180.             else{
  181.                 throw new Exception("RegistroServizi Non disponibile");
  182.             }
  183.         }catch(Exception e){
  184.             throw new DriverRegistroServiziException("Visualizzazione Statistiche riguardante la cache del registro dei servizi non riuscita: "+e.getMessage(),e);
  185.         }
  186.     }
  187.     public static void abilitaCache() throws DriverRegistroServiziException{
  188.         try{
  189.             RegistroServiziReader registroServiziReader = org.openspcoop2.protocol.registry.RegistroServiziReader.getInstance();
  190.             if(registroServiziReader!=null && registroServiziReader.registroServizi!=null){
  191.                 registroServiziReader.registroServizi.abilitaCache();
  192.             }
  193.         }catch(Exception e){
  194.             throw new DriverRegistroServiziException("Abilitazione cache di accesso ai registri dei servizi non riuscita: "+e.getMessage(),e);
  195.         }
  196.     }
  197.     public static void abilitaCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond, CryptConfig cryptConfigSoggetti) throws DriverRegistroServiziException{
  198.         try{
  199.             RegistroServiziReader registroServiziReader = org.openspcoop2.protocol.registry.RegistroServiziReader.getInstance();
  200.             if(registroServiziReader!=null && registroServiziReader.registroServizi!=null){
  201.                 registroServiziReader.registroServizi.abilitaCache(dimensioneCache,algoritmoCacheLRU,itemIdleTime,itemLifeSecond, cryptConfigSoggetti);
  202.             }
  203.         }catch(Exception e){
  204.             throw new DriverRegistroServiziException("Abilitazione cache di accesso ai registri dei servizi non riuscita: "+e.getMessage(),e);
  205.         }
  206.     }
  207.     public static void disabilitaCache() throws DriverRegistroServiziException{
  208.         try{
  209.             RegistroServiziReader registroServiziReader = org.openspcoop2.protocol.registry.RegistroServiziReader.getInstance();
  210.             if(registroServiziReader!=null && registroServiziReader.registroServizi!=null){
  211.                 registroServiziReader.registroServizi.disabilitaCache();
  212.             }
  213.         }catch(Exception e){
  214.             throw new DriverRegistroServiziException("Disabilitazione cache di accesso ai registri dei servizi non riuscita: "+e.getMessage(),e);
  215.         }
  216.     }  
  217.     public static String listKeysCache(String separator) throws DriverRegistroServiziException{
  218.         try{
  219.             RegistroServiziReader registroServiziReader = org.openspcoop2.protocol.registry.RegistroServiziReader.getInstance();
  220.             if(registroServiziReader!=null && registroServiziReader.registroServizi!=null){
  221.                 return registroServiziReader.registroServizi.listKeysCache(separator);
  222.             }
  223.             else{
  224.                 throw new Exception("RegistroServizi Non disponibile");
  225.             }
  226.         }catch(Exception e){
  227.             throw new DriverRegistroServiziException("Visualizzazione chiavi presenti nella cache del RegistroServizi non riuscita: "+e.getMessage(),e);
  228.         }
  229.     }
  230.     public static List<String> keysCache() throws DriverRegistroServiziException{
  231.         try{
  232.             RegistroServiziReader registroServiziReader = org.openspcoop2.protocol.registry.RegistroServiziReader.getInstance();
  233.             if(registroServiziReader!=null && registroServiziReader.registroServizi!=null){
  234.                 return registroServiziReader.registroServizi.keysCache();
  235.             }
  236.             else{
  237.                 throw new Exception("RegistroServizi Non disponibile");
  238.             }
  239.         }catch(Exception e){
  240.             throw new DriverRegistroServiziException("Visualizzazione chiavi presenti nella cache del RegistroServizi non riuscita: "+e.getMessage(),e);
  241.         }
  242.     }
  243.    
  244.     public static String getObjectCache(String key) throws DriverRegistroServiziException{
  245.         try{
  246.             RegistroServiziReader registroServiziReader = org.openspcoop2.protocol.registry.RegistroServiziReader.getInstance();
  247.             if(registroServiziReader!=null && registroServiziReader.registroServizi!=null){
  248.                 return registroServiziReader.registroServizi.getObjectCache(key);
  249.             }
  250.             else{
  251.                 throw new Exception("RegistroServizi Non disponibile");
  252.             }
  253.         }catch(Exception e){
  254.             throw new DriverRegistroServiziException("Visualizzazione oggetto presente nella cache del RegistroServizi non riuscita: "+e.getMessage(),e);
  255.         }
  256.     }
  257.    
  258.     public static Object getRawObjectCache(String key) throws DriverRegistroServiziException{
  259.         try{
  260.             RegistroServiziReader registroServiziReader = org.openspcoop2.protocol.registry.RegistroServiziReader.getInstance();
  261.             if(registroServiziReader!=null && registroServiziReader.registroServizi!=null){
  262.                 return registroServiziReader.registroServizi.getRawObjectCache(key);
  263.             }
  264.             else{
  265.                 throw new Exception("ConfigurazionePdD Non disponibile");
  266.             }
  267.         }catch(Exception e){
  268.             throw new DriverRegistroServiziException("Visualizzazione oggetto presente nella cache del RegistroServizi non riuscita: "+e.getMessage(),e);
  269.         }
  270.     }
  271.    
  272.     public static void removeObjectCache(String key) throws DriverRegistroServiziException{
  273.         try{
  274.             RegistroServiziReader registroServiziReader = org.openspcoop2.protocol.registry.RegistroServiziReader.getInstance();
  275.             if(registroServiziReader!=null && registroServiziReader.registroServizi!=null){
  276.                 registroServiziReader.registroServizi.removeObjectCache(key);
  277.             }
  278.             else{
  279.                 throw new Exception("RegistroServizi Non disponibile");
  280.             }
  281.         }catch(Exception e){
  282.             throw new DriverRegistroServiziException("Rimozione oggetto presente nella cache del RegistroServizi non riuscita: "+e.getMessage(),e);
  283.         }
  284.     }
  285.    
  286.    
  287.    
  288.    
  289.    
  290.    
  291.     /*----------------- CLEANER --------------------*/

  292.     public static void removeAccordoCooperazione(IDAccordoCooperazione idAccordo) throws Exception {
  293.         if(RegistroServiziReader.isCacheAbilitata()) {
  294.            
  295.             for (int i = 0; i < 3; i++) {
  296.                 Boolean readContenutiAllegati = null;
  297.                 if(i==1) {
  298.                     readContenutiAllegati = true;
  299.                 }
  300.                 else if(i==2) {
  301.                     readContenutiAllegati = false;
  302.                 }
  303.                 String keyIdAccordo = RegistroServizi._getKey_getAccordoCooperazione(IDAccordoCooperazioneFactory.getInstance(), idAccordo,readContenutiAllegati);
  304.                 RegistroServiziReader.removeObjectCache(keyIdAccordo);
  305.             }
  306.            
  307.             List<String> keyForClean = new ArrayList<>();
  308.             List<String> keys = RegistroServiziReader.keysCache();
  309.             if(keys!=null && !keys.isEmpty()) {
  310.                
  311.                 String prefixGetAllId = RegistroServizi._toKey_getAllIdAccordiCooperazione_method();
  312.                
  313.                 for (String key : keys) {
  314.                     if(key!=null) {
  315.                         if(key.startsWith(prefixGetAllId)) {
  316.                             Object oCode = RegistroServiziReader.getRawObjectCache(key);
  317.                             if(oCode!=null && oCode instanceof List<?>) {
  318.                                 List<?> l = (List<?>) oCode;
  319.                                 if(l!=null && !l.isEmpty()) {
  320.                                     for (Object object : l) {
  321.                                         if(object!=null && object instanceof IDAccordoCooperazione) {
  322.                                             IDAccordoCooperazione idCheck = (IDAccordoCooperazione) object;
  323.                                             if(idCheck.equals(idAccordo)) {
  324.                                                 keyForClean.add(key);
  325.                                                 break;
  326.                                             }
  327.                                         }
  328.                                     }
  329.                                 }
  330.                             }
  331.                         }
  332.                     }
  333.                 }
  334.             }
  335.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  336.                 for (String key : keyForClean) {
  337.                     removeObjectCache(key);
  338.                 }
  339.             }
  340.         }
  341.     }
  342.    
  343.     public static void removeApi(IDAccordo idAccordo) throws Exception {
  344.         if(RegistroServiziReader.isCacheAbilitata()) {
  345.            
  346.             for (int i = 0; i < 3; i++) {
  347.                 Boolean readContenutiAllegati = null;
  348.                 if(i==1) {
  349.                     readContenutiAllegati = true;
  350.                 }
  351.                 else if(i==2) {
  352.                     readContenutiAllegati = false;
  353.                 }
  354.                 Boolean readDatiRegistro = null;
  355.                 for (int j = 0; j < 3; j++) {
  356.                     if(i==1) {
  357.                         readDatiRegistro = true;
  358.                     }
  359.                     else if(i==2) {
  360.                         readDatiRegistro = false;
  361.                     }
  362.                     String keyIdAccordo = RegistroServizi._getKey_getAccordoServizioParteComune(IDAccordoFactory.getInstance(), idAccordo,readContenutiAllegati,readDatiRegistro);
  363.                     RegistroServiziReader.removeObjectCache(keyIdAccordo);
  364.                 }
  365.             }

  366.             List<IDServizio> serviziImplementati = null;
  367.             try {
  368.                 FiltroRicercaServizi filtro = new FiltroRicercaServizi();
  369.                 filtro.setIdAccordoServizioParteComune(idAccordo);
  370.                 serviziImplementati = RegistroServiziManager.getInstance().getAllIdServizi(filtro, null);
  371.             }catch(Throwable t) {
  372.                 // ignore
  373.             }
  374.            
  375.             List<String> keyForClean = new ArrayList<>();
  376.             List<String> keys = RegistroServiziReader.keysCache();
  377.             if(keys!=null && !keys.isEmpty()) {
  378.                
  379.                 String prefixServizioCorrelatoPrefix = RegistroServizi._toKey_getAccordoServizioParteSpecifica_ServizioCorrelato_prefix();
  380.                 String servizioCorrelato = RegistroServizi._toKey_getAccordoServizioParteSpecifica_ServizioCorrelato(IDAccordoFactory.getInstance(), idAccordo);
  381.                
  382.                 String prefixGetAllId = RegistroServizi._toKey_getAllIdAccordiServizioParteComune_method();
  383.                 String prefixGetAllId_portTypes = RegistroServizi._toKey_getAllIdPortType_method();
  384.                 String prefixGetAllId_azionePortType = RegistroServizi._toKey_getAllIdAzionePortType_method();
  385.                 String prefixGetAllId_azione = RegistroServizi._toKey_getAllIdAzione_method();
  386.                 String prefixGetAllId_resource = RegistroServizi._toKey_getAllIdResource_method();
  387.                
  388.                 String wsdlAccordoServizioPrefix = RegistroServizi._toKey_getWsdlAccordoServizioPrefix();
  389.                
  390.                 String restAccordoServizioPrefix = RegistroServizi._toKey_getRestAccordoServizioPrefix();
  391.                
  392.                 String documentoPrefix = RegistroServizi._toKey_prefixGetAllegatoAccordoServizioParteComune(idAccordo);
  393.                
  394.                 for (String key : keys) {
  395.                     if(key!=null) {
  396.                         if(key.startsWith(prefixServizioCorrelatoPrefix) && key.contains(servizioCorrelato)) {
  397.                             keyForClean.add(key);
  398.                         }
  399.                         else if(key.startsWith(prefixGetAllId)) {
  400.                             Object oCode = RegistroServiziReader.getRawObjectCache(key);
  401.                             if(oCode!=null && oCode instanceof List<?>) {
  402.                                 List<?> l = (List<?>) oCode;
  403.                                 if(l!=null && !l.isEmpty()) {
  404.                                     for (Object object : l) {
  405.                                         if(object!=null && object instanceof IDAccordo) {
  406.                                             IDAccordo idCheck = (IDAccordo) object;
  407.                                             if(idCheck.equals(idAccordo)) {
  408.                                                 keyForClean.add(key);
  409.                                                 break;
  410.                                             }
  411.                                         }
  412.                                     }
  413.                                 }
  414.                             }
  415.                         }
  416.                         else if(key.startsWith(prefixGetAllId_portTypes)) {
  417.                             Object oCode = RegistroServiziReader.getRawObjectCache(key);
  418.                             if(oCode!=null && oCode instanceof List<?>) {
  419.                                 List<?> l = (List<?>) oCode;
  420.                                 if(l!=null && !l.isEmpty()) {
  421.                                     for (Object object : l) {
  422.                                         if(object!=null && object instanceof IDPortType) {
  423.                                             IDPortType idCheck = (IDPortType) object;
  424.                                             if(idCheck.getIdAccordo().equals(idAccordo)) {
  425.                                                 keyForClean.add(key);
  426.                                                 break;
  427.                                             }
  428.                                         }
  429.                                     }
  430.                                 }
  431.                             }
  432.                         }
  433.                         else if(key.startsWith(prefixGetAllId_azionePortType)) {
  434.                             Object oCode = RegistroServiziReader.getRawObjectCache(key);
  435.                             if(oCode!=null && oCode instanceof List<?>) {
  436.                                 List<?> l = (List<?>) oCode;
  437.                                 if(l!=null && !l.isEmpty()) {
  438.                                     for (Object object : l) {
  439.                                         if(object!=null && object instanceof IDPortTypeAzione) {
  440.                                             IDPortTypeAzione idCheck = (IDPortTypeAzione) object;
  441.                                             if(idCheck.getIdPortType().getIdAccordo().equals(idAccordo)) {
  442.                                                 keyForClean.add(key);
  443.                                                 break;
  444.                                             }
  445.                                         }
  446.                                     }
  447.                                 }
  448.                             }
  449.                         }
  450.                         else if(key.startsWith(prefixGetAllId_azione)) {
  451.                             Object oCode = RegistroServiziReader.getRawObjectCache(key);
  452.                             if(oCode!=null && oCode instanceof List<?>) {
  453.                                 List<?> l = (List<?>) oCode;
  454.                                 if(l!=null && !l.isEmpty()) {
  455.                                     for (Object object : l) {
  456.                                         if(object!=null && object instanceof IDAccordoAzione) {
  457.                                             IDAccordoAzione idCheck = (IDAccordoAzione) object;
  458.                                             if(idCheck.getIdAccordo().equals(idAccordo)) {
  459.                                                 keyForClean.add(key);
  460.                                                 break;
  461.                                             }
  462.                                         }
  463.                                     }
  464.                                 }
  465.                             }
  466.                         }
  467.                         else if(key.startsWith(prefixGetAllId_resource)) {
  468.                             Object oCode = RegistroServiziReader.getRawObjectCache(key);
  469.                             if(oCode!=null && oCode instanceof List<?>) {
  470.                                 List<?> l = (List<?>) oCode;
  471.                                 if(l!=null && !l.isEmpty()) {
  472.                                     for (Object object : l) {
  473.                                         if(object!=null && object instanceof IDResource) {
  474.                                             IDResource idCheck = (IDResource) object;
  475.                                             if(idCheck.getIdAccordo().equals(idAccordo)) {
  476.                                                 keyForClean.add(key);
  477.                                                 break;
  478.                                             }
  479.                                         }
  480.                                     }
  481.                                 }
  482.                             }
  483.                         }
  484.                         else if(key.startsWith(wsdlAccordoServizioPrefix) && serviziImplementati!=null && !serviziImplementati.isEmpty()) {
  485.                             for (IDServizio idServizio : serviziImplementati) {
  486.                                 String wsdlAccordoServizioService = RegistroServizi._toKey_getWsdlAccordoServizioService(idServizio);
  487.                                 if(key.contains(wsdlAccordoServizioService)) {
  488.                                     keyForClean.add(key);
  489.                                 }
  490.                             }
  491.                         }
  492.                         else if(key.startsWith(restAccordoServizioPrefix)) {
  493.                             for (IDServizio idServizio : serviziImplementati) {
  494.                                 String restAccordoServizioService = RegistroServizi._toKey_getRestAccordoServizioService(idServizio);
  495.                                 if(key.contains(restAccordoServizioService)) {
  496.                                     keyForClean.add(key);
  497.                                 }
  498.                             }
  499.                         }
  500.                         else if(key.startsWith(documentoPrefix)) {
  501.                             keyForClean.add(key);
  502.                         }
  503.                     }
  504.                 }
  505.             }
  506.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  507.                 for (String key : keyForClean) {
  508.                     removeObjectCache(key);
  509.                 }
  510.             }
  511.            
  512.         }
  513.     }
  514.    
  515.     public static void removeErogazione(IDServizio idServizio) throws Exception {
  516.         removeApiImpl(null, idServizio, true);
  517.     }
  518.     public static void removeFruizione(IDSoggetto fruitore, IDServizio idServizio) throws Exception {
  519.         removeApiImpl(fruitore, idServizio, false);
  520.     }
  521.     private static void removeApiImpl(IDSoggetto idFruitore, IDServizio idServizio, boolean erogazione) throws Exception {
  522.         if(RegistroServiziReader.isCacheAbilitata()) {
  523.            
  524.             // non funziona, viene anche inserita l'azione nella chiave della cache
  525. //          for (int i = 0; i < 3; i++) {
  526. //              Boolean readContenutiAllegati = null;
  527. //              if(i==1) {
  528. //                  readContenutiAllegati = true;
  529. //              }
  530. //              else if(i==2) {
  531. //                  readContenutiAllegati = false;
  532. //              }
  533. //              String keyIdAccordo = RegistroServizi._getKey_getAccordoServizioParteSpecifica(idServizio,readContenutiAllegati);
  534. //              RegistroServiziReader.removeObjectCache(keyIdAccordo);
  535. //          }
  536.            
  537.             String keyServiceBinding = RegistroServizi._getKey_getServiceBinding(idServizio);
  538.             RegistroServiziReader.removeObjectCache(keyServiceBinding);
  539.            
  540.             List<String> keyForClean = new ArrayList<>();
  541.             List<String> keys = RegistroServiziReader.keysCache();
  542.             if(keys!=null && !keys.isEmpty()) {
  543.                
  544.                 String prefixAccordo = RegistroServizi._toKey_getAccordoServizioParteSpecificaPrefix(idServizio);
  545.                
  546.                 String prefixGetAllId = RegistroServizi._toKey_getAllIdServizi_method();
  547.                 String prefixGetAllIdFruizione = null;
  548.                 if(!erogazione) {
  549.                     prefixGetAllIdFruizione = RegistroServizi._toKey_getAllIdFruizioniServizio_method();
  550.                 }
  551.                
  552.                 String wsdlAccordoServizioPrefix = RegistroServizi._toKey_getWsdlAccordoServizioPrefix();
  553.                 String wsdlAccordoServizioService = RegistroServizi._toKey_getWsdlAccordoServizioService(idServizio);
  554.                
  555.                 String restAccordoServizioPrefix = RegistroServizi._toKey_getRestAccordoServizioPrefix();
  556.                 String restAccordoServizioService = RegistroServizi._toKey_getRestAccordoServizioService(idServizio);
  557.                
  558.                 String documentoPrefix = RegistroServizi._toKey_prefixGetAllegatoAccordoServizioParteSpecifica(idServizio);
  559.                
  560.                 for (String key : keys) {
  561.                     if(key!=null) {
  562.                         if(key.startsWith(prefixAccordo)) {
  563.                             keyForClean.add(key);
  564.                         }
  565.                         else if(key.startsWith(prefixGetAllId)) {
  566.                             Object oCode = RegistroServiziReader.getRawObjectCache(key);
  567.                             if(oCode!=null && oCode instanceof List<?>) {
  568.                                 List<?> l = (List<?>) oCode;
  569.                                 if(l!=null && !l.isEmpty()) {
  570.                                     for (Object object : l) {
  571.                                         if(object!=null && object instanceof IDServizio) {
  572.                                             IDServizio idCheck = (IDServizio) object;
  573.                                             if(idCheck.equals(idServizio, false)) {
  574.                                                 keyForClean.add(key);
  575.                                                 break;
  576.                                             }
  577.                                         }
  578.                                     }
  579.                                 }
  580.                             }
  581.                         }
  582.                         else if(!erogazione && key.startsWith(prefixGetAllIdFruizione)) {
  583.                             Object oCode = RegistroServiziReader.getRawObjectCache(key);
  584.                             if(oCode!=null && oCode instanceof List<?>) {
  585.                                 List<?> l = (List<?>) oCode;
  586.                                 if(l!=null && !l.isEmpty()) {
  587.                                     for (Object object : l) {
  588.                                         if(object!=null && object instanceof IDFruizione) {
  589.                                             IDFruizione idCheck = (IDFruizione) object;
  590.                                             if(idCheck.getIdFruitore().equals(idFruitore) && idCheck.getIdServizio().equals(idServizio, false)) {
  591.                                                 keyForClean.add(key);
  592.                                                 break;
  593.                                             }
  594.                                         }
  595.                                     }
  596.                                 }
  597.                             }
  598.                         }
  599.                         else if(key.startsWith(wsdlAccordoServizioPrefix) && key.contains(wsdlAccordoServizioService)) {
  600.                             keyForClean.add(key);
  601.                         }
  602.                         else if(key.startsWith(restAccordoServizioPrefix) && key.contains(restAccordoServizioService)) {
  603.                             keyForClean.add(key);
  604.                         }
  605.                         else if(key.startsWith(documentoPrefix)) {
  606.                             keyForClean.add(key);
  607.                         }
  608.                     }
  609.                 }
  610.             }
  611.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  612.                 for (String key : keyForClean) {
  613.                     removeObjectCache(key);
  614.                 }
  615.             }
  616.            
  617.         }
  618.     }
  619.    
  620.     public static void removePdd(String portaDominio) throws Exception {
  621.         if(RegistroServiziReader.isCacheAbilitata()) {
  622.            
  623.             String keyPdd = RegistroServizi._getKey_getPortaDominio(portaDominio);
  624.             RegistroServiziReader.removeObjectCache(keyPdd);
  625.            
  626.             List<String> keyForClean = new ArrayList<>();
  627.             List<String> keys = RegistroServiziReader.keysCache();
  628.             if(keys!=null && !keys.isEmpty()) {
  629.                
  630.                 String prefixGetAllId = RegistroServizi._toKey_getAllIdPorteDominio_method();
  631.                
  632.                 for (String key : keys) {
  633.                     if(key!=null) {
  634.                         if(key.startsWith(prefixGetAllId)) {
  635.                             Object oCode = RegistroServiziReader.getRawObjectCache(key);
  636.                             if(oCode!=null && oCode instanceof List<?>) {
  637.                                 List<?> l = (List<?>) oCode;
  638.                                 if(l!=null && !l.isEmpty()) {
  639.                                     for (Object object : l) {
  640.                                         if(object!=null && object instanceof String) {
  641.                                             String idCheck = (String) object;
  642.                                             if(idCheck.equals(portaDominio)) {
  643.                                                 keyForClean.add(key);
  644.                                                 break;
  645.                                             }
  646.                                         }
  647.                                     }
  648.                                 }
  649.                             }
  650.                         }
  651.                     }
  652.                 }
  653.             }
  654.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  655.                 for (String key : keyForClean) {
  656.                     removeObjectCache(key);
  657.                 }
  658.             }
  659.            
  660.         }
  661.     }
  662.     public static void removeSoggetto(IDSoggetto idSoggetto) throws Exception {
  663.         if(RegistroServiziReader.isCacheAbilitata()) {
  664.            
  665.             String keySoggetto = RegistroServizi._getKey_getSoggetto(idSoggetto);
  666.             RegistroServiziReader.removeObjectCache(keySoggetto);
  667.            
  668.             List<String> keyForClean = new ArrayList<>();
  669.             List<String> keys = RegistroServiziReader.keysCache();
  670.             if(keys!=null && !keys.isEmpty()) {
  671.                
  672.                 String prefixCredenzialiBasic = RegistroServizi._toKey_getSoggettoByCredenzialiBasicPrefix();
  673.                 String prefixCredenzialiApiKey = RegistroServizi._toKey_getSoggettoByCredenzialiApiKeyPrefix(false);
  674.                 String prefixCredenzialiApiKeyAppId = RegistroServizi._toKey_getSoggettoByCredenzialiApiKeyPrefix(true);
  675.                 String prefixCredenzialiSsl = RegistroServizi._toKey_getSoggettoByCredenzialiSslPrefix(true);
  676.                 String prefixCredenzialiSslCert = RegistroServizi._toKey_getSoggettoByCredenzialiSslCertPrefix(true);
  677.                 String prefixCredenzialiPrincipal = RegistroServizi._toKey_getSoggettoByCredenzialiPrincipalPrefix();
  678.                
  679.                 String prefixGetAllId = RegistroServizi._toKey_getAllIdSoggetti_method();
  680.                
  681.                 for (String key : keys) {
  682.                     if(key!=null) {
  683.                         if(key.startsWith(prefixCredenzialiBasic) ||
  684.                                 key.startsWith(prefixCredenzialiApiKey) ||
  685.                                 key.startsWith(prefixCredenzialiApiKeyAppId) ||
  686.                                 key.startsWith(prefixCredenzialiSsl) ||
  687.                                 key.startsWith(prefixCredenzialiSslCert) ||
  688.                                 key.startsWith(prefixCredenzialiPrincipal)) {
  689.                            
  690.                             Object o = RegistroServiziReader.getRawObjectCache(key);
  691.                             if(o!=null && o instanceof Soggetto) {
  692.                                 Soggetto soggetto = (Soggetto) o;
  693.                                 if(soggetto.getTipo().equals(idSoggetto.getTipo()) &&
  694.                                         soggetto.getNome().equals(idSoggetto.getNome())) {
  695.                                     keyForClean.add(key);
  696.                                 }
  697.                             }
  698.                            
  699.                         }
  700.                         else if(key.startsWith(prefixGetAllId)) {
  701.                             Object oCode = RegistroServiziReader.getRawObjectCache(key);
  702.                             if(oCode!=null && oCode instanceof List<?>) {
  703.                                 List<?> l = (List<?>) oCode;
  704.                                 if(l!=null && !l.isEmpty()) {
  705.                                     for (Object object : l) {
  706.                                         if(object!=null && object instanceof IDSoggetto) {
  707.                                             IDSoggetto idCheck = (IDSoggetto) object;
  708.                                             if(idCheck.equals(idSoggetto)) {
  709.                                                 keyForClean.add(key);
  710.                                                 break;
  711.                                             }
  712.                                         }
  713.                                     }
  714.                                 }
  715.                             }
  716.                         }
  717.                     }
  718.                 }
  719.             }
  720.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  721.                 for (String key : keyForClean) {
  722.                     removeObjectCache(key);
  723.                 }
  724.             }
  725.         }
  726.     }
  727.    
  728.     public static void removeGruppo(IDGruppo idGruppo) throws Exception {
  729.         if(RegistroServiziReader.isCacheAbilitata()) {
  730.            
  731.             String keyGruppo = RegistroServizi._getKey_getGruppo(idGruppo.getNome());
  732.             RegistroServiziReader.removeObjectCache(keyGruppo);
  733.            
  734.             List<String> keyForClean = new ArrayList<>();
  735.             List<String> keys = RegistroServiziReader.keysCache();
  736.             if(keys!=null && !keys.isEmpty()) {
  737.                
  738.                 String prefixGetAllId = RegistroServizi._toKey_getAllIdGruppi_method();
  739.                
  740.                 for (String key : keys) {
  741.                     if(key!=null &&
  742.                         key.startsWith(prefixGetAllId)) {
  743.                         Object oCode = RegistroServiziReader.getRawObjectCache(key);
  744.                         if(oCode instanceof List<?>) {
  745.                             List<?> l = (List<?>) oCode;
  746.                             if(l!=null && !l.isEmpty()) {
  747.                                 for (Object object : l) {
  748.                                     if(object instanceof IDGruppo) {
  749.                                         IDGruppo idCheck = (IDGruppo) object;
  750.                                         if(idCheck.equals(idGruppo)) {
  751.                                             keyForClean.add(key);
  752.                                             break;
  753.                                         }
  754.                                     }
  755.                                 }
  756.                             }
  757.                         }
  758.                     }
  759.                 }
  760.             }
  761.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  762.                 for (String key : keyForClean) {
  763.                     removeObjectCache(key);
  764.                 }
  765.             }
  766.         }
  767.     }
  768.    
  769.     public static void removeRuolo(IDRuolo idRuolo) throws Exception {
  770.         if(RegistroServiziReader.isCacheAbilitata()) {
  771.            
  772.             String keyRuolo = RegistroServizi._getKey_getRuolo(idRuolo.getNome());
  773.             RegistroServiziReader.removeObjectCache(keyRuolo);
  774.            
  775.             List<String> keyForClean = new ArrayList<>();
  776.             List<String> keys = RegistroServiziReader.keysCache();
  777.             if(keys!=null && !keys.isEmpty()) {
  778.                
  779.                 String prefixGetAllId = RegistroServizi._toKey_getAllIdRuoli_method();
  780.                
  781.                 for (String key : keys) {
  782.                     if(key!=null) {
  783.                         if(key.startsWith(prefixGetAllId)) {
  784.                             Object oCode = RegistroServiziReader.getRawObjectCache(key);
  785.                             if(oCode!=null && oCode instanceof List<?>) {
  786.                                 List<?> l = (List<?>) oCode;
  787.                                 if(l!=null && !l.isEmpty()) {
  788.                                     for (Object object : l) {
  789.                                         if(object!=null && object instanceof IDRuolo) {
  790.                                             IDRuolo idCheck = (IDRuolo) object;
  791.                                             if(idCheck.equals(idRuolo)) {
  792.                                                 keyForClean.add(key);
  793.                                                 break;
  794.                                             }
  795.                                         }
  796.                                     }
  797.                                 }
  798.                             }
  799.                         }
  800.                     }
  801.                 }
  802.             }
  803.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  804.                 for (String key : keyForClean) {
  805.                     removeObjectCache(key);
  806.                 }
  807.             }
  808.         }
  809.     }
  810.    
  811.     public static void removeScope(IDScope idScope) throws Exception {
  812.         if(RegistroServiziReader.isCacheAbilitata()) {
  813.            
  814.             String keyScope = RegistroServizi._getKey_getScope(idScope.getNome());
  815.             RegistroServiziReader.removeObjectCache(keyScope);
  816.            
  817.             List<String> keyForClean = new ArrayList<>();
  818.             List<String> keys = RegistroServiziReader.keysCache();
  819.             if(keys!=null && !keys.isEmpty()) {
  820.                
  821.                 String prefixGetAllId = RegistroServizi._toKey_getAllIdScope_method();
  822.                
  823.                 for (String key : keys) {
  824.                     if(key!=null) {
  825.                         if(key.startsWith(prefixGetAllId)) {
  826.                             Object oCode = RegistroServiziReader.getRawObjectCache(key);
  827.                             if(oCode!=null && oCode instanceof List<?>) {
  828.                                 List<?> l = (List<?>) oCode;
  829.                                 if(l!=null && !l.isEmpty()) {
  830.                                     for (Object object : l) {
  831.                                         if(object!=null && object instanceof IDScope) {
  832.                                             IDScope idCheck = (IDScope) object;
  833.                                             if(idCheck.equals(idScope)) {
  834.                                                 keyForClean.add(key);
  835.                                                 break;
  836.                                             }
  837.                                         }
  838.                                     }
  839.                                 }
  840.                             }
  841.                         }
  842.                     }
  843.                 }
  844.             }
  845.             if(keyForClean!=null && !keyForClean.isEmpty()) {
  846.                 for (String key : keyForClean) {
  847.                     removeObjectCache(key);
  848.                 }
  849.             }
  850.         }
  851.     }
  852.    
  853.    
  854.    
  855.    
  856.    


  857.     /*   -------------- Metodi di inizializzazione -----------------  */

  858.     /**
  859.      * Si occupa di inizializzare l'engine che permette di effettuare
  860.      * query al registro dei servizi.
  861.      * L'engine inizializzato sara' diverso a seconda del <var>tipo</var> di registro :
  862.      * <ul>
  863.      * <li> {@link org.openspcoop2.core.registry.driver.uddi.DriverRegistroServiziUDDI}, interroga un registro dei servizi UDDI.
  864.      * <li> {@link org.openspcoop2.core.registry.driver.xml.DriverRegistroServiziXML}, interroga un registro dei servizi realizzato tramite un file xml.
  865.      * <li> {@link org.openspcoop2.core.registry.driver.web.DriverRegistroServiziWEB}, interroga un registro dei servizi realizzato come un WEB Server.
  866.      * <li> {@link org.openspcoop2.core.registry.driver.db.DriverRegistroServiziDB}, interroga un registro dei servizi realizzato come un Database relazionale.
  867.      * </ul>
  868.      *
  869.      * @param accessoRegistro Informazioni per accedere al registro Servizi.
  870.      * @return true se l'inizializzazione ha successo, false altrimenti.
  871.      */
  872.     public static boolean initialize(AccessoRegistro accessoRegistro,Logger aLog,Logger aLogconsole,
  873.             boolean raggiungibilitaTotale, boolean readObjectStatoBozza,
  874.             String jndiNameDatasourcePdD, boolean useOp2UtilsDatasource, boolean bindJMX,
  875.             boolean prefillCache, CryptConfig cryptConfigSoggetti,
  876.             CacheType cacheType, IDriverBYOK driverBYOK){

  877.         try {
  878.             RegistroServiziReader.registroServiziReader =
  879.                 new RegistroServiziReader(accessoRegistro,aLog,aLogconsole,raggiungibilitaTotale,readObjectStatoBozza,
  880.                         jndiNameDatasourcePdD,useOp2UtilsDatasource,bindJMX,
  881.                         prefillCache, cryptConfigSoggetti,
  882.                         cacheType, driverBYOK);
  883.             return RegistroServiziReader.initialize;
  884.         }
  885.         catch(Exception e) {
  886.             return false;
  887.         }
  888.     }

  889.     /**
  890.      * Ritorna lo stato dell'engine che permette di effettuare
  891.      * query al registro dei servizi.
  892.      *
  893.      * @return true se l'inizializzazione all'engine e' stata precedentemente effettuata, false altrimenti.
  894.      */
  895.     public static boolean isInitialize(){
  896.         return RegistroServiziReader.initialize;
  897.     }

  898.     /**
  899.      * Ritorna l'istanza di questa classe
  900.      *
  901.      * @return Istanza del Reader del Registro
  902.      */
  903.     public static RegistroServiziReader getInstance(){
  904.         return RegistroServiziReader.registroServiziReader;
  905.     }

  906.     public static java.util.Map<String, IDriverRegistroServiziGet> getDriverRegistroServizi() {
  907.         return RegistroServiziReader.registroServiziReader.registroServizi.getDriverRegistroServizi();
  908.     }










  909.     /*   -------------- Costruttore -----------------  */

  910.     /**
  911.      * Inizializza il reader
  912.      *
  913.      * @param accessoRegistro Informazioni per accedere al registro Servizi.
  914.      */
  915.     public RegistroServiziReader(AccessoRegistro accessoRegistro,Logger aLog,
  916.             Logger aLogconsole,boolean raggiungibilitaTotale, boolean readObjectStatoBozza,
  917.             String jndiNameDatasourcePdD, boolean useOp2UtilsDatasource, boolean bindJMX,
  918.             boolean prefillCache, CryptConfig cryptConfigSoggetti,
  919.             CacheType cacheType, IDriverBYOK driverBYOK)throws DriverRegistroServiziException{
  920.         try{
  921.             if(aLog!=null)
  922.                 this.log = aLog;
  923.             else
  924.                 this.log = LoggerWrapperFactory.getLogger(RegistroServiziReader.class);
  925.             this.registroServizi = new RegistroServizi(accessoRegistro,this.log,aLogconsole,raggiungibilitaTotale,readObjectStatoBozza,
  926.                     jndiNameDatasourcePdD, useOp2UtilsDatasource, bindJMX,
  927.                     prefillCache, cryptConfigSoggetti,
  928.                     cacheType, driverBYOK);
  929.             RegistroServiziReader.initialize = true;
  930.         }catch(Exception e){
  931.             RegistroServiziReader.initialize = false;
  932.         }
  933.     }






  934.     /**
  935.      * Metodo che verica la connessione ad una risorsa.
  936.      * Se la connessione non e' presente, viene lanciata una eccezione che contiene il motivo della mancata connessione
  937.      *
  938.      * @throws CoreException eccezione che contiene il motivo della mancata connessione
  939.      */
  940.     protected void isAlive(boolean controlloTotale) throws CoreException{
  941.         if(controlloTotale){
  942.             for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  943.                 try{
  944.                     IMonitoraggioRisorsa monitorDriver = (IMonitoraggioRisorsa) this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  945.                     monitorDriver.isAlive();
  946.                 }catch(Exception e){
  947.                     throw new CoreException("[Registro "+nomeRegInLista+"] "+e.getMessage(),e);
  948.                 }
  949.             }
  950.         }else{
  951.             boolean registroRaggiungibile = false;
  952.             StringBuilder eccezioni = new StringBuilder();
  953.             for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  954.                 try{
  955.                     IMonitoraggioRisorsa monitorDriver = (IMonitoraggioRisorsa) this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  956.                     monitorDriver.isAlive();
  957.                     registroRaggiungibile = true;
  958.                     break;
  959.                 }catch(Exception e){
  960.                     this.log.debug("Registro non accessibile [Registro "+nomeRegInLista+"]",e);
  961.                     eccezioni.append("\n[Registro "+nomeRegInLista+"] "+e.getMessage());
  962.                 }
  963.             }
  964.             if(registroRaggiungibile == false){
  965.                 throw new CoreException(eccezioni.toString());
  966.             }
  967.         }
  968.     }
  969.    
  970.    
  971.     /**
  972.      * Validazione semantica dei registri servizi
  973.      *
  974.      * @throws CoreException eccezione che contiene il motivo della validazione semantica errata
  975.      */
  976.     protected void validazioneSemantica(boolean controlloTotale,boolean verificaURI,
  977.             String[] tipiSoggettiValidi,String [] tipiServiziSoapValidi, String [] tipiServiziRestValidi, String[] tipiConnettoriValidi,
  978.             boolean validazioneSemanticaAbilitataXML,boolean validazioneSemanticaAbilitataAltriRegistri,
  979.             Logger logConsole) throws CoreException{
  980.         if(controlloTotale){
  981.             for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  982.                 try{
  983.                     Object o = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  984.                     boolean validazione = false;
  985.                     if(o instanceof DriverRegistroServiziXML){
  986.                         validazione = validazioneSemanticaAbilitataXML;
  987.                     }else{
  988.                         validazione = validazioneSemanticaAbilitataAltriRegistri;
  989.                     }
  990.                     if(validazione){
  991.                         BeanUtilities driverRegistro = (BeanUtilities) o;
  992.                         org.openspcoop2.core.registry.RegistroServizi registroServizi = driverRegistro.getImmagineCompletaRegistroServizi();
  993.                         ValidazioneSemantica validazioneSemantica = new ValidazioneSemantica(registroServizi,verificaURI,
  994.                                 tipiConnettoriValidi,tipiSoggettiValidi,tipiServiziSoapValidi,tipiServiziRestValidi);
  995.                         validazioneSemantica.validazioneSemantica(false);
  996.                         if(logConsole!=null){
  997.                             logConsole.info("Validazione semantica del registro dei servizi ["+nomeRegInLista+"] effettuata.");
  998.                         }
  999.                     }
  1000.                 }catch(Exception e){
  1001.                     throw new CoreException("[Registro "+nomeRegInLista+"] "+e.getMessage(),e);
  1002.                 }
  1003.             }
  1004.         }else{
  1005.             boolean registroRaggiungibile = false;
  1006.             StringBuilder eccezioni = new StringBuilder();
  1007.             for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1008.                 try{
  1009.                     Object o = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1010.                     boolean validazione = false;
  1011.                     if(o instanceof DriverRegistroServiziXML){
  1012.                         validazione = validazioneSemanticaAbilitataXML;
  1013.                     }else{
  1014.                         validazione = validazioneSemanticaAbilitataAltriRegistri;
  1015.                     }
  1016.                     if(validazione){
  1017.                         BeanUtilities driverRegistro = (BeanUtilities) o;
  1018.                         org.openspcoop2.core.registry.RegistroServizi registroServizi = driverRegistro.getImmagineCompletaRegistroServizi();
  1019.                         ValidazioneSemantica validazioneSemantica = new ValidazioneSemantica(registroServizi,verificaURI,
  1020.                                 tipiConnettoriValidi,tipiSoggettiValidi,tipiServiziSoapValidi,tipiServiziRestValidi);
  1021.                         validazioneSemantica.validazioneSemantica(false);
  1022.                         if(logConsole!=null){
  1023.                             logConsole.info("Validazione semantica del registro dei servizi ["+nomeRegInLista+"] effettuata.");
  1024.                         }
  1025.                         registroRaggiungibile = true;
  1026.                         break;
  1027.                     }
  1028.                 }catch(Exception e){
  1029.                     this.log.debug("Registro non accessibile [Registro "+nomeRegInLista+"]",e);
  1030.                     eccezioni.append("\n[Registro "+nomeRegInLista+"] "+e.getMessage());
  1031.                 }
  1032.             }
  1033.             if(registroRaggiungibile == false){
  1034.                 throw new CoreException(eccezioni.toString());
  1035.             }
  1036.         }
  1037.     }
  1038.    
  1039.    
  1040.    
  1041.     protected void setValidazioneSemanticaModificaRegistroServiziXML(boolean verificaURI,
  1042.             String[] tipiSoggettiValidi,String [] tipiServiziSoapValidi, String [] tipiServiziRestValidi, String[] tipiConnettoriValidi) throws CoreException{
  1043.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1044.             try{
  1045.                 Object o = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1046.                 if(o instanceof DriverRegistroServiziXML){
  1047.                     DriverRegistroServiziXML driver = (DriverRegistroServiziXML) o;
  1048.                     driver.abilitazioneValidazioneSemanticaDuranteModificaXML(verificaURI,
  1049.                             tipiConnettoriValidi,tipiSoggettiValidi,tipiServiziSoapValidi,tipiServiziRestValidi);
  1050.                 }
  1051.             }catch(Exception e){
  1052.                 throw new CoreException("[Registro "+nomeRegInLista+"] "+e.getMessage(),e);
  1053.             }
  1054.         }
  1055.     }
  1056.    
  1057.    
  1058.     protected void verificaConsistenzaRegistroServizi() throws DriverRegistroServiziException {
  1059.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1060.             Object o = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1061.             if(o instanceof DriverRegistroServiziXML){
  1062.                 DriverRegistroServiziXML driver = (DriverRegistroServiziXML) o;
  1063.                 driver.refreshRegistroServiziXML();
  1064.             }  
  1065.         }
  1066.     }
  1067.    
  1068.    
  1069.    
  1070.     /* ********  G E T   O G G E T T I   PRIMITIVI   NO CACHE ******** */
  1071.    
  1072.     public PortaDominio getPortaDominio_noCache(String nome,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1073.         PortaDominio r = null;
  1074.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1075.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1076.                 continue;
  1077.             }
  1078.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1079.             try{
  1080.                 r = driver.getPortaDominio(nome);
  1081.             }catch(DriverRegistroServiziNotFound notFound){
  1082.                 // ignore
  1083.             }
  1084.             if(r!=null || nomeRegistro!=null){
  1085.                 break;
  1086.             }
  1087.         }
  1088.         if(r==null){
  1089.             throw new DriverRegistroServiziNotFound();
  1090.         }
  1091.         return r;
  1092.     }
  1093.    
  1094.     public Ruolo getRuolo_noCache(String nome,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1095.         Ruolo r = null;
  1096.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1097.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1098.                 continue;
  1099.             }
  1100.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1101.             try{
  1102.                 IDRuolo idRuolo = new IDRuolo(nome);
  1103.                 r = driver.getRuolo(idRuolo);
  1104.             }catch(DriverRegistroServiziNotFound notFound){
  1105.                 // ignore
  1106.             }
  1107.             if(r!=null || nomeRegistro!=null){
  1108.                 break;
  1109.             }
  1110.         }
  1111.         if(r==null){
  1112.             throw new DriverRegistroServiziNotFound();
  1113.         }
  1114.         return r;
  1115.     }
  1116.    
  1117.     public Soggetto getSoggetto_noCache(IDSoggetto idSoggetto,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1118.         Soggetto r = null;
  1119.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1120.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1121.                 continue;
  1122.             }
  1123.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1124.             try{
  1125.                 r = driver.getSoggetto(idSoggetto);
  1126.             }catch(DriverRegistroServiziNotFound notFound){
  1127.                 // ignore
  1128.             }
  1129.             if(r!=null || nomeRegistro!=null){
  1130.                 break;
  1131.             }
  1132.         }
  1133.         if(r==null){
  1134.             throw new DriverRegistroServiziNotFound();
  1135.         }
  1136.         return r;
  1137.     }
  1138.    
  1139.     public AccordoServizioParteComune getAccordoServizioParteComune_noCache(IDAccordo idAccordo,String nomeRegistro,Boolean readContenutiAllegati, Boolean readDatiRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1140.         AccordoServizioParteComune r = null;
  1141.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1142.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1143.                 continue;
  1144.             }
  1145.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1146.             try{
  1147.                 if(driver instanceof DriverRegistroServiziDB){
  1148.                     r = ((DriverRegistroServiziDB)driver).getAccordoServizioParteComune(idAccordo,readContenutiAllegati,readDatiRegistro);
  1149.                 }
  1150.                 else{
  1151.                     r = driver.getAccordoServizioParteComune(idAccordo);
  1152.                 }
  1153.             }catch(DriverRegistroServiziNotFound notFound){
  1154.                 // ignore
  1155.             }
  1156.             if(r!=null || nomeRegistro!=null){
  1157.                 break;
  1158.             }
  1159.         }
  1160.         if(r==null){
  1161.             throw new DriverRegistroServiziNotFound();
  1162.         }
  1163.         return r;
  1164.     }
  1165.    
  1166.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica_noCache(IDServizio idServizio,String nomeRegistro,Boolean readContenutiAllegati) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1167.         AccordoServizioParteSpecifica r = null;
  1168.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1169.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1170.                 continue;
  1171.             }
  1172.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1173.             try{
  1174.                 if(driver instanceof DriverRegistroServiziDB){
  1175.                     r = ((DriverRegistroServiziDB)driver).getAccordoServizioParteSpecifica(idServizio,readContenutiAllegati);
  1176.                 }
  1177.                 else{
  1178.                     r = driver.getAccordoServizioParteSpecifica(idServizio);
  1179.                 }
  1180.             }catch(DriverRegistroServiziNotFound notFound){
  1181.                 // ignore
  1182.             }
  1183.             if(r!=null || nomeRegistro!=null){
  1184.                 break;
  1185.             }
  1186.         }
  1187.         if(r==null){
  1188.             throw new DriverRegistroServiziNotFound();
  1189.         }
  1190.         return r;
  1191.     }
  1192.    
  1193.     public AccordoCooperazione getAccordoCooperazione_noCache(IDAccordoCooperazione idAccordo,String nomeRegistro,Boolean readContenutiAllegati) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1194.         AccordoCooperazione r = null;
  1195.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1196.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1197.                 continue;
  1198.             }
  1199.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1200.             try{
  1201.                 if(driver instanceof DriverRegistroServiziDB){
  1202.                     r = ((DriverRegistroServiziDB)driver).getAccordoCooperazione(idAccordo,readContenutiAllegati);
  1203.                 }
  1204.                 else{
  1205.                     r = driver.getAccordoCooperazione(idAccordo);
  1206.                 }
  1207.             }catch(DriverRegistroServiziNotFound notFound){
  1208.                 // ignore
  1209.             }
  1210.             if(r!=null || nomeRegistro!=null){
  1211.                 break;
  1212.             }
  1213.         }
  1214.         if(r==null){
  1215.             throw new DriverRegistroServiziNotFound();
  1216.         }
  1217.         return r;
  1218.     }
  1219.    
  1220.    
  1221.     /* ********  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  NO CACHE  ******** */
  1222.    
  1223.     public List<String> getAllIdPorteDominio_noCache(FiltroRicerca filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1224.         List<String> r = null;
  1225.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1226.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1227.                 continue;
  1228.             }
  1229.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1230.             try{
  1231.                 r = driver.getAllIdPorteDominio(filtroRicerca);
  1232.             }catch(DriverRegistroServiziNotFound notFound){
  1233.                 // ignore
  1234.             }
  1235.             if(r!=null || nomeRegistro!=null){
  1236.                 break;
  1237.             }
  1238.         }
  1239.         if(r==null){
  1240.             throw new DriverRegistroServiziNotFound();
  1241.         }
  1242.         return r;
  1243.     }
  1244.    
  1245.     public List<IDRuolo> getAllIdRuoli_noCache(FiltroRicercaRuoli filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1246.         List<IDRuolo> r = null;
  1247.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1248.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1249.                 continue;
  1250.             }
  1251.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1252.             try{
  1253.                 r = driver.getAllIdRuoli(filtroRicerca);
  1254.             }catch(DriverRegistroServiziNotFound notFound){
  1255.                 // ignore
  1256.             }
  1257.             if(r!=null || nomeRegistro!=null){
  1258.                 break;
  1259.             }
  1260.         }
  1261.         if(r==null){
  1262.             throw new DriverRegistroServiziNotFound();
  1263.         }
  1264.         return r;
  1265.     }
  1266.    
  1267.     public List<IDSoggetto> getAllIdSoggetti_noCache(FiltroRicercaSoggetti filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1268.         List<IDSoggetto> r = null;
  1269.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1270.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1271.                 continue;
  1272.             }
  1273.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1274.             try{
  1275.                 r = driver.getAllIdSoggetti(filtroRicerca);
  1276.             }catch(DriverRegistroServiziNotFound notFound){
  1277.                 // ignore
  1278.             }
  1279.             if(r!=null || nomeRegistro!=null){
  1280.                 break;
  1281.             }
  1282.         }
  1283.         if(r==null){
  1284.             throw new DriverRegistroServiziNotFound();
  1285.         }
  1286.         return r;
  1287.     }
  1288.    
  1289.     public List<IDAccordoCooperazione> getAllIdAccordiCooperazione_noCache(FiltroRicercaAccordi filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1290.         List<IDAccordoCooperazione> r = null;
  1291.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1292.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1293.                 continue;
  1294.             }
  1295.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1296.             try{
  1297.                 r = driver.getAllIdAccordiCooperazione(filtroRicerca);
  1298.             }catch(DriverRegistroServiziNotFound notFound){
  1299.                 // ignore
  1300.             }
  1301.             if(r!=null || nomeRegistro!=null){
  1302.                 break;
  1303.             }
  1304.         }
  1305.         if(r==null){
  1306.             throw new DriverRegistroServiziNotFound();
  1307.         }
  1308.         return r;
  1309.     }
  1310.    
  1311.     public List<IDAccordo> getAllIdAccordiServizioParteComune_noCache(FiltroRicercaAccordi filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1312.         List<IDAccordo> r = null;
  1313.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1314.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1315.                 continue;
  1316.             }
  1317.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1318.             try{
  1319.                 r = driver.getAllIdAccordiServizioParteComune(filtroRicerca);
  1320.             }catch(DriverRegistroServiziNotFound notFound){
  1321.                 // ignore
  1322.             }
  1323.             if(r!=null || nomeRegistro!=null){
  1324.                 break;
  1325.             }
  1326.         }
  1327.         if(r==null){
  1328.             throw new DriverRegistroServiziNotFound();
  1329.         }
  1330.         return r;
  1331.     }
  1332.    
  1333.     public List<IDPortType> getAllIdPortType_noCache(FiltroRicercaPortTypes filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1334.         List<IDPortType> r = null;
  1335.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1336.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1337.                 continue;
  1338.             }
  1339.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1340.             try{
  1341.                 r = driver.getAllIdPortType(filtroRicerca);
  1342.             }catch(DriverRegistroServiziNotFound notFound){
  1343.                 // ignore
  1344.             }
  1345.             if(r!=null || nomeRegistro!=null){
  1346.                 break;
  1347.             }
  1348.         }
  1349.         if(r==null){
  1350.             throw new DriverRegistroServiziNotFound();
  1351.         }
  1352.         return r;
  1353.     }
  1354.    
  1355.     public List<IDPortTypeAzione> getAllIdAzionePortType_noCache(FiltroRicercaOperations filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1356.         List<IDPortTypeAzione> r = null;
  1357.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1358.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1359.                 continue;
  1360.             }
  1361.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1362.             try{
  1363.                 r = driver.getAllIdAzionePortType(filtroRicerca);
  1364.             }catch(DriverRegistroServiziNotFound notFound){
  1365.                 // ignore
  1366.             }
  1367.             if(r!=null || nomeRegistro!=null){
  1368.                 break;
  1369.             }
  1370.         }
  1371.         if(r==null){
  1372.             throw new DriverRegistroServiziNotFound();
  1373.         }
  1374.         return r;
  1375.     }
  1376.    
  1377.     public List<IDAccordoAzione> getAllIdAzioneAccordo_noCache(FiltroRicercaAzioni filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1378.         List<IDAccordoAzione> r = null;
  1379.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1380.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1381.                 continue;
  1382.             }
  1383.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1384.             try{
  1385.                 r = driver.getAllIdAzioneAccordo(filtroRicerca);
  1386.             }catch(DriverRegistroServiziNotFound notFound){
  1387.                 // ignore
  1388.             }
  1389.             if(r!=null || nomeRegistro!=null){
  1390.                 break;
  1391.             }
  1392.         }
  1393.         if(r==null){
  1394.             throw new DriverRegistroServiziNotFound();
  1395.         }
  1396.         return r;
  1397.     }
  1398.    
  1399.     public List<IDServizio> getAllIdServizi_noCache(FiltroRicercaServizi filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1400.         List<IDServizio> r = null;
  1401.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1402.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1403.                 continue;
  1404.             }
  1405.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1406.             try{
  1407.                 r = driver.getAllIdServizi(filtroRicerca);
  1408.             }catch(DriverRegistroServiziNotFound notFound){
  1409.                 // ignore
  1410.             }
  1411.             if(r!=null || nomeRegistro!=null){
  1412.                 break;
  1413.             }
  1414.         }
  1415.         if(r==null){
  1416.             throw new DriverRegistroServiziNotFound();
  1417.         }
  1418.         return r;
  1419.     }
  1420.    
  1421.     public List<IDFruizione> getAllIdFruizioniServizio_noCache(FiltroRicercaFruizioniServizio filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1422.         List<IDFruizione> r = null;
  1423.         for (String nomeRegInLista : this.registroServizi.getDriverRegistroServizi().keySet()) {
  1424.             if(nomeRegistro!=null && !nomeRegistro.equals(nomeRegInLista)){
  1425.                 continue;
  1426.             }
  1427.             IDriverRegistroServiziGet driver = this.registroServizi.getDriverRegistroServizi().get(nomeRegInLista);
  1428.             try{
  1429.                 r = driver.getAllIdFruizioniServizio(filtroRicerca);
  1430.             }catch(DriverRegistroServiziNotFound notFound){
  1431.                 // ignore
  1432.             }
  1433.             if(r!=null || nomeRegistro!=null){
  1434.                 break;
  1435.             }
  1436.         }
  1437.         if(r==null){
  1438.             throw new DriverRegistroServiziNotFound();
  1439.         }
  1440.         return r;
  1441.     }
  1442.    
  1443.    
  1444.    
  1445.    
  1446.    
  1447.    
  1448.    
  1449.    
  1450.    
  1451.    
  1452.     /* ********  P R O F I L O   D I   G E S T I O N E  ******** */
  1453.    
  1454.     protected String getProfiloGestioneFruizioneServizio(Connection connectionPdD,IDServizio idServizio,String nomeRegistro, RequestInfo requestInfo)
  1455.         throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1456.        
  1457.         String profilo = null;
  1458.        
  1459.         // ricerca servizio richiesto
  1460.         org.openspcoop2.core.registry.AccordoServizioParteSpecifica servizio = null;
  1461.         try{
  1462.             servizio = this.registroServizi.getAccordoServizioParteSpecifica(connectionPdD,nomeRegistro,idServizio);
  1463.         }catch(DriverRegistroServiziNotFound e){
  1464.             // ignore
  1465.         }
  1466.         if(servizio != null){
  1467.             // Profilo di gestione
  1468.             profilo = servizio.getVersioneProtocollo();
  1469.         }
  1470.         if(profilo == null){
  1471.             // vedo se il soggetto erogatore ha un profilo
  1472.             Soggetto soggettoErogatore = RegistroServiziManager._getSoggettoFromRequestInfo(idServizio.getSoggettoErogatore(), requestInfo);
  1473.             if (soggettoErogatore == null){
  1474.                 soggettoErogatore =  this.registroServizi.getSoggetto(connectionPdD,nomeRegistro, idServizio.getSoggettoErogatore());
  1475.             }
  1476.             if (soggettoErogatore == null){
  1477.                 throw new DriverRegistroServiziNotFound("getProfiloGestioneFruizioneServizio, soggettoErogatore ["+idServizio.getSoggettoErogatore()+"] non definito (o non registrato)");
  1478.             }
  1479.             profilo = soggettoErogatore.getVersioneProtocollo();
  1480.         }
  1481.         return profilo;
  1482.     }
  1483.    
  1484.     protected String getProfiloGestioneErogazioneServizio(Connection connectionPdD,IDSoggetto idFruitore,IDServizio idServizio,String nomeRegistro, RequestInfo requestInfo)
  1485.             throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1486.        
  1487.         String profilo = null;
  1488.        
  1489.         // vedo se il soggetto fruitore ha un profilo
  1490.         Soggetto soggettoFruitore = RegistroServiziManager._getSoggettoFromRequestInfo(idFruitore, requestInfo);
  1491.         if(soggettoFruitore==null) {
  1492.             soggettoFruitore = this.registroServizi.getSoggetto(connectionPdD,nomeRegistro, idFruitore);
  1493.         }
  1494.         if (soggettoFruitore == null){
  1495.             throw new DriverRegistroServiziNotFound("getProfiloGestioneErogazioneServizio, soggettoFruitore ["+idFruitore+"] non definito (o non registrato)");
  1496.         }
  1497.         profilo = soggettoFruitore.getVersioneProtocollo();
  1498.        
  1499.         return profilo;
  1500.     }
  1501.    
  1502.     protected String getProfiloGestioneSoggetto(Connection connectionPdD,IDSoggetto idSoggetto,String nomeRegistro, RequestInfo requestInfo)
  1503.             throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1504.        
  1505.         // Profilo di gestione
  1506.         String profilo = null;
  1507.        
  1508.         // vedo se il soggetto fruitore ha un profilo
  1509.         Soggetto soggetto = RegistroServiziManager._getSoggettoFromRequestInfo(idSoggetto, requestInfo);
  1510.         if (soggetto == null){
  1511.             soggetto =  this.registroServizi.getSoggetto(connectionPdD, nomeRegistro, idSoggetto);
  1512.         }
  1513.         if (soggetto == null){
  1514.             throw new DriverRegistroServiziNotFound("getProfiloGestioneSoggetto, Soggetto ["+idSoggetto+"] non definito (o non registrato)");
  1515.         }
  1516.         profilo = soggetto.getVersioneProtocollo();
  1517.        
  1518.         return profilo;
  1519.     }
  1520.    
  1521.    
  1522.    
  1523.    
  1524.    
  1525.    
  1526.    
  1527.     /* ********  R I C E R C A   I N F O     S E R V I Z I  ******** */
  1528.     /**
  1529.      * Si occupa di ritornare le informazioni sulle funzionalita' associate
  1530.      * al servizio registrato nell'indice dei servizi di openspcoop. Il servizio, viene identificato
  1531.      * grazie ai fields 'tipoDestinatario','Destinatario','Servizio','TipoServizio' e 'Azione' impostati
  1532.      * all'interno del parametro <var>idService</var> di tipo {@link org.openspcoop2.core.id.IDServizio}.
  1533.      * <p>
  1534.      * Il metodo si occupa di ritornare un oggetto {@link org.openspcoop2.protocol.sdk.Servizio}
  1535.      * impostando in esso le funzionalita' che sono riscontrate nel registro dei servizi
  1536.      * al servizio identificato da <var>idService</var>.
  1537.      *
  1538.      * @param idSoggetto Soggetto richiedente del servizio
  1539.      * @param idService Identificatore del Servizio di tipo {@link org.openspcoop2.core.id.IDServizio}.
  1540.      * @param nomeRegistro nome del registro su cui effettuare la ricerca (null per effettuare una ricerca su tutti i registri)
  1541.      * @return l'oggetto di tipo {@link org.openspcoop2.core.id.IDServizio}
  1542.      */
  1543.     protected Servizio getInfoServizio(Connection connectionPdD,IDSoggetto idSoggetto, IDServizio idService,String nomeRegistro, boolean verificaEsistenzaServizioAzioneCorrelato, boolean throwAzioneNotFound)
  1544.             throws DriverRegistroServiziException,DriverRegistroServiziNotFound,DriverRegistroServiziAzioneNotFound,DriverRegistroServiziPortTypeNotFound,DriverRegistroServiziCorrelatoNotFound{
  1545.         return getInfoServizio(connectionPdD,false,false,idSoggetto,idService,nomeRegistro,verificaEsistenzaServizioAzioneCorrelato, throwAzioneNotFound);
  1546.     }

  1547.     /**
  1548.      * Si occupa di ritornare le informazioni sulle funzionalita' associate
  1549.      * ad un servizio correlato registrato nell'indice dei servizi di openspcoop. Il servizio, viene identificato
  1550.      * grazie ai fields 'tipoDestinatario','Destinatario','Servizio','TipoServizio' e 'Azione' impostati
  1551.      * all'interno del parametro <var>idService</var> di tipo {@link org.openspcoop2.core.id.IDServizio}.
  1552.      * <p>
  1553.      * Il metodo si occupa di ritornare un oggetto {@link org.openspcoop2.protocol.sdk.Servizio}
  1554.      * impostando in esso le funzionalita' che sono riscontrate nel registro dei servizi
  1555.      * al servizio identificato da <var>idService</var>.
  1556.      *
  1557.      * @param idSoggetto Soggetto richiedente del servizio
  1558.      * @param idService Identificatore del Servizio di tipo {@link org.openspcoop2.core.id.IDServizio}.
  1559.      * @param nomeRegistro nome del registro su cui effettuare la ricerca (null per effettuare una ricerca su tutti i registri)
  1560.      * @return l'oggetto di tipo {@link org.openspcoop2.protocol.sdk.Servizio}
  1561.      */
  1562.     protected Servizio getInfoServizioCorrelato(Connection connectionPdD,IDSoggetto idSoggetto,IDServizio idService,String nomeRegistro, boolean throwAzioneNotFound)
  1563.             throws DriverRegistroServiziException,DriverRegistroServiziNotFound,DriverRegistroServiziAzioneNotFound,DriverRegistroServiziPortTypeNotFound,DriverRegistroServiziCorrelatoNotFound{
  1564.         return getInfoServizio(connectionPdD,true,false,idSoggetto,idService,nomeRegistro,false, throwAzioneNotFound);
  1565.     }
  1566.    
  1567.     /**
  1568.      * Ritorna l'informazione su di un servizio, in cui l'azione chiamata e' correlata.
  1569.      *
  1570.      * @param idSoggetto
  1571.      * @param idService
  1572.      * @param nomeRegistro
  1573.      * @return Servizio
  1574.      * @throws DriverRegistroServiziException
  1575.      * @throws DriverRegistroServiziNotFound
  1576.      * @throws DriverRegistroServiziAzioneNotFound
  1577.      */
  1578.     protected Servizio getInfoServizioAzioneCorrelata(Connection connectionPdD,IDSoggetto idSoggetto,IDServizio idService,String nomeRegistro, boolean throwAzioneNotFound)
  1579.         throws DriverRegistroServiziException,DriverRegistroServiziNotFound,DriverRegistroServiziAzioneNotFound,DriverRegistroServiziPortTypeNotFound,DriverRegistroServiziCorrelatoNotFound{
  1580.         return getInfoServizio(connectionPdD,false,true,idSoggetto,idService,nomeRegistro,false, throwAzioneNotFound);
  1581.     }

  1582.     /**
  1583.      * Si occupa di ritornare le informazioni sulle funzionalita' associate
  1584.      * al servizio registrato nell'indice dei servizi di openspcoop. Il servizio, viene identificato
  1585.      * grazie ai fields 'tipoDestinatario','Destinatario','Servizio','TipoServizio' e 'Azione' impostati
  1586.      * all'interno del parametro <var>idService</var> di tipo {@link org.openspcoop2.core.id.IDServizio}.
  1587.      * <p>
  1588.      * Il metodo si occupa di ritornare un oggetto {@link org.openspcoop2.protocol.sdk.Servizio}
  1589.      * impostando in esso le funzionalita' che sono riscontrate nel registro dei servizi
  1590.      * al servizio identificato da <var>idService</var>.
  1591.      *
  1592.      * @param servizioCorrelato true se il servizio e' un servizio correlato
  1593.      * @param idSoggetto Soggetto richiedente del servizio
  1594.      * @param idService Identificatore del Servizio di tipo {@link org.openspcoop2.core.id.IDServizio}.
  1595.      * @param nomeRegistro nome del registro su cui effettuare la ricerca (null per effettuare una ricerca su tutti i registri)
  1596.      * @return l'oggetto di tipo {@link org.openspcoop2.core.id.IDServizio}
  1597.      */
  1598.     private Servizio getInfoServizio(Connection connectionPdD,boolean servizioCorrelato,boolean azioneCorrelata,IDSoggetto idSoggetto, IDServizio idService,
  1599.             String nomeRegistro, boolean verificaEsistenzaServizioAzioneCorrelato, boolean throwAzioneNotFound)
  1600.             throws DriverRegistroServiziException,DriverRegistroServiziNotFound,DriverRegistroServiziAzioneNotFound,DriverRegistroServiziPortTypeNotFound,DriverRegistroServiziCorrelatoNotFound{

  1601.         Servizio infoServizio = new Servizio();

  1602.         // ricerca servizio richiesto
  1603.         org.openspcoop2.core.registry.AccordoServizioParteSpecifica servizio = null;
  1604.         servizio = this.registroServizi.getAccordoServizioParteSpecifica(connectionPdD,nomeRegistro,idService);
  1605.         if(servizio == null){
  1606.             throw new DriverRegistroServiziNotFound("Servizio non definito");
  1607.         }
  1608.         TipologiaServizio tipologiaServizio = servizio.getTipologiaServizio();
  1609.         if(servizioCorrelato){
  1610.             if(!TipologiaServizio.CORRELATO.equals(tipologiaServizio)){
  1611.                 throw new DriverRegistroServiziNotFound("Servizio ["+idService.toString()+"] (tipologia:"+tipologiaServizio+") non è di tipologia correlata");
  1612.             }
  1613.         }else{
  1614.             if(!TipologiaServizio.NORMALE.equals(tipologiaServizio)){
  1615.                 throw new DriverRegistroServiziNotFound("Servizio ["+idService.toString()+"] (tipologia:"+tipologiaServizio+") è di tipologia normale");
  1616.             }
  1617.         }

  1618.         String azione = idService.getAzione();

  1619.         if(azioneCorrelata && (azione==null) ){
  1620.             throw new DriverRegistroServiziException("Azione obbligatoria in questa modalità di ricerca");
  1621.         }

  1622.         String uriAccordo = servizio.getAccordoServizioParteComune();
  1623.         if(uriAccordo == null){
  1624.             throw new DriverRegistroServiziException("Identificativo dell'API non definito nel servizio");
  1625.         }
  1626.         IDAccordo idAccordo = this.idAccordoFactory.getIDAccordoFromUri(uriAccordo);
  1627.         org.openspcoop2.core.registry.AccordoServizioParteComune as = this.registroServizi.getAccordoServizioParteComune(connectionPdD,nomeRegistro,idAccordo);
  1628.         if (as == null){
  1629.             throw new DriverRegistroServiziNotFound("API '"+uriAccordo+"' non trovata");
  1630.         }
  1631.         infoServizio.setIdAccordo(idAccordo);
  1632.         ServiceBinding serviceBinding = as.getServiceBinding();
  1633.         infoServizio.setServiceBinding(RegistroServiziUtils.convertToMessage(serviceBinding));
  1634.        
  1635.         infoServizio.setIDServizio(idService);
  1636.        
  1637.         if(ServiceBinding.SOAP.equals(serviceBinding)) {
  1638.             return this._getInfoServizioSOAP(idService, servizio,
  1639.                     idAccordo, as, uriAccordo,
  1640.                     azione, infoServizio, idSoggetto,
  1641.                     verificaEsistenzaServizioAzioneCorrelato, servizioCorrelato, azioneCorrelata, nomeRegistro, connectionPdD, throwAzioneNotFound);
  1642.         }
  1643.         else {
  1644.             return this._getInfoServizioREST(as, uriAccordo, azione, infoServizio, throwAzioneNotFound);
  1645.         }
  1646.        
  1647.     }
  1648.    
  1649.     private Servizio _getInfoServizioREST(org.openspcoop2.core.registry.AccordoServizioParteComune as, String uriAccordo,
  1650.             String azione, Servizio infoServizio, boolean throwAzioneNotFound) throws DriverRegistroServiziAzioneNotFound {
  1651.        
  1652.         org.openspcoop2.core.registry.Resource resource = null;
  1653.         if(azione==null){
  1654.             if(throwAzioneNotFound) {
  1655.                 throw new DriverRegistroServiziAzioneNotFound("La richiesta effettuata non è associabile a nessuna risorsa definita nell'API "+uriAccordo);
  1656.             }
  1657.         }else{
  1658.             // Controllo esistenza azione
  1659.             boolean find = false;
  1660.             // search in accordo
  1661.             for(int i=0; i<as.sizeResourceList(); i++){
  1662.                 if(azione.equals(as.getResource(i).getNome())){
  1663.                     resource = as.getResource(i);
  1664.                     find = true;
  1665.                     break;
  1666.                 }
  1667.             }
  1668.             if(find==false){
  1669.                 if(throwAzioneNotFound) {
  1670.                     throw new DriverRegistroServiziAzioneNotFound("Risorsa '"+azione+"' non trovata nell'API "+uriAccordo);
  1671.                 }
  1672.             }
  1673.         }
  1674.        
  1675.        
  1676.         infoServizio.setInoltro(Inoltro.CON_DUPLICATI);
  1677.         infoServizio.setCollaborazione(false);
  1678.         infoServizio.setConfermaRicezione(false);
  1679.         infoServizio.setOrdineConsegna(false);
  1680.         infoServizio.setCorrelato(false);
  1681.        
  1682.        

  1683.        
  1684.         // ----------- 1. Accordo di Servizio ------------------

  1685.         // profilo di collaborazione (default: oneway)
  1686.         if(as.getProfiloCollaborazione()!=null) {
  1687.             if(org.openspcoop2.core.registry.constants.ProfiloCollaborazione.ONEWAY.equals(as.getProfiloCollaborazione())) {
  1688.                 infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ONEWAY);
  1689.             }
  1690.             else {
  1691.                 infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.SINCRONO);
  1692.             }
  1693.         }else {
  1694.             infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.SINCRONO);
  1695.         }

  1696.         // ID-Collaborazione (default: false)
  1697.         if(as.getIdCollaborazione() == null)
  1698.             infoServizio.setCollaborazione(false);
  1699.         else if(as.getIdCollaborazione().equals(CostantiRegistroServizi.DISABILITATO))
  1700.             infoServizio.setCollaborazione(false);
  1701.         else if(as.getIdCollaborazione().equals(CostantiRegistroServizi.ABILITATO))
  1702.             infoServizio.setCollaborazione(true);
  1703.         else
  1704.             infoServizio.setCollaborazione(false);

  1705.         // ID-RiferimentoRichiesta (default: false)
  1706.         if(as.getIdRiferimentoRichiesta() == null)
  1707.             infoServizio.setIdRiferimentoRichiesta(false);
  1708.         else if(as.getIdRiferimentoRichiesta().equals(CostantiRegistroServizi.DISABILITATO))
  1709.             infoServizio.setIdRiferimentoRichiesta(false);
  1710.         else if(as.getIdRiferimentoRichiesta().equals(CostantiRegistroServizi.ABILITATO))
  1711.             infoServizio.setIdRiferimentoRichiesta(true);
  1712.         else
  1713.             infoServizio.setIdRiferimentoRichiesta(false);
  1714.        
  1715.         // Consegna in Ordine (default: false)
  1716.         if(as.getConsegnaInOrdine() == null)
  1717.             infoServizio.setOrdineConsegna(false);
  1718.         else if(as.getConsegnaInOrdine().equals(CostantiRegistroServizi.DISABILITATO))
  1719.             infoServizio.setOrdineConsegna(false);
  1720.         else if(as.getConsegnaInOrdine().equals(CostantiRegistroServizi.ABILITATO))
  1721.             infoServizio.setOrdineConsegna(true);
  1722.         else
  1723.             infoServizio.setOrdineConsegna(false);

  1724.         // ConfermaRicezione (default: false)
  1725.         if(as.getConfermaRicezione() == null)
  1726.             infoServizio.setConfermaRicezione(false);
  1727.         else if(as.getConfermaRicezione().equals(CostantiRegistroServizi.DISABILITATO))
  1728.             infoServizio.setConfermaRicezione(false);
  1729.         else if(as.getConfermaRicezione().equals(CostantiRegistroServizi.ABILITATO))
  1730.             infoServizio.setConfermaRicezione(true);
  1731.         else
  1732.             infoServizio.setConfermaRicezione(false);

  1733.         // Filtro Duplicati (default: false)
  1734.         if(as.getFiltroDuplicati() == null)
  1735.             infoServizio.setInoltro(Inoltro.CON_DUPLICATI);
  1736.         else if(as.getFiltroDuplicati().equals(CostantiRegistroServizi.DISABILITATO))
  1737.             infoServizio.setInoltro(Inoltro.CON_DUPLICATI);
  1738.         else if(as.getFiltroDuplicati().equals(CostantiRegistroServizi.ABILITATO))
  1739.             infoServizio.setInoltro(Inoltro.SENZA_DUPLICATI);
  1740.         else
  1741.             infoServizio.setInoltro(Inoltro.CON_DUPLICATI);

  1742.         // Costruzione scadenza
  1743.         if(as.getScadenza() != null){
  1744.             try{
  1745.                 long minuti = Long.parseLong(as.getScadenza());
  1746.                 Date nowDate = DateManager.getDate();
  1747.                 long now = nowDate.getTime();
  1748.                 now = now + (minuti*60*1000);
  1749.                 nowDate.setTime(now);
  1750.                 infoServizio.setScadenza(nowDate);
  1751.                 infoServizio.setScadenzaMinuti(minuti);
  1752.             }catch(Exception e){
  1753.                 // ignore
  1754.             }
  1755.         }


  1756.        
  1757.    


  1758.         // ---------- 2. overwrite con risorsa dell'accordo di servizio o del port-type (se definito) -----------------
  1759.         if(resource!=null){

  1760.             boolean ridefinisci = true;
  1761.             if(CostantiRegistroServizi.PROFILO_AZIONE_DEFAULT.equals(resource.getProfAzione())){
  1762.                 ridefinisci = false;
  1763.             }
  1764.                        
  1765.             if(ridefinisci){
  1766.    
  1767.                 // ID-Collaborazione (default: false)
  1768.                 StatoFunzionalita idCollaborazione = resource.getIdCollaborazione();
  1769.                 if(idCollaborazione != null){
  1770.                     if(idCollaborazione.equals(CostantiRegistroServizi.DISABILITATO))
  1771.                         infoServizio.setCollaborazione(false);
  1772.                     else if(idCollaborazione.equals(CostantiRegistroServizi.ABILITATO))
  1773.                         infoServizio.setCollaborazione(true);
  1774.                 }
  1775.                
  1776.                 // ID-RiferimentoRichiesta (default: false)
  1777.                 StatoFunzionalita idRiferimentoRichiesta = resource.getIdRiferimentoRichiesta();
  1778.                 if(idRiferimentoRichiesta != null){
  1779.                     if(idRiferimentoRichiesta.equals(CostantiRegistroServizi.DISABILITATO))
  1780.                         infoServizio.setIdRiferimentoRichiesta(false);
  1781.                     else if(idRiferimentoRichiesta.equals(CostantiRegistroServizi.ABILITATO))
  1782.                         infoServizio.setIdRiferimentoRichiesta(true);
  1783.                 }
  1784.    
  1785.                 // Consegna in Ordine (default: false)
  1786.                 StatoFunzionalita consegnaInOrdine = resource.getConsegnaInOrdine();
  1787.                 if(consegnaInOrdine != null){
  1788.                     if(consegnaInOrdine.equals(CostantiRegistroServizi.DISABILITATO))
  1789.                         infoServizio.setOrdineConsegna(false);
  1790.                     else if(consegnaInOrdine.equals(CostantiRegistroServizi.ABILITATO))
  1791.                         infoServizio.setOrdineConsegna(true);
  1792.                 }
  1793.    
  1794.                 // ConfermaRicezione (default: false)
  1795.                 StatoFunzionalita confermaRicezione = resource.getConfermaRicezione();
  1796.                 if(confermaRicezione != null){
  1797.                     if(confermaRicezione.equals(CostantiRegistroServizi.DISABILITATO))
  1798.                         infoServizio.setConfermaRicezione(false);
  1799.                     else if(confermaRicezione.equals(CostantiRegistroServizi.ABILITATO))
  1800.                         infoServizio.setConfermaRicezione(true);
  1801.                 }
  1802.    
  1803.                 // Filtro Duplicati (default: false)
  1804.                 StatoFunzionalita filtroDuplicati = resource.getFiltroDuplicati();
  1805.                 if(filtroDuplicati != null){
  1806.                     if(filtroDuplicati.equals(CostantiRegistroServizi.DISABILITATO))
  1807.                         infoServizio.setInoltro(Inoltro.CON_DUPLICATI);
  1808.                     else if(filtroDuplicati.equals(CostantiRegistroServizi.ABILITATO))
  1809.                         infoServizio.setInoltro(Inoltro.SENZA_DUPLICATI);
  1810.                 }
  1811.    
  1812.                 // Costruzione scadenza
  1813.                 String scadenza = resource.getScadenza();
  1814.                 if(scadenza != null){
  1815.                     try{
  1816.                         long minuti = Long.parseLong(scadenza);
  1817.                         Date nowDate = DateManager.getDate();
  1818.                         long now = nowDate.getTime();
  1819.                         now = now + (minuti*60*1000);
  1820.                         nowDate.setTime(now);
  1821.                         infoServizio.setScadenza(nowDate);
  1822.                         infoServizio.setScadenzaMinuti(minuti);
  1823.                     }catch(Exception e){
  1824.                         // ignore
  1825.                     }
  1826.                 }
  1827.                
  1828.             }
  1829.         }

  1830.            
  1831.         return infoServizio;
  1832.     }
  1833.    
  1834.     private Servizio _getInfoServizioSOAP(IDServizio idService, org.openspcoop2.core.registry.AccordoServizioParteSpecifica servizio,
  1835.             IDAccordo idAccordo, org.openspcoop2.core.registry.AccordoServizioParteComune as, String uriAccordo,
  1836.             String azione, Servizio infoServizio, IDSoggetto idSoggetto,
  1837.             boolean verificaEsistenzaServizioAzioneCorrelato, boolean servizioCorrelato,boolean azioneCorrelata, String nomeRegistro,
  1838.             Connection connectionPdD, boolean throwAzioneNotFound) throws DriverRegistroServiziPortTypeNotFound, DriverRegistroServiziAzioneNotFound, DriverRegistroServiziCorrelatoNotFound, DriverRegistroServiziNotFound {
  1839.        
  1840.         org.openspcoop2.core.registry.PortType pt = null;
  1841.         // search port type
  1842.         if (servizio.getPortType()!=null){
  1843.             for(int i=0; i<as.sizePortTypeList();i++){
  1844.                 if(servizio.getPortType().equals(as.getPortType(i).getNome())){
  1845.                     pt = as.getPortType(i);
  1846.                 }
  1847.             }
  1848.             if(pt==null){
  1849.                 throw new DriverRegistroServiziPortTypeNotFound("Servizio '"+servizio.getPortType()+"' non definito nell'API "+uriAccordo);
  1850.             }
  1851.         }
  1852.        
  1853.         org.openspcoop2.core.registry.Azione az = null;
  1854.         org.openspcoop2.core.registry.Operation ptAz = null;
  1855.         if(azione==null){
  1856.             // controllo possibilita di utilizzare il servizio senza azione
  1857.             if(pt!=null){
  1858.                 // se e' definito un port-type non ha senso che si possa invocare il servizio (port-type) senza azione (operation).
  1859.                 if(throwAzioneNotFound) {
  1860.                     throw new DriverRegistroServiziAzioneNotFound("La richiesta effettuata non è associabile a nessuna azione (servizio: "+pt.getNome() +") dell'API "+uriAccordo);
  1861.                 }
  1862.             }else{
  1863.                 if(as.getUtilizzoSenzaAzione()==false){
  1864.                     if(throwAzioneNotFound) {
  1865.                         throw new DriverRegistroServiziAzioneNotFound("La richiesta effettuata non è associabile a nessuna azione dell'API "+uriAccordo+ " (invocazione senza la definizione di una azione non permessa)");
  1866.                     }
  1867.                 }
  1868.             }
  1869.         }else{
  1870.             // Controllo esistenza azione
  1871.             boolean find = false;
  1872.             if(pt!=null){
  1873.                 // search in port-type
  1874.                 for(int i=0; i<pt.sizeAzioneList(); i++){
  1875.                     if(azione.equals(pt.getAzione(i).getNome())){
  1876.                         ptAz = pt.getAzione(i);
  1877.                         find = true;
  1878.                         break;
  1879.                     }
  1880.                 }
  1881.                 if(find==false){
  1882.                     if(throwAzioneNotFound) {
  1883.                         throw new DriverRegistroServiziAzioneNotFound("Azione '"+azione+"' non trovata per il servizio ["+pt.getNome()+"] dell'API "+uriAccordo);
  1884.                     }
  1885.                 }
  1886.             }else{
  1887.                 // search in accordo
  1888.                 for(int i=0; i<as.sizeAzioneList(); i++){
  1889.                     if(azione.equals(as.getAzione(i).getNome())){
  1890.                         az = as.getAzione(i);
  1891.                         find = true;
  1892.                         break;
  1893.                     }
  1894.                 }
  1895.                 if(find==false){
  1896.                     if(throwAzioneNotFound) {
  1897.                         throw new DriverRegistroServiziAzioneNotFound("Azione '"+azione+"' non trovata nell'API "+uriAccordo);
  1898.                     }
  1899.                 }
  1900.             }
  1901.         }

  1902.         // popolamento oggetto Servizio
  1903.         // 1. Accordo di Servizio
  1904.         // 2. overwrite con Port-type
  1905.         // 3. overwrite con azione dell'accordo di servizio o del port-type (se definito)
  1906.         // 4. overwrite con servizio
  1907.         // 5. overwrite con fruitore

  1908.        
  1909.         // ----------- 1. Accordo di Servizio ------------------

  1910.         // profilo di collaborazione (default: oneway)
  1911.         if(as.getProfiloCollaborazione() == null)
  1912.             infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ONEWAY);
  1913.         else if(as.getProfiloCollaborazione().equals(CostantiRegistroServizi.ONEWAY))
  1914.             infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ONEWAY);
  1915.         else if(as.getProfiloCollaborazione().equals(CostantiRegistroServizi.SINCRONO))
  1916.             infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.SINCRONO);
  1917.         else if(as.getProfiloCollaborazione().equals(CostantiRegistroServizi.ASINCRONO_SIMMETRICO))
  1918.             infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  1919.         else if(as.getProfiloCollaborazione().equals(CostantiRegistroServizi.ASINCRONO_ASIMMETRICO))
  1920.             infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO);
  1921.         else
  1922.             infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ONEWAY);

  1923.         // ID-Collaborazione (default: false)
  1924.         if(as.getIdCollaborazione() == null)
  1925.             infoServizio.setCollaborazione(false);
  1926.         else if(as.getIdCollaborazione().equals(CostantiRegistroServizi.DISABILITATO))
  1927.             infoServizio.setCollaborazione(false);
  1928.         else if(as.getIdCollaborazione().equals(CostantiRegistroServizi.ABILITATO))
  1929.             infoServizio.setCollaborazione(true);
  1930.         else
  1931.             infoServizio.setCollaborazione(false);

  1932.         // ID-RiferimentoRichiesta (default: false)
  1933.         if(as.getIdRiferimentoRichiesta() == null)
  1934.             infoServizio.setIdRiferimentoRichiesta(false);
  1935.         else if(as.getIdRiferimentoRichiesta().equals(CostantiRegistroServizi.DISABILITATO))
  1936.             infoServizio.setIdRiferimentoRichiesta(false);
  1937.         else if(as.getIdRiferimentoRichiesta().equals(CostantiRegistroServizi.ABILITATO))
  1938.             infoServizio.setIdRiferimentoRichiesta(true);
  1939.         else
  1940.             infoServizio.setIdRiferimentoRichiesta(false);
  1941.        
  1942.         // Consegna in Ordine (default: false)
  1943.         if(as.getConsegnaInOrdine() == null)
  1944.             infoServizio.setOrdineConsegna(false);
  1945.         else if(as.getConsegnaInOrdine().equals(CostantiRegistroServizi.DISABILITATO))
  1946.             infoServizio.setOrdineConsegna(false);
  1947.         else if(as.getConsegnaInOrdine().equals(CostantiRegistroServizi.ABILITATO))
  1948.             infoServizio.setOrdineConsegna(true);
  1949.         else
  1950.             infoServizio.setOrdineConsegna(false);

  1951.         // ConfermaRicezione (default: false)
  1952.         if(as.getConfermaRicezione() == null)
  1953.             infoServizio.setConfermaRicezione(false);
  1954.         else if(as.getConfermaRicezione().equals(CostantiRegistroServizi.DISABILITATO))
  1955.             infoServizio.setConfermaRicezione(false);
  1956.         else if(as.getConfermaRicezione().equals(CostantiRegistroServizi.ABILITATO))
  1957.             infoServizio.setConfermaRicezione(true);
  1958.         else
  1959.             infoServizio.setConfermaRicezione(false);

  1960.         // Filtro Duplicati (default: false)
  1961.         if(as.getFiltroDuplicati() == null)
  1962.             infoServizio.setInoltro(Inoltro.CON_DUPLICATI);
  1963.         else if(as.getFiltroDuplicati().equals(CostantiRegistroServizi.DISABILITATO))
  1964.             infoServizio.setInoltro(Inoltro.CON_DUPLICATI);
  1965.         else if(as.getFiltroDuplicati().equals(CostantiRegistroServizi.ABILITATO))
  1966.             infoServizio.setInoltro(Inoltro.SENZA_DUPLICATI);
  1967.         else
  1968.             infoServizio.setInoltro(Inoltro.CON_DUPLICATI);

  1969.         // Costruzione scadenza
  1970.         if(as.getScadenza() != null){
  1971.             try{
  1972.                 long minuti = Long.parseLong(as.getScadenza());
  1973.                 Date nowDate = DateManager.getDate();
  1974.                 long now = nowDate.getTime();
  1975.                 now = now + (minuti*60*1000);
  1976.                 nowDate.setTime(now);
  1977.                 infoServizio.setScadenza(nowDate);
  1978.                 infoServizio.setScadenzaMinuti(minuti);
  1979.             }catch(Exception e){
  1980.                 // ignore
  1981.             }
  1982.         }


  1983.        
  1984.        
  1985.         // 2. ------------------ overwrite con Port-type --------------------
  1986.         if(pt!=null){

  1987.             boolean ridefinisci = true;
  1988.             if(CostantiRegistroServizi.PROFILO_AZIONE_DEFAULT.equals(pt.getProfiloPT())){
  1989.                 ridefinisci = false;
  1990.             }
  1991.            
  1992.             if(ridefinisci){
  1993.            
  1994.                 // Profilo di Collaborazione
  1995.                 if(pt.getProfiloCollaborazione()!=null){
  1996.                     if(pt.getProfiloCollaborazione().equals(CostantiRegistroServizi.ONEWAY))
  1997.                         infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ONEWAY);
  1998.                     else if(pt.getProfiloCollaborazione().equals(CostantiRegistroServizi.SINCRONO))
  1999.                         infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.SINCRONO);
  2000.                     else if(pt.getProfiloCollaborazione().equals(CostantiRegistroServizi.ASINCRONO_SIMMETRICO))
  2001.                         infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  2002.                     else if(pt.getProfiloCollaborazione().equals(CostantiRegistroServizi.ASINCRONO_ASIMMETRICO))
  2003.                         infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO);
  2004.                 }
  2005.    
  2006.                 // ID-Collaborazione (default: false)
  2007.                 if(pt.getIdCollaborazione() != null){
  2008.                     if(pt.getIdCollaborazione().equals(CostantiRegistroServizi.DISABILITATO))
  2009.                         infoServizio.setCollaborazione(false);
  2010.                     else if(pt.getIdCollaborazione().equals(CostantiRegistroServizi.ABILITATO))
  2011.                         infoServizio.setCollaborazione(true);
  2012.                 }
  2013.                
  2014.                 // ID-RiferimentoRichiesta (default: false)
  2015.                 if(pt.getIdRiferimentoRichiesta() != null){
  2016.                     if(pt.getIdRiferimentoRichiesta().equals(CostantiRegistroServizi.DISABILITATO))
  2017.                         infoServizio.setIdRiferimentoRichiesta(false);
  2018.                     else if(pt.getIdRiferimentoRichiesta().equals(CostantiRegistroServizi.ABILITATO))
  2019.                         infoServizio.setIdRiferimentoRichiesta(true);
  2020.                 }
  2021.    
  2022.                 // Consegna in Ordine (default: false)
  2023.                 if(pt.getConsegnaInOrdine() != null){
  2024.                     if(pt.getConsegnaInOrdine().equals(CostantiRegistroServizi.DISABILITATO))
  2025.                         infoServizio.setOrdineConsegna(false);
  2026.                     else if(pt.getConsegnaInOrdine().equals(CostantiRegistroServizi.ABILITATO))
  2027.                         infoServizio.setOrdineConsegna(true);
  2028.                 }
  2029.    
  2030.                 // ConfermaRicezione (default: false)
  2031.                 if(pt.getConfermaRicezione() != null){
  2032.                     if(pt.getConfermaRicezione().equals(CostantiRegistroServizi.DISABILITATO))
  2033.                         infoServizio.setConfermaRicezione(false);
  2034.                     else if(pt.getConfermaRicezione().equals(CostantiRegistroServizi.ABILITATO))
  2035.                         infoServizio.setConfermaRicezione(true);
  2036.                 }
  2037.    
  2038.                 // Filtro Duplicati (default: false)
  2039.                 if(pt.getFiltroDuplicati() != null){
  2040.                     if(pt.getFiltroDuplicati().equals(CostantiRegistroServizi.DISABILITATO))
  2041.                         infoServizio.setInoltro(Inoltro.CON_DUPLICATI);
  2042.                     else if(pt.getFiltroDuplicati().equals(CostantiRegistroServizi.ABILITATO))
  2043.                         infoServizio.setInoltro(Inoltro.SENZA_DUPLICATI);
  2044.                 }
  2045.    
  2046.                 // Costruzione scadenza
  2047.                 if(pt.getScadenza() != null){
  2048.                     try{
  2049.                         long minuti = Long.parseLong(pt.getScadenza());
  2050.                         Date nowDate = DateManager.getDate();
  2051.                         long now = nowDate.getTime();
  2052.                         now = now + (minuti*60*1000);
  2053.                         nowDate.setTime(now);
  2054.                         infoServizio.setScadenza(nowDate);
  2055.                         infoServizio.setScadenzaMinuti(minuti);
  2056.                     }catch(Exception e){
  2057.                         // ignore
  2058.                     }
  2059.                 }
  2060.                
  2061.             }
  2062.         }
  2063.        
  2064.        
  2065.        


  2066.         // ---------- 3. overwrite con azione dell'accordo di servizio o del port-type (se definito) -----------------
  2067.         if(az!=null || ptAz!=null){

  2068.             boolean ridefinisci = true;
  2069.             if(az!=null){
  2070.                 if(CostantiRegistroServizi.PROFILO_AZIONE_DEFAULT.equals(az.getProfAzione())){
  2071.                     ridefinisci = false;
  2072.                 }
  2073.             }
  2074.             else{
  2075.                 if(CostantiRegistroServizi.PROFILO_AZIONE_DEFAULT.equals(ptAz.getProfAzione())){
  2076.                     ridefinisci = false;
  2077.                 }
  2078.             }
  2079.            
  2080.             if(ridefinisci){
  2081.            
  2082.                 // Profilo di Collaborazione
  2083.                 ProfiloCollaborazione profilo = null;
  2084.                 if(az!=null)
  2085.                     profilo = az.getProfiloCollaborazione();
  2086.                 else
  2087.                     profilo = ptAz.getProfiloCollaborazione();
  2088.                 if(profilo!=null){
  2089.                     if(profilo.equals(CostantiRegistroServizi.ONEWAY))
  2090.                         infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ONEWAY);
  2091.                     else if(profilo.equals(CostantiRegistroServizi.SINCRONO))
  2092.                         infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.SINCRONO);
  2093.                     else if(profilo.equals(CostantiRegistroServizi.ASINCRONO_SIMMETRICO))
  2094.                         infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  2095.                     else if(profilo.equals(CostantiRegistroServizi.ASINCRONO_ASIMMETRICO))
  2096.                         infoServizio.setProfiloDiCollaborazione(ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO);
  2097.                 }
  2098.    
  2099.                 // ID-Collaborazione (default: false)
  2100.                 StatoFunzionalita idCollaborazione = null;
  2101.                 if(az!=null)
  2102.                     idCollaborazione = az.getIdCollaborazione();
  2103.                 else
  2104.                     idCollaborazione = ptAz.getIdCollaborazione();
  2105.                 if(idCollaborazione != null){
  2106.                     if(idCollaborazione.equals(CostantiRegistroServizi.DISABILITATO))
  2107.                         infoServizio.setCollaborazione(false);
  2108.                     else if(idCollaborazione.equals(CostantiRegistroServizi.ABILITATO))
  2109.                         infoServizio.setCollaborazione(true);
  2110.                 }
  2111.                
  2112.                 // ID-RiferimentoRichiesta (default: false)
  2113.                 StatoFunzionalita idRiferimentoRichiesta = null;
  2114.                 if(az!=null)
  2115.                     idRiferimentoRichiesta = az.getIdRiferimentoRichiesta();
  2116.                 else
  2117.                     idRiferimentoRichiesta = ptAz.getIdRiferimentoRichiesta();
  2118.                 if(idRiferimentoRichiesta != null){
  2119.                     if(idRiferimentoRichiesta.equals(CostantiRegistroServizi.DISABILITATO))
  2120.                         infoServizio.setIdRiferimentoRichiesta(false);
  2121.                     else if(idRiferimentoRichiesta.equals(CostantiRegistroServizi.ABILITATO))
  2122.                         infoServizio.setIdRiferimentoRichiesta(true);
  2123.                 }
  2124.    
  2125.                 // Consegna in Ordine (default: false)
  2126.                 StatoFunzionalita consegnaInOrdine = null;
  2127.                 if(az!=null)
  2128.                     consegnaInOrdine = az.getConsegnaInOrdine();
  2129.                 else
  2130.                     consegnaInOrdine = ptAz.getConsegnaInOrdine();
  2131.                 if(consegnaInOrdine != null){
  2132.                     if(consegnaInOrdine.equals(CostantiRegistroServizi.DISABILITATO))
  2133.                         infoServizio.setOrdineConsegna(false);
  2134.                     else if(consegnaInOrdine.equals(CostantiRegistroServizi.ABILITATO))
  2135.                         infoServizio.setOrdineConsegna(true);
  2136.                 }
  2137.    
  2138.                 // ConfermaRicezione (default: false)
  2139.                 StatoFunzionalita confermaRicezione = null;
  2140.                 if(az!=null)
  2141.                     confermaRicezione = az.getConfermaRicezione();
  2142.                 else
  2143.                     confermaRicezione = ptAz.getConfermaRicezione();
  2144.                 if(confermaRicezione != null){
  2145.                     if(confermaRicezione.equals(CostantiRegistroServizi.DISABILITATO))
  2146.                         infoServizio.setConfermaRicezione(false);
  2147.                     else if(confermaRicezione.equals(CostantiRegistroServizi.ABILITATO))
  2148.                         infoServizio.setConfermaRicezione(true);
  2149.                 }
  2150.    
  2151.                 // Filtro Duplicati (default: false)
  2152.                 StatoFunzionalita filtroDuplicati = null;
  2153.                 if(az!=null)
  2154.                     filtroDuplicati = az.getFiltroDuplicati();
  2155.                 else
  2156.                     filtroDuplicati = ptAz.getFiltroDuplicati();
  2157.                 if(filtroDuplicati != null){
  2158.                     if(filtroDuplicati.equals(CostantiRegistroServizi.DISABILITATO))
  2159.                         infoServizio.setInoltro(Inoltro.CON_DUPLICATI);
  2160.                     else if(filtroDuplicati.equals(CostantiRegistroServizi.ABILITATO))
  2161.                         infoServizio.setInoltro(Inoltro.SENZA_DUPLICATI);
  2162.                 }
  2163.    
  2164.                 // Costruzione scadenza
  2165.                 String scadenza = null;
  2166.                 if(az!=null)
  2167.                     scadenza = az.getScadenza();
  2168.                 else
  2169.                     scadenza = ptAz.getScadenza();
  2170.                 if(scadenza != null){
  2171.                     try{
  2172.                         long minuti = Long.parseLong(scadenza);
  2173.                         Date nowDate = DateManager.getDate();
  2174.                         long now = nowDate.getTime();
  2175.                         now = now + (minuti*60*1000);
  2176.                         nowDate.setTime(now);
  2177.                         infoServizio.setScadenza(nowDate);
  2178.                         infoServizio.setScadenzaMinuti(minuti);
  2179.                     }catch(Exception e){
  2180.                         // ignore
  2181.                     }
  2182.                 }
  2183.                
  2184.             }
  2185.         }




  2186.         // ------------- 4. overwrite con servizio ------------------
  2187.         // SERVIZIO (Sovrascrivo caratteristiche sia delle azioni che dell'accordo...)
  2188.         // ID-Collaborazione (default: false)
  2189.         if(servizio.getIdCollaborazione() != null){
  2190.             if(servizio.getIdCollaborazione().equals(CostantiRegistroServizi.DISABILITATO))
  2191.                 infoServizio.setCollaborazione(false);
  2192.             else if(servizio.getIdCollaborazione().equals(CostantiRegistroServizi.ABILITATO))
  2193.                 infoServizio.setCollaborazione(true);
  2194.         }  
  2195.         // ID-RiferimentoRichiesta (default: false)
  2196.         if(servizio.getIdRiferimentoRichiesta() != null){
  2197.             if(servizio.getIdRiferimentoRichiesta().equals(CostantiRegistroServizi.DISABILITATO))
  2198.                 infoServizio.setIdRiferimentoRichiesta(false);
  2199.             else if(servizio.getIdRiferimentoRichiesta().equals(CostantiRegistroServizi.ABILITATO))
  2200.                 infoServizio.setIdRiferimentoRichiesta(true);
  2201.         }      
  2202.         // Consegna in Ordine (default: false)
  2203.         if(servizio.getConsegnaInOrdine() != null){
  2204.             if(servizio.getConsegnaInOrdine().equals(CostantiRegistroServizi.DISABILITATO))
  2205.                 infoServizio.setOrdineConsegna(false);
  2206.             else if(servizio.getConsegnaInOrdine().equals(CostantiRegistroServizi.ABILITATO))
  2207.                 infoServizio.setOrdineConsegna(true);
  2208.         }  
  2209.         // ConfermaRicezione (default: false)
  2210.         if(servizio.getConfermaRicezione() != null){
  2211.             if(servizio.getConfermaRicezione().equals(CostantiRegistroServizi.DISABILITATO))
  2212.                 infoServizio.setConfermaRicezione(false);
  2213.             else if(servizio.getConfermaRicezione().equals(CostantiRegistroServizi.ABILITATO))
  2214.                 infoServizio.setConfermaRicezione(true);
  2215.         }  
  2216.         // Filtro Duplicati (default: false)
  2217.         if(servizio.getFiltroDuplicati() != null){
  2218.             if(servizio.getFiltroDuplicati().equals(CostantiRegistroServizi.DISABILITATO))
  2219.                 infoServizio.setInoltro(Inoltro.CON_DUPLICATI);
  2220.             else if(servizio.getFiltroDuplicati().equals(CostantiRegistroServizi.ABILITATO))
  2221.                 infoServizio.setInoltro(Inoltro.SENZA_DUPLICATI);
  2222.         }  
  2223.         // Costruzione scadenza
  2224.         if(servizio.getScadenza() != null){
  2225.             try{
  2226.                 long minuti = Long.parseLong(servizio.getScadenza());
  2227.                 Date nowDate = DateManager.getDate();
  2228.                 long now = nowDate.getTime();
  2229.                 now = now + (minuti*60*1000);
  2230.                 nowDate.setTime(now);
  2231.                 infoServizio.setScadenza(nowDate);
  2232.                 infoServizio.setScadenzaMinuti(minuti);
  2233.             }catch(Exception e){
  2234.                 // ignore
  2235.             }
  2236.         }




  2237.        
  2238.         if(verificaEsistenzaServizioAzioneCorrelato){
  2239.            
  2240.             // Profilo Asincrono Simmetrico e Servizio Correlato da inserire nella richiesta:
  2241.             //   Si cerca un servizio correlato del soggetto fruitore (parametro idSoggetto)
  2242.             //   che contenga il riferimento all'accordo di servizio 'nomeAccordo'.
  2243.             if(ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(infoServizio.getProfiloDiCollaborazione())){
  2244.                
  2245.                 // verifica
  2246.                 org.openspcoop2.core.registry.AccordoServizioParteSpecifica servizioC = null;
  2247.                 try{
  2248.                     if(idSoggetto==null || idSoggetto.getTipo()==null || idSoggetto.getNome()==null){
  2249.                         throw new Exception("Identita soggetto fruitore non fornita");
  2250.                     }
  2251.                     servizioC = this.registroServizi.getAccordoServizioParteSpecifica_ServizioCorrelato(connectionPdD,nomeRegistro,idSoggetto,idAccordo);
  2252.                 }catch(Exception e){
  2253.                     throw new DriverRegistroServiziCorrelatoNotFound("getInfoServizio, servizio correlato da associare al servizio asincrono simmetrico non trovato: "+e.getMessage());
  2254.                 }
  2255.                 if(servizioC==null){
  2256.                     throw new DriverRegistroServiziCorrelatoNotFound("getInfoServizio, servizio correlato da associare al servizio asincrono simmetrico non trovato");
  2257.                 }
  2258.                 if(servizioC.getNome()==null || servizioC.getTipo()==null || servizioC.getVersione()==null){
  2259.                     throw new DriverRegistroServiziCorrelatoNotFound("getInfoServizio, servizio correlato al servizio asincrono simmetrico non configurato correttamente (tipo e/o nome is null?)");
  2260.                 }
  2261.                
  2262.                 // ritorno valori per farli inserire nella richiesta
  2263.                 infoServizio.setServizioCorrelato(servizioC.getNome());
  2264.                 infoServizio.setTipoServizioCorrelato(servizioC.getTipo());
  2265.                 infoServizio.setVersioneServizioCorrelato(servizioC.getVersione());
  2266.             }
  2267.        
  2268.             // Profilo Asincrono Asimmetrico
  2269.             // Il servizio correlato puo' essere un altro servizio correlato oppure un'azione correlata dello stesso servizio.
  2270.             if(ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(infoServizio.getProfiloDiCollaborazione())){
  2271.                
  2272.                 // verifica
  2273.                 // 1. cerco come servizio correlato
  2274.                 DriverRegistroServiziCorrelatoNotFound eFound = null;
  2275.                 org.openspcoop2.core.registry.AccordoServizioParteSpecifica servizioC = null;
  2276.                 try{
  2277.                     servizioC = this.registroServizi.getAccordoServizioParteSpecifica_ServizioCorrelato(connectionPdD,nomeRegistro,idService.getSoggettoErogatore(),idAccordo);
  2278.                 }catch(Exception e){
  2279.                     eFound = new DriverRegistroServiziCorrelatoNotFound("servizio correlato da associare al servizio asincrono asimmetrico non trovato: "+e.getMessage());
  2280.                 }
  2281.                 if(eFound==null){
  2282.                     if(servizioC==null){
  2283.                         eFound = new DriverRegistroServiziCorrelatoNotFound("servizio correlato da associare al servizio asincrono asimmetrico non trovato");
  2284.                     }else{
  2285.                         if(servizioC.getNome()==null || servizioC.getTipo()==null || servizioC.getVersione()==null){
  2286.                             throw new DriverRegistroServiziCorrelatoNotFound("servizio correlato al servizio asincrono asimmetrico non configurato correttamente (tipo e/o nome is null?)");
  2287.                         }
  2288.                     }
  2289.                 }
  2290.                 if(eFound!=null){
  2291.                     // 2. cerco come azione correlata
  2292.                    
  2293.                     if(az!=null){
  2294.                         boolean find = false;
  2295.                         for(int i=0; i<as.sizeAzioneList();i++){
  2296.                             Azione azCheck = as.getAzione(i);
  2297.                             if(azCheck.getNome().equals(az.getNome())){
  2298.                                 continue;
  2299.                             }
  2300.                             if(azCheck.getCorrelata()!=null && azCheck.getCorrelata().equals(az.getNome())){
  2301.                                 find = true;
  2302.                                 break;
  2303.                             }
  2304.                         }
  2305.                         if(!find){
  2306.                             throw new DriverRegistroServiziCorrelatoNotFound("getInfoServizio, azione correlata o "+eFound.getMessage());
  2307.                         }
  2308.                     }
  2309.                     else if(ptAz!=null && pt!=null){
  2310.                         boolean find = false;
  2311.                         for(int i=0; i<pt.sizeAzioneList();i++){
  2312.                             Operation azCheck = pt.getAzione(i);
  2313.                             if(azCheck.getNome().equals(ptAz.getNome())){
  2314.                                 continue;
  2315.                             }
  2316.                             if(azCheck.getCorrelata()!=null && azCheck.getCorrelata().equals(ptAz.getNome())){
  2317.                                 if(azCheck.getCorrelataServizio()==null || "".equals(azCheck.getCorrelataServizio()) || azCheck.getCorrelataServizio().equals(pt.getNome())){
  2318.                                     find = true;
  2319.                                     break;
  2320.                                 }
  2321.                             }
  2322.                                    
  2323.                         }
  2324.                         if(!find){
  2325.                             throw new DriverRegistroServiziCorrelatoNotFound("getInfoServizio, azione correlata o "+eFound.getMessage());
  2326.                         }
  2327.                     }
  2328.                     else{
  2329.                         throw eFound;
  2330.                     }
  2331.                 }
  2332.             }
  2333.         }

  2334.        
  2335.         // Controllo in caso di azione correlato su un servizio
  2336.         // che l'azione dell'accordo sia effettivamente correlata
  2337.         if( (!servizioCorrelato) && (azioneCorrelata) && ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(infoServizio.getProfiloDiCollaborazione())){
  2338.             String azionePT = null;
  2339.             String correlazione = null;
  2340.             if(ptAz!=null){
  2341.                 azionePT = ptAz.getNome();
  2342.                 correlazione = ptAz.getCorrelata();
  2343.             }else if(az!=null) {
  2344.                 azionePT = az.getNome();
  2345.                 correlazione = az.getCorrelata();
  2346.             }
  2347.            
  2348.             String uriServizio = null;
  2349.             try{
  2350.                 uriServizio = IDServizioFactory.getInstance().getUriFromIDServizio(idService);
  2351.             }catch(Exception e){
  2352.                 uriServizio = idService.toString(false);
  2353.             }
  2354.            
  2355.             if(correlazione==null){
  2356.                 throw new DriverRegistroServiziNotFound("getInfoServizio, l'azione ["+azionePT+"] invocata con il servizio ["+uriServizio+"] non e' correlata ad un'altra azione dell'accordo");
  2357.             }else{
  2358.                 // check azione correlata esista
  2359.                 boolean find = false;
  2360.                 if(pt!=null){
  2361.                     for(int i=0; i<pt.sizeAzioneList();i++){
  2362.                         if(correlazione.equals(pt.getAzione(i).getNome())){
  2363.                             find = true;
  2364.                             break;
  2365.                         }
  2366.                     }
  2367.                 }else{
  2368.                     for(int i=0; i<as.sizeAzioneList();i++){
  2369.                         if(correlazione.equals(as.getAzione(i).getNome())){
  2370.                             find = true;
  2371.                             break;
  2372.                         }
  2373.                     }
  2374.                 }
  2375.                
  2376.                 if(!find){
  2377.                     if(pt!=null){
  2378.                         throw new DriverRegistroServiziNotFound("getInfoServizio, l'operation ["+correlazione+"] definita come correlata nell'operation ["+azionePT+"] non esiste ( port type["+pt.getNome()+"], servizio["+uriServizio+"] accordo di servizio["+uriAccordo+"]");
  2379.                     }else{
  2380.                         throw new DriverRegistroServiziNotFound("getInfoServizio, l'azione ["+correlazione+"] definita come correlata nell'azione ["+azionePT+"] non esiste ( servizio["+uriServizio+"] accordo di servizio["+uriAccordo+"]");
  2381.                     }
  2382.                 }
  2383.             }
  2384.         }
  2385.        
  2386.         return infoServizio;
  2387.     }

  2388.    
  2389.    
  2390.    
  2391.    
  2392.     protected Allegati getAllegati(Connection connectionPdD, IDServizio idASPS)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2393.    
  2394.         Allegati allegati = new Allegati();
  2395.        
  2396.         AccordoServizioParteSpecifica asps = this.registroServizi.getAccordoServizioParteSpecifica(connectionPdD, null, idASPS, true);
  2397.         allegati.setAllegatiASParteSpecifica(asps.getAllegatoList());
  2398.         allegati.setSpecificheSemiformaliASParteSpecifica(asps.getSpecificaSemiformaleList());
  2399.         allegati.setSpecificheSicurezzaASParteSpecifica(asps.getSpecificaSicurezzaList());
  2400.         allegati.setSpecificheLivelloServizioASParteSpecifica(asps.getSpecificaLivelloServizioList());
  2401.        
  2402.         AccordoServizioParteComune aspc = this.registroServizi.getAccordoServizioParteComune(connectionPdD, null, this.idAccordoFactory.getIDAccordoFromUri(asps.getAccordoServizioParteComune()),true, false);
  2403.         allegati.setAllegatiASParteComune(aspc.getAllegatoList());
  2404.         allegati.setSpecificheSemiformaliASParteComune(aspc.getSpecificaSemiformaleList());
  2405.        
  2406.         return allegati;
  2407.        
  2408.     }
  2409.    
  2410.     protected Documento getAllegato(Connection connectionPdD, IDAccordo idAccordo, String nome, RequestInfo requestInfo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2411.         return this.registroServizi.getAllegato(connectionPdD, null, idAccordo, nome, requestInfo);
  2412.     }
  2413.     protected Documento getSpecificaSemiformale(Connection connectionPdD, IDAccordo idAccordo, TipiDocumentoSemiformale tipo, String nome, RequestInfo requestInfo)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2414.         return this.registroServizi.getSpecificaSemiformale(connectionPdD, null, idAccordo, tipo, nome, requestInfo);
  2415.     }
  2416.    
  2417.     protected Documento getAllegato(Connection connectionPdD, IDServizio idASPS, String nome, RequestInfo requestInfo)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2418.         return this.registroServizi.getAllegato(connectionPdD, null, idASPS, nome, requestInfo);
  2419.     }
  2420.     protected Documento getSpecificaSemiformale(Connection connectionPdD, IDServizio idASPS, TipiDocumentoSemiformale tipo, String nome, RequestInfo requestInfo)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2421.         return this.registroServizi.getSpecificaSemiformale(connectionPdD, null, idASPS, tipo, nome, requestInfo);
  2422.     }
  2423.     protected Documento getSpecificaSicurezza(Connection connectionPdD, IDServizio idASPS, TipiDocumentoSicurezza tipo, String nome, RequestInfo requestInfo)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2424.         return this.registroServizi.getSpecificaSicurezza(connectionPdD, null, idASPS, tipo, nome, requestInfo);
  2425.     }
  2426.     protected Documento getSpecificaLivelloServizio(Connection connectionPdD, IDServizio idASPS, TipiDocumentoLivelloServizio tipo, String nome, RequestInfo requestInfo)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2427.         return this.registroServizi.getSpecificaLivelloServizio(connectionPdD, null, idASPS, tipo, nome, requestInfo);
  2428.     }
  2429.    







  2430.     /**
  2431.      * Si occupa di ritornare le informazioni sui wsdl di un servizio
  2432.      *
  2433.      * @param idService Identificatore del Servizio di tipo {@link org.openspcoop2.core.id.IDServizio}.
  2434.      * @return l'oggetto di tipo {@link org.openspcoop2.core.registry.wsdl.AccordoServizioWrapper} se la ricerca nel registro ha successo,
  2435.      *         null altrimenti.
  2436.      */
  2437.     protected org.openspcoop2.core.registry.wsdl.AccordoServizioWrapper getWsdlAccordoServizio(Connection connectionPdD,IDServizio idService,InformationApiSource infoWsdlSource,boolean buildSchemaXSD, boolean readDatiRegistro)
  2438.             throws DriverRegistroServiziException,DriverRegistroServiziNotFound{

  2439.         return this.registroServizi.getWsdlAccordoServizio(connectionPdD, null, idService,infoWsdlSource,buildSchemaXSD, readDatiRegistro);
  2440.     }
  2441.    
  2442.     /**
  2443.      * Si occupa di ritornare le informazioni REST di un servizio
  2444.      *
  2445.      * @param idService Identificatore del Servizio di tipo {@link org.openspcoop2.core.id.IDServizio}.
  2446.      * @return l'oggetto di tipo {@link org.openspcoop2.core.registry.wsdl.AccordoServizioWrapper} se la ricerca nel registro ha successo,
  2447.      *         null altrimenti.
  2448.      */
  2449.     protected org.openspcoop2.core.registry.rest.AccordoServizioWrapper getRestAccordoServizio(Connection connectionPdD,IDServizio idService,InformationApiSource infoWsdlSource,boolean buildSchemaXSD, boolean processIncludeForOpenApi, boolean readDatiRegistro)
  2450.             throws DriverRegistroServiziException,DriverRegistroServiziNotFound{

  2451.         return this.registroServizi.getRestAccordoServizio(connectionPdD, null, idService,infoWsdlSource,buildSchemaXSD, processIncludeForOpenApi, readDatiRegistro);
  2452.     }
  2453.    
  2454.     /**
  2455.      * Si occupa di ritornare il tipo di service binding del servizio
  2456.      *
  2457.      * @param idService Identificatore del Servizio di tipo {@link org.openspcoop2.core.id.IDServizio}.
  2458.      * @return l'oggetto di tipo {@link org.openspcoop2.core.registry.constants.ServiceBinding} se la ricerca nel registro ha successo,
  2459.      *         null altrimenti.
  2460.      */
  2461.     protected org.openspcoop2.core.registry.constants.ServiceBinding getServiceBinding(Connection connectionPdD,IDServizio idService)
  2462.             throws DriverRegistroServiziException,DriverRegistroServiziNotFound{

  2463.         return this.registroServizi.getServiceBinding(connectionPdD, null, idService);
  2464.     }


  2465.     /**
  2466.      * Si occupa di verificare se un fruitore e' autorizzato ad invocare un servizio
  2467.      *
  2468.      * @param pdd Subject/Username della Porta di Dominio
  2469.      * @param servizioApplicativo Servizio Applicativo che richiede il processo
  2470.      * @param soggetto Soggetto con cui viene mappato il servizio applicativo
  2471.      * @param servizio Servizio invocato
  2472.      * @return true in caso di autorizzazione con successo, false altrimenti.
  2473.      * @throws DriverRegistroServiziServizioNotFound
  2474.      */
  2475.     protected EsitoAutorizzazioneRegistro isFruitoreServizioAutorizzato(Connection connectionPdD,String pdd,String servizioApplicativo,IDSoggetto soggetto,IDServizio servizio)
  2476.             throws DriverRegistroServiziException,DriverRegistroServiziNotFound, DriverRegistroServiziServizioNotFound{
  2477.         try{

  2478.             EsitoAutorizzazioneRegistro esitoAutorizzazione = new EsitoAutorizzazioneRegistro();
  2479.            
  2480.             if(soggetto==null){
  2481.                 String error = "identita del chiamante non fornita (autenticazione non attiva?)";
  2482.                 this.log.error("Identita del chiamante non fornita");
  2483.                 esitoAutorizzazione.setServizioAutorizzato(false);
  2484.                 esitoAutorizzazione.setDetails(error);
  2485.                 return esitoAutorizzazione;
  2486.             }
  2487.            
  2488.             // client-auth soggetto
  2489.             Soggetto fruitoreSoggetto = this.registroServizi.getSoggetto(connectionPdD,null, soggetto);
  2490.             if(fruitoreSoggetto.getPortaDominio()!=null){
  2491.                 PortaDominio portaDominio = this.registroServizi.getPortaDominio(connectionPdD,null, fruitoreSoggetto.getPortaDominio());
  2492.                 StatoFunzionalita authMode = portaDominio.getClientAuth();
  2493.                 if(authMode==null)
  2494.                     authMode = CostantiRegistroServizi.DISABILITATO;
  2495.                 if(CostantiRegistroServizi.ABILITATO.equals(authMode)){
  2496.                     if(pdd==null){
  2497.                         String error = "subject della porta di dominio che ha inviato la busta non presente (https attivo?, client-auth attivo?)";
  2498.                         this.log.error("Autorizzazione ("+soggetto.toString()+" -> "+servizio.toString()+") fallita: "+error);
  2499.                         esitoAutorizzazione.setServizioAutorizzato(false);
  2500.                         esitoAutorizzazione.setDetails(error);
  2501.                         return esitoAutorizzazione;
  2502.                     }
  2503.                     if(CertificateUtils.sslVerify(portaDominio.getSubject(), pdd, PrincipalType.SUBJECT, this.log)==false){
  2504.                     //if(pdd.equals(portaDominio.getSubject())==false){
  2505.                         String error = "subject estratto dal certificato client ["+pdd+"] diverso da quello registrato per la porta di dominio "+portaDominio.getNome()+" del mittente ["+portaDominio.getSubject()+"]";
  2506.                         this.log.error("Autorizzazione ("+soggetto.toString()+" -> "+servizio.toString()+") fallita: "+error);
  2507.                         esitoAutorizzazione.setServizioAutorizzato(false);
  2508.                         esitoAutorizzazione.setDetails(error);
  2509.                         return esitoAutorizzazione;
  2510.                     }else{
  2511.                         this.log.info("Autorizzazione ("+soggetto.toString()+" -> "+servizio.toString()+") effettuata: subject corrispondono");
  2512.                         esitoAutorizzazione.setServizioAutorizzato(true);
  2513.                         return esitoAutorizzazione;
  2514.                     }
  2515.                 }else if(CostantiRegistroServizi.DISABILITATO.equals(authMode)){
  2516.                     // filtro anti spam per default disabilitato
  2517.                     this.log.debug("Autorizzazione ("+soggetto.toString()+" -> "+servizio.toString()+") effettuata: client-auth disabilitato nella porta di dominio "+portaDominio.getNome());
  2518.                     esitoAutorizzazione.setServizioAutorizzato(true);
  2519.                     esitoAutorizzazione.setDetails("client-auth disabilitato nella porta di dominio "+portaDominio.getNome());
  2520.                     return esitoAutorizzazione;
  2521.                 }else{
  2522.                     throw new Exception("Valore di client-auth presente nella porta di dominio "+portaDominio.getNome()+" non valido: "+authMode);
  2523.                 }
  2524.             }else{
  2525.                 // filtro anti spam per default disabilitato
  2526.                 this.log.debug("Autorizzazione ("+soggetto.toString()+" -> "+servizio.toString()+") effettuata: client-auth non effettuata; il soggetto fruitore non è associato ad una porta di dominio");
  2527.                 esitoAutorizzazione.setServizioAutorizzato(true);
  2528.                 esitoAutorizzazione.setDetails("client-auth disabilitato");
  2529.                 return esitoAutorizzazione;
  2530.             }

  2531.         }catch(DriverRegistroServiziNotFound e){
  2532.             throw e;
  2533.         }catch(DriverRegistroServiziServizioNotFound e){
  2534.             throw e;
  2535.         }catch(Exception e){
  2536.             throw new DriverRegistroServiziException("Errore durante il controllo della fruizione di un servizio: "+e.getMessage(),e);
  2537.         }
  2538.     }









  2539.     /* ********  C O N N E T T O R I  ******** */

  2540.     /**
  2541.      * Si occupa di ritornare il connettore <var>nomeConnettore</var> associato al soggetto identificato grazie al parametro
  2542.      * <var>idSoggetto</var> di tipo {@link org.openspcoop2.core.id.IDSoggetto}.
  2543.      * Il connettore viene ricercato come definizione esterna, al soggetto (xml nel registro direttamente)
  2544.      *
  2545.      * @param nomeConnettore Connettore richiesto.
  2546.      * @param nomeRegistro nome del registro su cui effettuare la ricerca (null per effettuare una ricerca su tutti i registri)
  2547.      * @return l'oggetto di tipo {@link org.openspcoop2.core.config.Connettore} se la ricerca nel registro ha successo,
  2548.      *         null altrimenti.
  2549.      */
  2550.     private org.openspcoop2.core.config.Connettore getConnettore(IDSoggetto idSoggetto, String nomeConnettore,String nomeRegistro) {

  2551.         org.openspcoop2.core.registry.RegistroServizi [] registri = this.registroServizi.getRegistriServiziXML();
  2552.         if(registri!=null){
  2553.             for(int l=0; l<registri.length; l++){
  2554.                 for(int i=0; i< registri[l].sizeConnettoreList(); i++){
  2555.                     if(nomeConnettore.equals(registri[l].getConnettore(i).getNome())){
  2556.                         org.openspcoop2.core.registry.Connettore conn = registri[l].getConnettore(i);
  2557.                         if(conn!=null && !CostantiConfigurazione.NONE.equals(conn.getTipo()))
  2558.                             return conn.mappingIntoConnettoreConfigurazione();
  2559.                         else
  2560.                             return null;
  2561.                     }  
  2562.                 }
  2563.             }
  2564.         }
  2565.         return null;
  2566.     }

  2567.     /**
  2568.      * Si occupa di ritornare il connettore <var>nomeConnettore</var> associato al servizio di un soggetto
  2569.      * identificato grazie al parametro
  2570.      * <var>idService</var> di tipo {@link org.openspcoop2.core.id.IDServizio}.
  2571.      * (se non presente viene ritornato quello del soggetto erogatore del servizio)
  2572.      *
  2573.      * @param idService Identificatore del Servizio di tipo {@link org.openspcoop2.core.id.IDServizio}.
  2574.      * @param nomeConnettore Connettore richiesto.
  2575.      * @param nomeRegistro nome del registro su cui effettuare la ricerca (null per effettuare una ricerca su tutti i registri)
  2576.      * @return l'oggetto di tipo {@link org.openspcoop2.core.config.Connettore} se la ricerca nel registro ha successo,
  2577.      *         null altrimenti.
  2578.      */
  2579.     private org.openspcoop2.core.config.Connettore getConnettore(IDServizio idService, String nomeConnettore,String nomeRegistro){

  2580.         org.openspcoop2.core.registry.RegistroServizi [] registri = this.registroServizi.getRegistriServiziXML();
  2581.         if(registri!=null){
  2582.             for(int l=0; l<registri.length; l++){
  2583.                 for(int i=0; i< registri[l].sizeConnettoreList(); i++){
  2584.                     if(nomeConnettore.equals(registri[l].getConnettore(i).getNome())){
  2585.                         org.openspcoop2.core.registry.Connettore conn = registri[l].getConnettore(i);
  2586.                         if(conn!=null && !CostantiConfigurazione.NONE.equals(conn.getTipo()))
  2587.                             return conn.mappingIntoConnettoreConfigurazione();
  2588.                         else
  2589.                             return null;
  2590.                     }
  2591.                 }
  2592.             }
  2593.         }
  2594.         return null;
  2595.     }

  2596.     /**
  2597.      * Dato un oggetto di tipo {@link org.openspcoop2.core.id.IDServizio}, fornito con il parametro
  2598.      * <var>idService</var> cerca di trovare il connettore
  2599.      * associato al servizio, effettuando una ricerca gerarchica per:
  2600.      * <ul>
  2601.      * <li> Fruitore di un'Azione di un Servizio
  2602.      * <li> Azione di un Servizio
  2603.      * <li> Soggetto fruitore del Servizio
  2604.      * <li> Servizio
  2605.      * <li> Soggetto erogatore
  2606.      * </ul>
  2607.      * Quindi la ricerca scorre fintanto che non viene trovato un connettore,
  2608.      * cercandolo prima tra le informazioni associate al servizio,
  2609.      * fino a trovarlo obbligatoriamente nel soggetto erogatore.
  2610.      * Le informazioni sul connettore sono inserite in un oggetto di tipo {@link org.openspcoop2.core.config.Connettore}
  2611.      *
  2612.      * @param idSoggetto Soggetto richiedente del servizio
  2613.      * @param idService Identificativo del Servizio.
  2614.      * @param nomeRegistro nome del registro su cui effettuare la ricerca (null per effettuare una ricerca su tutti i registri)
  2615.      * @return il connettore ({@link org.openspcoop2.core.config.Connettore}) associato al servizio.
  2616.      */
  2617.     protected org.openspcoop2.core.config.Connettore getConnettore(Connection connectionPdD,IDSoggetto idSoggetto,IDServizio idService,String nomeRegistro)
  2618.             throws DriverRegistroServiziException,DriverRegistroServiziNotFound{

  2619.         if(idService == null)
  2620.             throw new DriverRegistroServiziException("getConnettore error: Servizio non definito");
  2621.         // ricerca servizio richiesto (Prima come servizio normale)
  2622.         org.openspcoop2.core.registry.AccordoServizioParteSpecifica servizio = null;
  2623.         try{
  2624.             servizio = this.registroServizi.getAccordoServizioParteSpecifica(connectionPdD,nomeRegistro,idService);
  2625.         }catch(DriverRegistroServiziNotFound e){
  2626.             // ignore
  2627.         }
  2628.         String uriServizio = null;
  2629.         try{
  2630.             uriServizio = IDServizioFactory.getInstance().getUriFromIDServizio(idService);
  2631.         }catch(Exception e){
  2632.             uriServizio = idService.toString(false);
  2633.         }
  2634.         if(servizio == null)
  2635.             throw new DriverRegistroServiziNotFound("getConnettore, Servizio ["+uriServizio+"] non definito nel registro");
  2636.         org.openspcoop2.core.config.Connettore connector = null;

  2637.         String azione = idService.getAzione();
  2638.         String nomeFruitore = idSoggetto.getNome();
  2639.         String tipoFruitore = idSoggetto.getTipo();

  2640.         //Cerco il connettore nel soggetto fruitore (e nelle azioni)
  2641.         if(connector == null || CostantiRegistroServizi.DISABILITATO.equals(connector.getTipo())){
  2642.             for(int i=0; i<servizio.sizeFruitoreList(); i++){
  2643.                 org.openspcoop2.core.registry.Fruitore f = servizio.getFruitore(i);
  2644.                 if( (f.getTipo() != null) &&
  2645.                         (f.getNome() != null) ){
  2646.                     if( (f.getTipo().equals(tipoFruitore)) &&
  2647.                             (f.getNome().equals(nomeFruitore)) ){
  2648.                        
  2649.                         for(int j=0; j<f.sizeConfigurazioneAzioneList();j++){
  2650.                             boolean findAzione = false;
  2651.                             ConfigurazioneServizioAzione conf = f.getConfigurazioneAzione(j);
  2652.                             if(conf!=null && conf.sizeAzioneList()>0) {
  2653.                                 for (String azioneCheck : conf.getAzioneList()) {
  2654.                                     if(azione!=null && azione.equals(azioneCheck)){
  2655.                                         findAzione = true;
  2656.                                     }
  2657.                                 }
  2658.                             }
  2659.                             if(findAzione){
  2660.                                 //  Uso il connettore dell'azione del fruitore
  2661.                                 if(conf.getConnettore()!=null){
  2662.                                     if (conf.getConnettore().getTipo() != null)
  2663.                                         connector = conf.getConnettore().mappingIntoConnettoreConfigurazione();
  2664.                                     else
  2665.                                         connector = getConnettore(idService,conf.getConnettore().getNome(),nomeRegistro);
  2666.                                 }
  2667.                                 break;
  2668.                             }
  2669.                         }
  2670.                        
  2671.                         if(connector!=null && !CostantiRegistroServizi.DISABILITATO.equals(connector.getTipo()))
  2672.                             break;
  2673.                        
  2674.                         if(f.getConnettore()!=null){
  2675.                             if (f.getConnettore().getTipo() != null)
  2676.                                 connector = f.getConnettore().mappingIntoConnettoreConfigurazione();
  2677.                             else
  2678.                                 connector = getConnettore(idService,f.getConnettore().getNome(),nomeRegistro);
  2679.                         }
  2680.                         break;
  2681.                     }
  2682.                 }
  2683.             }
  2684.         }

  2685.         //Cerco il connettore nell'azione del servizio
  2686.         if(connector == null || CostantiRegistroServizi.DISABILITATO.equals(connector.getTipo())){
  2687.             if(azione != null){
  2688.                 if(servizio.getConfigurazioneServizio()!=null){
  2689.                     for(int i=0; i<servizio.getConfigurazioneServizio().sizeConfigurazioneAzioneList();i++){
  2690.                         boolean findAzione = false;
  2691.                         ConfigurazioneServizioAzione conf = servizio.getConfigurazioneServizio().getConfigurazioneAzione(i);
  2692.                         if(conf!=null && conf.sizeAzioneList()>0) {
  2693.                             for (String azioneCheck : conf.getAzioneList()) {
  2694.                                 if(azione.equals(azioneCheck)){
  2695.                                     findAzione = true;
  2696.                                 }
  2697.                             }
  2698.                         }
  2699.                         if(findAzione){
  2700.                             //  Uso il connettore dell'azione
  2701.                             if(conf.getConnettore()!=null){
  2702.                                 if (conf.getConnettore().getTipo() != null)
  2703.                                     connector = conf.getConnettore().mappingIntoConnettoreConfigurazione();
  2704.                                 else
  2705.                                     connector = getConnettore(idService,conf.getConnettore().getNome(),nomeRegistro);
  2706.                             }
  2707.                             break;
  2708.                         }
  2709.                     }
  2710.                 }
  2711.             }
  2712.         }
  2713.        
  2714.         //Cerco il connettore nel servizio
  2715.         if (connector == null || CostantiRegistroServizi.DISABILITATO.equals(connector.getTipo())) {
  2716.             if(servizio.getConfigurazioneServizio()!=null && servizio.getConfigurazioneServizio().getConnettore()!=null){
  2717.                 if (servizio.getConfigurazioneServizio().getConnettore().getTipo() != null)
  2718.                     connector = servizio.getConfigurazioneServizio().getConnettore().mappingIntoConnettoreConfigurazione();
  2719.                 else
  2720.                     connector = getConnettore(idService,servizio.getConfigurazioneServizio().getConnettore().getNome(),nomeRegistro);
  2721.             }
  2722.         }

  2723.         //Cerco il connettore nel soggetto erogatore
  2724.         if (connector == null || CostantiRegistroServizi.DISABILITATO.equals(connector.getTipo())) {
  2725.             org.openspcoop2.core.registry.Soggetto soggettoErogatore = this.registroServizi.getSoggetto(connectionPdD,nomeRegistro,idService.getSoggettoErogatore());
  2726.             if(soggettoErogatore.getConnettore()!=null){
  2727.                 if(soggettoErogatore.getConnettore().getTipo()!=null)
  2728.                     connector = soggettoErogatore.getConnettore().mappingIntoConnettoreConfigurazione();
  2729.                 else
  2730.                     connector = getConnettore(idService,soggettoErogatore.getConnettore().getNome(),nomeRegistro);
  2731.             }
  2732.         }

  2733.         if (connector == null || CostantiRegistroServizi.DISABILITATO.equals(connector.getTipo()))
  2734.             throw new DriverRegistroServiziNotFound("Connettore non trovato per il Servizio ["+idService.toString()+"]");

  2735.         // imposto proprieta'
  2736.         connector.setNomeDestinatarioTrasmissioneBusta(idService.getSoggettoErogatore().getNome());
  2737.         connector.setTipoDestinatarioTrasmissioneBusta(idService.getSoggettoErogatore().getTipo());
  2738.        
  2739.         return connector;
  2740.     }


  2741.     /**
  2742.      * Dato un oggetto di tipo {@link org.openspcoop2.core.id.IDSoggetto}, fornito con il parametro
  2743.      * <var>idSoggetto</var> cerca di trovare il connettore
  2744.      * associato al soggetto.
  2745.      * Le informazioni sul connettore sono inserite in un oggetto di tipo {@link org.openspcoop2.core.config.Connettore}
  2746.      *
  2747.      * @param idSoggetto Identificativo del Soggetto.
  2748.      * @param nomeRegistro nome del registro su cui effettuare la ricerca (null per effettuare una ricerca su tutti i registri)
  2749.      * @return il connettore ({@link org.openspcoop2.core.config.Connettore}) associato al servizio.
  2750.      */
  2751.     protected org.openspcoop2.core.config.Connettore getConnettore(Connection connectionPdD,IDSoggetto idSoggetto,String nomeRegistro)
  2752.             throws DriverRegistroServiziException,DriverRegistroServiziNotFound{

  2753.         if(idSoggetto == null)
  2754.             throw new DriverRegistroServiziException("getConnettore error: Soggetto destinatario non definito");

  2755.         org.openspcoop2.core.config.Connettore connector = null;

  2756.         // utilizzo quello del soggetto
  2757.         org.openspcoop2.core.registry.Soggetto soggetto = this.registroServizi.getSoggetto(connectionPdD,nomeRegistro,idSoggetto);
  2758.         if(soggetto.getConnettore()!=null){
  2759.             if(soggetto.getConnettore().getTipo()!=null)
  2760.                 connector = soggetto.getConnettore().mappingIntoConnettoreConfigurazione(); // Connettore definito all'interno del servizio
  2761.             else
  2762.                 connector = getConnettore(idSoggetto,soggetto.getConnettore().getNome(),nomeRegistro);
  2763.         }

  2764.         if(connector==null || CostantiRegistroServizi.DISABILITATO.equals(connector.getTipo()))
  2765.             throw new DriverRegistroServiziNotFound("Connettore non trovato per il Soggetto ["+idSoggetto.toString()+"]");

  2766.         // raccolgo proprieta'
  2767.         connector.setNomeDestinatarioTrasmissioneBusta(idSoggetto.getNome());
  2768.         connector.setTipoDestinatarioTrasmissioneBusta(idSoggetto.getTipo());
  2769.         return connector;
  2770.     }
  2771.        










  2772.     /* ********  VALIDAZIONE  ******** */

  2773.     /**
  2774.      * Si occupa di ritornare il dominio associato ad un soggetto  
  2775.      * identificato grazie al parametro
  2776.      * <var>idSoggetto</var> di tipo {@link org.openspcoop2.core.id.IDSoggetto}.
  2777.      * Se il soggetto non e' registrato nel registro dei servizi ritorna null.
  2778.      *
  2779.      * @param idSoggetto Identificatore del Soggetto di tipo {@link org.openspcoop2.core.id.IDSoggetto}.
  2780.      * @param nomeRegistro nome del registro su cui effettuare la ricerca (null per effettuare una ricerca su tutti i registri)
  2781.      * @return il dominio associato al soggetto se la ricerca nel registro ha successo,
  2782.      *         null altrimenti.
  2783.      */
  2784.     protected String getDominio(Connection connectionPdD,IDSoggetto idSoggetto,String nomeRegistro,IProtocolFactory<?> protocolFactory)
  2785.             throws DriverRegistroServiziException,DriverRegistroServiziNotFound{

  2786.         if(idSoggetto == null)
  2787.             throw new DriverRegistroServiziException("getDominio error: soggetto non definito");

  2788.         org.openspcoop2.core.registry.Soggetto soggetto = this.registroServizi.getSoggetto(connectionPdD,nomeRegistro,idSoggetto);

  2789.         if(soggetto==null)
  2790.             throw new DriverRegistroServiziNotFound("getDominio, soggetto non definito nel registro");
  2791.         else{
  2792.             if(soggetto.getIdentificativoPorta() != null){
  2793.                 return soggetto.getIdentificativoPorta();
  2794.             }else{
  2795.                 try{
  2796.                     return protocolFactory.createTraduttore().getIdentificativoPortaDefault(idSoggetto);
  2797.                 }catch(Exception e){
  2798.                     throw new DriverRegistroServiziException(e.getMessage(),e);
  2799.                 }
  2800.             }
  2801.         }
  2802.     }
  2803.    
  2804.     /**
  2805.      * Si occupa di ritornare l'implementazione associata ad un soggetto  
  2806.      * identificata grazie al parametro
  2807.      * <var>idSoggetto</var> di tipo {@link org.openspcoop2.core.id.IDSoggetto}.
  2808.      * Se il soggetto non e' registrato nel registro dei servizi ritorna l'indicazione di una gestione 'Standard'.
  2809.      *
  2810.      * @param idSoggetto Identificatore del Soggetto di tipo {@link org.openspcoop2.core.id.IDSoggetto}.
  2811.      * @param nomeRegistro nome del registro su cui effettuare la ricerca (null per effettuare una ricerca su tutti i registri)
  2812.      * @return il dominio associato al soggetto se la ricerca nel registro ha successo,
  2813.      *         'standard' altrimenti.
  2814.      */
  2815.     protected String getImplementazionePdD(Connection connectionPdD,IDSoggetto idSoggetto,String nomeRegistro)
  2816.             throws DriverRegistroServiziException{

  2817.         try{
  2818.             PortaDominio pdd = this.getPortaDominio(connectionPdD, idSoggetto, nomeRegistro, "getImplementazionePdD");
  2819.             //if(pdd!=null){
  2820.             if(pdd.getImplementazione()!=null)
  2821.                 return pdd.getImplementazione();
  2822.             else
  2823.                 return CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD;
  2824.             //}else{
  2825.             //  return CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD;
  2826.             //}
  2827.         }catch(DriverRegistroServiziNotFound e){
  2828.             return CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD;
  2829.         }

  2830.     }
  2831.    
  2832.     protected String getIdPortaDominio(Connection connectionPdD,IDSoggetto idSoggetto,String nomeRegistro)
  2833.             throws DriverRegistroServiziException{

  2834.         try{
  2835.             PortaDominio pdd = this.getPortaDominio(connectionPdD, idSoggetto, nomeRegistro, "getImplementazionePdD");
  2836.             //if(pdd!=null){
  2837.             return pdd.getNome();
  2838.             //}else{
  2839.             //  return null; // significa che non è associato alcuna porta di dominio al soggetto
  2840.             //}
  2841.         }catch(DriverRegistroServiziNotFound e){
  2842.             return null; // significa che non è associato alcuna porta di dominio al soggetto
  2843.         }

  2844.     }
  2845.    
  2846.     private PortaDominio getPortaDominio(Connection connectionPdD,IDSoggetto idSoggetto,String nomeRegistro,String nomeMetodo)
  2847.             throws DriverRegistroServiziException, DriverRegistroServiziNotFound{

  2848.         // NOTA: non ritornare mai oggetto null!
  2849.        
  2850.         if(idSoggetto == null)
  2851.             throw new DriverRegistroServiziException(nomeMetodo+" error: soggetto non definito");

  2852.         org.openspcoop2.core.registry.Soggetto soggetto = null;
  2853.         try{
  2854.             soggetto = this.registroServizi.getSoggetto(connectionPdD,nomeRegistro,idSoggetto);
  2855.             if(soggetto == null){
  2856.                 throw new DriverRegistroServiziNotFound("Soggetto non esistente (null)");
  2857.             }
  2858.         }catch(DriverRegistroServiziNotFound e){
  2859.             this.log.debug(nomeMetodo+", soggetto ["+idSoggetto.toString()+"] non trovato: "+e.getMessage());
  2860.             throw e;
  2861.         }catch(DriverRegistroServiziException ex){
  2862.             this.log.error(nomeMetodo+", soggetto ["+idSoggetto.toString()+"] ricerca con errore: "+ex.getMessage(),ex);
  2863.             throw ex;
  2864.         }catch(Exception ex){
  2865.             this.log.error(nomeMetodo+", soggetto ["+idSoggetto.toString()+"] ricerca con errore generale: "+ex.getMessage(),ex);
  2866.             throw new DriverRegistroServiziException(nomeMetodo+", soggetto ["+idSoggetto.toString()+"] ricerca con errore generale: "+ex.getMessage(),ex);
  2867.         }
  2868.        
  2869.        
  2870.         if(soggetto.getPortaDominio()!=null){
  2871.             PortaDominio pdd = null;
  2872.             try{
  2873.                 pdd = this.registroServizi.getPortaDominio(connectionPdD,nomeRegistro, soggetto.getPortaDominio());
  2874.                 if(pdd == null){
  2875.                     throw new DriverRegistroServiziNotFound("PdD non esistente (null)");
  2876.                 }
  2877.             }catch(DriverRegistroServiziNotFound e){
  2878.                 this.log.debug(nomeMetodo+", porta di domino ["+soggetto.getPortaDominio()+"] associata al soggetto ["+idSoggetto.toString()+"] non trovata: "+e.getMessage());
  2879.                 throw new DriverRegistroServiziNotFound("Il soggetto ["+idSoggetto.toString()+"] è associato ad una Porta di Dominio ["+soggetto.getPortaDominio()+"] non registrata",e);
  2880.             }catch(DriverRegistroServiziException ex){
  2881.                 this.log.error(nomeMetodo+", porta di domino ["+soggetto.getPortaDominio()+"] associata al soggetto ["+idSoggetto.toString()+"]  ricerca con errore: "+ex.getMessage(),ex);
  2882.                 throw ex;
  2883.             }catch(Exception ex){
  2884.                 this.log.error(nomeMetodo+", porta di domino ["+soggetto.getPortaDominio()+"] associata al soggetto ["+idSoggetto.toString()+"]  ricerca con errore generale: "+ex.getMessage(),ex);
  2885.                 throw new DriverRegistroServiziException(nomeMetodo+", porta di domino ["+soggetto.getPortaDominio()+"] associata al soggetto ["+idSoggetto.toString()+"]  ricerca con errore generale: "+ex.getMessage(),ex);
  2886.             }
  2887.             return pdd;
  2888.         }else{
  2889.             throw new DriverRegistroServiziNotFound("Il soggetto ["+idSoggetto.toString()+"] non è associato a nessuna Porta di Dominio");
  2890.         }
  2891.     }


  2892.     /**
  2893.      * Si occupa di ritornare il risultato della validazione di un servizio
  2894.      *
  2895.      * @param soggettoFruitore Fruitore del Servizio
  2896.      * @param idService Identificatore del Servizio di tipo {@link org.openspcoop2.core.id.IDServizio}.
  2897.      * @param nomeRegistro nome del registro su cui effettuare la ricerca (null per effettuare una ricerca su tutti i registri)
  2898.      * @return Risultato della Validazione
  2899.      */
  2900.     protected RisultatoValidazione validaServizio(Connection connectionPdD,IDSoggetto soggettoFruitore,IDServizio idService,String nomeRegistro)throws DriverRegistroServiziException,DriverRegistroServiziPortTypeNotFound{



  2901.         // 1. Check di esistenza del servizio
  2902.         RisultatoValidazione risultato = new RisultatoValidazione();

  2903.         if(idService == null){
  2904.             risultato.setServizioRegistrato(false);
  2905.             return risultato;
  2906.         }



  2907.         // 2. Ricerca Servizio e Check di correlazione
  2908.         boolean correlato = false;
  2909.         org.openspcoop2.core.registry.AccordoServizioParteSpecifica servizio = null;
  2910.         try{
  2911.             servizio = this.registroServizi.getAccordoServizioParteSpecifica(connectionPdD,nomeRegistro,idService);
  2912.         }catch(DriverRegistroServiziNotFound e){
  2913.             // ignore
  2914.         }
  2915.         if(servizio==null){
  2916.             risultato.setServizioRegistrato(false);
  2917.             return risultato;
  2918.         }
  2919.         else{
  2920.             correlato = TipologiaServizio.CORRELATO.equals(servizio.getTipologiaServizio());
  2921.         }
  2922.         risultato.setIsServizioCorrelato(correlato);

  2923.        
  2924.            
  2925.        
  2926.         // 3. Search accordo e portType
  2927.         String uriAccordo = servizio.getAccordoServizioParteComune();
  2928.         IDAccordo idAccordo = this.idAccordoFactory.getIDAccordoFromUri(uriAccordo);
  2929.         org.openspcoop2.core.registry.AccordoServizioParteComune as = null;
  2930.         try{
  2931.             as = this.registroServizi.getAccordoServizioParteComune(connectionPdD,nomeRegistro,idAccordo);
  2932.         }catch(DriverRegistroServiziNotFound e){
  2933.             // ignore
  2934.         }
  2935.         if (as == null){
  2936.             risultato.setServizioRegistrato(false);
  2937.             return risultato;
  2938.         }
  2939.         ServiceBinding serviceBinding = as.getServiceBinding();
  2940.        
  2941.         if(ServiceBinding.REST.equals(serviceBinding)) {
  2942.        
  2943.             risultato.setAccessoSenzaAzione(false);
  2944.            
  2945.             for(int i=0; i<as.sizeResourceList(); i++) {
  2946.                 risultato.addAzione(as.getResource(i).getNome());
  2947.             }
  2948.            
  2949.             risultato.setServizioRegistrato(true);
  2950.             return risultato;
  2951.            
  2952.         }
  2953.         else {
  2954.        
  2955.             org.openspcoop2.core.registry.PortType pt = null;
  2956.             // search port type
  2957.             if (servizio.getPortType()!=null){
  2958.                 for(int i=0; i<as.sizePortTypeList();i++){
  2959.                     if(servizio.getPortType().equals(as.getPortType(i).getNome())){
  2960.                         pt = as.getPortType(i);
  2961.                     }
  2962.                 }
  2963.                 if(pt==null){
  2964.                     throw new DriverRegistroServiziPortTypeNotFound("Port-Type ["+servizio.getPortType()+"] associato al servizio non definito nell'accordo di servizio "+uriAccordo);
  2965.                 }
  2966.             }
  2967.            
  2968.            
  2969.            
  2970.             // 4. Check di invocazione senza azione
  2971.             // controllo possibilita di utilizzare il servizio senza azione
  2972.             if(pt!=null){
  2973.                 // se e' definito un port-type non ha senso che si possa invocare il servizio (port-type) senza azione (operation).
  2974.                 risultato.setAccessoSenzaAzione(false);
  2975.             }else{
  2976.                 risultato.setAccessoSenzaAzione(as.getUtilizzoSenzaAzione());
  2977.             }
  2978.    
  2979.    
  2980.            
  2981.             // 5. Ricerca nome del servizio correlato  
  2982.             if(correlato == false && soggettoFruitore!=null){
  2983.                
  2984.                 // Profilo di collaborazione
  2985.                 ProfiloCollaborazione profiloCollaborazione = as.getProfiloCollaborazione();
  2986.                
  2987.                 if(idService.getAzione()!=null){
  2988.                     if(pt!=null){
  2989.                         if(pt.getProfiloCollaborazione()!=null)
  2990.                             profiloCollaborazione = pt.getProfiloCollaborazione();
  2991.                         for(int k=0; k<pt.sizeAzioneList(); k++){
  2992.                             if(idService.getAzione().equals(pt.getAzione(k).getNome())){
  2993.                                 if(pt.getAzione(k).getProfiloCollaborazione()!=null){
  2994.                                     profiloCollaborazione = pt.getAzione(k).getProfiloCollaborazione();
  2995.                                 }
  2996.                                 break;
  2997.                             }
  2998.                         }
  2999.                     }else{
  3000.                         for(int k=0; k<as.sizeAzioneList(); k++){
  3001.                             if(idService.getAzione().equals(as.getAzione(k).getNome())){
  3002.                                 if(as.getAzione(k).getProfiloCollaborazione()!=null){
  3003.                                     profiloCollaborazione = as.getAzione(k).getProfiloCollaborazione();
  3004.                                 }
  3005.                                 break;
  3006.                             }
  3007.                         }
  3008.                     }
  3009.                 }
  3010.                
  3011.                 //  Profilo Asincrono Simmetrico:
  3012.                 //  Si cerca un servizio correlato del soggetto fruitore
  3013.                 //  che contenga il riferimento all'accordo di servizio 'nomeAccordo'.
  3014.                 if(CostantiRegistroServizi.ASINCRONO_SIMMETRICO.equals(profiloCollaborazione)){
  3015.                     org.openspcoop2.core.registry.AccordoServizioParteSpecifica servizioC = null;
  3016.                     try{
  3017.                         servizioC = this.registroServizi.getAccordoServizioParteSpecifica_ServizioCorrelato(connectionPdD,nomeRegistro,soggettoFruitore,idAccordo);
  3018.                     }catch(DriverRegistroServiziNotFound e){
  3019.                         // ignore
  3020.                     }
  3021.                     if(servizioC!=null){
  3022.                         if(servizioC.getNome()!=null && servizioC.getTipo()!=null && servizioC.getVersione()!=null){
  3023.                             risultato.setTipoServizioCorrelato(servizioC.getTipo());
  3024.                             risultato.setServizioCorrelato(servizioC.getNome());
  3025.                             risultato.setVersioneServizioCorrelato(servizioC.getVersione());
  3026.                         }
  3027.                     }
  3028.                 }
  3029.                 // Profilo Asincrono Asimmetrico:
  3030.                 // Viene prima cercata nell'accordo, se presente, un'azione correlata all'azione della richiesta.
  3031.                 // Se non presente, o se l'azione della richiesta e' null allora si cerca un servizio correlato del soggetto erogatore (parametro idService.getSoggettoErogatore)
  3032.                 // che contenga il riferimento all'accordo di servizio 'nomeAccordo' di questo servizio.
  3033.                 else if(CostantiRegistroServizi.ASINCRONO_ASIMMETRICO.equals(profiloCollaborazione)){
  3034.                     // Azione
  3035.                     String azioneRichiesta = idService.getAzione();
  3036.                     String azioneCorrelata = null;
  3037.                     if(azioneRichiesta!=null){
  3038.                         if(pt!=null){
  3039.                             for(int i=0; i<pt.sizeAzioneList(); i++){
  3040.                                 if( azioneRichiesta.equals(pt.getAzione(i).getCorrelata()) ){
  3041.                                     azioneCorrelata = pt.getAzione(i).getCorrelata();
  3042.                                     break;
  3043.                                 }
  3044.                             }
  3045.                         }else{
  3046.                             for(int i=0; i<as.sizeAzioneList(); i++){
  3047.                                 if( azioneRichiesta.equals(as.getAzione(i).getCorrelata()) ){
  3048.                                     azioneCorrelata = as.getAzione(i).getCorrelata();
  3049.                                     break;
  3050.                                 }
  3051.                             }
  3052.                         }
  3053.                     }
  3054.                    
  3055.                     if(azioneCorrelata!=null){
  3056.                         risultato.setTipoServizioCorrelato(idService.getTipo());
  3057.                         risultato.setServizioCorrelato(idService.getNome());
  3058.                         risultato.setVersioneServizioCorrelato(idService.getVersione());
  3059.                         risultato.setAzioneCorrelata(azioneCorrelata);
  3060.                     }else{
  3061.                         org.openspcoop2.core.registry.AccordoServizioParteSpecifica servizioC = null;
  3062.                         try{
  3063.                             servizioC = this.registroServizi.getAccordoServizioParteSpecifica_ServizioCorrelato(connectionPdD,nomeRegistro,idService.getSoggettoErogatore(),idAccordo);
  3064.                         }catch(DriverRegistroServiziNotFound e){
  3065.                             // ignore
  3066.                         }
  3067.                         if(servizioC!=null){
  3068.                             if(servizioC.getNome()!=null && servizioC.getTipo()!=null && servizioC.getVersione()!=null){
  3069.                                 risultato.setTipoServizioCorrelato(servizioC.getTipo());
  3070.                                 risultato.setServizioCorrelato(servizioC.getNome());
  3071.                                 risultato.setVersioneServizioCorrelato(servizioC.getVersione());
  3072.                             }
  3073.                         }
  3074.                     }
  3075.                 }
  3076.             }
  3077.    
  3078.    
  3079.             // 6. Azioni
  3080.             if(pt!=null){
  3081.                 for(int i=0; i<pt.sizeAzioneList(); i++) {
  3082.                     risultato.addAzione(pt.getAzione(i).getNome());
  3083.                 }
  3084.             }else{
  3085.                 for(int i=0; i<as.sizeAzioneList(); i++) {
  3086.                     risultato.addAzione(as.getAzione(i).getNome());
  3087.                 }
  3088.             }
  3089.            
  3090.            
  3091.            
  3092.             // 7. Tipologia di porta del soggetto fruitore
  3093.             /*
  3094.             Soggetto soggettoFruitore = null;
  3095.             try{
  3096.                 soggettoFruitore = this.registroServizi.getSoggetto(nomeRegistro, soggettoFruitore);
  3097.             }catch(DriverRegistroServiziNotFound e){
  3098.                 // ignore
  3099.             }
  3100.             if (soggettoFruitore == null){
  3101.                 this.log.debug("validaServizio, soggetto frutore ["+soggettoFruitore.toString()+"] non definito (o non registrato)");
  3102.                 risultato.setServizioRegistrato(false);
  3103.                 return risultato;
  3104.             }
  3105.             if(soggettoFruitore.getPortaDominio()!=null){
  3106.                 PortaDominio pdd = null;
  3107.                 try{
  3108.                     pdd = this.registroServizi.getPortaDominio(nomeRegistro, soggettoFruitore.getPortaDominio());
  3109.                 }catch(DriverRegistroServiziNotFound e){
  3110.                 // ignore
  3111.             }
  3112.                 if (pdd == null){
  3113.                     this.log.debug("validaServizio, porta di domino ["+soggettoFruitore.getPortaDominio()+"] associata al soggetto fruitore ["+soggettoFruitore.toString()+"] non definita (o non registrata)");
  3114.                     risultato.setServizioRegistrato(false);
  3115.                     return risultato;
  3116.                 }
  3117.                 if(pdd.getImplementazione()==null){
  3118.                     risultato.setImplementazionePdDSoggettoFruitore(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  3119.                 }else{
  3120.                     risultato.setImplementazionePdDSoggettoFruitore(pdd.getImplementazione());
  3121.                 }
  3122.             }else{
  3123.                 risultato.setImplementazionePdDSoggettoFruitore(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  3124.             }
  3125.             */
  3126.            
  3127.            
  3128.            
  3129.             // 8. Tipologia di porta del soggetto erogatore
  3130.             /*
  3131.             Soggetto soggettoErogatore = null;
  3132.             try{
  3133.                 soggettoErogatore = this.registroServizi.getSoggetto(nomeRegistro, idService.getSoggettoErogatore());
  3134.             }catch(DriverRegistroServiziNotFound e){
  3135.                 // ignore
  3136.             }
  3137.             if (soggettoErogatore == null){
  3138.                 this.log.debug("validaServizio, soggetto erogatore ["+idService.getSoggettoErogatore().toString()+"] non definito (o non registrato)");
  3139.                 risultato.setServizioRegistrato(false);
  3140.                 return risultato;
  3141.             }
  3142.             if(soggettoErogatore.getPortaDominio()!=null){
  3143.                 PortaDominio pdd = null;
  3144.                 try{
  3145.                     pdd = this.registroServizi.getPortaDominio(nomeRegistro, soggettoErogatore.getPortaDominio());
  3146.                 }catch(DriverRegistroServiziNotFound e){
  3147.                 // ignore
  3148.             }
  3149.                 if (pdd == null){
  3150.                     this.log.debug("validaServizio, porta di domino ["+soggettoErogatore.getPortaDominio()+"] associata al soggetto erogatore ["+idService.getSoggettoErogatore().toString()+"] non definita (o non registrata)");
  3151.                     risultato.setServizioRegistrato(false);
  3152.                     return risultato;
  3153.                 }
  3154.                 if(pdd.getImplementazione()==null){
  3155.                     risultato.setImplementazionePdDSoggettoErogatore(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  3156.                 }else{
  3157.                     risultato.setImplementazionePdDSoggettoErogatore(pdd.getImplementazione());
  3158.                 }
  3159.             }else{
  3160.                 risultato.setImplementazionePdDSoggettoErogatore(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  3161.             }
  3162.             */
  3163.            
  3164.         }
  3165.        
  3166.        

  3167.         risultato.setServizioRegistrato(true);
  3168.         return risultato;
  3169.     }

  3170.    
  3171.    
  3172.    
  3173.    
  3174.    
  3175.    
  3176.     /* ********  A U T E N T I C A Z I O N E   S O G G E T T I  ******** */
  3177.    
  3178.     public Soggetto getSoggettoByCredenzialiBasic(Connection connectionPdD,String username, String password, CryptConfig cryptConfig, String nomeRegistro)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3179.         return this.registroServizi.getSoggettoByCredenzialiBasic(connectionPdD, nomeRegistro, username, password, cryptConfig);
  3180.     }
  3181.    
  3182.     public Soggetto getSoggettoByCredenzialiApiKey(Connection connectionPdD,String username, String password, boolean appId, CryptConfig cryptConfig, String nomeRegistro)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3183.         return this.registroServizi.getSoggettoByCredenzialiApiKey(connectionPdD, nomeRegistro, username, password, appId, cryptConfig);
  3184.     }
  3185.    
  3186.     public Soggetto getSoggettoByCredenzialiSsl(Connection connectionPdD,String subject, String issuer, String nomeRegistro)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3187.         return this.registroServizi.getSoggettoByCredenzialiSsl(connectionPdD, nomeRegistro, subject, issuer);
  3188.     }
  3189.    
  3190.     public Soggetto getSoggettoByCredenzialiSsl(Connection connectionPdD,CertificateInfo certificate, boolean strictVerifier, String nomeRegistro)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3191.         return this.registroServizi.getSoggettoByCredenzialiSsl(connectionPdD, nomeRegistro, certificate, strictVerifier);
  3192.     }
  3193.    
  3194.     public Soggetto getSoggettoByCredenzialiPrincipal(Connection connectionPdD,String principal, String nomeRegistro)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3195.         return this.registroServizi.getSoggettoByCredenzialiPrincipal(connectionPdD, nomeRegistro, principal);
  3196.     }
  3197.    
  3198.     public IDSoggetto getIdSoggettoByCredenzialiBasic(Connection connectionPdD,String username, String password, CryptConfig cryptConfig, String nomeRegistro)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3199.         return convertToId(this.registroServizi.getSoggettoByCredenzialiBasic(connectionPdD, nomeRegistro, username, password, cryptConfig));
  3200.     }
  3201.    
  3202.     public IDSoggetto getIdSoggettoByCredenzialiApiKey(Connection connectionPdD,String username, String password,  boolean appId, CryptConfig cryptConfig, String nomeRegistro)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3203.         return convertToId(this.registroServizi.getSoggettoByCredenzialiApiKey(connectionPdD, nomeRegistro, username, password, appId, cryptConfig));
  3204.     }
  3205.    
  3206.     public IDSoggetto getIdSoggettoByCredenzialiSsl(Connection connectionPdD,String subject, String issuer, String nomeRegistro)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3207.         return convertToId(this.registroServizi.getSoggettoByCredenzialiSsl(connectionPdD, nomeRegistro, subject, issuer));
  3208.     }
  3209.    
  3210.     public IDSoggetto getIdSoggettoByCredenzialiSsl(Connection connectionPdD,CertificateInfo certificate, boolean strictVerifier, String nomeRegistro)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3211.         return convertToId(this.registroServizi.getSoggettoByCredenzialiSsl(connectionPdD, nomeRegistro, certificate, strictVerifier));
  3212.     }
  3213.    
  3214.     public IDSoggetto getIdSoggettoByCredenzialiPrincipal(Connection connectionPdD,String principal, String nomeRegistro)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3215.         return convertToId(this.registroServizi.getSoggettoByCredenzialiPrincipal(connectionPdD, nomeRegistro, principal));
  3216.     }
  3217.        
  3218.     private IDSoggetto convertToId(Soggetto s){
  3219.         IDSoggetto id = new IDSoggetto(s.getTipo(), s.getNome(), s.getIdentificativoPorta());
  3220.         return id;
  3221.     }
  3222.    
  3223.    
  3224.    
  3225.     /* ********  P R O P R I E T A  ******** */
  3226.    
  3227.     public Map<String, String> getProprietaConfigurazione(Soggetto soggetto) throws DriverRegistroServiziException {
  3228.         if (soggetto == null) {
  3229.             throw new DriverRegistroServiziException("Soggetto non fornito");
  3230.         } else if (soggetto.sizeProprietaList() <= 0) {
  3231.             return null;
  3232.         } else {
  3233.             Map<String, String> properties = new HashMap<>();

  3234.             for(int i = 0; i < soggetto.sizeProprietaList(); ++i) {
  3235.                 Proprieta p = soggetto.getProprieta(i);
  3236.                 properties.put(p.getNome(), p.getValore());
  3237.             }

  3238.             return properties;
  3239.         }
  3240.     }
  3241.    
  3242.    
  3243.    
  3244.    
  3245.    
  3246.     /* ********  C E R T I F I C A T I  ******** */
  3247.    
  3248.     protected CertificateCheck checkCertificatoSoggetto(Connection connectionPdD,boolean useCache,
  3249.             long idSoggetto, int sogliaWarningGiorni,
  3250.             boolean addCertificateDetails, String separator, String newLine) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  3251.        
  3252.         if(useCache) {
  3253.             throw new DriverRegistroServiziException("Not Implemented");
  3254.         }
  3255.        
  3256.         Soggetto soggetto = null;
  3257.         for (IDriverRegistroServiziGet driver : this.registroServizi.getDriverRegistroServizi().values()) {
  3258.             if(driver instanceof DriverRegistroServiziDB) {
  3259.                 DriverRegistroServiziDB driverDB = (DriverRegistroServiziDB) driver;
  3260.                 soggetto = driverDB.getSoggetto(idSoggetto);
  3261.                 break;
  3262.             }
  3263.             else {
  3264.                 throw new DriverRegistroServiziException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  3265.             }
  3266.         }
  3267.        
  3268.         return checkCertificatoSoggetto(soggetto,sogliaWarningGiorni,
  3269.                 addCertificateDetails, separator, newLine,
  3270.                 this.log);
  3271.     }
  3272.     protected CertificateCheck checkCertificatoSoggetto(Connection connectionPdD,boolean useCache,
  3273.             IDSoggetto idSoggetto, int sogliaWarningGiorni,
  3274.             boolean addCertificateDetails, String separator, String newLine) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  3275.        
  3276.         Soggetto soggetto = null;
  3277.         if(useCache) {
  3278.             this.registroServizi.getSoggetto(connectionPdD, null, idSoggetto);
  3279.         }
  3280.         else {
  3281.             for (IDriverRegistroServiziGet driver : this.registroServizi.getDriverRegistroServizi().values()) {
  3282.                 soggetto = driver.getSoggetto(idSoggetto);      
  3283.             }
  3284.         }
  3285.         return checkCertificatoSoggetto(soggetto, sogliaWarningGiorni,
  3286.                 addCertificateDetails, separator, newLine,
  3287.                 this.log);
  3288.     }
  3289.     public static CertificateCheck checkCertificatoSoggetto(Soggetto soggetto, int sogliaWarningGiorni,
  3290.             boolean addCertificateDetails, String separator, String newLine,
  3291.             Logger log) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  3292.        
  3293.         if(soggetto==null) {
  3294.             throw new DriverRegistroServiziException("Param soggetto is null");
  3295.         }
  3296.        
  3297.         if(soggetto.sizeCredenzialiList()<=0) {
  3298.             throw new DriverRegistroServiziException("Nessuna credenziale risulta associata al soggetto");
  3299.         }
  3300.         List<byte[]> certs = new ArrayList<byte[]>();
  3301.         List<Boolean> strictValidation = new ArrayList<Boolean>();
  3302.         for (int i = 0; i < soggetto.sizeCredenzialiList(); i++) {
  3303.             CredenzialiSoggetto c = soggetto.getCredenziali(i);
  3304.             if(!org.openspcoop2.core.registry.constants.CredenzialeTipo.SSL.equals(c.getTipo())) {
  3305.                 throw new DriverRegistroServiziException("La credenziale ("+c.getTipo()+") associata al soggetto non è un certificato x509");
  3306.             }
  3307.             if(c.getCertificate()!=null) {
  3308.                 certs.add(c.getCertificate());
  3309.                 strictValidation.add(c.isCertificateStrictVerification());
  3310.             }
  3311.         }
  3312.         if(certs.isEmpty()) {
  3313.             throw new DriverRegistroServiziException("Nessun certificato risulta associata al soggetto");
  3314.         }
  3315.         else {
  3316.             try {
  3317.                 return org.openspcoop2.protocol.registry.CertificateUtils.checkCertificateClient(certs, strictValidation, sogliaWarningGiorni,  
  3318.                         addCertificateDetails, separator, newLine,
  3319.                         log);
  3320.             }catch(Throwable t) {
  3321.                 throw new DriverRegistroServiziException(t.getMessage(),t);
  3322.             }
  3323.         }

  3324.     }
  3325.    
  3326.     protected CertificateCheck checkCertificatiConnettoreHttpsById(Connection connectionPdD,boolean useCache,
  3327.             long idConnettore, int sogliaWarningGiorni, IBYOKUnwrapFactory byokUnwrapFactory,
  3328.             boolean addCertificateDetails, String separator, String newLine) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  3329.        
  3330.         if(useCache) {
  3331.             throw new DriverRegistroServiziException("Not Implemented");
  3332.         }
  3333.        
  3334.         Connettore connettore = null;
  3335.         for (IDriverRegistroServiziGet driver : this.registroServizi.getDriverRegistroServizi().values()) {
  3336.             if(driver instanceof DriverRegistroServiziDB) {
  3337.                 DriverRegistroServiziDB driverDB = (DriverRegistroServiziDB) driver;
  3338.                 connettore = driverDB.getConnettore(idConnettore);
  3339.                 break;
  3340.             }
  3341.             else {
  3342.                 throw new DriverRegistroServiziException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  3343.             }
  3344.         }
  3345.        
  3346.         return checkCertificatiConnettoreHttpsById(connettore,
  3347.                 sogliaWarningGiorni, byokUnwrapFactory,
  3348.                 addCertificateDetails, separator, newLine,
  3349.                 this.log);
  3350.     }
  3351.     public static final String ID_CONFIGURAZIONE_CONNETTORE_HTTPS = "Configurazione connettore https";
  3352.     public static CertificateCheck checkCertificatiConnettoreHttpsById(Connettore connettore,
  3353.             int sogliaWarningGiorni, IBYOKUnwrapFactory byokUnwrapFactory,
  3354.             boolean addCertificateDetails, String separator, String newLine,
  3355.             Logger log) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  3356.        
  3357.         if(connettore==null) {
  3358.             throw new DriverRegistroServiziException("Param connettore is null");
  3359.         }
  3360.        
  3361.         TipiConnettore tipo = TipiConnettore.toEnumFromName(connettore.getTipo());
  3362.         if( !TipiConnettore.HTTPS.equals(tipo)) {
  3363.             throw new DriverRegistroServiziException("Il connettore indicato non è di tipo https");
  3364.         }
  3365.        
  3366.         SSLConfig httpsProp = null;
  3367.         try {
  3368.             httpsProp = ConnettoreHTTPSProperties.readProperties(connettore.getProperties());
  3369.         }catch(Throwable t) {
  3370.             throw new DriverRegistroServiziException(t.getMessage(),t);
  3371.         }
  3372.         CertificateCheck check = null;
  3373.         boolean classpathSupported = false;
  3374.                
  3375.         String storeDetails = null; // per evitare duplicazione
  3376.        
  3377.         if(httpsProp.getKeyStoreLocation()!=null) {
  3378.             try {
  3379.                 IBYOKUnwrapManager byokUnwrapManager = null;
  3380.                 if(byokUnwrapFactory!=null && httpsProp.getKeyStoreBYOKPolicy()!=null) {
  3381.                     byokUnwrapManager = byokUnwrapFactory.newInstance(httpsProp.getKeyStoreBYOKPolicy(),log);
  3382.                 }
  3383.                 check = org.openspcoop2.protocol.registry.CertificateUtils.checkKeyStore(httpsProp.getKeyStoreLocation(), classpathSupported, httpsProp.getKeyStoreType(),
  3384.                         httpsProp.getKeyStorePassword(),
  3385.                         byokUnwrapManager,
  3386.                         httpsProp.getKeyAlias(), httpsProp.getKeyPassword(),
  3387.                         sogliaWarningGiorni,
  3388.                         false, //addCertificateDetails,
  3389.                         separator, newLine,
  3390.                         log);
  3391.                
  3392.                 if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  3393.                     storeDetails = org.openspcoop2.protocol.registry.CertificateUtils.toStringKeyStore(httpsProp.getKeyStoreLocation(), httpsProp.getKeyStoreType(),
  3394.                             httpsProp.getKeyStoreBYOKPolicy(),
  3395.                             httpsProp.getKeyAlias(),
  3396.                             separator, newLine);
  3397.                 }
  3398.             }catch(Throwable t) {
  3399.                 throw new DriverRegistroServiziException(t.getMessage(),t);
  3400.             }
  3401.         }
  3402.        
  3403.         if(check==null || StatoCheck.OK.equals(check.getStatoCheck())) {
  3404.             if(!httpsProp.isTrustAllCerts() && httpsProp.getTrustStoreLocation()!=null) {
  3405.                 try {
  3406.                     check = org.openspcoop2.protocol.registry.CertificateUtils.checkTrustStore(httpsProp.getTrustStoreLocation(), classpathSupported, httpsProp.getTrustStoreType(),
  3407.                             httpsProp.getTrustStorePassword(), httpsProp.getTrustStoreCRLsLocation(), httpsProp.getTrustStoreOCSPPolicy(),
  3408.                             sogliaWarningGiorni,
  3409.                             false, //addCertificateDetails,
  3410.                             separator, newLine,
  3411.                             log);
  3412.                    
  3413.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  3414.                         storeDetails = org.openspcoop2.protocol.registry.CertificateUtils.toStringTrustStore(httpsProp.getTrustStoreLocation(), httpsProp.getTrustStoreType(),
  3415.                                 httpsProp.getTrustStoreCRLsLocation(), httpsProp.getTrustStoreOCSPPolicy(),
  3416.                                 separator, newLine);
  3417.                     }
  3418.                 }catch(Throwable t) {
  3419.                     throw new DriverRegistroServiziException(t.getMessage(),t);
  3420.                 }
  3421.             }
  3422.         }
  3423.        
  3424.         if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  3425.             String id = ID_CONFIGURAZIONE_CONNETTORE_HTTPS;
  3426.             if(addCertificateDetails && storeDetails!=null) {
  3427.                 id = id + newLine + storeDetails;
  3428.             }
  3429.             check.setConfigurationId(id);  
  3430.         }  
  3431.        
  3432.         if(check==null) {
  3433.             // connettore https con truststore 'all' senza client autentication
  3434.             check = new CertificateCheck();
  3435.             check.setStatoCheck(StatoCheck.OK);
  3436.         }
  3437.        
  3438.         return check;
  3439.     }
  3440.    
  3441.     protected CertificateCheck checkCertificatiModIErogazioneById(Connection connectionPdD,boolean useCache,
  3442.             long idAsps, int sogliaWarningGiorni, IBYOKUnwrapFactory byokUnwrapFactory,
  3443.             boolean addCertificateDetails, String separator, String newLine) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  3444.        
  3445.         if(connectionPdD!=null) {
  3446.             // nop
  3447.         }
  3448.        
  3449.         if(useCache) {
  3450.             throw new DriverRegistroServiziException("Not Implemented");
  3451.         }
  3452.        
  3453.         AccordoServizioParteSpecifica asps = null;
  3454.         AccordoServizioParteComune api = null;
  3455.         for (IDriverRegistroServiziGet driver : this.registroServizi.getDriverRegistroServizi().values()) {
  3456.             if(driver instanceof DriverRegistroServiziDB) {
  3457.                 DriverRegistroServiziDB driverDB = (DriverRegistroServiziDB) driver;
  3458.                 asps = driverDB.getAccordoServizioParteSpecifica(idAsps);
  3459.                 IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  3460.                 api = driverDB.getAccordoServizioParteComune(idAccordo);
  3461.                 break;
  3462.             }
  3463.             else {
  3464.                 throw new DriverRegistroServiziException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  3465.             }
  3466.         }
  3467.        
  3468.         return checkCertificatiModIErogazioneById(api,asps,
  3469.                 sogliaWarningGiorni, byokUnwrapFactory,
  3470.                 addCertificateDetails, separator, newLine,
  3471.                 this.log);
  3472.     }
  3473.     public static CertificateCheck checkCertificatiModIErogazioneById(AccordoServizioParteComune api, AccordoServizioParteSpecifica asps,
  3474.             int sogliaWarningGiorni, IBYOKUnwrapFactory byokUnwrapFactory,
  3475.             boolean addCertificateDetails, String separator, String newLine,
  3476.             Logger log) throws DriverRegistroServiziException {
  3477.        
  3478.         if(asps==null) {
  3479.             throw new DriverRegistroServiziException("Param asps is null");
  3480.         }
  3481.        
  3482.         boolean modi = asps.getTipoSoggettoErogatore().equals(CostantiLabel.MODIPA_PROTOCOL_NAME);
  3483.         if(!modi) {
  3484.             throw new DriverRegistroServiziException("Il profilo di interoperabilità non è "+CostantiLabel.MODIPA_PROTOCOL_LABEL);
  3485.         }
  3486.        
  3487.         KeystoreParams keystoreParams = null;
  3488.         // il keystore viene utilizzato se c'è la gestione risposta.
  3489.         boolean sicurezzaRisposta = false;
  3490.         if(ModISecurityUtils.isSicurezzaMessaggioRequired(api, asps.getPortType())) {
  3491.             sicurezzaRisposta = ModISecurityUtils.isProfiloSicurezzaMessaggioApplicabileRisposta(api, asps.getPortType(), true);
  3492.         }
  3493.         if(sicurezzaRisposta) {
  3494.             try {
  3495.                 keystoreParams = ModIUtils.getKeyStoreParams(asps.getProtocolPropertyList(), false);
  3496.             }catch(Exception e) {
  3497.                 throw new DriverRegistroServiziException(e.getMessage(),e);
  3498.             }
  3499.         }
  3500.        
  3501.         KeystoreParams truststoreParams = null;
  3502.         try {
  3503.             truststoreParams = ModIUtils.getTrustStoreParams(asps.getProtocolPropertyList());
  3504.         }catch(Exception e) {
  3505.             throw new DriverRegistroServiziException(e.getMessage(),e);
  3506.         }
  3507.         KeystoreParams truststoreSslParams = null;
  3508.         try {
  3509.             truststoreSslParams = ModIUtils.getTrustStoreSSLParams(asps.getProtocolPropertyList());
  3510.         }catch(Exception e) {
  3511.             throw new DriverRegistroServiziException(e.getMessage(),e);
  3512.         }

  3513.         List<RemoteStoreConfig> trustStoreRemoteConfig = null;
  3514.         try {
  3515.             trustStoreRemoteConfig = ModIUtils.getRemoteStoreConfig();
  3516.         }catch(Exception e) {
  3517.             throw new DriverRegistroServiziException(e.getMessage(),e);
  3518.         }
  3519.        
  3520.         return _checkStore(keystoreParams, byokUnwrapFactory,
  3521.                 truststoreParams,
  3522.                 truststoreSslParams,
  3523.                 sogliaWarningGiorni,
  3524.                 addCertificateDetails, separator, newLine,
  3525.                 log,
  3526.                 trustStoreRemoteConfig);
  3527.     }
  3528.    
  3529.     protected CertificateCheck checkCertificatiModIFruizioneById(Connection connectionPdD,boolean useCache,
  3530.             long idFruitore,
  3531.             int sogliaWarningGiorni, IBYOKUnwrapFactory byokUnwrapFactory,
  3532.             boolean addCertificateDetails, String separator, String newLine) throws DriverRegistroServiziException,DriverRegistroServiziNotFound {
  3533.        
  3534.         if(connectionPdD!=null) {
  3535.             // nop
  3536.         }
  3537.        
  3538.         if(useCache) {
  3539.             throw new DriverRegistroServiziException("Not Implemented");
  3540.         }
  3541.        
  3542.         AccordoServizioParteComune api = null;
  3543.         AccordoServizioParteSpecifica asps = null;
  3544.         Fruitore fruitore = null;
  3545.         for (IDriverRegistroServiziGet driver : this.registroServizi.getDriverRegistroServizi().values()) {
  3546.             if(driver instanceof DriverRegistroServiziDB) {
  3547.                 DriverRegistroServiziDB driverDB = (DriverRegistroServiziDB) driver;
  3548.                 fruitore = driverDB.getServizioFruitore(idFruitore);
  3549.                 asps = driverDB.getAccordoServizioParteSpecifica(fruitore.getIdServizio());
  3550.                 IDAccordo idAccordo = IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune());
  3551.                 api = driverDB.getAccordoServizioParteComune(idAccordo);
  3552.                 break;
  3553.             }
  3554.             else {
  3555.                 throw new DriverRegistroServiziException("Not Implemented with driver '"+driver.getClass().getName()+"'");
  3556.             }
  3557.         }
  3558.         if(fruitore==null) {
  3559.             throw new DriverRegistroServiziNotFound("Fruitore con id '"+idFruitore+"' non trovato");
  3560.         }
  3561.        
  3562.         return checkCertificatiModIFruizioneById(api, asps, fruitore,
  3563.                 sogliaWarningGiorni, byokUnwrapFactory,
  3564.                 addCertificateDetails, separator, newLine,
  3565.                 this.log);
  3566.     }
  3567.     public static CertificateCheck checkCertificatiModIFruizioneById(AccordoServizioParteComune api, AccordoServizioParteSpecifica asps, Fruitore fruitore,
  3568.             int sogliaWarningGiorni, IBYOKUnwrapFactory byokUnwrapFactory,
  3569.             boolean addCertificateDetails, String separator, String newLine,
  3570.             Logger log) throws DriverRegistroServiziException {
  3571.        
  3572.         boolean modi = fruitore.getTipo().equals(CostantiLabel.MODIPA_PROTOCOL_NAME);
  3573.         if(!modi) {
  3574.             throw new DriverRegistroServiziException("Il profilo di interoperabilità non è "+CostantiLabel.MODIPA_PROTOCOL_LABEL);
  3575.         }
  3576.        
  3577.         KeystoreParams keystoreParams = null;
  3578.         try {
  3579.             keystoreParams = ModIUtils.getKeyStoreParams(fruitore.getProtocolPropertyList(), true);
  3580.         }catch(Exception e) {
  3581.             throw new DriverRegistroServiziException(e.getMessage(),e);
  3582.         }
  3583.        
  3584.         KeystoreParams truststoreParams = null;
  3585.         KeystoreParams truststoreSslParams = null;
  3586.         List<RemoteStoreConfig> trustStoreRemoteConfig = null;
  3587.         // il truststore viene utilizzato se c'è la gestione risposta.
  3588.         boolean sicurezzaRisposta = false;
  3589.         if(ModISecurityUtils.isSicurezzaMessaggioRequired(api, asps.getPortType())) {
  3590.             sicurezzaRisposta = ModISecurityUtils.isProfiloSicurezzaMessaggioApplicabileRisposta(api, asps.getPortType(), true);
  3591.         }
  3592.         if(sicurezzaRisposta) {
  3593.             try {
  3594.                 truststoreParams = ModIUtils.getTrustStoreParams(fruitore.getProtocolPropertyList());
  3595.             }catch(Exception e) {
  3596.                 throw new DriverRegistroServiziException(e.getMessage(),e);
  3597.             }
  3598.             try {
  3599.                 truststoreSslParams = ModIUtils.getTrustStoreSSLParams(fruitore.getProtocolPropertyList());
  3600.             }catch(Exception e) {
  3601.                 throw new DriverRegistroServiziException(e.getMessage(),e);
  3602.             }
  3603.             try {
  3604.                 trustStoreRemoteConfig = ModIUtils.getRemoteStoreConfig();
  3605.             }catch(Exception e) {
  3606.                 throw new DriverRegistroServiziException(e.getMessage(),e);
  3607.             }
  3608.         }
  3609.        
  3610.         if(keystoreParams==null && !sicurezzaRisposta) {
  3611.             // non ci sono certificati da controllare
  3612.             CertificateCheck check = new CertificateCheck();
  3613.             check.setStatoCheck(StatoCheck.OK);
  3614.             return check;
  3615.         }
  3616.        
  3617.         return _checkStore(keystoreParams, byokUnwrapFactory,
  3618.                 truststoreParams,
  3619.                 truststoreSslParams,
  3620.                 sogliaWarningGiorni,
  3621.                 addCertificateDetails, separator, newLine,
  3622.                 log,
  3623.                 trustStoreRemoteConfig);
  3624.     }
  3625.    
  3626.     public static final String ID_CONFIGURAZIONE_FIRMA_MODI = "Configurazione della firma "+CostantiLabel.MODIPA_PROTOCOL_LABEL;
  3627.     private static CertificateCheck _checkStore(KeystoreParams keystoreParams, IBYOKUnwrapFactory byokUnwrapFactory,
  3628.             KeystoreParams truststoreParams,
  3629.             KeystoreParams truststoreSslParams,
  3630.             int sogliaWarningGiorni,
  3631.             boolean addCertificateDetails, String separator, String newLine,
  3632.             Logger log,
  3633.             List<RemoteStoreConfig> trustStoreRemoteConfig) throws DriverRegistroServiziException {
  3634.        
  3635.         if(keystoreParams==null && truststoreParams==null && truststoreSslParams==null) {
  3636.             throw new DriverRegistroServiziException("Non risulta alcun keystore ridefinito, da utilizzare per la gestione della firma "+CostantiLabel.MODIPA_PROTOCOL_LABEL);
  3637.         }
  3638.        
  3639.         CertificateCheck check = null;      
  3640.         boolean classpathSupported = false;
  3641.        
  3642.         String storeDetails = null; // per evitare duplicazione
  3643.        
  3644.         if(keystoreParams!=null) {
  3645.             try {
  3646.                 if(CostantiDB.KEYSTORE_TYPE_KEY_PAIR.equalsIgnoreCase(keystoreParams.getType())) {
  3647.                     IBYOKUnwrapManager byokUnwrapManager = null;
  3648.                     if(byokUnwrapFactory!=null && keystoreParams.getByokPolicy()!=null) {
  3649.                         byokUnwrapManager = byokUnwrapFactory.newInstance(keystoreParams.getByokPolicy(),log);
  3650.                     }
  3651.                     check = org.openspcoop2.protocol.registry.CertificateUtils.checkKeyPair(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyPairPublicKeyPath(), keystoreParams.getKeyPassword(), keystoreParams.getKeyPairAlgorithm(),
  3652.                             byokUnwrapManager,
  3653.                             false, //addCertificateDetails,  
  3654.                             separator, newLine);
  3655.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  3656.                         storeDetails = org.openspcoop2.protocol.registry.CertificateUtils.toStringKeyPair(keystoreParams,
  3657.                                 separator, newLine);
  3658.                     }
  3659.                 }
  3660.                 else if(CostantiDB.KEYSTORE_TYPE_PUBLIC_KEY.equalsIgnoreCase(keystoreParams.getType())) {
  3661.                     throw new DriverConfigurazioneException("Nella configurazione ModI viene utilizzato un keystore "+CostantiLabel.KEYSTORE_TYPE_PUBLIC_KEY+" non compatibile la firma dei messaggi");
  3662.                 }
  3663.                 else if(CostantiDB.KEYSTORE_TYPE_JWK.equalsIgnoreCase(keystoreParams.getType())) {
  3664.                     IBYOKUnwrapManager byokUnwrapManager = null;
  3665.                     if(byokUnwrapFactory!=null && keystoreParams.getByokPolicy()!=null) {
  3666.                         byokUnwrapManager = byokUnwrapFactory.newInstance(keystoreParams.getByokPolicy(),log);
  3667.                     }
  3668.                     check = org.openspcoop2.protocol.registry.CertificateUtils.checkKeystoreJWKs(classpathSupported, keystoreParams.getPath(), keystoreParams.getKeyAlias(),
  3669.                             byokUnwrapManager,
  3670.                             false, //addCertificateDetails,  
  3671.                             separator, newLine);
  3672.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  3673.                         storeDetails = org.openspcoop2.protocol.registry.CertificateUtils.toStringKeystoreJWKs(keystoreParams,
  3674.                                 separator, newLine);
  3675.                     }
  3676.                 }
  3677.                 else {
  3678.                     IBYOKUnwrapManager byokUnwrapManager = null;
  3679.                     if(byokUnwrapFactory!=null && keystoreParams.getByokPolicy()!=null) {
  3680.                         byokUnwrapManager = byokUnwrapFactory.newInstance(keystoreParams.getByokPolicy(),log);
  3681.                     }
  3682.                     if(keystoreParams.getStore()!=null) {
  3683.                         check = org.openspcoop2.protocol.registry.CertificateUtils.checkKeyStore(CostantiLabel.STORE_CARICATO_BASEDATI, keystoreParams.getStore(), keystoreParams.getType(), keystoreParams.getPassword(),
  3684.                                 byokUnwrapManager,
  3685.                                 keystoreParams.getKeyAlias(), keystoreParams.getKeyPassword(),
  3686.                                 sogliaWarningGiorni,
  3687.                                 false, //addCertificateDetails,
  3688.                                 separator, newLine,
  3689.                                 log);
  3690.                     }
  3691.                     else {
  3692.                         check = org.openspcoop2.protocol.registry.CertificateUtils.checkKeyStore(keystoreParams.getPath(), classpathSupported, keystoreParams.getType(), keystoreParams.getPassword(),
  3693.                                 byokUnwrapManager,
  3694.                                 keystoreParams.getKeyAlias(), keystoreParams.getKeyPassword(),
  3695.                                 sogliaWarningGiorni,
  3696.                                 false, //addCertificateDetails,
  3697.                                 separator, newLine,
  3698.                                 log);
  3699.                     }
  3700.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  3701.                         storeDetails = org.openspcoop2.protocol.registry.CertificateUtils.toStringKeyStore(keystoreParams, separator, newLine);
  3702.                     }
  3703.                 }
  3704.             }catch(Throwable t) {
  3705.                 throw new DriverRegistroServiziException(t.getMessage(),t);
  3706.             }
  3707.         }
  3708.        
  3709.         if(check==null || StatoCheck.OK.equals(check.getStatoCheck())) {
  3710.             if(truststoreParams!=null) {
  3711.                 try {
  3712.                     boolean isRemoteStore = false;
  3713.                     if(trustStoreRemoteConfig!=null && !trustStoreRemoteConfig.isEmpty()) {
  3714.                         for (RemoteStoreConfig remoteStoreConfig : trustStoreRemoteConfig) {
  3715.                             if(remoteStoreConfig!=null && remoteStoreConfig.getStoreName()!=null && remoteStoreConfig.getStoreName().equals(truststoreParams.getType())) {
  3716.                                 isRemoteStore = true;
  3717.                                 break;
  3718.                             }
  3719.                         }
  3720.                     }
  3721.                    
  3722.                     if(isRemoteStore) {
  3723.                         // nop; non posso effettuare verifiche
  3724.                         check = new CertificateCheck();
  3725.                         check.setStatoCheck(StatoCheck.OK);
  3726.                     }
  3727.                     else if(CostantiDB.KEYSTORE_TYPE_KEY_PAIR.equalsIgnoreCase(truststoreParams.getType())) {
  3728.                         throw new DriverConfigurazioneException("Nella configurazione ModI viene utilizzato un keystore "+CostantiLabel.KEYSTORE_TYPE_KEY_PAIR+" non compatibile la validazione della firma dei messaggi");
  3729.                     }
  3730.                     else if(CostantiDB.KEYSTORE_TYPE_PUBLIC_KEY.equalsIgnoreCase(truststoreParams.getType())) {
  3731.                         check = org.openspcoop2.protocol.registry.CertificateUtils.checkPublicKey(classpathSupported, truststoreParams.getPath(), truststoreParams.getKeyPairAlgorithm(),
  3732.                                 false, //addCertificateDetails,  
  3733.                                 separator, newLine);
  3734.                         if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  3735.                             storeDetails = org.openspcoop2.protocol.registry.CertificateUtils.toStringPublicKey(truststoreParams,
  3736.                                     separator, newLine);
  3737.                         }
  3738.                     }
  3739.                     else if(CostantiDB.KEYSTORE_TYPE_JWK.equalsIgnoreCase(truststoreParams.getType())) {
  3740.                         check = org.openspcoop2.protocol.registry.CertificateUtils.checkTruststoreJWKs(classpathSupported, truststoreParams.getPath(), truststoreParams.getKeyAlias(),
  3741.                                 false, //addCertificateDetails,  
  3742.                                 separator, newLine);
  3743.                         if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  3744.                             storeDetails = org.openspcoop2.protocol.registry.CertificateUtils.toStringKeystoreJWKs(truststoreParams,
  3745.                                     separator, newLine);
  3746.                         }
  3747.                     }
  3748.                     else {
  3749.                         check = org.openspcoop2.protocol.registry.CertificateUtils.checkTrustStore(truststoreParams.getPath(), classpathSupported, truststoreParams.getType(),
  3750.                                 truststoreParams.getPassword(), truststoreParams.getCrls(), truststoreParams.getOcspPolicy(),
  3751.                                 sogliaWarningGiorni,
  3752.                                 false, //addCertificateDetails,
  3753.                                 separator, newLine,
  3754.                                 log);
  3755.                         if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  3756.                             storeDetails = org.openspcoop2.protocol.registry.CertificateUtils.toStringTrustStore(truststoreParams, separator, newLine);
  3757.                         }
  3758.                     }
  3759.                 }catch(Throwable t) {
  3760.                     throw new DriverRegistroServiziException(t.getMessage(),t);
  3761.                 }
  3762.             }
  3763.         }
  3764.        
  3765.         if(check==null || StatoCheck.OK.equals(check.getStatoCheck())) {
  3766.             if(truststoreSslParams!=null) {
  3767.                 try {
  3768.                     check = org.openspcoop2.protocol.registry.CertificateUtils.checkTrustStore(truststoreSslParams.getPath(), classpathSupported, truststoreSslParams.getType(),
  3769.                             truststoreSslParams.getPassword(), truststoreSslParams.getCrls(), truststoreSslParams.getOcspPolicy(),
  3770.                             sogliaWarningGiorni,
  3771.                             false, //addCertificateDetails,
  3772.                             separator, newLine,
  3773.                             log);
  3774.                    
  3775.                     if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  3776.                         storeDetails = org.openspcoop2.protocol.registry.CertificateUtils.toStringTrustStore(truststoreSslParams, separator, newLine);
  3777.                     }
  3778.                 }catch(Throwable t) {
  3779.                     throw new DriverRegistroServiziException(t.getMessage(),t);
  3780.                 }
  3781.             }
  3782.         }
  3783.        
  3784.         if(check!=null && !StatoCheck.OK.equals(check.getStatoCheck())) {
  3785.             String id = ID_CONFIGURAZIONE_FIRMA_MODI;
  3786.             if(addCertificateDetails && storeDetails!=null) {
  3787.                 id = id + newLine + storeDetails;
  3788.             }
  3789.             check.setConfigurationId(id);  
  3790.         }
  3791.        
  3792.         return check;
  3793.     }
  3794.    
  3795.    
  3796.    
  3797.    
  3798.     /* ********  R I C E R C A  E L E M E N T I   P R I M I T I V I  ******** */
  3799.    
  3800.     public PortaDominio getPortaDominio(Connection connectionPdD,String nome,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3801.         return this.registroServizi.getPortaDominio(connectionPdD, nomeRegistro, nome);
  3802.     }
  3803.    
  3804.     public Ruolo getRuolo(Connection connectionPdD,String nome,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3805.         return this.registroServizi.getRuolo(connectionPdD, nomeRegistro, nome);
  3806.     }
  3807.    
  3808.     public Scope getScope(Connection connectionPdD,String nome,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3809.         return this.registroServizi.getScope(connectionPdD, nomeRegistro, nome);
  3810.     }

  3811.     public Soggetto getSoggetto(Connection connectionPdD,IDSoggetto idSoggetto,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3812.         return this.registroServizi.getSoggetto(connectionPdD, nomeRegistro, idSoggetto);
  3813.     }
  3814.    
  3815.     public AccordoServizioParteComune getAccordoServizioParteComune(Connection connectionPdD,IDAccordo idAccordo,Boolean readContenutiAllegati,Boolean readDatiRegistro,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3816.         return this.registroServizi.getAccordoServizioParteComune(connectionPdD, nomeRegistro, idAccordo, readContenutiAllegati, readDatiRegistro);
  3817.     }
  3818.    
  3819.     public AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(Connection connectionPdD,IDServizio idServizio,Boolean readContenutiAllegati,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3820.         return this.registroServizi.getAccordoServizioParteSpecifica(connectionPdD, nomeRegistro, idServizio, readContenutiAllegati);
  3821.     }
  3822.    
  3823.     public AccordoCooperazione getAccordoCooperazione(Connection connectionPdD,IDAccordoCooperazione idAccordoCooperazione,Boolean readContenutiAllegati,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3824.         return this.registroServizi.getAccordoCooperazione(connectionPdD, nomeRegistro, idAccordoCooperazione, readContenutiAllegati);
  3825.     }

  3826.    
  3827.    
  3828.    
  3829.     /* ********  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  ******** */
  3830.    
  3831.     public List<String> getAllIdPorteDominio(Connection connectionPdD,FiltroRicerca filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  3832.         return this.registroServizi.getAllIdPorteDominio(connectionPdD, nomeRegistro, filtroRicerca);
  3833.     }

  3834.     public List<IDGruppo> getAllIdGruppi(Connection connectionPdD,FiltroRicercaGruppi filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  3835.         return this.registroServizi.getAllIdGruppi(connectionPdD, nomeRegistro, filtroRicerca);
  3836.     }
  3837.    
  3838.     public List<IDRuolo> getAllIdRuoli(Connection connectionPdD,FiltroRicercaRuoli filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  3839.         return this.registroServizi.getAllIdRuoli(connectionPdD, nomeRegistro, filtroRicerca);
  3840.     }
  3841.    
  3842.     public List<IDScope> getAllIdScope(Connection connectionPdD,FiltroRicercaScope filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  3843.         return this.registroServizi.getAllIdScope(connectionPdD, nomeRegistro, filtroRicerca);
  3844.     }
  3845.    
  3846.     public List<IDSoggetto> getAllIdSoggetti(Connection connectionPdD,FiltroRicercaSoggetti filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  3847.         return this.registroServizi.getAllIdSoggetti(connectionPdD, nomeRegistro, filtroRicerca);
  3848.     }
  3849.    
  3850.     public List<IDAccordoCooperazione> getAllIdAccordiCooperazione(Connection connectionPdD,FiltroRicercaAccordi filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  3851.         return this.registroServizi.getAllIdAccordiCooperazione(connectionPdD, nomeRegistro, filtroRicerca);
  3852.     }
  3853.    
  3854.     public List<IDAccordo> getAllIdAccordiServizioParteComune(Connection connectionPdD,FiltroRicercaAccordi filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  3855.         return this.registroServizi.getAllIdAccordiServizioParteComune(connectionPdD, nomeRegistro, filtroRicerca);
  3856.     }
  3857.    
  3858.     public List<IDPortType> getAllIdPortType(Connection connectionPdD,FiltroRicercaPortTypes filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3859.         return this.registroServizi.getAllIdPortType(connectionPdD, nomeRegistro, filtroRicerca);
  3860.     }
  3861.    
  3862.     public List<IDPortTypeAzione> getAllIdAzionePortType(Connection connectionPdD,FiltroRicercaOperations filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3863.         return this.registroServizi.getAllIdAzionePortType(connectionPdD, nomeRegistro, filtroRicerca);
  3864.     }
  3865.    
  3866.     public List<IDAccordoAzione> getAllIdAzioneAccordo(Connection connectionPdD,FiltroRicercaAzioni filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3867.         return this.registroServizi.getAllIdAzioneAccordo(connectionPdD, nomeRegistro, filtroRicerca);
  3868.     }
  3869.    
  3870.     public List<IDResource> getAllIdResource(Connection connectionPdD,FiltroRicercaResources filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3871.         return this.registroServizi.getAllIdResource(connectionPdD, nomeRegistro, filtroRicerca);
  3872.     }
  3873.    
  3874.     public List<IDServizio> getAllIdServizi(Connection connectionPdD,FiltroRicercaServizi filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  3875.         return this.registroServizi.getAllIdServizi(connectionPdD, nomeRegistro, filtroRicerca);
  3876.     }
  3877.    
  3878.     public List<IDFruizione> getAllIdFruizioniServizio(Connection connectionPdD,FiltroRicercaFruizioniServizio filtroRicerca,String nomeRegistro) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  3879.         return this.registroServizi.getAllIdFruizioniServizio(connectionPdD, nomeRegistro, filtroRicerca);
  3880.     }

  3881.    
  3882.    
  3883.    
  3884.    
  3885.    
  3886.     /* ********  R E P O S I T O R Y    O G G E T T I   G E N E R I C I  ******** */
  3887.    
  3888.     public Serializable getGenericObject(String keyObject) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3889.         return this.registroServizi.getGenericObject(keyObject);
  3890.     }
  3891.    
  3892.     public Serializable pushGenericObject(String keyObject, Serializable object) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  3893.         return this.registroServizi.pushGenericObject(keyObject, object);
  3894.     }

  3895. }