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


  22. package org.openspcoop2.core.config.driver.xml;

  24. import java.io.File;
  25. import java.io.FileInputStream;
  26. import java.io.InputStream;
  27. import java.net.HttpURLConnection;
  28. import java.net.URL;
  29. import java.net.URLConnection;
  30. import java.util.ArrayList;
  31. import java.util.HashMap;
  32. import java.util.HashSet;
  33. import java.util.List;
  34. import java.util.Map;

  36. import org.openspcoop2.core.commons.CoreException;
  37. import org.openspcoop2.core.commons.IMonitoraggioRisorsa;
  38. import org.openspcoop2.core.config.AccessoConfigurazione;
  39. import org.openspcoop2.core.config.AccessoDatiAttributeAuthority;
  40. import org.openspcoop2.core.config.AccessoDatiAutenticazione;
  41. import org.openspcoop2.core.config.AccessoDatiAutorizzazione;
  42. import org.openspcoop2.core.config.AccessoDatiConsegnaApplicativi;
  43. import org.openspcoop2.core.config.AccessoDatiGestioneToken;
  44. import org.openspcoop2.core.config.AccessoDatiKeystore;
  45. import org.openspcoop2.core.config.AccessoDatiRichieste;
  46. import org.openspcoop2.core.config.AccessoRegistro;
  47. import org.openspcoop2.core.config.CanaliConfigurazione;
  48. import org.openspcoop2.core.config.Configurazione;
  49. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazione;
  50. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola;
  51. import org.openspcoop2.core.config.GenericProperties;
  52. import org.openspcoop2.core.config.GestioneErrore;
  53. import org.openspcoop2.core.config.Openspcoop2;
  54. import org.openspcoop2.core.config.PortaApplicativa;
  55. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  56. import org.openspcoop2.core.config.PortaDelegata;
  57. import org.openspcoop2.core.config.RegistroPlugin;
  58. import org.openspcoop2.core.config.RegistroPluginArchivio;
  59. import org.openspcoop2.core.config.RegistroPlugins;
  60. import org.openspcoop2.core.config.RoutingTable;
  61. import org.openspcoop2.core.config.ServizioApplicativo;
  62. import org.openspcoop2.core.config.Soggetto;
  63. import org.openspcoop2.core.config.StatoServiziPdd;
  64. import org.openspcoop2.core.config.SystemProperties;
  65. import org.openspcoop2.core.config.TrasformazioneRegola;
  66. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaServizioApplicativo;
  67. import org.openspcoop2.core.config.TrasformazioneRegolaApplicabilitaSoggetto;
  68. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  69. import org.openspcoop2.core.config.constants.PortaApplicativaAzioneIdentificazione;
  70. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  71. import org.openspcoop2.core.config.driver.BeanUtilities;
  72. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  73. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  74. import org.openspcoop2.core.config.driver.FiltroRicercaPorteApplicative;
  75. import org.openspcoop2.core.config.driver.FiltroRicercaPorteDelegate;
  76. import org.openspcoop2.core.config.driver.FiltroRicercaServiziApplicativi;
  77. import org.openspcoop2.core.config.driver.FiltroRicercaSoggetti;
  78. import org.openspcoop2.core.config.driver.IDServizioUtils;
  79. import org.openspcoop2.core.config.driver.IDriverConfigurazioneGet;
  80. import org.openspcoop2.core.config.driver.ValidazioneSemantica;
  81. import org.openspcoop2.core.id.IDConnettore;
  82. import org.openspcoop2.core.id.IDPortaApplicativa;
  83. import org.openspcoop2.core.id.IDPortaDelegata;
  84. import org.openspcoop2.core.id.IDServizio;
  85. import org.openspcoop2.core.id.IDServizioApplicativo;
  86. import org.openspcoop2.core.id.IDSoggetto;
  87. import org.openspcoop2.core.id.IdentificativiErogazione;
  88. import org.openspcoop2.core.id.IdentificativiFruizione;
  89. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  90. import org.openspcoop2.message.xml.ValidatoreXSD;
  91. import org.openspcoop2.utils.LoggerWrapperFactory;
  92. import org.openspcoop2.utils.certificate.ArchiveLoader;
  93. import org.openspcoop2.utils.certificate.ArchiveType;
  94. import org.openspcoop2.utils.certificate.Certificate;
  95. import org.openspcoop2.utils.certificate.CertificateInfo;
  96. import org.openspcoop2.utils.certificate.CertificateUtils;
  97. import org.openspcoop2.utils.certificate.PrincipalType;
  98. import org.openspcoop2.utils.crypt.CryptConfig;
  99. import org.openspcoop2.utils.crypt.CryptFactory;
  100. import org.openspcoop2.utils.crypt.ICrypt;
  101. import org.openspcoop2.utils.date.DateManager;
  102. import org.slf4j.Logger;

  104. /**
  105.  * Contiene un 'reader' della configurazione dell'infrastruttura OpenSPCoop.
  106.  * <p>
  107.  * Sono forniti metodi per la lettura della configurazione la quale contiene i seguenti soggetti :
  108.  * <ul>
  109.  * <li>Porte Delegate</li>
  110.  * <li>Porte Applicative</li>
  111.  * <li>SIL-Mittenti</li>
  112.  * <li>Porta di Dominio</li>
  113.  * <li>RoutingTable</li>
  114.  * <li>Altri aspetti di configurazione ...</li>
  115.  * </ul>
  116.  *
  117.  * @author Poli Andrea (apoli@link.it)
  118.  * @author $Author$
  119.  * @version $Rev$, $Date$
  120.  */

  122. public class DriverConfigurazioneXML extends BeanUtilities 
  123. implements IDriverConfigurazioneGet,IMonitoraggioRisorsa{

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

  127.     /** Indicazione di una corretta creazione */
  128.     public boolean create = false;

  130.     /** Path dove si trova il file xml che realizza la configurazione di OpenSPCoop. */
  131.     private String configuration_path;
  132.     /** 'Root' del servizio della configurazione di OpenSPCoop. */
  133.     private org.openspcoop2.core.config.Openspcoop2 openspcoop;

  135.     /** Validatore della configurazione */
  136.     private ValidatoreXSD validatoreConfigurazione = null;

  138.     /** Variabile che mantiene uno stato di ultima modifica della configurazione xml
  139.         od una variabile temporale che servira' per fare il refresh della configurazione 
  140.     una volta scaduto un timeout, nel caso il file sia posto in remoto (HTTP) .*/
  141.     private long lastModified = 0;
  142.     /** Logger utilizzato per info. */
  143.     private Logger log = null;
  144.     /** Indica ogni quanto deve essere effettuato il refresh del file dei registri dei servizi, 
  145.     nel caso sia posto in remoto (secondi)*/
  146.     private static final int timeoutRefresh = 30;




  151.     /** ************* parsing XML ************** */
  152.     private void parsingXMLConfigurazione() throws DriverConfigurazioneException{
  153.         
  154.         /* --- Validazione XSD -- */
  155.         if(buildXsdValidator) {
  156.             FileInputStream fXML = null;
  157.             try{
  158.                 if(this.configuration_path.startsWith("http://") || this.configuration_path.startsWith("file://")){
  159.                     this.validatoreConfigurazione.valida(this.configuration_path);  
  160.                 }else{
  161.                     fXML = new FileInputStream(this.configuration_path);
  162.                     this.validatoreConfigurazione.valida(fXML);
  163.                 }
  164.             }catch (Exception e) {
  165.                 throw new DriverConfigurazioneException("Riscontrato errore durante la validazione XSD della configurazione XML di OpenSPCoop: "+e.getMessage());
  166.             }finally{
  167.                 if(fXML!=null){
  168.                     try{
  169.                         fXML.close();
  170.                     }catch(Exception e){}
  171.                 }
  172.             }
  173.         }

  175.         /* ---- InputStream ---- */
  176.         InputStream iStream = null;
  177.         HttpURLConnection httpConn = null;
  178.         if(this.configuration_path.startsWith("http://") || this.configuration_path.startsWith("file://")){
  179.             try{ 
  180.                 URL url = new URL(this.configuration_path);
  181.                 URLConnection connection = url.openConnection();
  182.                 httpConn = (HttpURLConnection) connection;
  183.                 httpConn.setRequestMethod("GET");
  184.                 httpConn.setDoOutput(true);
  185.                 httpConn.setDoInput(true);
  186.                 iStream = httpConn.getInputStream();
  187.             }catch(Exception e) {
  188.                 try{  
  189. //                  if(iStream!=null)
  190. //                      iStream.close();
  191.                     if(httpConn !=null)
  192.                         httpConn.disconnect();
  193.                 } catch(Exception ef) {}
  194.                 throw new DriverConfigurazioneException("Riscontrato errore durante la creazione dell'inputStream della configurazione (HTTP) : \n\n"+e.getMessage());
  195.             }
  196.             this.lastModified = DateManager.getTimeMillis();
  197.         }else{
  198.             try{  
  199.                 iStream = new FileInputStream(this.configuration_path);
  200.             }catch(java.io.FileNotFoundException e) {
  201.                 throw new DriverConfigurazioneException("Riscontrato errore durante la creazione dell'inputStream della configurazione (FILE) : \n\n"+e.getMessage());
  202.             }
  203.             try{
  204.                 this.lastModified = (new File(this.configuration_path)).lastModified();
  205.             }catch(Exception e){
  206.                 try{  
  207.                     if(iStream!=null)
  208.                         iStream.close();
  209.                 } catch(java.io.IOException ef) {}
  210.                 throw new DriverConfigurazioneException("Riscontrato errore durante la lettura del file dove e' allocato la configurazione: "+e.getMessage());
  211.             }
  212.         }


  215.         /* ---- Unmarshall del file di configurazione ---- */
  216.         try{  
  217.             org.openspcoop2.core.config.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.config.utils.serializer.JaxbDeserializer();
  218.             this.openspcoop = deserializer.readOpenspcoop2(iStream);
  219.         } catch(Exception e) {
  220.             try{  
  221.                 if(iStream!=null)
  222.                     iStream.close();
  223.             } catch(Exception ef) {}
  224.             try{ 
  225.                 if(httpConn !=null)
  226.                     httpConn.disconnect();
  227.             } catch(Exception ef) {}
  228.             throw new DriverConfigurazioneException("Riscontrato errore durante l'unmarshall del file di configurazione: "+e.getMessage());
  229.         }
  230.         
  231.         try{  
  232.             // Chiusura dello Stream
  233.             if(iStream!=null)
  234.                 iStream.close();
  235.         } catch(Exception e) {
  236.             throw new DriverConfigurazioneException("Riscontrato errore durante la chiusura dell'Input Stream: "+e.getMessage());
  237.         }
  238.         try{
  239.             // Chiusura dell'eventuale connessione HTTP
  240.             if(httpConn !=null)
  241.                 httpConn.disconnect();
  242.         } catch(Exception e) {
  243.             throw new DriverConfigurazioneException("Riscontrato errore durante la chiusura dell'Input Stream (http): "+e.getMessage());
  244.         }
  245.     }




  250.     /* ********  COSTRUTTORI e METODI DI RELOAD  ******** */

  252.     private static boolean buildXsdValidator = true;
  253.     public static void disableBuildXsdValidator() {
  254.         buildXsdValidator = false;
  255.     }
  256.     
  257.     /**
  258.      * Costruttore.  Viene effettuato l'unmarshall del file di configurazione.
  259.      *
  260.      * @param path path dove si trova il file xml che realizza la configurazione di OpenSPCoop.
  261.      * 
  262.      */
  263.     public DriverConfigurazioneXML(String path,Logger alog){

  265.         if(alog==null)
  266.             this.log = LoggerWrapperFactory.getLogger(DriverConfigurazioneXML.class);
  267.         else
  268.             this.log = alog;
  269.         
  270.         if(path == null){
  271.             this.log.error("DriverConfigurazione: Riscontrato errore durante la creazione: url/path is null");
  272.             this.create=false;
  273.             return;
  274.         }
  275.         this.configuration_path = path;

  277.         /* --- Costruzione Validatore XSD -- */
  278.         try{
  279.             if(buildXsdValidator) {
  280.                 this.validatoreConfigurazione = new ValidatoreXSD(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), this.log,DriverConfigurazioneXML.class.getResourceAsStream("/config.xsd"));
  281.             }
  282.         }catch (Exception e) {
  283.             this.log.info("Riscontrato errore durante l'inizializzazione dello schema della configurazione di OpenSPCoop: "+e.getMessage(),e);
  284.             return;
  285.         }

  287.         try{
  288.             this.parsingXMLConfigurazione();
  289.         }catch(Exception e){
  290.             this.log.error("DriverConfigurazione: "+e.getMessage(),e);
  291.             this.create=false;
  292.             return;
  293.         }
  294.         this.create = true;
  295.     }

  297.     /**
  298.      * Metodo che si occupa di effettuare il refresh dell'unmarshall del file di configurazione
  299.      * se il file di configurazione e' stato modificato dall'ultimo unmarshall.
  300.      *
  301.      * 
  302.      */
  303.     private void forzaRefreshConfigurazioneXML() throws DriverConfigurazioneException{
  304.         refreshConfigurazioneXML(true);
  305.     }
  306.     
  307.     /**
  308.      * Metodo che si occupa di effettuare il refresh dell'unmarshall del file di configurazione
  309.      * se il file di configurazione e' stato modificato dall'ultimo unmarshall.
  310.      *
  311.      * 
  312.      */
  313.     public void refreshConfigurazioneXML() throws DriverConfigurazioneException{
  314.         refreshConfigurazioneXML(false);
  315.     }

  317.     /**
  318.      * Metodo che si occupa di effettuare il refresh dell'unmarshall del file di configurazione
  319.      * se il file di configurazione e' stato modificato dall'ultimo unmarshall.
  320.      *
  321.      * 
  322.      */
  323.     private synchronized void refreshConfigurazioneXML(boolean refreshForzato) throws DriverConfigurazioneException{

  325.         File fTest = null;
  326.         boolean refresh = refreshForzato;
  327.         if(refreshForzato==false){
  328.             if(this.configuration_path.startsWith("http://") || this.configuration_path.startsWith("file://")){
  329.                 long now = DateManager.getTimeMillis();
  330.                 if( (now-this.lastModified) > (DriverConfigurazioneXML.timeoutRefresh*1000) ){
  331.                     refresh=true;
  332.                 }
  333.             }else{
  334.                 fTest = new File(this.configuration_path);
  335.                 if(this.lastModified != fTest.lastModified()){
  336.                     refresh = true;
  337.                 }
  338.             }
  339.         }
  340.         if(refresh){
  341.             try{
  342.                 this.parsingXMLConfigurazione();
  343.             }catch(Exception e){
  344.                 this.log.error("DriverConfigurazione refreshError: "+e.getMessage());
  345.                 throw new DriverConfigurazioneException("DriverConfigurazione refreshError: "+e.getMessage());
  346.             }
  347.             if(this.configuration_path.startsWith("http://")==false &&
  348.                 this.configuration_path.startsWith("file://")==false){
  349.                 this.log.warn("Reloaded configuration context.");
  350.             }

  352.             if(this.validazioneSemanticaDuranteModificaXML){
  353.                 ValidazioneSemantica validazioneSemantica = new ValidazioneSemantica(this.openspcoop,this.tipiConnettori,
  354.                         this.tipiSoggetti,this.tipiServiziSoap,this.tipiServiziRest,
  355.                         this.tipoMsgDiagnosticiAppender,this.tipoTracciamentoAppender,this.tipoDumpAppender,
  356.                         this.tipoAutenticazionePortaDelegata,this.tipoAutenticazionePortaApplicativa,
  357.                         this.tipoAutorizzazionePortaDelegata,this.tipoAutorizzazionePortaApplicativa,
  358.                         this.tipoAutorizzazioneContenutoPortaDelegata,this.tipoAutorizzazioneContenutoPortaApplicativa,
  359.                         this.tipoIntegrazionePD,this.tipoIntegrazionePA,
  360.                         true,
  361.                         this.log);
  362.                 try{
  363.                     validazioneSemantica.validazioneSemantica(false);
  364.                 }catch(Exception e){
  365.                     this.log.error("DriverConfigurazione refreshError(ValidazioneSemantica): "+e.getMessage());
  366.                     throw new DriverConfigurazioneException("DriverConfigurazione refreshError(ValidazioneSemantica): "+e.getMessage());
  367.                 }               
  368.             }
  369.         }

  371.         if(this.openspcoop == null){
  372.             this.log.error("DriverConfigurazione refreshError: istanza della configurazione is null dopo il refresh");
  373.             throw new DriverConfigurazioneException("DriverConfigurazione refreshError: istanza della configurazione is null dopo il refresh");
  374.         }

  376.     }


  379.     private boolean validazioneSemanticaDuranteModificaXML = false;
  380.     private String[] tipiConnettori = null;
  381.     private String[] tipiSoggetti = null;
  382.     private String[] tipiServiziSoap = null;
  383.     private String[] tipiServiziRest = null;
  384.     private String[] tipoMsgDiagnosticiAppender = null;
  385.     private String[] tipoTracciamentoAppender = null;
  386.     private String[] tipoDumpAppender = null;
  387.     private String[] tipoAutenticazionePortaDelegata = null;
  388.     private String[] tipoAutenticazionePortaApplicativa = null;
  389.     private String[] tipoAutorizzazionePortaDelegata = null;
  390.     private String[] tipoAutorizzazionePortaApplicativa = null;
  391.     private String[] tipoAutorizzazioneContenutoPortaDelegata = null;
  392.     private String[] tipoAutorizzazioneContenutoPortaApplicativa = null;
  393.     private String[] tipoIntegrazionePD = null;
  394.     private String[] tipoIntegrazionePA = null;
  395.     public void abilitazioneValidazioneSemanticaDuranteModificaXML(String[] tipiConnettori,
  396.             String[] tipiSoggetti,String[] tipiServiziSoap,String[] tipiServiziRest,
  397.             String[]tipoMsgDiagnosticiAppender,String[]tipoTracciamentoAppender,String[]tipoDumpAppender,
  398.             String[]tipoAutenticazionePortaDelegata,String[]tipoAutenticazionePortaApplicativa,
  399.             String[]tipoAutorizzazionePortaDelegata,String[]tipoAutorizzazionePortaApplicativa,
  400.             String[]tipoAutorizzazioneContenutoPortaDelegata,String[]tipoAutorizzazioneContenutoPortaApplicativa,
  401.             String[]tipoIntegrazionePD,String[]tipoIntegrazionePA){
  402.         this.validazioneSemanticaDuranteModificaXML = true;
  403.         
  404.         this.tipiConnettori = tipiConnettori;
  405.         this.tipiSoggetti = tipiSoggetti;
  406.         this.tipiServiziSoap = tipiServiziSoap;
  407.         this.tipiServiziRest = tipiServiziRest;
  408.         this.tipoMsgDiagnosticiAppender= tipoMsgDiagnosticiAppender;
  409.         this.tipoTracciamentoAppender=tipoTracciamentoAppender;
  410.         this.tipoDumpAppender=tipoDumpAppender;
  411.         this.tipoAutenticazionePortaDelegata=tipoAutenticazionePortaDelegata;
  412.         this.tipoAutenticazionePortaApplicativa=tipoAutenticazionePortaApplicativa;
  413.         this.tipoAutorizzazionePortaDelegata=tipoAutorizzazionePortaDelegata;
  414.         this.tipoAutorizzazionePortaApplicativa=tipoAutorizzazionePortaApplicativa;
  415.         this.tipoAutorizzazioneContenutoPortaDelegata=tipoAutorizzazioneContenutoPortaDelegata;
  416.         this.tipoAutorizzazioneContenutoPortaApplicativa=tipoAutorizzazioneContenutoPortaApplicativa;
  417.         this.tipoIntegrazionePD=tipoIntegrazionePD;
  418.         this.tipoIntegrazionePA=tipoIntegrazionePA;
  419.     }
  420.     
  421.     
  422.     






  429.     // SOGGETTO 
  430.     
  431.     /**
  432.      * Restituisce Il soggetto identificato da <var>idSoggetto</var>
  433.      *
  434.      * @param aSoggetto Identificatore di un soggetto
  435.      * @return Il Soggetto identificato dal parametro.
  436.      * 
  437.      */
  438.     @Override
  439.     public Soggetto getSoggetto(IDSoggetto aSoggetto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  441.         if( (aSoggetto == null) || (aSoggetto.getNome()==null) || (aSoggetto.getTipo()==null)){
  442.             throw new DriverConfigurazioneException("[getSoggetto] Parametri Non Validi");
  443.         }

  445.         refreshConfigurazioneXML();

  447.         for(int i=0;i<this.openspcoop.sizeSoggettoList();i++){
  448.             Soggetto soggetto = this.openspcoop.getSoggetto(i);

  450.             if( aSoggetto.getNome().equals(soggetto.getNome()) &&
  451.                     aSoggetto.getTipo().equals(soggetto.getTipo())){

  453.                 return soggetto;
  454.             }

  456.         }  

  458.         throw new DriverConfigurazioneNotFound("[getSoggetto] Soggetto "+aSoggetto.toString()+" non Esistente");
  459.     }

  461.     /**
  462.      * Restituisce il soggetto configurato come router, se esiste nella Porta di Dominio un soggetto registrato come Router
  463.      * 
  464.      * @return il soggetto configurato come router, se esiste nella Porta di Dominio un soggetto registrato come Router
  465.      * 
  466.      */
  467.     @Override
  468.     public Soggetto getRouter() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  470.         refreshConfigurazioneXML();

  472.         // Deve esistere un soggetto configurato come Router
  473.         for(int i=0; i<this.openspcoop.sizeSoggettoList();i++){
  474.             if(this.openspcoop.getSoggetto(i).getRouter())
  475.                 return this.openspcoop.getSoggetto(i);
  476.         }

  478.         throw new DriverConfigurazioneNotFound("[getRouter] Router non esistente");
  479.     }

  481.     /**
  482.      * Restituisce la lista dei soggetti virtuali gestiti dalla PdD
  483.      * 
  484.      * @return Restituisce la lista dei soggetti virtuali gestiti dalla PdD
  485.      * @throws DriverConfigurazioneException
  486.      */
  487.     @Override
  488.     public List<IDSoggetto> getSoggettiVirtuali() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{    

  490.         refreshConfigurazioneXML();

  492.         List<IDSoggetto> lista = new ArrayList<IDSoggetto>();
  493.         try{
  494.             for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  495.                 Soggetto soggetto = this.openspcoop.getSoggetto(i);
  496.                 for(int j=0; j<soggetto.sizePortaApplicativaList(); j++){
  497.                     PortaApplicativa pa = soggetto.getPortaApplicativa(j);
  498.                     if(pa.getSoggettoVirtuale()!=null && 
  499.                             pa.getSoggettoVirtuale().getTipo()!=null &&
  500.                             pa.getSoggettoVirtuale().getNome()!=null){
  501.                         IDSoggetto soggettoVirtuale = new IDSoggetto(pa.getSoggettoVirtuale().getTipo(),pa.getSoggettoVirtuale().getNome());
  502.                         if(lista.contains(soggettoVirtuale)==false){
  503.                             this.log.info("aggiunto Soggetto "+soggettoVirtuale+" alla lista dei Soggetti Virtuali");
  504.                             lista.add(soggettoVirtuale);
  505.                         }
  506.                     }
  507.                 }
  508.             }   
  509.         }catch(Exception e){
  510.             throw new DriverConfigurazioneException("[getSoggettiVirtuali] Inizializzazione lista dei soggetti virtuali non riuscita: "+e.getMessage());
  511.         }

  513.         if(lista.size()==0){
  514.             throw new DriverConfigurazioneNotFound("[getSoggettiVirtuali] Soggetti virtuali non esistenti");
  515.         }
  516.         
  517.         return lista;
  518.     }

  520.     /**
  521.      * Restituisce la lista dei soggetti virtuali gestiti dalla PdD
  522.      * 
  523.      * @return Restituisce la lista dei servizi associati a soggetti virtuali gestiti dalla PdD
  524.      * @throws DriverConfigurazioneException
  525.      */
  526.     @Override
  527.     public List<IDServizio> getServiziSoggettiVirtuali() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  528.         
  529.         refreshConfigurazioneXML();

  531.         List<IDServizio> lista = new ArrayList<>();
  532.         HashSet<String> unique = new HashSet<>();
  533.         try{
  534.             for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  535.                 Soggetto soggetto = this.openspcoop.getSoggetto(i);
  536.                 for(int j=0; j<soggetto.sizePortaApplicativaList(); j++){
  537.                     PortaApplicativa pa = soggetto.getPortaApplicativa(j);
  538.                     if(pa.getSoggettoVirtuale()!=null && 
  539.                             pa.getSoggettoVirtuale().getTipo()!=null &&
  540.                             pa.getSoggettoVirtuale().getNome()!=null){
  541.                         IDServizio s = IDServizioUtils.buildIDServizio(pa.getServizio().getTipo(), pa.getServizio().getNome(), 
  542.                                 new IDSoggetto(pa.getSoggettoVirtuale().getTipo(),pa.getSoggettoVirtuale().getNome()), 
  543.                                 pa.getServizio().getVersione());
  544.                         if(!unique.contains(s.toString())){
  545.                             /**log.info("aggiunto Servizio "+s.toString()+" alla lista dei servizi erogati da Soggetti Virtuali");*/
  546.                             lista.add(s);
  547.                             unique.add(s.toString());
  548.                         }
  549.                     }
  550.                 }
  551.             }   
  552.         }catch(Exception e){
  553.             throw new DriverConfigurazioneException("[getServiziSoggettiVirtuali] Inizializzazione lista servizi dei soggetti virtuali non riuscita: "+e.getMessage());
  554.         }
  555.         
  556.         
  557.         if(lista.isEmpty()){
  558.             throw new DriverConfigurazioneNotFound("[getServiziSoggettiVirtuali] Servizi erogati da Soggetti virtuali non esistenti");
  559.         }
  560.     
  561.         return lista;
  562.         
  563.     }
  564.     
  565.     /**
  566.      * Restituisce la lista degli identificativi dei soggetti
  567.      * 
  568.      * @param filtroRicerca
  569.      * @return lista degli identificativi dei soggetti
  570.      * @throws DriverConfigurazioneException
  571.      * @throws DriverConfigurazioneNotFound
  572.      */
  573.     @Override
  574.     public List<IDSoggetto> getAllIdSoggetti(
  575.             FiltroRicercaSoggetti filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  576.     
  577.         refreshConfigurazioneXML();
  578.         
  579.         List<IDSoggetto> listIDSoggetti = new ArrayList<IDSoggetto>();
  580.         
  581.         for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  582.             Soggetto soggetto = this.openspcoop.getSoggetto(i);
  583.             if(filtroRicerca!=null){
  584.                 // Filtro By Data
  585.                 if(filtroRicerca.getMinDate()!=null){
  586.                     if(soggetto.getOraRegistrazione()==null){
  587.                         this.log.debug("[getAllIdSoggetti](FiltroByMinDate) Soggetto ["+soggetto.getTipo()+"/"+soggetto.getNome()+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  588.                         continue;
  589.                     }else if(soggetto.getOraRegistrazione().before(filtroRicerca.getMinDate())){
  590.                         continue;
  591.                     }
  592.                 }
  593.                 if(filtroRicerca.getMaxDate()!=null){
  594.                     if(soggetto.getOraRegistrazione()==null){
  595.                         this.log.debug("[getAllIdSoggetti](FiltroByMaxDate) Soggetto ["+soggetto.getTipo()+"/"+soggetto.getNome()+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  596.                         continue;
  597.                     }else if(soggetto.getOraRegistrazione().after(filtroRicerca.getMaxDate())){
  598.                         continue;
  599.                     }
  600.                 }
  601.                 // Filtro By Tipo e Nome
  602.                 if(filtroRicerca.getTipo()!=null){
  603.                     if(soggetto.getTipo().equals(filtroRicerca.getTipo()) == false){
  604.                         continue;
  605.                     }
  606.                 }
  607.                 if(filtroRicerca.getNome()!=null){
  608.                     if(soggetto.getNome().equals(filtroRicerca.getNome()) == false){
  609.                         continue;
  610.                     }
  611.                 }
  612.             }
  613.             listIDSoggetti.add(new IDSoggetto(soggetto.getTipo(), soggetto.getNome()));
  614.         }
  615.         
  616.         if(listIDSoggetti.size()<=0){
  617.             if(filtroRicerca!=null)
  618.                 throw new DriverConfigurazioneNotFound("Soggetti non trovati che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  619.             else
  620.                 throw new DriverConfigurazioneNotFound("Soggetti non trovati");
  621.         }
  622.         
  623.         return listIDSoggetti;
  624.     }
  625.     
  626.     
  627.     
  628.     
  629.     
  630.     
  631.     
  632.     
  633.     // PORTA DELEGATA

  635.     private IDPortaDelegata convertToIDPortaDelegata(PortaDelegata pd) throws DriverConfigurazioneException{
  636.         
  637.         IDPortaDelegata idPD = new IDPortaDelegata();
  638.         idPD.setNome(pd.getNome());
  639.         
  640.         IdentificativiFruizione idFruizione = new IdentificativiFruizione();
  641.         
  642.         IDSoggetto soggettoFruitore = new IDSoggetto(pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario());
  643.         idFruizione.setSoggettoFruitore(soggettoFruitore);
  644.         
  645.         try{
  646.             IDServizio idServizio = IDServizioUtils.buildIDServizio(pd.getServizio().getTipo(), pd.getServizio().getNome(), 
  647.                     new IDSoggetto(pd.getSoggettoErogatore().getTipo(),pd.getSoggettoErogatore().getNome()), 
  648.                     pd.getServizio().getVersione()); 
  649.             if(pd.getAzione()!=null && pd.getAzione().getNome()!=null && !"".equals(pd.getAzione().getNome())){
  650.                 idServizio.setAzione(pd.getAzione().getNome()); 
  651.             }
  652.             idFruizione.setIdServizio(idServizio);
  653.         }catch(Exception e){
  654.             throw new DriverConfigurazioneException(e.getMessage(),e);
  655.         }
  656.         
  657.         idPD.setIdentificativiFruizione(idFruizione);
  658.         
  659.         return idPD;
  660.     }
  661.     
  662.     @Override
  663.     public IDPortaDelegata getIDPortaDelegata(String nome) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  665.         if(nome == null)
  666.             throw new DriverConfigurazioneException("[getIDPortaDelegata] Parametro Non Validi");

  668.         refreshConfigurazioneXML();

  670.         for(int i=0;i<this.openspcoop.sizeSoggettoList();i++){
  671.             Soggetto soggetto = this.openspcoop.getSoggetto(i);

  673.             //  ricerca PD
  674.             for(int j=0; j<soggetto.sizePortaDelegataList() ; j++){
  675.                 PortaDelegata pd = soggetto.getPortaDelegata(j);
  676.                 if(nome.equals(pd.getNome())){
  677.                     pd.setTipoSoggettoProprietario(soggetto.getTipo());
  678.                     pd.setNomeSoggettoProprietario(soggetto.getNome());
  679.                     return convertToIDPortaDelegata(pd);
  680.                 }
  681.             }  
  682.         }  

  684.         throw new DriverConfigurazioneNotFound("Porta Delegata ["+nome+"] non esistente");
  685.     }
  686.     
  687.     @Override
  688.     public PortaDelegata getPortaDelegata(IDPortaDelegata idPD) throws DriverConfigurazioneException,DriverConfigurazioneNotFound { 

  690.         if(idPD == null)
  691.             throw new DriverConfigurazioneException("[getPortaDelegata] Parametro idPD Non Validi");

  693.         String nome = idPD.getNome();

  695.         if( (nome == null) )
  696.             throw new DriverConfigurazioneException("[getPortaDelegata] Parametri non Validi");

  698.         // Il getIDPortaDelegata effettua il REFRESH XML
  699.         IDPortaDelegata id = this.getIDPortaDelegata(nome);
  700.         IDSoggetto soggettoProprietario = id.getIdentificativiFruizione().getSoggettoFruitore();
  701.         
  702.         // Il getSoggetto effettua il REFRESH XML
  703.         Soggetto soggetto = null;
  704.         try{
  705.             soggetto = getSoggetto(soggettoProprietario);
  706.         }catch(Exception e){
  707.             // ignore
  708.         }
  709.         if(soggetto == null)
  710.             throw new DriverConfigurazioneException("[getPortaDelegata] Soggetto fruitore ["+soggettoProprietario.getTipo()+"/"+soggettoProprietario.getNome()+"] non esistente");

  712.         // ricerca PD
  713.         for(int j=0; j<soggetto.sizePortaDelegataList() ; j++){

  715.             PortaDelegata pd = soggetto.getPortaDelegata(j);
  716.             if(nome.equals(pd.getNome())){
  717.                 pd.setTipoSoggettoProprietario(soggetto.getTipo());
  718.                 pd.setNomeSoggettoProprietario(soggetto.getNome());
  719.                 return pd;
  720.             }
  721.         }  

  723.         throw new DriverConfigurazioneNotFound("PortaDelegata ["+nome+"] non esistente");
  724.     }

  726.     @Override
  727.     public List<IDPortaDelegata> getAllIdPorteDelegate(
  728.             FiltroRicercaPorteDelegate filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  729.     
  730.         refreshConfigurazioneXML();
  731.         
  732.         List<IDPortaDelegata> listIDPorteDelegate = new ArrayList<IDPortaDelegata>();
  733.         
  734.         for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  735.             Soggetto soggetto = this.openspcoop.getSoggetto(i);
  736.             for (int j = 0; j < soggetto.sizePortaDelegataList(); j++) {
  737.                 PortaDelegata pd = soggetto.getPortaDelegata(j);
  738.                 
  739.                 String id = pd.getNome();
  740.                 
  741.                 if(filtroRicerca!=null){
  742.                     
  743.                     boolean porteDelegatePerAzioni = false;
  744.                     if(filtroRicerca.getNomePortaDelegante()!=null) {
  745.                         porteDelegatePerAzioni = true;
  746.                     }
  747.                     
  748.                     // Filtro By Data
  749.                     if(filtroRicerca.getMinDate()!=null){
  750.                         if(pd.getOraRegistrazione()==null){
  751.                             this.log.debug("[getAllIdPorteDelegate](FiltroByMinDate) PortaDelegata ["+id+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  752.                             continue;
  753.                         }else if(pd.getOraRegistrazione().before(filtroRicerca.getMinDate())){
  754.                             continue;
  755.                         }
  756.                     }
  757.                     if(filtroRicerca.getMaxDate()!=null){
  758.                         if(soggetto.getOraRegistrazione()==null){
  759.                             this.log.debug("[getAllIdPorteDelegate](FiltroByMaxDate) PortaDelegata ["+id+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  760.                             continue;
  761.                         }else if(soggetto.getOraRegistrazione().after(filtroRicerca.getMaxDate())){
  762.                             continue;
  763.                         }
  764.                     }
  765.                     // Filtro By Tipo e Nome
  766.                     if(filtroRicerca.getTipoSoggetto()!=null){
  767.                         if(soggetto.getTipo().equals(filtroRicerca.getTipoSoggetto()) == false){
  768.                             continue;
  769.                         }
  770.                     }
  771.                     if(filtroRicerca.getNomeSoggetto()!=null){
  772.                         if(soggetto.getNome().equals(filtroRicerca.getNomeSoggetto()) == false){
  773.                             continue;
  774.                         }
  775.                     }
  776.                     // Filtro By Tipo e Nome soggetto erogatore
  777.                     if(filtroRicerca.getTipoSoggettoErogatore()!=null){
  778.                         if(pd.getSoggettoErogatore().getTipo().equals(filtroRicerca.getTipoSoggettoErogatore()) == false){
  779.                             continue;
  780.                         }
  781.                     }
  782.                     if(filtroRicerca.getNomeSoggettoErogatore()!=null){
  783.                         if(pd.getSoggettoErogatore().getNome()==null){
  784.                             continue;
  785.                         }
  786.                         if(pd.getSoggettoErogatore().getNome().equals(filtroRicerca.getNomeSoggettoErogatore()) == false){
  787.                             continue;
  788.                         }
  789.                     }
  790.                     // Filtro By Tipo e Nome servizio
  791.                     if(filtroRicerca.getTipoServizio()!=null){
  792.                         if(pd.getServizio().getTipo().equals(filtroRicerca.getTipoServizio()) == false){
  793.                             continue;
  794.                         }
  795.                     }
  796.                     if(filtroRicerca.getNomeServizio()!=null){
  797.                         if(pd.getServizio().getNome()==null){
  798.                             continue;
  799.                         }
  800.                         if(pd.getServizio().getNome().equals(filtroRicerca.getNomeServizio()) == false){
  801.                             continue;
  802.                         }
  803.                     }
  804.                     if(filtroRicerca.getVersioneServizio()!=null){
  805.                         if(pd.getServizio().getVersione()==null){
  806.                             continue;
  807.                         }
  808.                         if(pd.getServizio().getVersione().intValue() != filtroRicerca.getVersioneServizio().intValue()){
  809.                             continue;
  810.                         }
  811.                     }
  812.                     // Filtro By azione
  813.                     if(!porteDelegatePerAzioni && filtroRicerca.getAzione()!=null){
  814.                         if(pd.getAzione().getNome()==null){
  815.                             continue;
  816.                         }
  817.                         if(pd.getAzione().getNome().equals(filtroRicerca.getAzione()) == false){
  818.                             continue;
  819.                         }
  820.                     }
  821.                     // Filtro By Ruoli
  822.                     if(filtroRicerca.getIdRuolo()!=null && filtroRicerca.getIdRuolo().getNome()!=null){
  823.                         if(pd.getRuoli()==null){
  824.                             continue;
  825.                         }
  826.                         boolean contains = false;
  827.                         for (int z = 0; z < pd.getRuoli().sizeRuoloList(); z++) {
  828.                             if(filtroRicerca.getIdRuolo().getNome().equals(pd.getRuoli().getRuolo(z).getNome())){
  829.                                 contains = true;
  830.                                 break;
  831.                             }
  832.                         }
  833.                         if(!contains){
  834.                             continue;
  835.                         }
  836.                     }
  837.                     // Filtro By Scope
  838.                     if(filtroRicerca.getIdScope()!=null && filtroRicerca.getIdScope().getNome()!=null){
  839.                         if(pd.getScope()==null){
  840.                             continue;
  841.                         }
  842.                         boolean contains = false;
  843.                         for (int z = 0; z < pd.getScope().sizeScopeList(); z++) {
  844.                             if(filtroRicerca.getIdScope().getNome().equals(pd.getScope().getScope(z).getNome())){
  845.                                 contains = true;
  846.                                 break;
  847.                             }
  848.                         }
  849.                         if(!contains){
  850.                             continue;
  851.                         }
  852.                     }
  853.                     // Filtro By Autorizzazione Servizio Applicativo
  854.                     if(filtroRicerca.getNomeServizioApplicativo()!=null) {
  855.                         if(pd.sizeServizioApplicativoList()<=0){
  856.                             continue;
  857.                         }
  858.                         boolean contains = false;
  859.                         for (int z = 0; z < pd.sizeServizioApplicativoList(); z++) {
  860.                             if(filtroRicerca.getNomeServizioApplicativo().equals(pd.getServizioApplicativo(z).getNome())){
  861.                                 contains = true;
  862.                                 break;
  863.                             }
  864.                         }
  865.                         if(!contains){
  866.                             continue;
  867.                         }
  868.                     }   
  869.                     // Filtro By Autorizzazione Token Servizio Applicativo
  870.                     if(filtroRicerca.getNomeServizioApplicativoToken()!=null) {
  871.                         if(pd.getAutorizzazioneToken()==null || pd.getAutorizzazioneToken().getServiziApplicativi()==null ||
  872.                                 pd.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()<=0){
  873.                             continue;
  874.                         }
  875.                         boolean contains = false;
  876.                         for (int z = 0; z < pd.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList(); z++) {
  877.                             if(filtroRicerca.getNomeServizioApplicativoToken().equals(pd.getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativo(z).getNome())){
  878.                                 contains = true;
  879.                                 break;
  880.                             }
  881.                         }
  882.                         if(!contains){
  883.                             continue;
  884.                         }
  885.                     }   
  886.                     // Filtro By Ruoli Token
  887.                     if(filtroRicerca.getIdRuoloToken()!=null && filtroRicerca.getIdRuoloToken().getNome()!=null){
  888.                         if(pd.getAutorizzazioneToken()==null || pd.getAutorizzazioneToken().getRuoli()==null ||
  889.                                 pd.getAutorizzazioneToken().getRuoli().sizeRuoloList()<=0){
  890.                             continue;
  891.                         }
  892.                         boolean contains = false;
  893.                         for (int z = 0; z < pd.getAutorizzazioneToken().getRuoli().sizeRuoloList(); z++) {
  894.                             if(filtroRicerca.getIdRuoloToken().getNome().equals(pd.getAutorizzazioneToken().getRuoli().getRuolo(z).getNome())){
  895.                                 contains = true;
  896.                                 break;
  897.                             }
  898.                         }
  899.                         if(!contains){
  900.                             continue;
  901.                         }
  902.                     }
  903.                     // Filtro By Applicabilita Trasformazione Servizio Applicativo
  904.                     if(filtroRicerca.getNomeServizioApplicativoRiferitoApplicabilitaTrasformazione()!=null) {
  905.                         if(pd.getTrasformazioni()==null || pd.getTrasformazioni().sizeRegolaList()<=0){
  906.                             continue;
  907.                         }
  908.                         boolean contains = false;
  909.                         for (int z = 0; z < pd.getTrasformazioni().sizeRegolaList(); z++) {
  910.                             TrasformazioneRegola regola = pd.getTrasformazioni().getRegola(z);
  911.                             if(regola.getApplicabilita()!=null && regola.getApplicabilita().sizeServizioApplicativoList()>0) {
  912.                                 for (TrasformazioneRegolaApplicabilitaServizioApplicativo tSA : regola.getApplicabilita().getServizioApplicativoList()) {
  913.                                     if(filtroRicerca.getNomeServizioApplicativoRiferitoApplicabilitaTrasformazione().equals(tSA.getNome())){
  914.                                         contains = true;
  915.                                         break;
  916.                                     }
  917.                                 }
  918.                                 if(contains){
  919.                                     break;
  920.                                 }
  921.                             }
  922.                         }
  923.                         if(!contains){
  924.                             continue;
  925.                         }
  926.                     }   
  927.                     // Filtro By Applicabilita Trasformazione Servizio Applicativo Token
  928.                     if(filtroRicerca.getNomeServizioApplicativoTokenRiferitoApplicabilitaTrasformazione()!=null) {
  929.                         if(pd.getTrasformazioni()==null || pd.getTrasformazioni().sizeRegolaList()<=0){
  930.                             continue;
  931.                         }
  932.                         boolean contains = false;
  933.                         for (int z = 0; z < pd.getTrasformazioni().sizeRegolaList(); z++) {
  934.                             TrasformazioneRegola regola = pd.getTrasformazioni().getRegola(z);
  935.                             if(regola.getApplicabilita()!=null && regola.getApplicabilita().sizeServizioApplicativoList()>0) {
  936.                                 for (TrasformazioneRegolaApplicabilitaServizioApplicativo tSA : regola.getApplicabilita().getServizioApplicativoList()) {
  937.                                     if(filtroRicerca.getNomeServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().equals(tSA.getNome())){
  938.                                         contains = true;
  939.                                         break;
  940.                                     }
  941.                                 }
  942.                                 if(contains){
  943.                                     break;
  944.                                 }
  945.                             }
  946.                         }
  947.                         if(!contains){
  948.                             continue;
  949.                         }
  950.                     }   
  951.                     // Filtro By Stato
  952.                     if(filtroRicerca.getStato()!=null){
  953.                         if(pd.getStato()==null){
  954.                             // equivale a abilitato
  955.                             if(!StatoFunzionalita.ABILITATO.equals(filtroRicerca.getStato())){
  956.                                 continue;
  957.                             }
  958.                         }               
  959.                         else if(!pd.getStato().equals(filtroRicerca.getStato())){
  960.                             continue;
  961.                         }
  962.                     }
  963.                     // Filtro By NomePortaDelegante
  964.                     if(porteDelegatePerAzioni) {
  965.                         if(pd.getAzione()==null || pd.getAzione().getNomePortaDelegante()==null){
  966.                             continue;
  967.                         }               
  968.                         else if(!pd.getAzione().getNomePortaDelegante().equals(filtroRicerca.getNomePortaDelegante())){
  969.                             continue;
  970.                         }
  971.                         if(filtroRicerca.getAzione()!=null) {
  972.                             if(pd.getAzione().getAzioneDelegataList().size()<=0){
  973.                                 continue;
  974.                             }
  975.                             if(pd.getAzione().getAzioneDelegataList().contains(filtroRicerca.getAzione()) == false){
  976.                                 continue;
  977.                             }
  978.                         }
  979.                     }
  980.                 }
  981.                 
  982.                 pd.setTipoSoggettoProprietario(soggetto.getTipo());
  983.                 pd.setNomeSoggettoProprietario(soggetto.getNome());
  984.                 listIDPorteDelegate.add(this.convertToIDPortaDelegata(pd));
  985.             }
  986.         }
  987.         
  988.         if(listIDPorteDelegate.size()<=0){
  989.             if(filtroRicerca!=null)
  990.                 throw new DriverConfigurazioneNotFound("PorteDelegate non trovate che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  991.             else
  992.                 throw new DriverConfigurazioneNotFound("PorteDelegate non trovate");
  993.         }
  994.         
  995.         return listIDPorteDelegate;
  996.     }
  997.     
  998.     
  999.     
  1000.     
  1001.     
  1002.     
  1003.     
  1004.     // PORTA APPLICATIVA
  1005.     
  1006.     private IDPortaApplicativa convertToIDPortaApplicativa(PortaApplicativa pa) throws DriverConfigurazioneException{
  1007.         
  1008.         IDPortaApplicativa idPA = new IDPortaApplicativa();
  1009.         idPA.setNome(pa.getNome());
  1010.         
  1011.         IdentificativiErogazione idErogazione = new IdentificativiErogazione();
  1012.         
  1013.         if(pa.getSoggettoVirtuale()!=null){
  1014.             IDSoggetto soggettoVirtuale = new IDSoggetto(pa.getSoggettoVirtuale().getTipo(),pa.getSoggettoVirtuale().getNome());
  1015.             idErogazione.setSoggettoVirtuale(soggettoVirtuale);
  1016.         }
  1017.         
  1018.         try{
  1019.             IDServizio idServizio = IDServizioUtils.buildIDServizio(pa.getServizio().getTipo(), pa.getServizio().getNome(), 
  1020.                     new IDSoggetto(pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()), 
  1021.                     pa.getServizio().getVersione()); 
  1022.             if(pa.getAzione()!=null && pa.getAzione().getNome()!=null && !"".equals(pa.getAzione().getNome())){
  1023.                 idServizio.setAzione(pa.getAzione().getNome()); 
  1024.             }
  1025.             idErogazione.setIdServizio(idServizio);
  1026.         }catch(Exception e){
  1027.             throw new DriverConfigurazioneException(e.getMessage(),e);
  1028.         }
  1029.         
  1030.         idPA.setIdentificativiErogazione(idErogazione);
  1031.         
  1032.         return idPA;
  1033.     }
  1034.     
  1035.     @Override
  1036.     public IDPortaApplicativa getIDPortaApplicativa(String nome) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  1038.         if(nome == null)
  1039.             throw new DriverConfigurazioneException("[getIDPortaApplicativa] Parametro Non Validi");

  1041.         refreshConfigurazioneXML();

  1043.         for(int i=0;i<this.openspcoop.sizeSoggettoList();i++){
  1044.             Soggetto soggetto = this.openspcoop.getSoggetto(i);

  1046.             //  ricerca PA
  1047.             for(int j=0; j<soggetto.sizePortaApplicativaList() ; j++){
  1048.                 PortaApplicativa pa = soggetto.getPortaApplicativa(j);
  1049.                 if(nome.equals(pa.getNome())){              
  1050.                     pa.setTipoSoggettoProprietario(soggetto.getTipo());
  1051.                     pa.setNomeSoggettoProprietario(soggetto.getNome());
  1052.                     return convertToIDPortaApplicativa(pa);
  1053.                 }
  1054.             }  
  1055.         }  

  1057.         throw new DriverConfigurazioneNotFound("Porta Applicativa ["+nome+"] non esistente");
  1058.     }
  1059.     
  1060.     @Override
  1061.     public PortaApplicativa getPortaApplicativa(IDPortaApplicativa idPA) throws DriverConfigurazioneException,DriverConfigurazioneNotFound { 

  1063.         if(idPA == null)
  1064.             throw new DriverConfigurazioneException("[getPortaApplicativa] Parametro idPA Non Validi");

  1066.         String nome = idPA.getNome();

  1068.         if( (nome == null) )
  1069.             throw new DriverConfigurazioneException("[getPortaApplicativa] Parametri non Validi");

  1071.         // Il getIDPortaApplicativa effettua il REFRESH XML
  1072.         IDPortaApplicativa id = this.getIDPortaApplicativa(nome);
  1073.         IDSoggetto soggettoProprietario = id.getIdentificativiErogazione().getIdServizio().getSoggettoErogatore();
  1074.         
  1075.         // Il getSoggetto effettua il REFRESH XML
  1076.         Soggetto soggetto = null;
  1077.         try{
  1078.             soggetto = getSoggetto(soggettoProprietario);
  1079.         }catch(Exception e){
  1080.             // ignore
  1081.         }
  1082.         if(soggetto == null)
  1083.             throw new DriverConfigurazioneException("[getPortaApplicativa] Soggetto fruitore ["+soggettoProprietario.getTipo()+"/"+soggettoProprietario.getNome()+"] non esistente");

  1085.         // ricerca PA
  1086.         for(int j=0; j<soggetto.sizePortaApplicativaList() ; j++){

  1088.             PortaApplicativa pa = soggetto.getPortaApplicativa(j);
  1089.             if(nome.equals(pa.getNome())){
  1090.                 pa.setTipoSoggettoProprietario(soggetto.getTipo());
  1091.                 pa.setNomeSoggettoProprietario(soggetto.getNome());
  1092.                 return pa;
  1093.             }
  1094.         }  

  1096.         throw new DriverConfigurazioneNotFound("PortaApplicativa ["+nome+"] non esistente");
  1097.     }
  1098.     
  1099.     @Override
  1100.     public List<PortaApplicativa> getPorteApplicative(IDServizio idServizio, boolean ricercaPuntuale) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1101.         return this.getEnginePorteApplicative_engine(idServizio, null, ricercaPuntuale);
  1102.     }
  1103.     
  1104.     @Override
  1105.     public List<PortaApplicativa> getPorteApplicativeVirtuali(IDSoggetto soggettoVirtuale,IDServizio idServizio, boolean ricercaPuntuale) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1106.         return this.getEnginePorteApplicative_engine(idServizio, soggettoVirtuale, ricercaPuntuale);
  1107.     }
  1108.     
  1109.     private List<PortaApplicativa> getEnginePorteApplicative_engine(IDServizio service,IDSoggetto soggettoVirtuale,boolean ricercaPuntuale) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{ 

  1111.         if(service == null)
  1112.             throw new DriverConfigurazioneException("[getPortaApplicativa] Parametro idServizio non definito");
  1113.         
  1114.         IDSoggetto soggettoErogatore = service.getSoggettoErogatore();
  1115.         if(soggettoErogatore == null)
  1116.             throw new DriverConfigurazioneException("[getPortaApplicativa] Parametri non validi (Soggetto Erogatore is null)");
  1117.     
  1118.         String servizio = service.getNome();
  1119.         String tipoServizio = service.getTipo();
  1120.         Integer versioneServizio = service.getVersione();
  1121.         String azione = service.getAzione();
  1122.         if((servizio==null)||(tipoServizio==null)||versioneServizio==null)
  1123.             throw new DriverConfigurazioneException("[getPortaApplicativa] Parametri (Servizio) non validi");

  1125.         //  Il getSoggetto effettua il REFRESH XML
  1126.         Soggetto soggetto = null;
  1127.         try{
  1128.             soggetto = getSoggetto(soggettoErogatore);
  1129.         }catch(DriverConfigurazioneNotFound dn){
  1130.             throw new DriverConfigurazioneNotFound("[getPortaApplicativa] "+dn.getMessage(),dn);
  1131.         }
  1132.         catch(Exception e){}
  1133.         if(soggetto == null)
  1134.             throw new DriverConfigurazioneException("[getPortaApplicativa] Soggetto erogatore ["+soggettoErogatore.getTipo()+"/"+soggettoErogatore.getNome()+"] non esistente");

  1136.         if(soggettoVirtuale!=null){
  1137.             if(soggettoVirtuale.getTipo()==null || soggettoVirtuale.getNome()==null)
  1138.                 throw new DriverConfigurazioneException("[getPortaApplicativa] Parametri (Soggetto Virtuale) non validi");
  1139.         }
  1140.         
  1141.         // ricerca PA
  1142.         List<PortaApplicativa> paSenzaAzioneList = new ArrayList<PortaApplicativa>();
  1143.         List<PortaApplicativa> paList = new ArrayList<PortaApplicativa>();
  1144.         for(int j=0; j<soggetto.sizePortaApplicativaList() ; j++){

  1146.             PortaApplicativa pa = soggetto.getPortaApplicativa(j);

  1148.             boolean paMatchaCriteriDiRicerca = false;
  1149.             if(soggettoVirtuale==null){
  1150.                 paMatchaCriteriDiRicerca = servizio.equals(pa.getServizio().getNome()) && 
  1151.                                            tipoServizio.equals(pa.getServizio().getTipo()) &&
  1152.                                            versioneServizio.intValue() == pa.getServizio().getVersione().intValue();
  1153.             }else{
  1154.                 paMatchaCriteriDiRicerca = servizio.equals(pa.getServizio().getNome()) && 
  1155.                                            tipoServizio.equals(pa.getServizio().getTipo()) &&
  1156.                                            versioneServizio.intValue() == pa.getServizio().getVersione().intValue() &&
  1157.                                            pa.getSoggettoVirtuale()!=null &&
  1158.                                            soggettoVirtuale.getTipo().equals(pa.getSoggettoVirtuale().getTipo()) &&
  1159.                                            soggettoVirtuale.getNome().equals(pa.getSoggettoVirtuale().getNome());
  1160.             }
  1161.             if(paMatchaCriteriDiRicerca) {
  1162.                 if(pa.getAzione()!=null && PortaApplicativaAzioneIdentificazione.DELEGATED_BY.equals(pa.getAzione().getIdentificazione())) {
  1163.                     paMatchaCriteriDiRicerca = false;
  1164.                 }
  1165.             }
  1166.                 
  1167.                 
  1168.             if(paMatchaCriteriDiRicerca){

  1170.                 // ricerca di una porta applicativa senza azione
  1171.                 if(azione==null){
  1172.                     if(pa.getAzione() == null){
  1173.                         pa.setTipoSoggettoProprietario(soggetto.getTipo());
  1174.                         pa.setNomeSoggettoProprietario(soggetto.getNome());
  1175.                         paList.add(pa);
  1176.                     }
  1177.                 }
  1178.                 // ricerca di una porta applicativa con azione
  1179.                 else{
  1180.                     if(pa.getAzione() == null){
  1181.                         PortaApplicativa paSenzaAzione = pa; // potenziale porta applicativa che mappa solo il servizio (se non esiste)
  1182.                         paSenzaAzione.setTipoSoggettoProprietario(soggetto.getTipo());
  1183.                         paSenzaAzione.setNomeSoggettoProprietario(soggetto.getNome());
  1184.                         paSenzaAzioneList.add(paSenzaAzione);
  1185.                     }
  1186.                     else if(azione.equals(pa.getAzione().getNome())){
  1187.                         pa.setTipoSoggettoProprietario(soggetto.getTipo());
  1188.                         pa.setNomeSoggettoProprietario(soggetto.getNome());
  1189.                         paList.add(pa);
  1190.                     }
  1191.                 }
  1192.             }
  1193.         }  
  1194.         
  1195.         if(paList.size()>0){
  1196.             return paList;
  1197.         }
  1198.         
  1199.         if(paSenzaAzioneList.size()>0 && ricercaPuntuale==false)
  1200.             return paSenzaAzioneList;

  1202.         throw new DriverConfigurazioneNotFound("PorteApplicative non esistenti");
  1203.     }
  1204.     
  1205.     @Override
  1206.     public Map<IDSoggetto,PortaApplicativa> getPorteApplicativeSoggettiVirtuali(IDServizio idServizio)throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  1208.         if(idServizio==null)
  1209.             throw new DriverConfigurazioneException("[getPortaApplicativa_SoggettiVirtuali] Parametro idServizio non valido");
  1210.         if(idServizio.getSoggettoErogatore()==null)
  1211.             throw new DriverConfigurazioneException("[getPortaApplicativa_SoggettiVirtuali] Parametro Soggetto Erogatore non valido");

  1213.         refreshConfigurazioneXML();

  1215.         Map<IDSoggetto,PortaApplicativa> paConSoggetti = new HashMap<IDSoggetto,PortaApplicativa>();
  1216.         IDSoggetto soggettoVirtuale = idServizio.getSoggettoErogatore();    
  1217.         String servizio = idServizio.getNome();
  1218.         String tipoServizio = idServizio.getTipo();
  1219.         Integer versioneServizio = idServizio.getVersione();
  1220.         String azione = idServizio.getAzione();
  1221.         if((servizio==null)||(tipoServizio==null)||versioneServizio==null)
  1222.             throw new DriverConfigurazioneException("[getPortaApplicativa_SoggettiVirtuali] Parametri (Servizio) Non Validi");


  1225.         // Ricerca soggetti che possiedono porte applicative.... che hanno un soggetto virtuale
  1226.         for(int i=0; i<this.openspcoop.sizeSoggettoList();i++){

  1228.             Soggetto aSoggetto = this.openspcoop.getSoggetto(i);
  1229.             PortaApplicativa paSenzaAzione = null;

  1231.             // Ricerca tra le PA del soggetto...
  1232.             for(int j=0; j<aSoggetto.sizePortaApplicativaList() ; j++){

  1234.                 PortaApplicativa pa = aSoggetto.getPortaApplicativa(j);
  1235.                 if( pa.getSoggettoVirtuale()!= null  ){
  1236.                     if( (pa.getSoggettoVirtuale().getTipo().equals(soggettoVirtuale.getTipo())) &&
  1237.                             (pa.getSoggettoVirtuale().getNome().equals(soggettoVirtuale.getNome())) ){

  1239.                         // Porta applicativa con tale soggetto virtuale... guardo se possiede il servizio e l'azione della busta
  1240.                         if(servizio.equals(pa.getServizio().getNome()) &&
  1241.                                 tipoServizio.equals(pa.getServizio().getTipo()) &&
  1242.                                 versioneServizio.intValue() == pa.getServizio().getVersione().intValue()){

  1244.                             // ricerca di una porta applicativa senza azione
  1245.                             if(azione==null){
  1246.                                 if(pa.getAzione() == null){
  1247.                                     for(int k=0; k<pa.sizeServizioApplicativoList(); k++){
  1248.                                         paConSoggetti.put(new IDSoggetto(aSoggetto.getTipo(),aSoggetto.getNome()),
  1249.                                                 pa);
  1250.                                     }
  1251.                                     break; // ricerca in questo soggetto terminata.
  1252.                                 }
  1253.                             }
  1254.                             // ricerca di una porta applicativa con azione
  1255.                             else{
  1256.                                 if(pa.getAzione() == null){
  1257.                                     paSenzaAzione = pa; // potenziale porta applicativa che mappa solo il servizio (se non esiste)
  1258.                                     continue;
  1259.                                 }
  1260.                                 if(azione.equals(pa.getAzione().getNome())){
  1261.                                     for(int k=0; k<pa.sizeServizioApplicativoList(); k++){
  1262.                                         paConSoggetti.put(new IDSoggetto(aSoggetto.getTipo(),aSoggetto.getNome()),
  1263.                                                 pa);
  1264.                                         paSenzaAzione = null;
  1265.                                     }
  1266.                                     break; // ricerca in questo soggetto terminata.
  1267.                                 }
  1268.                             }
  1269.                         }
  1270.                     }
  1271.                 }
  1272.             }// Fine ricerca tra le PA del soggetto
  1273.             if(paSenzaAzione!=null){
  1274.                 // Trovata PA con solo match per azione
  1275.                 paConSoggetti.put(new IDSoggetto(aSoggetto.getTipo(),aSoggetto.getNome()),
  1276.                         paSenzaAzione);
  1277.             }

  1279.         }  // fine Ricerca

  1281.         if(paConSoggetti.size() == 0)
  1282.             throw new DriverConfigurazioneNotFound("[getPortaApplicativa_SoggettiVirtuali] Porte applicative di soggetti virtuali non esistenti.");
  1283.         
  1284.         return paConSoggetti;
  1285.     }

  1287.     @Override
  1288.     public List<IDPortaApplicativa> getAllIdPorteApplicative(
  1289.             FiltroRicercaPorteApplicative filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  1290.         
  1291.         refreshConfigurazioneXML();
  1292.         
  1293.         List<IDPortaApplicativa> listIDPorteApplicative = new ArrayList<IDPortaApplicativa>();
  1294.         
  1295.         for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  1296.             Soggetto soggetto = this.openspcoop.getSoggetto(i);
  1297.             for (int j = 0; j < soggetto.sizePortaApplicativaList(); j++) {
  1298.                 PortaApplicativa pa = soggetto.getPortaApplicativa(j);
  1299.                 
  1300.                 String id = pa.getNome();
  1301.                 
  1302.                 if(filtroRicerca!=null){
  1303.                     
  1304.                     boolean porteDelegatePerAzioni = false;
  1305.                     if(filtroRicerca.getNomePortaDelegante()!=null) {
  1306.                         porteDelegatePerAzioni = true;
  1307.                     }
  1308.                     
  1309.                     // Filtro By Data
  1310.                     if(filtroRicerca.getMinDate()!=null){
  1311.                         if(pa.getOraRegistrazione()==null){
  1312.                             this.log.debug("[getAllIdPorteApplicative](FiltroByMinDate) PortaApplicativa ["+id+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  1313.                             continue;
  1314.                         }else if(pa.getOraRegistrazione().before(filtroRicerca.getMinDate())){
  1315.                             continue;
  1316.                         }
  1317.                     }
  1318.                     if(filtroRicerca.getMaxDate()!=null){
  1319.                         if(soggetto.getOraRegistrazione()==null){
  1320.                             this.log.debug("[getAllIdPorteApplicative](FiltroByMaxDate) PortaApplicativa ["+id+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  1321.                             continue;
  1322.                         }else if(soggetto.getOraRegistrazione().after(filtroRicerca.getMaxDate())){
  1323.                             continue;
  1324.                         }
  1325.                     }
  1326.                     // Filtro By Tipo e Nome
  1327.                     if(filtroRicerca.getTipoSoggetto()!=null){
  1328.                         if(soggetto.getTipo().equals(filtroRicerca.getTipoSoggetto()) == false){
  1329.                             continue;
  1330.                         }
  1331.                     }
  1332.                     if(filtroRicerca.getNomeSoggetto()!=null){
  1333.                         if(soggetto.getNome().equals(filtroRicerca.getNomeSoggetto()) == false){
  1334.                             continue;
  1335.                         }
  1336.                     }
  1337.                     // Filtro By Tipo e Nome servizio
  1338.                     if(filtroRicerca.getTipoServizio()!=null){
  1339.                         if(pa.getServizio().getTipo().equals(filtroRicerca.getTipoServizio()) == false){
  1340.                             continue;
  1341.                         }
  1342.                     }
  1343.                     if(filtroRicerca.getNomeServizio()!=null){
  1344.                         if(pa.getServizio().getNome()==null){
  1345.                             continue;
  1346.                         }
  1347.                         if(pa.getServizio().getNome().equals(filtroRicerca.getNomeServizio()) == false){
  1348.                             continue;
  1349.                         }
  1350.                     }
  1351.                     if(filtroRicerca.getVersioneServizio()!=null){
  1352.                         if(pa.getServizio().getVersione()==null){
  1353.                             continue;
  1354.                         }
  1355.                         if(pa.getServizio().getVersione().intValue() != filtroRicerca.getVersioneServizio().intValue()){
  1356.                             continue;
  1357.                         }
  1358.                     }
  1359.                     // Filtro By azione
  1360.                     if(!porteDelegatePerAzioni && filtroRicerca.getAzione()!=null){
  1361.                         if(pa.getAzione().getNome()==null){
  1362.                             continue;
  1363.                         }
  1364.                         if(pa.getAzione().getNome().equals(filtroRicerca.getAzione()) == false){
  1365.                             continue;
  1366.                         }
  1367.                     }
  1368.                     // Filtro By Ruoli
  1369.                     if(filtroRicerca.getIdRuolo()!=null && filtroRicerca.getIdRuolo().getNome()!=null){
  1370.                         if(pa.getRuoli()==null){
  1371.                             continue;
  1372.                         }
  1373.                         boolean contains = false;
  1374.                         for (int z = 0; z < pa.getRuoli().sizeRuoloList(); z++) {
  1375.                             if(filtroRicerca.getIdRuolo().getNome().equals(pa.getRuoli().getRuolo(z).getNome())){
  1376.                                 contains = true;
  1377.                                 break;
  1378.                             }
  1379.                         }
  1380.                         if(!contains){
  1381.                             continue;
  1382.                         }
  1383.                     }
  1384.                     // Filtro By Scope
  1385.                     if(filtroRicerca.getIdScope()!=null && filtroRicerca.getIdScope().getNome()!=null){
  1386.                         if(pa.getScope()==null){
  1387.                             continue;
  1388.                         }
  1389.                         boolean contains = false;
  1390.                         for (int z = 0; z < pa.getScope().sizeScopeList(); z++) {
  1391.                             if(filtroRicerca.getIdScope().getNome().equals(pa.getScope().getScope(z).getNome())){
  1392.                                 contains = true;
  1393.                                 break;
  1394.                             }
  1395.                         }
  1396.                         if(!contains){
  1397.                             continue;
  1398.                         }
  1399.                     }
  1400.                     // Filtro By SoggettoAutorizzato
  1401.                     if(filtroRicerca.getIdSoggettoAutorizzato()!=null &&
  1402.                             (filtroRicerca.getIdSoggettoAutorizzato().getTipo()!=null || 
  1403.                             filtroRicerca.getIdSoggettoAutorizzato().getNome()!=null)){
  1404.                         if(pa.getSoggetti()==null || pa.getSoggetti().sizeSoggettoList()<=0) {
  1405.                             continue;
  1406.                         }
  1407.                         boolean contains = false;
  1408.                         for (int z = 0; z < pa.getSoggetti().sizeSoggettoList(); z++) {
  1409.                             if(filtroRicerca.getIdSoggettoAutorizzato().getTipo()!=null &&
  1410.                                     !filtroRicerca.getIdSoggettoAutorizzato().getTipo().equals(pa.getSoggetti().getSoggetto(z).getTipo())){
  1411.                                 continue;
  1412.                             }
  1413.                             if(filtroRicerca.getIdSoggettoAutorizzato().getNome()!=null &&
  1414.                                     !filtroRicerca.getIdSoggettoAutorizzato().getNome().equals(pa.getSoggetti().getSoggetto(z).getNome())){
  1415.                                 continue;
  1416.                             }
  1417.                             contains = true;
  1418.                             break;
  1419.                         }
  1420.                         if(!contains){
  1421.                             continue;
  1422.                         }
  1423.                     }
  1424.                     // Filtro By ServizioApplicativoAutorizzato (ricerca puntuale)
  1425.                     if(filtroRicerca.getIdServizioApplicativoAutorizzato()!=null &&
  1426.                             filtroRicerca.getIdServizioApplicativoAutorizzato().getNome()!=null &&
  1427.                             filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario()!=null &&
  1428.                             filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getTipo()!=null &&
  1429.                             filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getNome()!=null
  1430.                             ){
  1431.                         if(pa.getServiziApplicativiAutorizzati()==null || pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList()<=0) {
  1432.                             continue;
  1433.                         }
  1434.                         boolean contains = false;
  1435.                         for (int z = 0; z < pa.getServiziApplicativiAutorizzati().sizeServizioApplicativoList(); z++) {
  1436.                             if(!filtroRicerca.getIdServizioApplicativoAutorizzato().getNome().equals(pa.getServiziApplicativiAutorizzati().getServizioApplicativo(z).getNome())){
  1437.                                 continue;
  1438.                             }
  1439.                             if(!filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getTipo().equals(pa.getServiziApplicativiAutorizzati().getServizioApplicativo(z).getTipoSoggettoProprietario())){
  1440.                                 continue;
  1441.                             }   
  1442.                             if(!filtroRicerca.getIdServizioApplicativoAutorizzato().getIdSoggettoProprietario().getNome().equals(pa.getServiziApplicativiAutorizzati().getServizioApplicativo(z).getNomeSoggettoProprietario())){
  1443.                                 continue;
  1444.                             }
  1445.                             contains = true;
  1446.                             break;
  1447.                         }
  1448.                         if(!contains){
  1449.                             continue;
  1450.                         }
  1451.                     }
  1452.                     // Filtro By SoggettoAutorizzato
  1453.                     if(filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione()!=null &&
  1454.                             (filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getTipo()!=null || 
  1455.                             filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getNome()!=null)){
  1456.                         if(pa.getTrasformazioni()==null || pa.getTrasformazioni().sizeRegolaList()<=0){
  1457.                             continue;
  1458.                         }
  1459.                         boolean contains = false;
  1460.                         for (int z = 0; z < pa.getTrasformazioni().sizeRegolaList(); z++) {
  1461.                             TrasformazioneRegola regola = pa.getTrasformazioni().getRegola(z);
  1462.                             if(regola.getApplicabilita()!=null && regola.getApplicabilita().sizeSoggettoList()>0) {
  1463.                                 for (TrasformazioneRegolaApplicabilitaSoggetto tSoggetto : regola.getApplicabilita().getSoggettoList()) {
  1464.                                     if(filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getTipo()!=null &&
  1465.                                             !filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getTipo().equals(tSoggetto.getTipo())){
  1466.                                         continue;
  1467.                                     }
  1468.                                     if(filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getNome()!=null &&
  1469.                                             !filtroRicerca.getIdSoggettoRiferitoApplicabilitaTrasformazione().getNome().equals(tSoggetto.getNome())){
  1470.                                         continue;
  1471.                                     }
  1472.                                     contains = true;
  1473.                                     break;
  1474.                                 }
  1475.                                 if(contains){
  1476.                                     break;
  1477.                                 }
  1478.                             }
  1479.                         }
  1480.                         if(!contains){
  1481.                             continue;
  1482.                         }
  1483.                     }
  1484.                     // Filtro By ServizioApplicativoAutorizzatoToken (ricerca puntuale)
  1485.                     if(filtroRicerca.getIdServizioApplicativoAutorizzatoToken()!=null &&
  1486.                             filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getNome()!=null &&
  1487.                             filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario()!=null &&
  1488.                             filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getTipo()!=null &&
  1489.                             filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getNome()!=null
  1490.                             ){
  1491.                         if(pa.getAutorizzazioneToken()==null || pa.getAutorizzazioneToken().getServiziApplicativi()== null || pa.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList()<=0) {
  1492.                             continue;
  1493.                         }
  1494.                         boolean contains = false;
  1495.                         for (int z = 0; z < pa.getAutorizzazioneToken().getServiziApplicativi().sizeServizioApplicativoList(); z++) {
  1496.                             if(!filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getNome().equals(pa.getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativo(z).getNome())){
  1497.                                 continue;
  1498.                             }
  1499.                             if(!filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getTipo().equals(pa.getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativo(z).getTipoSoggettoProprietario())){
  1500.                                 continue;
  1501.                             }   
  1502.                             if(!filtroRicerca.getIdServizioApplicativoAutorizzatoToken().getIdSoggettoProprietario().getNome().equals(pa.getAutorizzazioneToken().getServiziApplicativi().getServizioApplicativo(z).getNomeSoggettoProprietario())){
  1503.                                 continue;
  1504.                             }
  1505.                             contains = true;
  1506.                             break;
  1507.                         }
  1508.                         if(!contains){
  1509.                             continue;
  1510.                         }
  1511.                     }
  1512.                     // Filtro By Ruoli Token
  1513.                     if(filtroRicerca.getIdRuoloToken()!=null && filtroRicerca.getIdRuoloToken().getNome()!=null){
  1514.                         if(pa.getAutorizzazioneToken()==null || pa.getAutorizzazioneToken().getRuoli()== null || pa.getAutorizzazioneToken().getRuoli().sizeRuoloList()<=0) {
  1515.                             continue;
  1516.                         }
  1517.                         boolean contains = false;
  1518.                         for (int z = 0; z < pa.getAutorizzazioneToken().getRuoli().sizeRuoloList(); z++) {
  1519.                             if(filtroRicerca.getIdRuoloToken().getNome().equals(pa.getAutorizzazioneToken().getRuoli().getRuolo(z).getNome())){
  1520.                                 contains = true;
  1521.                                 break;
  1522.                             }
  1523.                         }
  1524.                         if(!contains){
  1525.                             continue;
  1526.                         }
  1527.                     }
  1528.                     // Filtro By Applicabilita Trasformazione Servizio Applicativo
  1529.                     if(filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione()!=null &&
  1530.                             filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getNome()!=null &&
  1531.                             filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario()!=null &&
  1532.                             filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo()!=null &&
  1533.                             filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getNome()!=null
  1534.                             ){
  1535.                         if(pa.getTrasformazioni()==null || pa.getTrasformazioni().sizeRegolaList()<=0){
  1536.                             continue;
  1537.                         }
  1538.                         boolean contains = false;
  1539.                         for (int z = 0; z < pa.getTrasformazioni().sizeRegolaList(); z++) {
  1540.                             TrasformazioneRegola regola = pa.getTrasformazioni().getRegola(z);
  1541.                             if(regola.getApplicabilita()!=null && regola.getApplicabilita().sizeServizioApplicativoList()>0) {
  1542.                                 for (TrasformazioneRegolaApplicabilitaServizioApplicativo tSA : regola.getApplicabilita().getServizioApplicativoList()) {
  1543.                                     if(!filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getNome().equals(tSA.getNome())){
  1544.                                         continue;
  1545.                                     }
  1546.                                     if(!filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo().equals(tSA.getTipoSoggettoProprietario())){
  1547.                                         continue;
  1548.                                     }   
  1549.                                     if(!filtroRicerca.getIdServizioApplicativoRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getNome().equals(tSA.getNomeSoggettoProprietario())){
  1550.                                         continue;
  1551.                                     }
  1552.                                     contains = true;
  1553.                                     break;
  1554.                                 }
  1555.                                 if(contains){
  1556.                                     break;
  1557.                                 }
  1558.                             }
  1559.                         }
  1560.                         if(!contains){
  1561.                             continue;
  1562.                         }
  1563.                     }
  1564.                     // Filtro By Applicabilita Trasformazione Servizio Applicativo Token
  1565.                     if(filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione()!=null &&
  1566.                             filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getNome()!=null &&
  1567.                             filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario()!=null &&
  1568.                             filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo()!=null &&
  1569.                             filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getNome()!=null
  1570.                             ){
  1571.                         if(pa.getTrasformazioni()==null || pa.getTrasformazioni().sizeRegolaList()<=0){
  1572.                             continue;
  1573.                         }
  1574.                         boolean contains = false;
  1575.                         for (int z = 0; z < pa.getTrasformazioni().sizeRegolaList(); z++) {
  1576.                             TrasformazioneRegola regola = pa.getTrasformazioni().getRegola(z);
  1577.                             if(regola.getApplicabilita()!=null && regola.getApplicabilita().sizeServizioApplicativoList()>0) {
  1578.                                 for (TrasformazioneRegolaApplicabilitaServizioApplicativo tSA : regola.getApplicabilita().getServizioApplicativoList()) {
  1579.                                     if(!filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getNome().equals(tSA.getNome())){
  1580.                                         continue;
  1581.                                     }
  1582.                                     if(!filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getTipo().equals(tSA.getTipoSoggettoProprietario())){
  1583.                                         continue;
  1584.                                     }   
  1585.                                     if(!filtroRicerca.getIdServizioApplicativoTokenRiferitoApplicabilitaTrasformazione().getIdSoggettoProprietario().getNome().equals(tSA.getNomeSoggettoProprietario())){
  1586.                                         continue;
  1587.                                     }
  1588.                                     contains = true;
  1589.                                     break;
  1590.                                 }
  1591.                                 if(contains){
  1592.                                     break;
  1593.                                 }
  1594.                             }
  1595.                         }
  1596.                         if(!contains){
  1597.                             continue;
  1598.                         }
  1599.                     }
  1600.                     // Filtro By Stato
  1601.                     if(filtroRicerca.getStato()!=null){
  1602.                         if(pa.getStato()==null){
  1603.                             // equivale a abilitato
  1604.                             if(!StatoFunzionalita.ABILITATO.equals(filtroRicerca.getStato())){
  1605.                                 continue;
  1606.                             }
  1607.                         }               
  1608.                         else if(!pa.getStato().equals(filtroRicerca.getStato())){
  1609.                             continue;
  1610.                         }
  1611.                     }
  1612.                     // Filtro By NomePortaDelegante
  1613.                     if(porteDelegatePerAzioni) {
  1614.                         if(pa.getAzione()==null || pa.getAzione().getNomePortaDelegante()==null){
  1615.                             continue;
  1616.                         }               
  1617.                         else if(!pa.getAzione().getNomePortaDelegante().equals(filtroRicerca.getNomePortaDelegante())){
  1618.                             continue;
  1619.                         }
  1620.                         if(filtroRicerca.getAzione()!=null) {
  1621.                             if(pa.getAzione().getAzioneDelegataList().size()<=0){
  1622.                                 continue;
  1623.                             }
  1624.                             if(pa.getAzione().getAzioneDelegataList().contains(filtroRicerca.getAzione()) == false){
  1625.                                 continue;
  1626.                             }
  1627.                         }
  1628.                     }
  1629.                 }
  1630.                 
  1631.                 pa.setTipoSoggettoProprietario(soggetto.getTipo());
  1632.                 pa.setNomeSoggettoProprietario(soggetto.getNome());
  1633.                 listIDPorteApplicative.add(this.convertToIDPortaApplicativa(pa));
  1634.                 
  1635.             }
  1636.         }
  1637.         
  1638.         if(listIDPorteApplicative.size()<=0){
  1639.             if(filtroRicerca!=null)
  1640.                 throw new DriverConfigurazioneNotFound("PorteApplicative non trovate che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  1641.             else
  1642.                 throw new DriverConfigurazioneNotFound("PorteApplicative non trovate");
  1643.         }
  1644.         
  1645.         return listIDPorteApplicative;
  1646.     }
  1647.     
  1648.     
  1649.     
  1650.     
  1651.     
  1652.     
  1653.     
  1654.     // SERVIZIO APPLICATIVO
  1655.     
  1656.     @Override
  1657.     public ServizioApplicativo getServizioApplicativo(IDServizioApplicativo idServizioApplicativo) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1658.         
  1659.         if(idServizioApplicativo==null){
  1660.             throw new DriverConfigurazioneException("IDServizioApplicativo non definito");
  1661.         }
  1662.         if(idServizioApplicativo.getIdSoggettoProprietario()==null){
  1663.             throw new DriverConfigurazioneException("IDServizioApplicativo.idSoggettoProprietario non definito");
  1664.         }
  1665.         if(idServizioApplicativo.getNome()==null){
  1666.             throw new DriverConfigurazioneException("IDServizioApplicativo.nome non definito");
  1667.         }
  1668.         
  1669.         Soggetto soggettoProprietario = this.getSoggetto(idServizioApplicativo.getIdSoggettoProprietario());
  1670.         for(int j=0; j<soggettoProprietario.sizeServizioApplicativoList(); j++){
  1671.             ServizioApplicativo sa = soggettoProprietario.getServizioApplicativo(j);
  1672.             if(idServizioApplicativo.getNome().equals(sa.getNome())){
  1673.                 sa.setTipoSoggettoProprietario(soggettoProprietario.getTipo());
  1674.                 sa.setNomeSoggettoProprietario(soggettoProprietario.getNome());
  1675.                 return sa;
  1676.             }
  1677.         }
  1678.         
  1679.         throw new DriverConfigurazioneNotFound("Servizio Applicativo non trovato");
  1680.     }
  1681.     
  1682.     
  1683.     @Override
  1684.     public ServizioApplicativo getServizioApplicativoByCredenzialiBasic(String aUser,String aPassword, CryptConfig config) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1685.         
  1686.         if(aUser==null){
  1687.             throw new DriverConfigurazioneException("Username non definito");
  1688.         }
  1689.         if(aPassword==null){
  1690.             throw new DriverConfigurazioneException("Password non definita");
  1691.         }
  1692.         
  1693.         boolean testInChiaro = false;
  1694.         ICrypt crypt = null;
  1695.         if(config==null || config.isBackwardCompatibility()) {
  1696.             testInChiaro = true;
  1697.         }
  1698.         if(config!=null) {
  1699.             try {
  1700.                 crypt = CryptFactory.getCrypt(this.log, config);
  1701.             }catch(Exception e) {
  1702.                 throw new DriverConfigurazioneException(e.getMessage(),e);
  1703.             }
  1704.         }
  1705.                 
  1706.         for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  1707.             Soggetto soggettoSearch = this.openspcoop.getSoggetto(i);
  1708.             for(int j=0; j<soggettoSearch.sizeServizioApplicativoList(); j++){
  1709.                 ServizioApplicativo sa = soggettoSearch.getServizioApplicativo(j);
  1710.                 if(sa.getInvocazionePorta()!=null){
  1711.                     for(int z=0;z<sa.getInvocazionePorta().sizeCredenzialiList();z++){
  1712.                         if(sa.getInvocazionePorta().getCredenziali(z).getTipo()!=null &&
  1713.                                 CostantiConfigurazione.CREDENZIALE_BASIC.equals(sa.getInvocazionePorta().getCredenziali(z).getTipo())){
  1714.                             if( (aUser.equals(sa.getInvocazionePorta().getCredenziali(z).getUser())) ){
  1715.                                 
  1716.                                 String passwordSaved = sa.getInvocazionePorta().getCredenziali(z).getPassword();
  1717.                                 
  1718.                                 boolean found = false;
  1719.                                 if(testInChiaro) {
  1720.                                     found = aPassword.equals(passwordSaved);
  1721.                                 }
  1722.                                 if(!found && crypt!=null) {
  1723.                                     found = crypt.check(aPassword, passwordSaved);
  1724.                                 }
  1725.                                 
  1726.                                 if( found ) {
  1727.                                     sa.setTipoSoggettoProprietario(soggettoSearch.getTipo());
  1728.                                     sa.setNomeSoggettoProprietario(soggettoSearch.getNome());
  1729.                                     return sa;
  1730.                                 }
  1731.                             }
  1732.                         }
  1733.                     }
  1734.                 }
  1735.             }
  1736.         }
  1737.         
  1738.         throw new DriverConfigurazioneNotFound("Servizio Applicativo cercato con credenziali basic non trovato");
  1739.     }
  1740.     
  1741.     @Override
  1742.     public ServizioApplicativo getServizioApplicativoByCredenzialiApiKey(String aUser,String aPassword, boolean appId, CryptConfig config) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1743.         
  1744.         if(aUser==null){
  1745.             throw new DriverConfigurazioneException("Username non definito");
  1746.         }
  1747.         if(aPassword==null){
  1748.             throw new DriverConfigurazioneException("Password non definita");
  1749.         }
  1750.         
  1751.         boolean testInChiaro = false;
  1752.         ICrypt crypt = null;
  1753.         if(config!=null) {
  1754.             try {
  1755.                 crypt = CryptFactory.getCrypt(this.log, config);
  1756.             }catch(Exception e) {
  1757.                 throw new DriverConfigurazioneException(e.getMessage(),e);
  1758.             }
  1759.         }
  1760.         else {
  1761.             testInChiaro = true;
  1762.         }
  1763.                 
  1764.         for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  1765.             Soggetto soggettoSearch = this.openspcoop.getSoggetto(i);
  1766.             for(int j=0; j<soggettoSearch.sizeServizioApplicativoList(); j++){
  1767.                 ServizioApplicativo sa = soggettoSearch.getServizioApplicativo(j);
  1768.                 if(sa.getInvocazionePorta()!=null){
  1769.                     for(int z=0;z<sa.getInvocazionePorta().sizeCredenzialiList();z++){
  1770.                         if(sa.getInvocazionePorta().getCredenziali(z).getTipo()!=null &&
  1771.                                 CostantiConfigurazione.CREDENZIALE_APIKEY.equals(sa.getInvocazionePorta().getCredenziali(z).getTipo())){
  1772.                             if( (aUser.equals(sa.getInvocazionePorta().getCredenziali(z).getUser())) ){
  1773.                                 
  1774.                                 if(appId) {
  1775.                                     if(!sa.getInvocazionePorta().getCredenziali(z).isAppId()) {
  1776.                                         continue;
  1777.                                     }
  1778.                                 }
  1779.                                 else {
  1780.                                     if(sa.getInvocazionePorta().getCredenziali(z).isAppId()) {
  1781.                                         continue;
  1782.                                     }
  1783.                                 }
  1784.                                 
  1785.                                 String passwordSaved = sa.getInvocazionePorta().getCredenziali(z).getPassword();
  1786.                                 
  1787.                                 boolean found = false;
  1788.                                 if(testInChiaro) {
  1789.                                     found = aPassword.equals(passwordSaved);
  1790.                                 }
  1791.                                 if(!found && crypt!=null) {
  1792.                                     found = crypt.check(aPassword, passwordSaved);
  1793.                                 }
  1794.                                 
  1795.                                 if( found ) {
  1796.                                     sa.setTipoSoggettoProprietario(soggettoSearch.getTipo());
  1797.                                     sa.setNomeSoggettoProprietario(soggettoSearch.getNome());
  1798.                                     return sa;
  1799.                                 }
  1800.                             }
  1801.                         }
  1802.                     }
  1803.                 }
  1804.             }
  1805.         }
  1806.         
  1807.         throw new DriverConfigurazioneNotFound("Servizio Applicativo cercato con credenziali basic non trovato");
  1808.     }
  1809.     
  1810.     @Override
  1811.     public ServizioApplicativo getServizioApplicativoByCredenzialiToken(String tokenPolicy, String tokenClientId, boolean tokenWithHttpsEnabled) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1812.         if(tokenPolicy==null){
  1813.             throw new DriverConfigurazioneException("TokenPolicy non definita");
  1814.         }
  1815.         if(tokenClientId==null){
  1816.             throw new DriverConfigurazioneException("TokenClientId non definito");
  1817.         }
  1818.         
  1819.         for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  1820.             Soggetto soggettoSearch = this.openspcoop.getSoggetto(i);
  1821.             for(int j=0; j<soggettoSearch.sizeServizioApplicativoList(); j++){
  1822.                 ServizioApplicativo sa = soggettoSearch.getServizioApplicativo(j);
  1823.                 if(sa.getInvocazionePorta()!=null){
  1824.                     for(int z=0;z<sa.getInvocazionePorta().sizeCredenzialiList();z++){
  1825.                         if(sa.getInvocazionePorta().getCredenziali(z).getTipo()!=null &&
  1826.                                 (
  1827.                                         CostantiConfigurazione.CREDENZIALE_TOKEN.equals(sa.getInvocazionePorta().getCredenziali(z).getTipo())
  1828.                                         ||
  1829.                                         (tokenWithHttpsEnabled && CostantiConfigurazione.CREDENZIALE_SSL.equals(sa.getInvocazionePorta().getCredenziali(z).getTipo()))
  1830.                                 )
  1831.                                 ){
  1832.                             if( tokenClientId.equals(sa.getInvocazionePorta().getCredenziali(z).getUser()) &&
  1833.                                     tokenPolicy.equals(sa.getInvocazionePorta().getCredenziali(z).getTokenPolicy())){
  1834.                                 sa.setTipoSoggettoProprietario(soggettoSearch.getTipo());
  1835.                                 sa.setNomeSoggettoProprietario(soggettoSearch.getNome());
  1836.                                 return sa;
  1837.                             }
  1838.                         }
  1839.                     }
  1840.                 }
  1841.             }
  1842.         }
  1843.         
  1844.         throw new DriverConfigurazioneNotFound("Servizio Applicativo cercato con credenziali principal non trovato");
  1845.     }
  1846.     
  1847.     @Override
  1848.     public ServizioApplicativo getServizioApplicativoByCredenzialiSsl(String aSubject, String aIssuer) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1849.         
  1850.         if(aSubject==null){
  1851.             throw new DriverConfigurazioneException("Subject non definito");
  1852.         }
  1853.         
  1854.         for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  1855.             Soggetto soggettoSearch = this.openspcoop.getSoggetto(i);
  1856.             for(int j=0; j<soggettoSearch.sizeServizioApplicativoList(); j++){
  1857.                 ServizioApplicativo sa = soggettoSearch.getServizioApplicativo(j);
  1858.                 if(sa.getInvocazionePorta()!=null){
  1859.                     for(int z=0;z<sa.getInvocazionePorta().sizeCredenzialiList();z++){
  1860.                         //  Default: SSL
  1861.                         if(sa.getInvocazionePorta().getCredenziali(z).getTipo() == null){
  1862.                             try{
  1863.                                 if(sa.getInvocazionePorta().getCredenziali(z).getSubject()==null) {
  1864.                                     continue;
  1865.                                 }
  1866.                                 boolean subjectValid = CertificateUtils.sslVerify(sa.getInvocazionePorta().getCredenziali(z).getSubject(), aSubject, PrincipalType.SUBJECT, this.log);
  1867.                                 boolean issuerValid = true;
  1868.                                 if(aIssuer!=null) {
  1869.                                     if(sa.getInvocazionePorta().getCredenziali(z).getIssuer()==null) {
  1870.                                         issuerValid = false;
  1871.                                     }else {
  1872.                                         issuerValid = CertificateUtils.sslVerify(sa.getInvocazionePorta().getCredenziali(z).getIssuer(), aIssuer, PrincipalType.ISSUER, this.log);
  1873.                                     }
  1874.                                 }
  1875.                                 else {
  1876.                                     issuerValid = (sa.getInvocazionePorta().getCredenziali(z).getIssuer() == null);
  1877.                                 }
  1878.                                 if(subjectValid && issuerValid){
  1879.                                     sa.setTipoSoggettoProprietario(soggettoSearch.getTipo());
  1880.                                     sa.setNomeSoggettoProprietario(soggettoSearch.getNome());
  1881.                                     return sa;
  1882.                                 }   
  1883.                             }catch(Exception e){
  1884.                                 throw new DriverConfigurazioneException(e.getMessage(),e);
  1885.                             }
  1886.                         }
  1887.                         if(sa.getInvocazionePorta().getCredenziali(z).getTipo()!=null &&
  1888.                                 CostantiConfigurazione.CREDENZIALE_SSL.equals(sa.getInvocazionePorta().getCredenziali(z).getTipo())){
  1889.                             try{
  1890.                                 if(sa.getInvocazionePorta().getCredenziali(z).getSubject()==null) {
  1891.                                     continue;
  1892.                                 }
  1893.                                 boolean subjectValid = CertificateUtils.sslVerify(sa.getInvocazionePorta().getCredenziali(z).getSubject(), aSubject, PrincipalType.SUBJECT, this.log);
  1894.                                 boolean issuerValid = true;
  1895.                                 if(aIssuer!=null) {
  1896.                                     if(sa.getInvocazionePorta().getCredenziali(z).getIssuer()==null) {
  1897.                                         issuerValid = false;
  1898.                                     }else {
  1899.                                         issuerValid = CertificateUtils.sslVerify(sa.getInvocazionePorta().getCredenziali(z).getIssuer(), aIssuer, PrincipalType.ISSUER, this.log);
  1900.                                     }
  1901.                                 }
  1902.                                 else {
  1903.                                     issuerValid = (sa.getInvocazionePorta().getCredenziali(z).getIssuer() == null);
  1904.                                 }
  1905.                                 if(subjectValid && issuerValid){
  1906.                                     sa.setTipoSoggettoProprietario(soggettoSearch.getTipo());
  1907.                                     sa.setNomeSoggettoProprietario(soggettoSearch.getNome());
  1908.                                     return sa;
  1909.                                 }   
  1910.                             }catch(Exception e){
  1911.                                 throw new DriverConfigurazioneException(e.getMessage(),e);
  1912.                             }
  1913.                         }
  1914.                     }
  1915.                 }
  1916.             }
  1917.         }
  1918.         
  1919.         throw new DriverConfigurazioneNotFound("Servizio Applicativo cercato con credenziali ssl non trovato");
  1920.     }
  1921.     
  1922.     @Override
  1923.     public ServizioApplicativo getServizioApplicativoByCredenzialiSsl(CertificateInfo aCertificate, boolean aStrictVerifier) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1924.         
  1925.         if(aCertificate==null){
  1926.             throw new DriverConfigurazioneException("Certificato non definito");
  1927.         }
  1928.         
  1929.         for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  1930.             Soggetto soggettoSearch = this.openspcoop.getSoggetto(i);
  1931.             for(int j=0; j<soggettoSearch.sizeServizioApplicativoList(); j++){
  1932.                 ServizioApplicativo sa = soggettoSearch.getServizioApplicativo(j);
  1933.                 if(sa.getInvocazionePorta()!=null){
  1934.                     for(int z=0;z<sa.getInvocazionePorta().sizeCredenzialiList();z++){
  1935.                         //  Default: SSL
  1936.                         if(sa.getInvocazionePorta().getCredenziali(z).getTipo() == null){
  1937.                             try{
  1938.                                 if(sa.getInvocazionePorta().getCredenziali(z).getCertificate()==null) {
  1939.                                     continue;
  1940.                                 }
  1941.                                 if(aStrictVerifier != sa.getInvocazionePorta().getCredenziali(z).isCertificateStrictVerification()) {
  1942.                                     continue;
  1943.                                 }
  1944.                                 String cnSubject = aCertificate.getSubject().getCN();
  1945.                                 if(cnSubject.equals(sa.getInvocazionePorta().getCredenziali(z).getCnSubject())) {
  1946.                                     Certificate certificato = ArchiveLoader.load(ArchiveType.CER, sa.getInvocazionePorta().getCredenziali(z).getCertificate(), 0, null);
  1947.                                     if(aCertificate.equals(certificato.getCertificate(),aStrictVerifier)) {
  1948.                                         sa.setTipoSoggettoProprietario(soggettoSearch.getTipo());
  1949.                                         sa.setNomeSoggettoProprietario(soggettoSearch.getNome());
  1950.                                         return sa;
  1951.                                     }
  1952.                                 }
  1953.                             }catch(Exception e){
  1954.                                 throw new DriverConfigurazioneException(e.getMessage(),e);
  1955.                             }
  1956.                         }
  1957.                         if(sa.getInvocazionePorta().getCredenziali(z).getTipo()!=null &&
  1958.                                 CostantiConfigurazione.CREDENZIALE_SSL.equals(sa.getInvocazionePorta().getCredenziali(z).getTipo())){
  1959.                             try{
  1960.                                 if(sa.getInvocazionePorta().getCredenziali(z).getCertificate()==null) {
  1961.                                     continue;
  1962.                                 }
  1963.                                 if(aStrictVerifier != sa.getInvocazionePorta().getCredenziali(z).isCertificateStrictVerification()) {
  1964.                                     continue;
  1965.                                 }
  1966.                                 String cnSubject = aCertificate.getSubject().getCN();
  1967.                                 if(cnSubject.equals(sa.getInvocazionePorta().getCredenziali(z).getCnSubject())) {
  1968.                                     Certificate certificato = ArchiveLoader.load(ArchiveType.CER, sa.getInvocazionePorta().getCredenziali(z).getCertificate(), 0, null);
  1969.                                     if(aCertificate.equals(certificato.getCertificate(),aStrictVerifier)) {
  1970.                                         sa.setTipoSoggettoProprietario(soggettoSearch.getTipo());
  1971.                                         sa.setNomeSoggettoProprietario(soggettoSearch.getNome());
  1972.                                         return sa;
  1973.                                     }   
  1974.                                 }
  1975.                             }catch(Exception e){
  1976.                                 throw new DriverConfigurazioneException(e.getMessage(),e);
  1977.                             }
  1978.                         }
  1979.                     }
  1980.                 }
  1981.             }
  1982.         }
  1983.         
  1984.         throw new DriverConfigurazioneNotFound("Servizio Applicativo cercato con credenziali ssl non trovato");
  1985.         
  1986.     }
  1987.     
  1988.     @Override
  1989.     public ServizioApplicativo getServizioApplicativoByCredenzialiPrincipal(String aUserPrincipal) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  1990.         
  1991.         if(aUserPrincipal==null){
  1992.             throw new DriverConfigurazioneException("Principal non definito");
  1993.         }
  1994.         
  1995.         for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  1996.             Soggetto soggettoSearch = this.openspcoop.getSoggetto(i);
  1997.             for(int j=0; j<soggettoSearch.sizeServizioApplicativoList(); j++){
  1998.                 ServizioApplicativo sa = soggettoSearch.getServizioApplicativo(j);
  1999.                 if(sa.getInvocazionePorta()!=null){
  2000.                     for(int z=0;z<sa.getInvocazionePorta().sizeCredenzialiList();z++){
  2001.                         if(sa.getInvocazionePorta().getCredenziali(z).getTipo()!=null &&
  2002.                                 CostantiConfigurazione.CREDENZIALE_PRINCIPAL.equals(sa.getInvocazionePorta().getCredenziali(z).getTipo())){
  2003.                             if( aUserPrincipal.equals(sa.getInvocazionePorta().getCredenziali(z).getUser()) ){
  2004.                                 sa.setTipoSoggettoProprietario(soggettoSearch.getTipo());
  2005.                                 sa.setNomeSoggettoProprietario(soggettoSearch.getNome());
  2006.                                 return sa;
  2007.                             }
  2008.                         }
  2009.                     }
  2010.                 }
  2011.             }
  2012.         }
  2013.         
  2014.         throw new DriverConfigurazioneNotFound("Servizio Applicativo cercato con credenziali principal non trovato");
  2015.     }

  2017.     
  2018.     /**
  2019.      * Restituisce la lista degli identificativi dei servizi applicativi
  2020.      * 
  2021.      * @param filtroRicerca
  2022.      * @return lista degli identificativi dei servizi applicativi
  2023.      * @throws DriverConfigurazioneException
  2024.      * @throws DriverConfigurazioneNotFound
  2025.      */
  2026.     @Override
  2027.     public List<IDServizioApplicativo> getAllIdServiziApplicativi(
  2028.             FiltroRicercaServiziApplicativi filtroRicerca) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2029.         
  2030.         refreshConfigurazioneXML();
  2031.         
  2032.         List<IDServizioApplicativo> listIDServiziApplicativi = new ArrayList<IDServizioApplicativo>();
  2033.         
  2034.         for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  2035.             Soggetto soggetto = this.openspcoop.getSoggetto(i);
  2036.             for (int j = 0; j < soggetto.sizeServizioApplicativoList(); j++) {
  2037.                 ServizioApplicativo sa = soggetto.getServizioApplicativo(j);
  2038.                 
  2039.                 String id = sa.getNome();
  2040.                 
  2041.                 if(filtroRicerca!=null){
  2042.                     // Filtro By Data
  2043.                     if(filtroRicerca.getMinDate()!=null){
  2044.                         if(sa.getOraRegistrazione()==null){
  2045.                             this.log.debug("[getAllIdPorteApplicative](FiltroByMinDate) PortaApplicativa ["+id+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  2046.                             continue;
  2047.                         }else if(sa.getOraRegistrazione().before(filtroRicerca.getMinDate())){
  2048.                             continue;
  2049.                         }
  2050.                     }
  2051.                     if(filtroRicerca.getMaxDate()!=null){
  2052.                         if(soggetto.getOraRegistrazione()==null){
  2053.                             this.log.debug("[getAllIdPorteApplicative](FiltroByMaxDate) PortaApplicativa ["+id+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  2054.                             continue;
  2055.                         }else if(soggetto.getOraRegistrazione().after(filtroRicerca.getMaxDate())){
  2056.                             continue;
  2057.                         }
  2058.                     }
  2059.                     // Filtro By Tipo e Nome
  2060.                     if(filtroRicerca.getTipoSoggetto()!=null){
  2061.                         if(soggetto.getTipo().equals(filtroRicerca.getTipoSoggetto()) == false){
  2062.                             continue;
  2063.                         }
  2064.                     }
  2065.                     if(filtroRicerca.getNomeSoggetto()!=null){
  2066.                         if(soggetto.getNome().equals(filtroRicerca.getNomeSoggetto()) == false){
  2067.                             continue;
  2068.                         }
  2069.                     }
  2070.                     // Filtro By Ruoli
  2071.                     if(filtroRicerca.getIdRuolo()!=null && filtroRicerca.getIdRuolo().getNome()!=null){
  2072.                         if(sa.getInvocazionePorta()==null){
  2073.                             continue;
  2074.                         }
  2075.                         if(sa.getInvocazionePorta().getRuoli()==null){
  2076.                             continue;
  2077.                         }
  2078.                         boolean contains = false;
  2079.                         for (int z = 0; z < sa.getInvocazionePorta().getRuoli().sizeRuoloList(); z++) {
  2080.                             if(filtroRicerca.getIdRuolo().getNome().equals(sa.getInvocazionePorta().getRuoli().getRuolo(z).getNome())){
  2081.                                 contains = true;
  2082.                                 break;
  2083.                             }
  2084.                         }
  2085.                         if(!contains){
  2086.                             continue;
  2087.                         }
  2088.                     }
  2089.                 }
  2090.                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  2091.                 idSA.setNome(id);
  2092.                 idSA.setIdSoggettoProprietario(new IDSoggetto(soggetto.getTipo(), soggetto.getNome()));
  2093.                 listIDServiziApplicativi.add(idSA);
  2094.             }
  2095.         }
  2096.         
  2097.         if(listIDServiziApplicativi.size()<=0){
  2098.             if(filtroRicerca!=null)
  2099.                 throw new DriverConfigurazioneNotFound("ServiziApplicativi non trovati che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  2100.             else
  2101.                 throw new DriverConfigurazioneNotFound("ServiziApplicativi non trovati");
  2102.         }
  2103.         
  2104.         return listIDServiziApplicativi;
  2105.         
  2106.     }
  2107.     
  2108.     @Override
  2109.     public List<IDConnettore> getConnettoriConsegnaNotifichePrioritarie(String queueName) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2110.     
  2111.         refreshConfigurazioneXML();
  2112.         
  2113.         List<IDConnettore> listIDServiziApplicativi = new ArrayList<IDConnettore>();
  2114.         
  2115.         for(int i=0; i<this.openspcoop.sizeSoggettoList(); i++){
  2116.             Soggetto soggetto = this.openspcoop.getSoggetto(i);
  2117.             for (int j = 0; j < soggetto.sizePortaApplicativaList(); j++) {
  2118.                 PortaApplicativa pa = soggetto.getPortaApplicativa(j);
  2119.                 if(pa.sizeServizioApplicativoList()>0) {
  2120.                     for (int k = 0; k <pa.sizeServizioApplicativoList(); k++) {
  2121.                         PortaApplicativaServizioApplicativo pasa = pa.getServizioApplicativo(k);
  2122.                         if(pasa.getDatiConnettore()!=null && pasa.getDatiConnettore().isPrioritaMax()) {
  2123.                             if(queueName!=null) {
  2124.                                 String coda = pasa.getDatiConnettore().getCoda();
  2125.                                 if(coda==null) {
  2126.                                     coda = CostantiConfigurazione.CODA_DEFAULT;
  2127.                                 }
  2128.                                 if(!queueName.equals(coda)){
  2129.                                     continue;
  2130.                                 }
  2131.                             }
  2132.                             IDConnettore idSA = new IDConnettore();
  2133.                             idSA.setNome(pasa.getNome());
  2134.                             idSA.setIdSoggettoProprietario(new IDSoggetto(soggetto.getTipo(), soggetto.getNome()));
  2135.                             idSA.setNomeConnettore(pasa.getDatiConnettore().getNome());
  2136.                             if(idSA.getNomeConnettore()==null) {
  2137.                                 idSA.setNomeConnettore(CostantiConfigurazione.NOME_CONNETTORE_DEFAULT);
  2138.                             }
  2139.                             listIDServiziApplicativi.add(idSA);
  2140.                         }
  2141.                     }
  2142.                 }
  2143.             }
  2144.         }
  2145.         
  2146.         if(listIDServiziApplicativi.size()<=0){
  2147.             if(queueName!=null)
  2148.                 throw new DriverConfigurazioneNotFound("ServiziApplicativi non trovati per la coda '"+queueName+"'");
  2149.             else
  2150.                 throw new DriverConfigurazioneNotFound("ServiziApplicativi non trovati");
  2151.         }
  2152.         
  2153.         return listIDServiziApplicativi;
  2154.     }
  2155.     
  2156.     
  2157.     
  2158.     
  2159.     
  2160.     
  2161.     

  2163.     // CONFIGURAZIONE

  2165.     /**
  2166.      * Restituisce la RoutingTable definita nella Porta di Dominio 
  2167.      *
  2168.      * @return RoutingTable
  2169.      * 
  2170.      */
  2171.     @Override
  2172.     public RoutingTable getRoutingTable() throws DriverConfigurazioneException{

  2174.         refreshConfigurazioneXML();

  2176.         RoutingTable r = null;
  2177.         if(this.openspcoop.getConfigurazione().getRoutingTable()==null){
  2178.             r = new RoutingTable();
  2179.             r.setAbilitata(false);
  2180.         }else{
  2181.             r =  this.openspcoop.getConfigurazione().getRoutingTable();
  2182.             r.setAbilitata(true);
  2183.         }
  2184.         
  2185.         return r;
  2186.     }

  2188.     /**
  2189.      * Restituisce l'accesso al registro definito nella Porta di Dominio 
  2190.      *
  2191.      * @return AccessoRegistro
  2192.      * 
  2193.      */
  2194.     @Override
  2195.     public AccessoRegistro getAccessoRegistro() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  2197.         refreshConfigurazioneXML();

  2199.         if(this.openspcoop.getConfigurazione().getAccessoRegistro()==null)
  2200.             throw new DriverConfigurazioneNotFound("[getAccessoRegistro] Informazioni di accesso al RegistroServizi non trovate");
  2201.         
  2202.         return this.openspcoop.getConfigurazione().getAccessoRegistro();
  2203.     }
  2204.     
  2205.     /**
  2206.      * Restituisce l'accesso alla configurazione definito nella Porta di Dominio 
  2207.      *
  2208.      * @return AccessoConfigurazione
  2209.      * 
  2210.      */
  2211.     @Override
  2212.     public AccessoConfigurazione getAccessoConfigurazione() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2213.         
  2214.         refreshConfigurazioneXML();

  2216.         if(this.openspcoop.getConfigurazione().getAccessoConfigurazione()==null)
  2217.             throw new DriverConfigurazioneNotFound("[getAccessoConfigurazione] Informazioni di accesso alla configurazione non trovate");
  2218.         
  2219.         return this.openspcoop.getConfigurazione().getAccessoConfigurazione();
  2220.     }
  2221.     
  2222.     /**
  2223.      * Restituisce l'accesso ai dati di autorizzazione definiti nella Porta di Dominio 
  2224.      *
  2225.      * @return AccessoDatiAutorizzazione
  2226.      * 
  2227.      */
  2228.     @Override
  2229.     public AccessoDatiAutorizzazione getAccessoDatiAutorizzazione() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2230.         
  2231.         refreshConfigurazioneXML();

  2233.         if(this.openspcoop.getConfigurazione().getAccessoDatiAutorizzazione()==null)
  2234.             throw new DriverConfigurazioneNotFound("[getAccessoDatiAutorizzazione] Informazioni di accesso ai dati di autorizzazione non trovate");
  2235.         
  2236.         return this.openspcoop.getConfigurazione().getAccessoDatiAutorizzazione();
  2237.         
  2238.     }
  2239.     
  2240.     /**
  2241.      * Restituisce l'accesso ai dati di autenticazione definiti nella Porta di Dominio 
  2242.      *
  2243.      * @return AccessoDatiAutenticazione
  2244.      * 
  2245.      */
  2246.     @Override
  2247.     public AccessoDatiAutenticazione getAccessoDatiAutenticazione() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2248.         
  2249.         refreshConfigurazioneXML();

  2251.         if(this.openspcoop.getConfigurazione().getAccessoDatiAutenticazione()==null)
  2252.             throw new DriverConfigurazioneNotFound("[getAccessoDatiAutenticazione] Informazioni di accesso ai dati di autenticazione non trovate");
  2253.         
  2254.         return this.openspcoop.getConfigurazione().getAccessoDatiAutenticazione();
  2255.         
  2256.     }

  2258.     
  2259.     /**
  2260.      * Restituisce l'accesso ai dati di gestione token
  2261.      *
  2262.      * @return AccessoDatiGestioneToken
  2263.      * 
  2264.      */
  2265.     @Override
  2266.     public AccessoDatiGestioneToken getAccessoDatiGestioneToken() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2267.         
  2268.         refreshConfigurazioneXML();

  2270.         if(this.openspcoop.getConfigurazione().getAccessoDatiGestioneToken()==null)
  2271.             throw new DriverConfigurazioneNotFound("[getAccessoDatiGestioneToken] Informazioni di accesso ai dati di gestione dei token non trovati");
  2272.         
  2273.         return this.openspcoop.getConfigurazione().getAccessoDatiGestioneToken();
  2274.         
  2275.     }
  2276.     
  2277.     /**
  2278.      * Restituisce l'accesso ai dati recuperati da attribute authority
  2279.      *
  2280.      * @return AccessoDatiAttributeAuthority
  2281.      * 
  2282.      */
  2283.     @Override
  2284.     public AccessoDatiAttributeAuthority getAccessoDatiAttributeAuthority() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2285.         
  2286.         refreshConfigurazioneXML();

  2288.         if(this.openspcoop.getConfigurazione().getAccessoDatiAttributeAuthority()==null)
  2289.             throw new DriverConfigurazioneNotFound("[getAccessoDatiAttributeAuthority] Informazioni di accesso ai dati recuperati da Attribute Authority non trovati");
  2290.         
  2291.         return this.openspcoop.getConfigurazione().getAccessoDatiAttributeAuthority();
  2292.         
  2293.     }
  2294.     
  2295.     /**
  2296.      * Restituisce l'accesso ai dati per la gestione dei keystore
  2297.      *
  2298.      * @return AccessoDatiKeystore
  2299.      * 
  2300.      */
  2301.     @Override
  2302.     public AccessoDatiKeystore getAccessoDatiKeystore() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2303.     
  2304.         refreshConfigurazioneXML();

  2306.         if(this.openspcoop.getConfigurazione().getAccessoDatiKeystore()==null)
  2307.             throw new DriverConfigurazioneNotFound("[getAccessoDatiKeystore] Informazioni di accesso ai dati per la gestione dei keystore non trovati");
  2308.         
  2309.         return this.openspcoop.getConfigurazione().getAccessoDatiKeystore();
  2310.         
  2311.     }
  2312.     
  2313.     /**
  2314.      * Restituisce l'accesso ai dati per la gestione delle richieste
  2315.      *
  2316.      * @return AccessoDatiRichieste
  2317.      * 
  2318.      */
  2319.     @Override
  2320.     public AccessoDatiRichieste getAccessoDatiRichieste() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2321.     
  2322.         refreshConfigurazioneXML();

  2324.         if(this.openspcoop.getConfigurazione().getAccessoDatiRichieste()==null)
  2325.             throw new DriverConfigurazioneNotFound("[getAccessoDatiRichieste] Informazioni di accesso ai dati per la gestione delle richieste non trovati");
  2326.         
  2327.         return this.openspcoop.getConfigurazione().getAccessoDatiRichieste();
  2328.         
  2329.     }
  2330.     
  2331.     /**
  2332.      * Restituisce l'accesso ai dati per la gestione della consegna agli applicativi
  2333.      *
  2334.      * @return AccessoDatiKeystore
  2335.      * 
  2336.      */
  2337.     @Override
  2338.     public AccessoDatiConsegnaApplicativi getAccessoDatiConsegnaApplicativi() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2339.     
  2340.         refreshConfigurazioneXML();

  2342.         if(this.openspcoop.getConfigurazione().getAccessoDatiConsegnaApplicativi()==null)
  2343.             throw new DriverConfigurazioneNotFound("[getAccessoDatiKeystore] Informazioni di accesso ai dati per la gestione della consegna agli applicativi non trovati");
  2344.         
  2345.         return this.openspcoop.getConfigurazione().getAccessoDatiConsegnaApplicativi();
  2346.         
  2347.     }
  2348.     
  2349.     
  2350.     /**
  2351.      * Restituisce la gestione dell'errore di default definita nella Porta di Dominio per il componente di cooperazione
  2352.      *
  2353.      * @return La gestione dell'errore
  2354.      * 
  2355.      */
  2356.     @Override
  2357.     public GestioneErrore getGestioneErroreComponenteCooperazione() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2358.         
  2359.         refreshConfigurazioneXML();
  2360.         
  2361.         if(this.openspcoop.getConfigurazione()==null)
  2362.             throw new DriverConfigurazioneNotFound("[getGestioneErroreComponenteCooperazione] Configurazione non trovata");
  2363.         if(this.openspcoop.getConfigurazione().getGestioneErrore()==null)
  2364.             throw new DriverConfigurazioneNotFound("[getGestioneErroreComponenteCooperazione] Informazioni per la gestione dell'errore non trovate");
  2365.         if(this.openspcoop.getConfigurazione().getGestioneErrore().getComponenteCooperazione()==null)
  2366.             throw new DriverConfigurazioneNotFound("[getGestioneErroreComponenteCooperazione] Informazioni per la gestione dell'errore per il componente di cooperazione non trovate");
  2367.     
  2368.         return this.openspcoop.getConfigurazione().getGestioneErrore().getComponenteCooperazione();
  2369.     }
  2370.     
  2371.     /**
  2372.      * Restituisce la gestione dell'errore di default definita nella Porta di Dominio per il componente di integrazione
  2373.      *
  2374.      * @return La gestione dell'errore
  2375.      * 
  2376.      */
  2377.     @Override
  2378.     public GestioneErrore getGestioneErroreComponenteIntegrazione() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2379.         
  2380.         refreshConfigurazioneXML();
  2381.         
  2382.         if(this.openspcoop.getConfigurazione()==null)
  2383.             throw new DriverConfigurazioneNotFound("[getGestioneErroreComponenteIntegrazione] Configurazione non trovata");
  2384.         if(this.openspcoop.getConfigurazione().getGestioneErrore()==null)
  2385.             throw new DriverConfigurazioneNotFound("[getGestioneErroreComponenteIntegrazione] Informazioni per la gestione dell'errore non trovate");
  2386.         if(this.openspcoop.getConfigurazione().getGestioneErrore().getComponenteIntegrazione()==null)
  2387.             throw new DriverConfigurazioneNotFound("[getGestioneErroreComponenteIntegrazione] Informazioni per la gestione dell'errore per il componente di cooperazione non trovate");
  2388.     
  2389.         return this.openspcoop.getConfigurazione().getGestioneErrore().getComponenteIntegrazione();
  2390.     }

  2392.     /**
  2393.      * Restituisce la servizio sui ServiziAttivi definiti nella Porta di Dominio 
  2394.      *
  2395.      * @return ServiziAttivi
  2396.      * 
  2397.      */
  2398.     @Override
  2399.     public StatoServiziPdd getStatoServiziPdD() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2400.         
  2401.         refreshConfigurazioneXML();
  2402.         
  2403.         if(this.openspcoop.getConfigurazione()==null)
  2404.             throw new DriverConfigurazioneNotFound("[getServiziAttiviPdD] Configurazione non trovata");
  2405.         if(this.openspcoop.getConfigurazione().getStatoServiziPdd()==null)
  2406.             throw new DriverConfigurazioneNotFound("[getServiziAttiviPdD] Configurazione servizi attivi sulla PdD non presente");
  2407.     
  2408.         return this.openspcoop.getConfigurazione().getStatoServiziPdd();
  2409.     }
  2410.     
  2411.     /**
  2412.      * Restituisce le proprieta' di sistema utilizzate dalla PdD
  2413.      *
  2414.      * @return proprieta' di sistema
  2415.      * 
  2416.      */
  2417.     @Override
  2418.     public SystemProperties getSystemPropertiesPdD() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2419.         
  2420.         refreshConfigurazioneXML();
  2421.         
  2422.         if(this.openspcoop.getConfigurazione()==null)
  2423.             throw new DriverConfigurazioneNotFound("[getServiziAttiviPdD] Configurazione non trovata");
  2424.         if(this.openspcoop.getConfigurazione().getSystemProperties()==null)
  2425.             throw new DriverConfigurazioneNotFound("[getServiziAttiviPdD] Configurazione System Properties non presenti");
  2426.     
  2427.         return this.openspcoop.getConfigurazione().getSystemProperties();
  2428.         
  2429.     }
  2430.     
  2431.     /**
  2432.      * Restituisce i nomi delle proprieta' di sistema cifrate
  2433.      *
  2434.      * @return proprieta' di sistema
  2435.      * 
  2436.      */
  2437.     @Override
  2438.     public List<String> getEncryptedSystemPropertiesPdD() throws DriverConfigurazioneException{
  2439.         return new ArrayList<>();
  2440.     }
  2441.     
  2442.     /**
  2443.      * Restituisce le proprieta' generiche utilizzate dalla PdD
  2444.      *
  2445.      * @return proprieta' generiche
  2446.      * 
  2447.      */
  2448.     @Override
  2449.     public List<GenericProperties> getGenericProperties() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2450.         
  2451.         refreshConfigurazioneXML();
  2452.         
  2453.         if(this.openspcoop.getConfigurazione()==null)
  2454.             throw new DriverConfigurazioneNotFound("[getGenericProperties] Configurazione non trovata");
  2455.         if(this.openspcoop.getConfigurazione().getGenericPropertiesList()==null || this.openspcoop.getConfigurazione().getGenericPropertiesList().size()<=0)
  2456.             throw new DriverConfigurazioneNotFound("[getGenericProperties] Configurazione Generic Properties non presenti");
  2457.     
  2458.         return this.openspcoop.getConfigurazione().getGenericPropertiesList();
  2459.         
  2460.     }
  2461.     
  2462.     /**
  2463.      * Restituisce le proprieta' generiche di una tipologia utilizzate dalla PdD
  2464.      *
  2465.      * @return proprieta' generiche
  2466.      * 
  2467.      */
  2468.     @Override
  2469.     public List<GenericProperties> getGenericProperties(String tipologia) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  2471.         refreshConfigurazioneXML();
  2472.         
  2473.         if(this.openspcoop.getConfigurazione()==null)
  2474.             throw new DriverConfigurazioneNotFound("[getGenericProperties] Configurazione non trovata");
  2475.         if(this.openspcoop.getConfigurazione().getGenericPropertiesList()==null || this.openspcoop.getConfigurazione().getGenericPropertiesList().size()<=0)
  2476.             throw new DriverConfigurazioneNotFound("[getGenericProperties] Configurazione Generic Properties non presenti");
  2477.          
  2478.         List<GenericProperties> list = new ArrayList<>();
  2479.         for (GenericProperties genericProperties : this.openspcoop.getConfigurazione().getGenericPropertiesList()) {
  2480.             if(tipologia!=null && tipologia.equals(genericProperties.getTipologia())) {
  2481.                 list.add(genericProperties);
  2482.             }
  2483.         }
  2484.         
  2485.         if(list.isEmpty()) {
  2486.             throw new DriverConfigurazioneNotFound("[getGenericProperties] Configurazione Generic Properties non presenti con tipologia '"+tipologia+"'");
  2487.         }
  2488.         
  2489.         return list;
  2490.     }
  2491.     
  2492.     @Override
  2493.     public GenericProperties getGenericProperties(String tipologia, String name) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2494.         
  2495.         refreshConfigurazioneXML();
  2496.         
  2497.         if(this.openspcoop.getConfigurazione()==null)
  2498.             throw new DriverConfigurazioneNotFound("[getGenericProperties] Configurazione non trovata");
  2499.         if(this.openspcoop.getConfigurazione().getGenericPropertiesList()==null || this.openspcoop.getConfigurazione().getGenericPropertiesList().size()<=0)
  2500.             throw new DriverConfigurazioneNotFound("[getGenericProperties] Configurazione Generic Properties non presenti");
  2501.          
  2502.         for (GenericProperties genericProperties : this.openspcoop.getConfigurazione().getGenericPropertiesList()) {
  2503.             if(tipologia!=null && tipologia.equals(genericProperties.getTipologia())) {
  2504.                 if(genericProperties.getNome().equals(name)) {
  2505.                     return genericProperties;
  2506.                 }
  2507.             }
  2508.         }
  2509.         
  2510.         throw new DriverConfigurazioneNotFound("[getGenericProperties] Configurazione Generic Properties non presenti con tipologia '"+tipologia+"' e nome '"+name+"'");
  2511.     }

  2513.     /**
  2514.      * Restituisce la configurazione dei plugins
  2515.      *
  2516.      * @return RegistroPlugins
  2517.      * 
  2518.      */
  2519.     @Override
  2520.     public RegistroPlugins getRegistroPlugins() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2521.         refreshConfigurazioneXML();

  2523.         RegistroPlugins registro = this.openspcoop.getConfigurazione().getRegistroPlugins();
  2524.         if(registro==null || registro.sizePluginList()<=0) {
  2525.             throw new DriverConfigurazioneNotFound("Nessun plugin registrato");
  2526.         }
  2527.         
  2528.         return registro;
  2529.     }
  2530.     

  2532.     @Override
  2533.     public CanaliConfigurazione getCanaliConfigurazione() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  2535.         refreshConfigurazioneXML();
  2536.         
  2537.         CanaliConfigurazione c = this.openspcoop.getConfigurazione().getGestioneCanali();
  2538.         if(c==null) {
  2539.             c = new CanaliConfigurazione();
  2540.             c.setStato(StatoFunzionalita.DISABILITATO);
  2541.         }
  2542.         return c;
  2543.     }

  2545.     /**
  2546.      * Restituisce la configurazione del plugin
  2547.      *
  2548.      * @return RegistroPlugin
  2549.      * 
  2550.      */
  2551.     @Override
  2552.     public RegistroPlugin getRegistroPlugin(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2553.         return getRegistroPlugin(nome, false);
  2554.     }
  2555.     @Override
  2556.     public RegistroPlugin getDatiRegistroPlugin(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2557.         return getRegistroPlugin(nome, true);
  2558.     }
  2559.     private RegistroPlugin getRegistroPlugin(String nome, boolean soloDati) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2560.         if(nome==null) {
  2561.             throw new DriverConfigurazioneException("Nome plugin non indicato");
  2562.         }
  2563.         
  2564.         refreshConfigurazioneXML();

  2566.         RegistroPlugins registro = this.openspcoop.getConfigurazione().getRegistroPlugins();
  2567.         if(registro==null || registro.sizePluginList()<=0) {
  2568.             throw new DriverConfigurazioneNotFound("Plugin '"+nome+"' non esistente");
  2569.         }
  2570.         for (int i = 0; i < registro.sizePluginList(); i++) {
  2571.             RegistroPlugin plug = registro.getPlugin(i);
  2572.             if(plug.getNome().equals(nome)) {
  2573.                 if(soloDati) {
  2574.                     RegistroPlugin plugCloned = (RegistroPlugin) plug.clone();
  2575.                     while(plugCloned.sizeArchivioList()>0) {
  2576.                         plugCloned.removeArchivio(0);
  2577.                     }
  2578.                 }
  2579.                 else {
  2580.                     return plug;
  2581.                 }
  2582.             }
  2583.         }
  2584.         throw new DriverConfigurazioneNotFound("Plugin '"+nome+"' non esistente");
  2585.     }
  2586.     
  2587.     @Override
  2588.     public RegistroPluginArchivio getRegistroPluginArchivio(String nomePlugin, String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2589.         
  2590.         RegistroPlugin plug = this.getRegistroPlugin(nomePlugin);
  2591.         
  2592.         if(nome==null) {
  2593.             throw new DriverConfigurazioneException("Nome archivio non indicato");
  2594.         }
  2595.         
  2596.         for (int i = 0; i < plug.sizeArchivioList(); i++) {
  2597.             RegistroPluginArchivio plugArchivio = plug.getArchivio(i);
  2598.             if(plugArchivio.getNome().equals(nome)) {
  2599.                 return plugArchivio;
  2600.             }
  2601.         }
  2602.         throw new DriverConfigurazioneNotFound("Archivio '"+nome+"' non esistente nel plugin '"+nomePlugin+"'");
  2603.     }
  2604.     
  2605.     @Override
  2606.     public ConfigurazioneUrlInvocazioneRegola getUrlInvocazioneRegola(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  2607.         if(nome==null) {
  2608.             throw new DriverConfigurazioneException("Nome regola non indicato");
  2609.         }
  2610.         
  2611.         refreshConfigurazioneXML();

  2613.         ConfigurazioneUrlInvocazione registro = this.openspcoop.getConfigurazione().getUrlInvocazione();
  2614.         if(registro==null || registro.sizeRegolaList()<=0) {
  2615.             throw new DriverConfigurazioneNotFound("Regola '"+nome+"' non esistente");
  2616.         }
  2617.         for (int i = 0; i < registro.sizeRegolaList(); i++) {
  2618.             ConfigurazioneUrlInvocazioneRegola regola = registro.getRegola(i);
  2619.             if(regola.getNome().equals(nome)) {
  2620.                 return regola;
  2621.             }
  2622.         }
  2623.         throw new DriverConfigurazioneNotFound("Regola '"+nome+"' non esistente");
  2624.     }
  2625.     
  2626.     /**
  2627.      * Restituisce la configurazione generale della Porta di Dominio 
  2628.      *
  2629.      * @return Configurazione
  2630.      * 
  2631.      */
  2632.     @SuppressWarnings("deprecation")
  2633.     @Override
  2634.     public Configurazione getConfigurazioneGenerale() throws DriverConfigurazioneException{

  2636.         refreshConfigurazioneXML();

  2638.         Configurazione config = this.openspcoop.getConfigurazione(); 
  2639.                 
  2640.         // Backward Compatibility
  2641.         if(config!=null && config.getDump()!=null) {
  2642.             if(config.getDump().getConfigurazione()!=null) {
  2643.                 if(config.getDump().getConfigurazionePortaApplicativa()==null && config.getDump().getConfigurazionePortaDelegata()==null) {
  2644.                     config.getDump().setConfigurazionePortaApplicativa(config.getDump().getConfigurazione());
  2645.                     config.getDump().setConfigurazionePortaDelegata(config.getDump().getConfigurazione());
  2646.                 }
  2647.             }
  2648.         }
  2649.         
  2650.         return config;
  2651.     }


  2654.     /**
  2655.      * Metodo che verica la connessione ad una risorsa.
  2656.      * Se la connessione non e' presente, viene lanciata una eccezione che contiene il motivo della mancata connessione
  2657.      * 
  2658.      * @throws DriverException eccezione che contiene il motivo della mancata connessione
  2659.      */
  2660.     @Override
  2661.     public void isAlive() throws CoreException{
  2662.         
  2663.         if(this.create==false)
  2664.             throw new CoreException("Driver non inizializzato");
  2665.         
  2666.         try{
  2667.             this.forzaRefreshConfigurazioneXML();
  2668.         }catch(Exception e){
  2669.             throw new CoreException("Connessione al registro non disponibile: "+e.getMessage(),e);
  2670.         }
  2671.     }




  2676.     @Override
  2677.     public Openspcoop2 getImmagineCompletaConfigurazionePdD() throws DriverConfigurazioneException{
  2678.         
  2679.         refreshConfigurazioneXML();     
  2680.         return this.openspcoop;
  2681.     }


  2684. }
Created with JaCoCo 0.8.8.202204050719