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




  24. package org.openspcoop2.core.registry.driver.web;

  26. import java.io.ByteArrayInputStream;
  27. import java.util.ArrayList;
  28. import java.util.List;

  30. import org.openspcoop2.core.commons.CoreException;
  31. import org.openspcoop2.core.commons.Filtri;
  32. import org.openspcoop2.core.commons.IDriverWS;
  33. import org.openspcoop2.core.commons.IMonitoraggioRisorsa;
  34. import org.openspcoop2.core.id.IDAccordo;
  35. import org.openspcoop2.core.id.IDAccordoAzione;
  36. import org.openspcoop2.core.id.IDAccordoCooperazione;
  37. import org.openspcoop2.core.id.IDFruizione;
  38. import org.openspcoop2.core.id.IDGruppo;
  39. import org.openspcoop2.core.id.IDPortType;
  40. import org.openspcoop2.core.id.IDPortTypeAzione;
  41. import org.openspcoop2.core.id.IDResource;
  42. import org.openspcoop2.core.id.IDRuolo;
  43. import org.openspcoop2.core.id.IDScope;
  44. import org.openspcoop2.core.id.IDServizio;
  45. import org.openspcoop2.core.id.IDSoggetto;
  46. import org.openspcoop2.core.registry.AccordoCooperazione;
  47. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  48. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  49. import org.openspcoop2.core.registry.Azione;
  50. import org.openspcoop2.core.registry.ConfigurazioneServizioAzione;
  51. import org.openspcoop2.core.registry.CredenzialiSoggetto;
  52. import org.openspcoop2.core.registry.Documento;
  53. import org.openspcoop2.core.registry.Fruitore;
  54. import org.openspcoop2.core.registry.Gruppo;
  55. import org.openspcoop2.core.registry.GruppoAccordo;
  56. import org.openspcoop2.core.registry.Operation;
  57. import org.openspcoop2.core.registry.PortType;
  58. import org.openspcoop2.core.registry.PortaDominio;
  59. import org.openspcoop2.core.registry.Resource;
  60. import org.openspcoop2.core.registry.Ruolo;
  61. import org.openspcoop2.core.registry.Scope;
  62. import org.openspcoop2.core.registry.Soggetto;
  63. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  64. import org.openspcoop2.core.registry.constants.CostantiXMLRepository;
  65. import org.openspcoop2.core.registry.constants.CredenzialeTipo;
  66. import org.openspcoop2.core.registry.constants.RuoloContesto;
  67. import org.openspcoop2.core.registry.constants.RuoloTipologia;
  68. import org.openspcoop2.core.registry.constants.ScopeContesto;
  69. import org.openspcoop2.core.registry.constants.TipiDocumentoLivelloServizio;
  70. import org.openspcoop2.core.registry.constants.TipiDocumentoSemiformale;
  71. import org.openspcoop2.core.registry.constants.TipiDocumentoSicurezza;
  72. import org.openspcoop2.core.registry.constants.TipologiaServizio;
  73. import org.openspcoop2.core.registry.driver.BeanUtilities;
  74. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  75. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  76. import org.openspcoop2.core.registry.driver.FiltroRicerca;
  77. import org.openspcoop2.core.registry.driver.FiltroRicercaAccordi;
  78. import org.openspcoop2.core.registry.driver.FiltroRicercaAzioni;
  79. import org.openspcoop2.core.registry.driver.FiltroRicercaFruizioniServizio;
  80. import org.openspcoop2.core.registry.driver.FiltroRicercaGruppi;
  81. import org.openspcoop2.core.registry.driver.FiltroRicercaOperations;
  82. import org.openspcoop2.core.registry.driver.FiltroRicercaPortTypes;
  83. import org.openspcoop2.core.registry.driver.FiltroRicercaResources;
  84. import org.openspcoop2.core.registry.driver.FiltroRicercaRuoli;
  85. import org.openspcoop2.core.registry.driver.FiltroRicercaScope;
  86. import org.openspcoop2.core.registry.driver.FiltroRicercaServizi;
  87. import org.openspcoop2.core.registry.driver.FiltroRicercaSoggetti;
  88. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  89. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  90. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  91. import org.openspcoop2.core.registry.driver.IDriverRegistroServiziCRUD;
  92. import org.openspcoop2.core.registry.driver.IDriverRegistroServiziGet;
  93. import org.openspcoop2.core.registry.driver.ProtocolPropertiesUtilities;
  94. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  95. import org.openspcoop2.message.xml.ValidatoreXSD;
  96. import org.openspcoop2.utils.LoggerWrapperFactory;
  97. import org.openspcoop2.utils.UtilsException;
  98. import org.openspcoop2.utils.UtilsRuntimeException;
  99. import org.openspcoop2.utils.certificate.ArchiveLoader;
  100. import org.openspcoop2.utils.certificate.ArchiveType;
  101. import org.openspcoop2.utils.certificate.Certificate;
  102. import org.openspcoop2.utils.certificate.CertificateInfo;
  103. import org.openspcoop2.utils.certificate.CertificateUtils;
  104. import org.openspcoop2.utils.certificate.PrincipalType;
  105. import org.openspcoop2.utils.crypt.CryptConfig;
  106. import org.openspcoop2.utils.crypt.CryptFactory;
  107. import org.openspcoop2.utils.crypt.ICrypt;
  108. import org.openspcoop2.utils.transport.http.HttpUtilities;
  109. import org.slf4j.Logger;

  111. /**
  112.  * Classe utilizzata per effettuare query ad un registro WEB, riguardanti specifiche
  113.  * proprieta' di servizi presenti all'interno del registro.
  114.  *
  115.  *
  116.  * @author Poli Andrea (apoli@link.it)
  117.  * @author $Author$
  118.  * @version $Rev$, $Date$
  119.  */

  121. public class DriverRegistroServiziWEB extends BeanUtilities
  122. implements IDriverRegistroServiziGet,IDriverRegistroServiziCRUD, IDriverWS,IMonitoraggioRisorsa{



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

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

  131.     /** --- URL Prefix utilizzato come prefisso 
  132.      per il repository WEB XML ------*/
  133.     private String urlPrefix;   
  134.     /** --- Utility per la generazione dell'XML ------*/
  135.     private XMLLib generatoreXML;

  137.     /** Validatore della configurazione */
  138.     private ValidatoreXSD validatoreRegistro = null;

  140.     /** Logger utilizzato per info. */
  141.     private org.slf4j.Logger log = null;

  143.     // Factory
  144.     private IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  145.     private IDAccordoCooperazioneFactory idAccordoCooperazioneFactory = IDAccordoCooperazioneFactory.getInstance();
  146.     private IDServizioFactory idServizioFactory = IDServizioFactory.getInstance();



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

  152.     /**
  153.      * Costruttore per interfaccia di query. 
  154.      *
  155.      * 
  156.      */
  157.     public DriverRegistroServiziWEB(String urlPrefix,Logger alog){  
  158.         this(urlPrefix,null,alog);
  159.     }
  160.     /**
  161.      * Costruttore per interfaccia CRUD. 
  162.      *
  163.      * 
  164.      */
  165.     public DriverRegistroServiziWEB(String urlPrefix,String pathPrefix,Logger alog){    

  167.         if(alog==null)
  168.             this.log = LoggerWrapperFactory.getLogger(DriverRegistroServiziWEB.class);
  169.         else
  170.             this.log = alog;
  171.         if(this.log==null) {
  172.             throw new UtilsRuntimeException("Logger unavailable");
  173.         }
  174.         try{
  175.             if (!urlPrefix.endsWith(CostantiRegistroServizi.URL_SEPARATOR))
  176.                 this.urlPrefix= urlPrefix + CostantiRegistroServizi.URL_SEPARATOR;
  177.             else
  178.                 this.urlPrefix = urlPrefix;

  180.             /* --- Costruzione Validatore XSD -- */
  181.             try{
  182.                 this.validatoreRegistro = new ValidatoreXSD(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), this.log,DriverRegistroServiziWEB.class.getResourceAsStream("/registroServizi.xsd"));
  183.             }catch (Exception e) {
  184.                 throw new Exception("Riscontrato errore durante l'inizializzazione dello schema del Registro dei Servizi di OpenSPCoop: "+e.getMessage(),e);
  185.             }

  187.             if(pathPrefix!=null)
  188.                 this.generatoreXML = new XMLLib(pathPrefix,urlPrefix);

  190.             this.create = true;
  191.         }catch(Exception e){
  192.             this.log.error("Inizializzazione fallita: "+e.getMessage());
  193.             this.create = false;
  194.         }
  195.     }








  204.     /* ********  INTERFACCIA IDriverRegistroServiziGet ******** */ 

  206.     
  207.     
  208.     /* Accordi di Cooperazione */
  209.     
  210.     /**
  211.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.AccordoCooperazione}, 
  212.      * identificato grazie al parametro 
  213.      * <var>nomeAccordo</var> 
  214.      *
  215.      * @param idAccordo Identificativo dell'accordo di Cooperazione
  216.      * @return un oggetto di tipo {@link org.openspcoop2.core.registry.AccordoCooperazione}.
  217.      * 
  218.      */
  219.     @Override
  220.     public org.openspcoop2.core.registry.AccordoCooperazione getAccordoCooperazione(IDAccordoCooperazione idAccordo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{

  222.         if( idAccordo == null)
  223.             throw new DriverRegistroServiziException("[getAccordoCooperazione] Parametro Non Valido");
  224.         if( idAccordo.getNome() == null)
  225.             throw new DriverRegistroServiziException("[getAccordoCooperazione] Nome accordo cooperazione non fornito");


  228.         org.openspcoop2.core.registry.AccordoCooperazione accRichiesto = null;

  230.         // Ottengo URL XML associato all'accordo
  231.         String fileName = this.generatoreXML.mappingIDAccordoCooperazioneToFileName(idAccordo);
  232.         String urlXMLAccordoCooperazione = this.urlPrefix + CostantiXMLRepository.ACCORDI_DI_COOPERAZIONE + CostantiRegistroServizi.URL_SEPARATOR + fileName + ".xml";    

  234.         // Ottengo oggetto Soggetto
  235.         ByteArrayInputStream bin = null;
  236.         try{
  237.             byte[] fileXML = null;
  238.             try{
  239.                 fileXML = HttpUtilities.requestHTTPFile(urlXMLAccordoCooperazione);
  240.             }catch(UtilsException e){
  241.                 // Controllo pre-esistenza dell'accordo
  242.                 if( "404".equals(e.getMessage()) ){
  243.                     throw new DriverRegistroServiziNotFound("[getAccordoCooperazione] Accordo richiesto non esiste: "+fileName);
  244.                 } else
  245.                     throw e;
  246.             }

  248.             /* --- Validazione XSD (ora che sono sicuro che non ho un 404) -- */
  249.             try{
  250.                 this.validatoreRegistro.valida(urlXMLAccordoCooperazione);  
  251.             }catch (Exception e) {
  252.                 throw new DriverRegistroServiziException("[getAccordoCooperazione] Riscontrato errore durante la validazione XSD del Registro dei Servizi XML di OpenSPCoop: "+e.getMessage(),e);
  253.             }

  255.             // parsing
  256.             bin = new ByteArrayInputStream(fileXML);
  257.             org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer();
  258.             org.openspcoop2.core.registry.RegistroServizi rs = 
  259.                 (org.openspcoop2.core.registry.RegistroServizi) deserializer.readRegistroServizi(bin);
  260.             if(rs.sizeAccordoCooperazioneList()>0)
  261.                 accRichiesto = rs.getAccordoCooperazione(0);
  262.             bin.close();
  263.         }catch(DriverRegistroServiziNotFound e){
  264.             throw e;
  265.         }catch(DriverRegistroServiziException e){
  266.             throw e;
  267.         }catch(Exception e){
  268.             try{
  269.                 if(bin!=null)
  270.                     bin.close();
  271.             } catch(Exception eis) {
  272.                 // close
  273.             }
  274.             if(e instanceof DriverRegistroServiziNotFound)
  275.                 throw (DriverRegistroServiziNotFound)e;
  276.             else
  277.                 throw new DriverRegistroServiziException("[getAccordoCooperazione] Errore durante il parsing xml: "+e.getMessage(),e);
  278.         }

  280.         if(accRichiesto==null)
  281.             throw new DriverRegistroServiziNotFound("[getAccordoCooperazione] Accordo di Cooperazione non trovato.");

  283.         return accRichiesto;
  284.     }

  286.     /**
  287.      * Ritorna gli identificatori degli accordi che rispettano il parametro di ricerca
  288.      * 
  289.      * @param filtroRicerca
  290.      * @return Una lista di ID degli accordi trovati
  291.      * @throws DriverRegistroServiziException
  292.      * @throws DriverRegistroServiziNotFound
  293.      */
  294.     @Override
  295.     public List<IDAccordoCooperazione> getAllIdAccordiCooperazione(FiltroRicercaAccordi filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  296.         try{

  298.             if(this.generatoreXML==null)
  299.                 throw new DriverRegistroServiziException("[getAllIdAccordiCooperazione] Gestore repository XML non istanziato. Necessario per l'implementazione di questo metodo.");

  301.             org.openspcoop2.core.registry.AccordoCooperazione[] acList = this.generatoreXML.getAccordiCooperazione();
  302.             if(acList==null)
  303.                 throw new DriverRegistroServiziNotFound("Accordi non esistenti nel repository WEB");

  305.             // Esamina degli accordi
  306.             List<IDAccordoCooperazione> idAccordi = new ArrayList<IDAccordoCooperazione>();
  307.             for(int i=0; i<acList.length; i++){

  309.                 String fileName = this.generatoreXML.mappingUriToFileName_accordoCooperazione(this.idAccordoCooperazioneFactory.getUriFromAccordo(acList[i]));
  310.                 String acUrlXML = this.urlPrefix + CostantiXMLRepository.ACCORDI_DI_COOPERAZIONE + CostantiRegistroServizi.URL_SEPARATOR+ fileName + ".xml";    
  311.                 String acURI = this.idAccordoCooperazioneFactory.getUriFromAccordo(acList[i]);


  314.                 /* --- Validazione XSD -- */
  315.                 try{
  316.                     this.validatoreRegistro.valida(acUrlXML);  
  317.                 }catch (Exception e) {
  318.                     throw new DriverRegistroServiziException("[getAllIdAccordiCooperazione] Riscontrato errore durante la validazione XSD ("+acUrlXML+"): "+e.getMessage(),e);
  319.                 }

  321.                 if(filtroRicerca!=null){
  322.                     // Filtro By Data
  323.                     if(filtroRicerca.getMinDate()!=null){
  324.                         if(acList[i].getOraRegistrazione()==null){
  325.                             this.log.debug("[getAllIdAccordiCooperazione](FiltroByMinDate) Accordo di servizio ["+acURI+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  326.                             continue;
  327.                         }else if(acList[i].getOraRegistrazione().before(filtroRicerca.getMinDate())){
  328.                             continue;
  329.                         }
  330.                     }
  331.                     if(filtroRicerca.getMaxDate()!=null){
  332.                         if(acList[i].getOraRegistrazione()==null){
  333.                             this.log.debug("[getAllIdAccordiCooperazione](FiltroByMaxDate) Accordo di servizio ["+acURI+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  334.                             continue;
  335.                         }else if(acList[i].getOraRegistrazione().after(filtroRicerca.getMaxDate())){
  336.                             continue;
  337.                         }
  338.                     }
  339.                     // Filtro By Nome
  340.                     if(filtroRicerca.getNomeAccordo()!=null){
  341.                         if(acList[i].getNome().equals(filtroRicerca.getNomeAccordo()) == false){
  342.                             continue;
  343.                         }
  344.                     }
  345.                     if(filtroRicerca.getVersione()!=null){
  346.                         if(acList[i].getVersione().equals(filtroRicerca.getVersione()) == false){
  347.                             continue;
  348.                         }
  349.                     }
  350.                     if(filtroRicerca.getTipoSoggettoReferente()!=null || filtroRicerca.getNomeSoggettoReferente()!=null){
  351.                         if(acList[i].getSoggettoReferente()==null)
  352.                             continue;
  353.                         if(filtroRicerca.getTipoSoggettoReferente()!=null){
  354.                             if(acList[i].getSoggettoReferente().getTipo().equals(filtroRicerca.getTipoSoggettoReferente()) == false){
  355.                                 continue;
  356.                             }
  357.                         }
  358.                         if(filtroRicerca.getNomeSoggettoReferente()!=null){
  359.                             if(acList[i].getSoggettoReferente().getNome().equals(filtroRicerca.getNomeSoggettoReferente()) == false){
  360.                                 continue;
  361.                             }
  362.                         }
  363.                     }
  364.                     // ProtocolProperties
  365.                     if(ProtocolPropertiesUtilities.isMatch(acList[i], filtroRicerca.getProtocolPropertiesAccordo())==false){
  366.                         continue;
  367.                     }
  368.                 }
  369.                 idAccordi.add(this.idAccordoCooperazioneFactory.getIDAccordoFromAccordo(acList[i]));
  370.             }
  371.             if(idAccordi.size()==0){
  372.                 throw new DriverRegistroServiziNotFound("Accordi non trovati che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  373.             }else{
  374.                 return idAccordi;
  375.             }
  376.         }catch(Exception e){
  377.             if(e instanceof DriverRegistroServiziNotFound)
  378.                 throw (DriverRegistroServiziNotFound)e;
  379.             else
  380.                 throw new DriverRegistroServiziException("getAllIdAccordiCooperazione error",e);
  381.         }
  382.     }


  385.     
  386.     
  387.     /* Accordi di Servizio Parte Comune */
  388.     
  389.     /**
  390.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.AccordoServizioParteComune}, 
  391.      * identificato grazie al parametro 
  392.      * <var>nomeAccordo</var> 
  393.      *
  394.      * @param idAccordo Identificativo dell'accordo di Servizio
  395.      * @return un oggetto di tipo {@link org.openspcoop2.core.registry.AccordoServizioParteComune}.
  396.      * 
  397.      */
  398.     @Override
  399.     public org.openspcoop2.core.registry.AccordoServizioParteComune getAccordoServizioParteComune(IDAccordo idAccordo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{

  401.         if( idAccordo == null)
  402.             throw new DriverRegistroServiziException("[AccordoServizioParteComune] Parametro Non Valido");
  403.         if( idAccordo.getNome() == null)
  404.             throw new DriverRegistroServiziException("[AccordoServizioParteComune] Nome accordo servizio non fornito");


  407.         org.openspcoop2.core.registry.AccordoServizioParteComune accRichiesto = null;

  409.         // Ottengo URL XML associato all'accordo
  410.         String fileName = this.generatoreXML.mappingIDAccordoToFileName(idAccordo);
  411.         String urlXMLAccordoServizio = this.urlPrefix + CostantiXMLRepository.ACCORDI_DI_SERVIZIO + CostantiRegistroServizi.URL_SEPARATOR + fileName + ".xml";    

  413.         // Ottengo oggetto Soggetto
  414.         ByteArrayInputStream bin = null;
  415.         try{
  416.             byte[] fileXML = null;
  417.             try{
  418.                 fileXML = HttpUtilities.requestHTTPFile(urlXMLAccordoServizio);
  419.             }catch(UtilsException e){
  420.                 // Controllo pre-esistenza dell'accordo
  421.                 if( "404".equals(e.getMessage()) ){
  422.                     throw new DriverRegistroServiziNotFound("[AccordoServizioParteComune] Accordo richiesto non esiste: "+fileName);
  423.                 } else
  424.                     throw e;
  425.             }

  427.             /* --- Validazione XSD (ora che sono sicuro che non ho un 404) -- */
  428.             try{
  429.                 this.validatoreRegistro.valida(urlXMLAccordoServizio);  
  430.             }catch (Exception e) {
  431.                 throw new DriverRegistroServiziException("[AccordoServizioParteComune] Riscontrato errore durante la validazione XSD del Registro dei Servizi XML di OpenSPCoop: "+e.getMessage(),e);
  432.             }

  434.             // parsing
  435.             bin = new ByteArrayInputStream(fileXML);
  436.             org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer();
  437.             org.openspcoop2.core.registry.RegistroServizi rs = 
  438.                 (org.openspcoop2.core.registry.RegistroServizi) deserializer.readRegistroServizi(bin);
  439.             if(rs.sizeAccordoServizioParteComuneList()>0)
  440.                 accRichiesto = rs.getAccordoServizioParteComune(0);
  441.             bin.close();
  442.         }catch(DriverRegistroServiziNotFound e){
  443.             throw e;
  444.         }catch(DriverRegistroServiziException e){
  445.             throw e;
  446.         }catch(Exception e){
  447.             try{
  448.                 if(bin!=null)
  449.                     bin.close();
  450.             } catch(Exception eis) {
  451.                 // close
  452.             }
  453.             if(e instanceof DriverRegistroServiziNotFound)
  454.                 throw (DriverRegistroServiziNotFound)e;
  455.             else
  456.                 throw new DriverRegistroServiziException("[AccordoServizioParteComune] Errore durante il parsing xml: "+e.getMessage(),e);
  457.         }

  459.         if(accRichiesto==null)
  460.             throw new DriverRegistroServiziNotFound("[AccordoServizioParteComune] Accordo di Servizio non trovato.");

  462.         // nomiAzione setting 
  463. //      accRichiesto.setNomiAzione(accRichiesto.readNomiAzione());

  465.         return accRichiesto;
  466.     }


  469.     @Override
  470.     public List<IDAccordo> getAllIdAccordiServizioParteComune(FiltroRicercaAccordi filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{

  472.         List<IDAccordo> list = new ArrayList<IDAccordo>();
  473.         _fillAllIdAccordiServizioParteComuneEngine("getAllIdAccordiServizioParteComune", filtroRicerca, null, null, null, null, list);
  474.         return list;
  475.     
  476.     }
  477.     
  478.     @Override
  479.     public List<IDPortType> getAllIdPortType(FiltroRicercaPortTypes filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  480.         
  481.         List<IDPortType> list = new ArrayList<IDPortType>();
  482.         _fillAllIdAccordiServizioParteComuneEngine("getAllIdPortType", filtroRicerca, filtroRicerca, null, null, null, list);
  483.         return list;
  484.         
  485.     }
  486.     
  487.     @Override
  488.     public List<IDPortTypeAzione> getAllIdAzionePortType(FiltroRicercaOperations filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  489.     
  490.         List<IDPortTypeAzione> list = new ArrayList<IDPortTypeAzione>();
  491.         _fillAllIdAccordiServizioParteComuneEngine("getAllIdAzionePortType", filtroRicerca, null, filtroRicerca, null, null, list);
  492.         return list;
  493.         
  494.     }
  495.     
  496.     @Override
  497.     public List<IDAccordoAzione> getAllIdAzioneAccordo(FiltroRicercaAzioni filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  498.         
  499.         List<IDAccordoAzione> list = new ArrayList<IDAccordoAzione>();
  500.         _fillAllIdAccordiServizioParteComuneEngine("getAllIdAzioneAccordo", filtroRicerca, null, null, filtroRicerca, null, list);
  501.         return list;
  502.         
  503.     }
  504.     
  505.     @Override
  506.     public List<IDResource> getAllIdResource(FiltroRicercaResources filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  507.         
  508.         List<IDResource> list = new ArrayList<IDResource>();
  509.         _fillAllIdAccordiServizioParteComuneEngine("getAllIdResource", filtroRicerca, null, null, null, filtroRicerca, list);
  510.         return list;
  511.         
  512.     }
  513.     
  514.     @SuppressWarnings("unchecked")
  515.     public <T> void _fillAllIdAccordiServizioParteComuneEngine(String nomeMetodo, 
  516.             FiltroRicercaAccordi filtroRicercaBase,
  517.             FiltroRicercaPortTypes filtroPT, FiltroRicercaOperations filtroOP, FiltroRicercaAzioni filtroAZ,
  518.             FiltroRicercaResources filtroResource,
  519.             List<T> listReturn) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  520.         try{

  522.             if(this.generatoreXML==null)
  523.                 throw new DriverRegistroServiziException("["+nomeMetodo+"] Gestore repository XML non istanziato. Necessario per l'implementazione di questo metodo.");

  525.             org.openspcoop2.core.registry.AccordoServizioParteComune[] asList = this.generatoreXML.getAccordiServizioParteComune(); 
  526.             if(asList==null)
  527.                 throw new DriverRegistroServiziNotFound("Accordi non esistenti nel repository WEB");

  529.             // Esamina degli accordi
  530.             for(int i=0; i<asList.length; i++){

  532.                 String fileName = this.generatoreXML.mappingUriToFileName(this.idAccordoFactory.getUriFromAccordo(asList[i]));
  533.                 String asUrlXML = this.urlPrefix + CostantiXMLRepository.ACCORDI_DI_SERVIZIO + CostantiRegistroServizi.URL_SEPARATOR+ fileName + ".xml";    
  534.                 String asURI = this.idAccordoFactory.getUriFromAccordo(asList[i]);


  537.                 /* --- Validazione XSD -- */
  538.                 try{
  539.                     this.validatoreRegistro.valida(asUrlXML);  
  540.                 }catch (Exception e) {
  541.                     throw new DriverRegistroServiziException("[getAllIdAccordiServizioParteComune] Riscontrato errore durante la validazione XSD ("+asUrlXML+"): "+e.getMessage(),e);
  542.                 }

  544.                 if(filtroRicercaBase!=null){
  545.                     
  546.                     List<String> tipoSoggettiProtocollo = null;
  547.                     try {
  548.                         if(filtroRicercaBase!=null && (filtroRicercaBase.getProtocollo()!=null || (filtroRicercaBase.getProtocolli()!=null && !filtroRicercaBase.getProtocolli().isEmpty()))){
  549.                             tipoSoggettiProtocollo = Filtri.convertToTipiSoggetti(filtroRicercaBase.getProtocollo(), Filtri.convertToString(filtroRicercaBase.getProtocolli()));
  550.                         }
  551.                     }catch(Exception e) {
  552.                         throw new DriverRegistroServiziException(e.getMessage(),e);
  553.                     }
  554.                     boolean searchByTipoSoggetto = (tipoSoggettiProtocollo!=null && tipoSoggettiProtocollo.size()>0);
  555.                     
  556.                     // Filtro By Data
  557.                     if(filtroRicercaBase.getMinDate()!=null){
  558.                         if(asList[i].getOraRegistrazione()==null){
  559.                             this.log.debug("["+nomeMetodo+"](FiltroByMinDate) Accordo di servizio ["+asURI+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  560.                             continue;
  561.                         }else if(asList[i].getOraRegistrazione().before(filtroRicercaBase.getMinDate())){
  562.                             continue;
  563.                         }
  564.                     }
  565.                     if(filtroRicercaBase.getMaxDate()!=null){
  566.                         if(asList[i].getOraRegistrazione()==null){
  567.                             this.log.debug("["+nomeMetodo+"](FiltroByMaxDate) Accordo di servizio ["+asURI+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  568.                             continue;
  569.                         }else if(asList[i].getOraRegistrazione().after(filtroRicercaBase.getMaxDate())){
  570.                             continue;
  571.                         }
  572.                     }
  573.                     // Filtro By Nome
  574.                     if(filtroRicercaBase.getNomeAccordo()!=null){
  575.                         if(asList[i].getNome().equals(filtroRicercaBase.getNomeAccordo()) == false){
  576.                             continue;
  577.                         }
  578.                     }
  579.                     if(filtroRicercaBase.getVersione()!=null){
  580.                         if(asList[i].getVersione().equals(filtroRicercaBase.getVersione()) == false){
  581.                             continue;
  582.                         }
  583.                     }
  584.                     if(searchByTipoSoggetto || filtroRicercaBase.getTipoSoggettoReferente()!=null || filtroRicercaBase.getNomeSoggettoReferente()!=null){
  585.                         if(asList[i].getSoggettoReferente()==null)
  586.                             continue;
  587.                         if(filtroRicercaBase.getTipoSoggettoReferente()!=null){
  588.                             if(asList[i].getSoggettoReferente().getTipo().equals(filtroRicercaBase.getTipoSoggettoReferente()) == false){
  589.                                 continue;
  590.                             }
  591.                         }
  592.                         else if(searchByTipoSoggetto) {
  593.                             boolean find = false;
  594.                             for (String tipoSoggettoProtocollo : tipoSoggettiProtocollo) {
  595.                                 if(asList[i].getSoggettoReferente().getTipo().equals(tipoSoggettoProtocollo)){
  596.                                     find = true;
  597.                                     break;
  598.                                 }
  599.                             }
  600.                             if(!find) {
  601.                                 continue;
  602.                             }
  603.                         }
  604.                         if(filtroRicercaBase.getNomeSoggettoReferente()!=null){
  605.                             if(asList[i].getSoggettoReferente().getNome().equals(filtroRicercaBase.getNomeSoggettoReferente()) == false){
  606.                                 continue;
  607.                             }
  608.                         }
  609.                     }
  610.                     if(filtroRicercaBase.getServiceBinding()!=null){
  611.                         if(asList[i].getServiceBinding().equals(filtroRicercaBase.getServiceBinding()) == false){
  612.                             continue;
  613.                         }
  614.                     }
  615.                     if(filtroRicercaBase.getIdGruppo()!=null && filtroRicercaBase.getIdGruppo().getNome()!=null){
  616.                         boolean found = false;
  617.                         if(asList[i].getGruppi()!=null && asList[i].getGruppi().sizeGruppoList()>0) {
  618.                             for (GruppoAccordo gruppo : asList[i].getGruppi().getGruppoList()) {
  619.                                 if(gruppo.getNome().equals(filtroRicercaBase.getIdGruppo().getNome())) {
  620.                                     found = true;
  621.                                     break;
  622.                                 }
  623.                             }
  624.                         }
  625.                         if(!found) {
  626.                             continue;
  627.                         }
  628.                     }
  629.                     
  630.                     if(filtroRicercaBase.getIdAccordoCooperazione()!=null &&
  631.                             (filtroRicercaBase.getIdAccordoCooperazione().getNome()!=null || 
  632.                             filtroRicercaBase.getIdAccordoCooperazione().getVersione()!=null) ){
  633.                         if(asList[i].getServizioComposto()==null){
  634.                             continue;
  635.                         }
  636.                         IDAccordoCooperazione idAC = this.idAccordoCooperazioneFactory.getIDAccordoFromUri(asList[i].getServizioComposto().getAccordoCooperazione());
  637.                         if(filtroRicercaBase.getIdAccordoCooperazione().getNome()!=null){
  638.                             if(idAC.getNome().equals(filtroRicercaBase.getIdAccordoCooperazione().getNome())== false){
  639.                                 continue;
  640.                             }
  641.                         }
  642.                         if(filtroRicercaBase.getIdAccordoCooperazione().getVersione()!=null){
  643.                             if(idAC.getVersione().equals(filtroRicercaBase.getIdAccordoCooperazione().getVersione())== false){
  644.                                 continue;
  645.                             }
  646.                         }
  647.                     }
  648.                     else if(filtroRicercaBase.isServizioComposto()!=null){
  649.                         if(filtroRicercaBase.isServizioComposto()){
  650.                             if(asList[i].getServizioComposto()==null){
  651.                                 continue;
  652.                             }
  653.                         }
  654.                         else {
  655.                             if(asList[i].getServizioComposto()!=null){
  656.                                 continue;
  657.                             }
  658.                         }
  659.                     }
  660.                     
  661.                     // ProtocolProperties
  662.                     if(ProtocolPropertiesUtilities.isMatch(asList[i], filtroRicercaBase.getProtocolPropertiesAccordo())==false){
  663.                         continue;
  664.                     }
  665.                     
  666.                 }
  667.                 
  668.                 IDAccordo idAccordo = this.idAccordoFactory.getIDAccordoFromValues(asList[i].getNome(),BeanUtilities.getSoggettoReferenteID(asList[i].getSoggettoReferente()),asList[i].getVersione());
  669.                 
  670.                 if(filtroPT!=null){
  671.                     for (PortType pt : asList[i].getPortTypeList()) {
  672.                         // Nome PT
  673.                         if(filtroPT.getNomePortType()!=null){
  674.                             if(pt.getNome().equals(filtroPT.getNomePortType()) == false){
  675.                                 continue;
  676.                             }
  677.                         }
  678.                         // ProtocolProperties PT
  679.                         if(ProtocolPropertiesUtilities.isMatch(pt, filtroPT.getProtocolPropertiesPortType())==false){
  680.                             continue;
  681.                         }
  682.                         
  683.                         IDPortType idPT = new IDPortType();
  684.                         idPT.setIdAccordo(idAccordo);
  685.                         idPT.setNome(pt.getNome());
  686.                         listReturn.add((T)idPT);
  687.                     }
  688.                 }
  689.                 else if(filtroOP!=null){
  690.                     for (PortType pt : asList[i].getPortTypeList()) {
  691.                         
  692.                         // Nome PT
  693.                         if(filtroOP.getNomePortType()!=null){
  694.                             if(pt.getNome().equals(filtroOP.getNomePortType()) == false){
  695.                                 continue;
  696.                             }
  697.                         }
  698.                         // ProtocolProperties PT
  699.                         if(ProtocolPropertiesUtilities.isMatch(pt, filtroOP.getProtocolPropertiesPortType())==false){
  700.                             continue;
  701.                         }
  702.                         
  703.                         for (Operation op : pt.getAzioneList()) {
  704.                             
  705.                             // Nome OP
  706.                             if(filtroOP.getNomeAzione()!=null){
  707.                                 if(op.getNome().equals(filtroOP.getNomeAzione()) == false){
  708.                                     continue;
  709.                                 }
  710.                             }
  711.                             // ProtocolProperties OP
  712.                             if(ProtocolPropertiesUtilities.isMatch(pt, filtroOP.getProtocolPropertiesAzione())==false){
  713.                                 continue;
  714.                             }
  715.                         
  716.                             IDPortTypeAzione idAzione = new IDPortTypeAzione();
  717.                             IDPortType idPT = new IDPortType();
  718.                             idPT.setIdAccordo(idAccordo);
  719.                             idPT.setNome(pt.getNome());
  720.                             idAzione.setIdPortType(idPT);
  721.                             idAzione.setNome(op.getNome());
  722.                             listReturn.add((T)idAzione);
  723.                         }
  724.                     }
  725.                 }
  726.                 else if(filtroAZ!=null){
  727.                     for (Azione az : asList[i].getAzioneList()) {
  728.                         
  729.                         // Nome AZ
  730.                         if(filtroAZ.getNomeAzione()!=null){
  731.                             if(az.getNome().equals(filtroAZ.getNomeAzione()) == false){
  732.                                 continue;
  733.                             }
  734.                         }
  735.                         // ProtocolProperties PT
  736.                         if(ProtocolPropertiesUtilities.isMatch(az, filtroAZ.getProtocolPropertiesAzione())==false){
  737.                             continue;
  738.                         }
  739.                         
  740.                         IDAccordoAzione idAzione = new IDAccordoAzione();
  741.                         idAzione.setIdAccordo(idAccordo);
  742.                         idAzione.setNome(az.getNome());
  743.                         listReturn.add((T)idAzione);
  744.                     }
  745.                 }
  746.                 else if(filtroResource!=null){
  747.                     for (Resource resource : asList[i].getResourceList()) {
  748.                         // Nome Risorsa
  749.                         if(filtroResource.getResourceName()!=null){
  750.                             if(resource.getNome().equals(filtroResource.getResourceName()) == false){
  751.                                 continue;
  752.                             }
  753.                         }
  754.                         // ProtocolProperties PT
  755.                         if(ProtocolPropertiesUtilities.isMatch(resource, filtroResource.getProtocolPropertiesResources())==false){
  756.                             continue;
  757.                         }
  758.                         
  759.                         IDResource idResource = new IDResource();
  760.                         idResource.setIdAccordo(idAccordo);
  761.                         idResource.setNome(resource.getNome());
  762.                         listReturn.add((T)idResource);
  763.                     }
  764.                 }
  765.                 else{
  766.                     listReturn.add((T)idAccordo);
  767.                 }
  768.                 
  769.             }
  770.             if(listReturn.size()<=0){
  771.                 String msgFiltro = "Elementi non trovati che rispettano il filtro di ricerca selezionato: ";
  772.                 if(filtroPT!=null){
  773.                     throw new DriverRegistroServiziNotFound(msgFiltro+filtroPT.toString());
  774.                 }
  775.                 else if(filtroOP!=null){
  776.                     throw new DriverRegistroServiziNotFound(msgFiltro+filtroOP.toString());
  777.                 }
  778.                 else if(filtroAZ!=null){
  779.                     throw new DriverRegistroServiziNotFound(msgFiltro+filtroAZ.toString());
  780.                 }
  781.                 else if(filtroRicercaBase!=null){
  782.                     throw new DriverRegistroServiziNotFound(msgFiltro+filtroRicercaBase.toString());
  783.                 }
  784.                 else{
  785.                     throw new DriverRegistroServiziNotFound("Elementi non trovati");
  786.                 }
  787.             }
  788.         }catch(Exception e){
  789.             if(e instanceof DriverRegistroServiziNotFound)
  790.                 throw (DriverRegistroServiziNotFound)e;
  791.             else
  792.                 throw new DriverRegistroServiziException(nomeMetodo+" error",e);
  793.         }
  794.     }

  796.     @Override
  797.     public Documento getAllegato(IDAccordo idAccordo, String nome) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  798.         throw new DriverRegistroServiziException("Not Implemented");
  799.     }
  800.     @Override
  801.     public Documento getSpecificaSemiformale(IDAccordo idAccordo, TipiDocumentoSemiformale tipo, String nome)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  802.         throw new DriverRegistroServiziException("Not Implemented");
  803.     }
  804.     
  805.     
  806.     
  807.     
  808.     /* Porte di Dominio */

  810.     /**
  811.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.PortaDominio}, 
  812.      * identificato grazie al parametro 
  813.      * <var>nomePdD</var> 
  814.      *
  815.      * @param nomePdD Nome della Porta di Dominio
  816.      * @return un oggetto di tipo {@link org.openspcoop2.core.registry.PortaDominio}.
  817.      * 
  818.      */
  819.     @Override
  820.     public org.openspcoop2.core.registry.PortaDominio getPortaDominio(String nomePdD) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  821.         if( nomePdD == null)
  822.             throw new DriverRegistroServiziException("[getPortaDominio] Parametro Non Valido");

  824.         org.openspcoop2.core.registry.PortaDominio pddRichiesta = null;

  826.         // Ottengo URL XML associata alla porta di dominio
  827.         String urlXMLPortaDominio = this.urlPrefix + CostantiXMLRepository.PORTE_DI_DOMINIO + CostantiRegistroServizi.URL_SEPARATOR + nomePdD + ".xml";   

  829.         // Ottengo oggetto Soggetto
  830.         ByteArrayInputStream bin = null;
  831.         try{
  832.             byte[] fileXML = null;
  833.             try{
  834.                 fileXML = HttpUtilities.requestHTTPFile(urlXMLPortaDominio);
  835.             }catch(UtilsException e){
  836.                 // Controllo pre-esistenza dell'accordo
  837.                 if( "404".equals(e.getMessage()) ){
  838.                     throw new DriverRegistroServiziNotFound("[getPortaDominio] Porta di dominio richiesta non esiste: "+nomePdD);
  839.                 } else
  840.                     throw e;
  841.             }

  843.             /* --- Validazione XSD (ora che sono sicuro che non ho un 404) -- */
  844.             try{
  845.                 this.validatoreRegistro.valida(urlXMLPortaDominio);  
  846.             }catch (Exception e) {
  847.                 throw new DriverRegistroServiziException("[getPortaDominio] Riscontrato errore durante la validazione XSD del Registro dei Servizi XML di OpenSPCoop: "+e.getMessage(),e);
  848.             }

  850.             // parsing
  851.             bin = new ByteArrayInputStream(fileXML);
  852.             org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer();
  853.             org.openspcoop2.core.registry.RegistroServizi rs = 
  854.                 (org.openspcoop2.core.registry.RegistroServizi) deserializer.readRegistroServizi(bin);
  855.             if(rs.sizePortaDominioList()>0)
  856.                 pddRichiesta = rs.getPortaDominio(0);
  857.             bin.close();
  858.         }catch(DriverRegistroServiziNotFound e){
  859.             throw e;
  860.         }catch(DriverRegistroServiziException e){
  861.             throw e;
  862.         }catch(Exception e){
  863.             try{
  864.                 if(bin!=null)
  865.                     bin.close();
  866.             } catch(Exception eis) {
  867.                 // close
  868.             }
  869.             if(e instanceof DriverRegistroServiziNotFound)
  870.                 throw (DriverRegistroServiziNotFound)e;
  871.             else
  872.                 throw new DriverRegistroServiziException("[getPortaDominio] Errore durante il parsing xml: "+e.getMessage(),e);
  873.         }

  875.         if(pddRichiesta==null)
  876.             throw new DriverRegistroServiziNotFound("[getPortaDominio] Porta di Dominio non trovata.");

  878.         return pddRichiesta;
  879.     }

  881.     /**
  882.      * Ritorna gli identificatori delle PdD che rispettano il parametro di ricerca
  883.      * 
  884.      * @param filtroRicerca
  885.      * @return Una lista di ID degli accordi trovati
  886.      * @throws DriverRegistroServiziException
  887.      * @throws DriverRegistroServiziNotFound
  888.      */
  889.     @Override
  890.     public List<String> getAllIdPorteDominio(FiltroRicerca filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  891.         try{

  893.             if(this.generatoreXML==null)
  894.                 throw new DriverRegistroServiziException("[getAllIdPorteDominio] Gestore repository XML non istanziato. Necessario per l'implementazione di questo metodo.");

  896.             org.openspcoop2.core.registry.PortaDominio[] pddList = this.generatoreXML.getPorteDominio();
  897.             if(pddList==null)
  898.                 throw new DriverRegistroServiziNotFound("Porte di dominio non esistenti nel repository WEB");

  900.             // Esamina delle pdd
  901.             List<String> nomiPdd = new ArrayList<>();
  902.             for(int i=0; i<pddList.length; i++){

  904.                 String pdUrlXML = this.urlPrefix + CostantiXMLRepository.PORTE_DI_DOMINIO + CostantiRegistroServizi.URL_SEPARATOR 
  905.                 + pddList[i].getNome() + ".xml";      


  908.                 /* --- Validazione XSD -- */
  909.                 try{
  910.                     this.validatoreRegistro.valida(pdUrlXML);  
  911.                 }catch (Exception e) {
  912.                     throw new DriverRegistroServiziException("[getAllIdPorteDominio] Riscontrato errore durante la validazione XSD ("+pdUrlXML+"): "+e.getMessage(),e);
  913.                 }

  915.                 if(filtroRicerca!=null){
  916.                     // Filtro By Data
  917.                     if(filtroRicerca.getMinDate()!=null){
  918.                         if(pddList[i].getOraRegistrazione()==null){
  919.                             this.log.debug("[getAllIdPorteDominio](FiltroByMinDate) Porta di Dominio ["+pddList[i].getNome()+"] non valorizzata nell'ora-registrazione. Non inserito nella lista ritornata.");
  920.                             continue;
  921.                         }else if(pddList[i].getOraRegistrazione().before(filtroRicerca.getMinDate())){
  922.                             continue;
  923.                         }
  924.                     }
  925.                     if(filtroRicerca.getMaxDate()!=null){
  926.                         if(pddList[i].getOraRegistrazione()==null){
  927.                             this.log.debug("[getAllIdPorteDominio](FiltroByMaxDate) Porta di Dominio ["+pddList[i].getNome()+"] non valorizzata nell'ora-registrazione. Non inserito nella lista ritornata.");
  928.                             continue;
  929.                         }else if(pddList[i].getOraRegistrazione().after(filtroRicerca.getMaxDate())){
  930.                             continue;
  931.                         }
  932.                     }
  933.                     // Filtro By Nome
  934.                     if(filtroRicerca.getNome()!=null){
  935.                         if(pddList[i].getNome().equals(filtroRicerca.getNome()) == false){
  936.                             continue;
  937.                         }
  938.                     }
  939.                 }
  940.                 nomiPdd.add(pddList[i].getNome());
  941.             }
  942.             if(nomiPdd.size()==0){
  943.                 throw new DriverRegistroServiziNotFound("Porte di dominio non trovate che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  944.             }else{
  945.                 return nomiPdd;
  946.             }
  947.         }catch(Exception e){
  948.             if(e instanceof DriverRegistroServiziNotFound)
  949.                 throw (DriverRegistroServiziNotFound)e;
  950.             else
  951.                 throw new DriverRegistroServiziException("getAllIdPorteDominio error",e);
  952.         }
  953.     }

  955.     
  956.     
  957.     
  958.     
  959.     
  960.     
  961.     
  962.     
  963.     /* Gruppi */
  964.     
  965.     /**
  966.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.Gruppo}, 
  967.      * identificato grazie al parametro 
  968.      * <var>nome</var> 
  969.      *
  970.      * @param idGruppo Identificativo del gruppo
  971.      * @return un oggetto di tipo {@link org.openspcoop2.core.registry.Gruppo}.
  972.      * 
  973.      */
  974.     @Override
  975.     public Gruppo getGruppo(
  976.             IDGruppo idGruppo) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  977.         if(idGruppo==null || idGruppo.getNome()==null)
  978.             throw new DriverRegistroServiziException("[getGruppo] Parametro Non Valido");

  980.         org.openspcoop2.core.registry.Gruppo gruppoRichiesto = null;

  982.         // Ottengo URL XML associata alla porta di dominio
  983.         String urlXMLPortaDominio = this.urlPrefix + CostantiXMLRepository.GRUPPI + CostantiRegistroServizi.URL_SEPARATOR + idGruppo.getNome() + ".xml";      

  985.         // Ottengo oggetto Soggetto
  986.         ByteArrayInputStream bin = null;
  987.         try{
  988.             byte[] fileXML = null;
  989.             try{
  990.                 fileXML = HttpUtilities.requestHTTPFile(urlXMLPortaDominio);
  991.             }catch(UtilsException e){
  992.                 // Controllo pre-esistenza dell'accordo
  993.                 if( "404".equals(e.getMessage()) ){
  994.                     throw new DriverRegistroServiziNotFound("[getGruppo] Gruppo richiesto non esiste: "+idGruppo.getNome());
  995.                 } else
  996.                     throw e;
  997.             }

  999.             /* --- Validazione XSD (ora che sono sicuro che non ho un 404) -- */
  1000.             try{
  1001.                 this.validatoreRegistro.valida(urlXMLPortaDominio);  
  1002.             }catch (Exception e) {
  1003.                 throw new DriverRegistroServiziException("[getGruppo] Riscontrato errore durante la validazione XSD del Registro dei Servizi XML di OpenSPCoop: "+e.getMessage(),e);
  1004.             }

  1006.             // parsing
  1007.             bin = new ByteArrayInputStream(fileXML);
  1008.             org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer();
  1009.             org.openspcoop2.core.registry.RegistroServizi rs = 
  1010.                 (org.openspcoop2.core.registry.RegistroServizi) deserializer.readRegistroServizi(bin);
  1011.             if(rs.sizeGruppoList()>0)
  1012.                 gruppoRichiesto = rs.getGruppo(0);
  1013.             bin.close();
  1014.         }catch(DriverRegistroServiziNotFound e){
  1015.             throw e;
  1016.         }catch(DriverRegistroServiziException e){
  1017.             throw e;
  1018.         }catch(Exception e){
  1019.             try{
  1020.                 if(bin!=null)
  1021.                     bin.close();
  1022.             } catch(Exception eis) {
  1023.                 // close
  1024.             }
  1025.             if(e instanceof DriverRegistroServiziNotFound)
  1026.                 throw (DriverRegistroServiziNotFound)e;
  1027.             else
  1028.                 throw new DriverRegistroServiziException("[getGruppo] Errore durante il parsing xml: "+e.getMessage(),e);
  1029.         }

  1031.         if(gruppoRichiesto==null)
  1032.             throw new DriverRegistroServiziNotFound("[getGruppo] Gruppo non trovato.");

  1034.         return gruppoRichiesto;
  1035.     }

  1037.     /**
  1038.      * Ritorna gli identificatori dei Gruppi che rispettano il parametro di ricerca
  1039.      * 
  1040.      * @param filtroRicerca
  1041.      * @return Una lista di ID dei gruppi trovati
  1042.      * @throws DriverRegistroServiziException
  1043.      * @throws DriverRegistroServiziNotFound
  1044.      */
  1045.     @Override
  1046.     public List<IDGruppo> getAllIdGruppi(
  1047.             FiltroRicercaGruppi filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1048.         try{

  1050.             if(this.generatoreXML==null)
  1051.                 throw new DriverRegistroServiziException("[getAllIdGruppi] Gestore repository XML non istanziato. Necessario per l'implementazione di questo metodo.");

  1053.             org.openspcoop2.core.registry.Gruppo[] gruppoList = this.generatoreXML.getGruppi();
  1054.             if(gruppoList==null)
  1055.                 throw new DriverRegistroServiziNotFound("Gruppi non esistenti nel repository WEB");

  1057.             // Esamina dei gruppi
  1058.             List<IDGruppo> idGruppi = new ArrayList<IDGruppo>();
  1059.             for(int i=0; i<gruppoList.length; i++){

  1061.                 String gruppoUrlXML = this.urlPrefix + CostantiXMLRepository.GRUPPI + CostantiRegistroServizi.URL_SEPARATOR 
  1062.                         + gruppoList[i].getNome() + ".xml";   


  1065.                 /* --- Validazione XSD -- */
  1066.                 try{
  1067.                     this.validatoreRegistro.valida(gruppoUrlXML);  
  1068.                 }catch (Exception e) {
  1069.                     throw new DriverRegistroServiziException("[getAllIdGruppi] Riscontrato errore durante la validazione XSD ("+gruppoUrlXML+"): "+e.getMessage(),e);
  1070.                 }

  1072.                 if(filtroRicerca!=null){
  1073.                     // Filtro By Data
  1074.                     if(filtroRicerca.getMinDate()!=null){
  1075.                         if(gruppoList[i].getOraRegistrazione()==null){
  1076.                             this.log.debug("[getAllIdGruppi](FiltroByMinDate) Gruppo ["+gruppoList[i].getNome()+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  1077.                             continue;
  1078.                         }else if(gruppoList[i].getOraRegistrazione().before(filtroRicerca.getMinDate())){
  1079.                             continue;
  1080.                         }
  1081.                     }
  1082.                     if(filtroRicerca.getMaxDate()!=null){
  1083.                         if(gruppoList[i].getOraRegistrazione()==null){
  1084.                             this.log.debug("[getAllIdGruppi](FiltroByMaxDate) Gruppo ["+gruppoList[i].getNome()+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  1085.                             continue;
  1086.                         }else if(gruppoList[i].getOraRegistrazione().after(filtroRicerca.getMaxDate())){
  1087.                             continue;
  1088.                         }
  1089.                     }
  1090.                     // Filtro By Nome
  1091.                     if(filtroRicerca.getNome()!=null){
  1092.                         if(gruppoList[i].getNome().equals(filtroRicerca.getNome()) == false){
  1093.                             continue;
  1094.                         }
  1095.                     }
  1096.                     // Filtro By ServiceBinding
  1097.                     if(filtroRicerca.getServiceBinding()!=null){
  1098.                         if(gruppoList[i].getServiceBinding()!=null){ // se e' uguale a null significa che va bene per qualsiasi service binding
  1099.                             if(gruppoList[i].getServiceBinding().equals(filtroRicerca.getServiceBinding()) == false) {
  1100.                                 continue;
  1101.                             }
  1102.                         }
  1103.                     }
  1104.                 }
  1105.                 IDGruppo id = new IDGruppo(gruppoList[i].getNome());
  1106.                 idGruppi.add(id);
  1107.             }
  1108.             if(idGruppi.size()==0){
  1109.                 throw new DriverRegistroServiziNotFound("Gruppi non trovati che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  1110.             }else{
  1111.                 return idGruppi;
  1112.             }
  1113.         }catch(Exception e){
  1114.             if(e instanceof DriverRegistroServiziNotFound)
  1115.                 throw (DriverRegistroServiziNotFound)e;
  1116.             else
  1117.                 throw new DriverRegistroServiziException("getAllIdGruppi error",e);
  1118.         }
  1119.     }
  1120.     
  1121.     
  1122.     
  1123.     
  1124.     
  1125.     
  1126.     
  1127.     
  1128.     /* Ruoli */
  1129.     
  1130.     /**
  1131.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.Ruolo}, 
  1132.      * identificato grazie al parametro 
  1133.      * <var>nome</var> 
  1134.      *
  1135.      * @param idRuolo Identificativo del ruolo
  1136.      * @return un oggetto di tipo {@link org.openspcoop2.core.registry.Ruolo}.
  1137.      * 
  1138.      */
  1139.     @Override
  1140.     public Ruolo getRuolo(
  1141.             IDRuolo idRuolo) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1142.         if(idRuolo==null || idRuolo.getNome()==null)
  1143.             throw new DriverRegistroServiziException("[getRuolo] Parametro Non Valido");

  1145.         org.openspcoop2.core.registry.Ruolo ruoloRichiesto = null;

  1147.         // Ottengo URL XML associata alla porta di dominio
  1148.         String urlXMLPortaDominio = this.urlPrefix + CostantiXMLRepository.RUOLI + CostantiRegistroServizi.URL_SEPARATOR + idRuolo.getNome() + ".xml";    

  1150.         // Ottengo oggetto Soggetto
  1151.         ByteArrayInputStream bin = null;
  1152.         try{
  1153.             byte[] fileXML = null;
  1154.             try{
  1155.                 fileXML = HttpUtilities.requestHTTPFile(urlXMLPortaDominio);
  1156.             }catch(UtilsException e){
  1157.                 // Controllo pre-esistenza dell'accordo
  1158.                 if( "404".equals(e.getMessage()) ){
  1159.                     throw new DriverRegistroServiziNotFound("[getRuolo] Ruolo richiesto non esiste: "+idRuolo.getNome());
  1160.                 } else
  1161.                     throw e;
  1162.             }

  1164.             /* --- Validazione XSD (ora che sono sicuro che non ho un 404) -- */
  1165.             try{
  1166.                 this.validatoreRegistro.valida(urlXMLPortaDominio);  
  1167.             }catch (Exception e) {
  1168.                 throw new DriverRegistroServiziException("[getRuolo] Riscontrato errore durante la validazione XSD del Registro dei Servizi XML di OpenSPCoop: "+e.getMessage(),e);
  1169.             }

  1171.             // parsing
  1172.             bin = new ByteArrayInputStream(fileXML);
  1173.             org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer();
  1174.             org.openspcoop2.core.registry.RegistroServizi rs = 
  1175.                 (org.openspcoop2.core.registry.RegistroServizi) deserializer.readRegistroServizi(bin);
  1176.             if(rs.sizeRuoloList()>0)
  1177.                 ruoloRichiesto = rs.getRuolo(0);
  1178.             bin.close();
  1179.         }catch(DriverRegistroServiziNotFound e){
  1180.             throw e;
  1181.         }catch(DriverRegistroServiziException e){
  1182.             throw e;
  1183.         }catch(Exception e){
  1184.             try{
  1185.                 if(bin!=null)
  1186.                     bin.close();
  1187.             } catch(Exception eis) {
  1188.                 // close
  1189.             }
  1190.             if(e instanceof DriverRegistroServiziNotFound)
  1191.                 throw (DriverRegistroServiziNotFound)e;
  1192.             else
  1193.                 throw new DriverRegistroServiziException("[getRuolo] Errore durante il parsing xml: "+e.getMessage(),e);
  1194.         }

  1196.         if(ruoloRichiesto==null)
  1197.             throw new DriverRegistroServiziNotFound("[getRuolo] Ruolo non trovato.");

  1199.         return ruoloRichiesto;
  1200.     }

  1202.     /**
  1203.      * Ritorna gli identificatori dei Ruoli che rispettano il parametro di ricerca
  1204.      * 
  1205.      * @param filtroRicerca
  1206.      * @return Una lista di ID dei ruoli trovati
  1207.      * @throws DriverRegistroServiziException
  1208.      * @throws DriverRegistroServiziNotFound
  1209.      */
  1210.     @Override
  1211.     public List<IDRuolo> getAllIdRuoli(
  1212.             FiltroRicercaRuoli filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1213.         try{

  1215.             if(this.generatoreXML==null)
  1216.                 throw new DriverRegistroServiziException("[getAllIdRuoli] Gestore repository XML non istanziato. Necessario per l'implementazione di questo metodo.");

  1218.             org.openspcoop2.core.registry.Ruolo[] ruoloList = this.generatoreXML.getRuoli();
  1219.             if(ruoloList==null)
  1220.                 throw new DriverRegistroServiziNotFound("Ruoli non esistenti nel repository WEB");

  1222.             // Esamina dei ruoli
  1223.             List<IDRuolo> idRuoli = new ArrayList<IDRuolo>();
  1224.             for(int i=0; i<ruoloList.length; i++){

  1226.                 String ruoloUrlXML = this.urlPrefix + CostantiXMLRepository.RUOLI + CostantiRegistroServizi.URL_SEPARATOR 
  1227.                         + ruoloList[i].getNome() + ".xml";    


  1230.                 /* --- Validazione XSD -- */
  1231.                 try{
  1232.                     this.validatoreRegistro.valida(ruoloUrlXML);  
  1233.                 }catch (Exception e) {
  1234.                     throw new DriverRegistroServiziException("[getAllIdRuoli] Riscontrato errore durante la validazione XSD ("+ruoloUrlXML+"): "+e.getMessage(),e);
  1235.                 }

  1237.                 if(filtroRicerca!=null){
  1238.                     // Filtro By Data
  1239.                     if(filtroRicerca.getMinDate()!=null){
  1240.                         if(ruoloList[i].getOraRegistrazione()==null){
  1241.                             this.log.debug("[getAllIdRuoli](FiltroByMinDate) Ruolo ["+ruoloList[i].getNome()+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  1242.                             continue;
  1243.                         }else if(ruoloList[i].getOraRegistrazione().before(filtroRicerca.getMinDate())){
  1244.                             continue;
  1245.                         }
  1246.                     }
  1247.                     if(filtroRicerca.getMaxDate()!=null){
  1248.                         if(ruoloList[i].getOraRegistrazione()==null){
  1249.                             this.log.debug("[getAllIdRuoli](FiltroByMaxDate) Ruolo ["+ruoloList[i].getNome()+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  1250.                             continue;
  1251.                         }else if(ruoloList[i].getOraRegistrazione().after(filtroRicerca.getMaxDate())){
  1252.                             continue;
  1253.                         }
  1254.                     }
  1255.                     // Filtro By Nome
  1256.                     if(filtroRicerca.getNome()!=null){
  1257.                         if(ruoloList[i].getNome().equals(filtroRicerca.getNome()) == false){
  1258.                             continue;
  1259.                         }
  1260.                     }
  1261.                     // Filtro By Tipologia
  1262.                     if(filtroRicerca.getTipologia()!=null && !RuoloTipologia.QUALSIASI.equals(filtroRicerca.getTipologia())){
  1263.                         if(ruoloList[i].getTipologia()==null){
  1264.                             continue;
  1265.                         }
  1266.                         if(!RuoloTipologia.QUALSIASI.equals(ruoloList[i].getTipologia())){
  1267.                             if(ruoloList[i].getTipologia().equals(filtroRicerca.getTipologia()) == false){
  1268.                                 continue;
  1269.                             }
  1270.                         }
  1271.                     }
  1272.                     // Filtro By Contesto
  1273.                     if(filtroRicerca.getContesto()!=null && !RuoloContesto.QUALSIASI.equals(filtroRicerca.getContesto())){
  1274.                         if(ruoloList[i].getContestoUtilizzo()==null){
  1275.                             continue;
  1276.                         }
  1277.                         if(!RuoloContesto.QUALSIASI.equals(ruoloList[i].getContestoUtilizzo())){
  1278.                             if(ruoloList[i].getContestoUtilizzo().equals(filtroRicerca.getContesto()) == false){
  1279.                                 continue;
  1280.                             }
  1281.                         }
  1282.                     }
  1283.                 }
  1284.                 IDRuolo id = new IDRuolo(ruoloList[i].getNome());
  1285.                 idRuoli.add(id);
  1286.             }
  1287.             if(idRuoli.size()==0){
  1288.                 throw new DriverRegistroServiziNotFound("Ruoli non trovati che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  1289.             }else{
  1290.                 return idRuoli;
  1291.             }
  1292.         }catch(Exception e){
  1293.             if(e instanceof DriverRegistroServiziNotFound)
  1294.                 throw (DriverRegistroServiziNotFound)e;
  1295.             else
  1296.                 throw new DriverRegistroServiziException("getAllIdRuoli error",e);
  1297.         }
  1298.     }
  1299.     
  1300.     
  1301.     
  1302.     
  1303.     
  1304.     
  1305.     
  1306.     
  1307.     /* Scope */
  1308.     
  1309.     /**
  1310.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.Scope}, 
  1311.      * identificato grazie al parametro 
  1312.      * <var>nome</var> 
  1313.      *
  1314.      * @param idScope Identificativo del scope
  1315.      * @return un oggetto di tipo {@link org.openspcoop2.core.registry.Scope}.
  1316.      * 
  1317.      */
  1318.     @Override
  1319.     public Scope getScope(
  1320.             IDScope idScope) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1321.         if(idScope==null || idScope.getNome()==null)
  1322.             throw new DriverRegistroServiziException("[getScope] Parametro Non Valido");

  1324.         org.openspcoop2.core.registry.Scope scopeRichiesto = null;

  1326.         // Ottengo URL XML associata alla porta di dominio
  1327.         String urlXMLPortaDominio = this.urlPrefix + CostantiXMLRepository.SCOPE + CostantiRegistroServizi.URL_SEPARATOR + idScope.getNome() + ".xml";    

  1329.         // Ottengo oggetto Soggetto
  1330.         ByteArrayInputStream bin = null;
  1331.         try{
  1332.             byte[] fileXML = null;
  1333.             try{
  1334.                 fileXML = HttpUtilities.requestHTTPFile(urlXMLPortaDominio);
  1335.             }catch(UtilsException e){
  1336.                 // Controllo pre-esistenza dell'accordo
  1337.                 if( "404".equals(e.getMessage()) ){
  1338.                     throw new DriverRegistroServiziNotFound("[getScope] Scope richiesto non esiste: "+idScope.getNome());
  1339.                 } else
  1340.                     throw e;
  1341.             }

  1343.             /* --- Validazione XSD (ora che sono sicuro che non ho un 404) -- */
  1344.             try{
  1345.                 this.validatoreRegistro.valida(urlXMLPortaDominio);  
  1346.             }catch (Exception e) {
  1347.                 throw new DriverRegistroServiziException("[getScope] Riscontrato errore durante la validazione XSD del Registro dei Servizi XML di OpenSPCoop: "+e.getMessage(),e);
  1348.             }

  1350.             // parsing
  1351.             bin = new ByteArrayInputStream(fileXML);
  1352.             org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer();
  1353.             org.openspcoop2.core.registry.RegistroServizi rs = 
  1354.                 (org.openspcoop2.core.registry.RegistroServizi) deserializer.readRegistroServizi(bin);
  1355.             if(rs.sizeScopeList()>0)
  1356.                 scopeRichiesto = rs.getScope(0);
  1357.             bin.close();
  1358.         }catch(DriverRegistroServiziNotFound e){
  1359.             throw e;
  1360.         }catch(DriverRegistroServiziException e){
  1361.             throw e;
  1362.         }catch(Exception e){
  1363.             try{
  1364.                 if(bin!=null)
  1365.                     bin.close();
  1366.             } catch(Exception eis) {
  1367.                 // close
  1368.             }
  1369.             if(e instanceof DriverRegistroServiziNotFound)
  1370.                 throw (DriverRegistroServiziNotFound)e;
  1371.             else
  1372.                 throw new DriverRegistroServiziException("[getScope] Errore durante il parsing xml: "+e.getMessage(),e);
  1373.         }

  1375.         if(scopeRichiesto==null)
  1376.             throw new DriverRegistroServiziNotFound("[getScope] Scope non trovato.");

  1378.         return scopeRichiesto;
  1379.     }

  1381.     /**
  1382.      * Ritorna gli identificatori dei Scope che rispettano il parametro di ricerca
  1383.      * 
  1384.      * @param filtroRicerca
  1385.      * @return Una lista di ID dei scope trovati
  1386.      * @throws DriverRegistroServiziException
  1387.      * @throws DriverRegistroServiziNotFound
  1388.      */
  1389.     @Override
  1390.     public List<IDScope> getAllIdScope(
  1391.             FiltroRicercaScope filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1392.         try{

  1394.             if(this.generatoreXML==null)
  1395.                 throw new DriverRegistroServiziException("[getAllIdScope] Gestore repository XML non istanziato. Necessario per l'implementazione di questo metodo.");

  1397.             org.openspcoop2.core.registry.Scope[] scopeList = this.generatoreXML.getScope();
  1398.             if(scopeList==null)
  1399.                 throw new DriverRegistroServiziNotFound("Scope non esistenti nel repository WEB");

  1401.             // Esamina dei scope
  1402.             List<IDScope> idScope = new ArrayList<IDScope>();
  1403.             for(int i=0; i<scopeList.length; i++){

  1405.                 String scopeUrlXML = this.urlPrefix + CostantiXMLRepository.SCOPE + CostantiRegistroServizi.URL_SEPARATOR 
  1406.                         + scopeList[i].getNome() + ".xml";    


  1409.                 /* --- Validazione XSD -- */
  1410.                 try{
  1411.                     this.validatoreRegistro.valida(scopeUrlXML);  
  1412.                 }catch (Exception e) {
  1413.                     throw new DriverRegistroServiziException("[getAllIdScope] Riscontrato errore durante la validazione XSD ("+scopeUrlXML+"): "+e.getMessage(),e);
  1414.                 }

  1416.                 if(filtroRicerca!=null){
  1417.                     // Filtro By Data
  1418.                     if(filtroRicerca.getMinDate()!=null){
  1419.                         if(scopeList[i].getOraRegistrazione()==null){
  1420.                             this.log.debug("[getAllIdScope](FiltroByMinDate) Scope ["+scopeList[i].getNome()+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  1421.                             continue;
  1422.                         }else if(scopeList[i].getOraRegistrazione().before(filtroRicerca.getMinDate())){
  1423.                             continue;
  1424.                         }
  1425.                     }
  1426.                     if(filtroRicerca.getMaxDate()!=null){
  1427.                         if(scopeList[i].getOraRegistrazione()==null){
  1428.                             this.log.debug("[getAllIdScope](FiltroByMaxDate) Scope ["+scopeList[i].getNome()+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  1429.                             continue;
  1430.                         }else if(scopeList[i].getOraRegistrazione().after(filtroRicerca.getMaxDate())){
  1431.                             continue;
  1432.                         }
  1433.                     }
  1434.                     // Filtro By Nome
  1435.                     if(filtroRicerca.getNome()!=null){
  1436.                         if(scopeList[i].getNome().equals(filtroRicerca.getNome()) == false){
  1437.                             continue;
  1438.                         }
  1439.                     }
  1440.                     // Filtro By Tipologia
  1441.                     if(filtroRicerca.getTipologia()!=null){
  1442.                         if(scopeList[i].getTipologia()==null){
  1443.                             continue;
  1444.                         }
  1445.                         if(scopeList[i].getTipologia().equals(filtroRicerca.getTipologia()) == false){
  1446.                             continue;
  1447.                         }
  1448.                     }
  1449.                     // Filtro By Contesto
  1450.                     if(filtroRicerca.getContesto()!=null && !ScopeContesto.QUALSIASI.equals(filtroRicerca.getContesto())){
  1451.                         if(scopeList[i].getContestoUtilizzo()==null){
  1452.                             continue;
  1453.                         }
  1454.                         if(!ScopeContesto.QUALSIASI.equals(scopeList[i].getContestoUtilizzo())){
  1455.                             if(scopeList[i].getContestoUtilizzo().equals(filtroRicerca.getContesto()) == false){
  1456.                                 continue;
  1457.                             }
  1458.                         }
  1459.                     }
  1460.                 }
  1461.                 IDScope id = new IDScope(scopeList[i].getNome());
  1462.                 idScope.add(id);
  1463.             }
  1464.             if(idScope.size()==0){
  1465.                 throw new DriverRegistroServiziNotFound("Scope non trovati che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  1466.             }else{
  1467.                 return idScope;
  1468.             }
  1469.         }catch(Exception e){
  1470.             if(e instanceof DriverRegistroServiziNotFound)
  1471.                 throw (DriverRegistroServiziNotFound)e;
  1472.             else
  1473.                 throw new DriverRegistroServiziException("getAllIdScope error",e);
  1474.         }
  1475.     }
  1476.     
  1477.     

  1479.     
  1480.     
  1481.     
  1482.     /* Soggetti */
  1483.     
  1484.     /**
  1485.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.Soggetto}, 
  1486.      * identificato grazie al parametro 
  1487.      * <var>idSoggetto</var> di tipo {@link org.openspcoop2.core.id.IDSoggetto}. 
  1488.      *
  1489.      * @param idSoggetto Identificatore del Soggetto di tipo {@link org.openspcoop2.core.id.IDSoggetto}.
  1490.      * @return l'oggetto di tipo {@link org.openspcoop2.core.registry.Soggetto}
  1491.      * 
  1492.      */
  1493.     @Override
  1494.     public org.openspcoop2.core.registry.Soggetto getSoggetto(IDSoggetto idSoggetto) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{

  1496.         if(idSoggetto==null)
  1497.             throw new DriverRegistroServiziException("[getSoggetto] Parametro Non Valido");
  1498.         String tipo = idSoggetto.getTipo();
  1499.         String nome = idSoggetto.getNome();
  1500.         if(tipo == null || nome == null)
  1501.             throw new DriverRegistroServiziException("[getSoggetto] Parametri Non Validi");

  1503.         org.openspcoop2.core.registry.Soggetto soggRichiesto = null;

  1505.         // Ottengo URL XML associato al Soggetto
  1506.         String idSoggettoXML = tipo + nome;
  1507.         String urlXMLSoggetto = this.urlPrefix + idSoggettoXML +CostantiRegistroServizi.URL_SEPARATOR  + idSoggettoXML + ".xml";



  1511.         // Ottengo oggetto Soggetto
  1512.         ByteArrayInputStream bin = null;
  1513.         try{
  1514.             byte[] fileXML = null;
  1515.             try{
  1516.                 fileXML = HttpUtilities.requestHTTPFile(urlXMLSoggetto);
  1517.             }catch(UtilsException e){
  1518.                 // Controllo pre-esistenza dell'accordo
  1519.                 if( "404".equals(e.getMessage()) ){
  1520.                     throw new DriverRegistroServiziNotFound("[getSoggetto] Il soggetto ["+idSoggetto.getTipo()+"/"+idSoggetto.getNome()+
  1521.                     "] non risulta gia' inserito nel registro dei servizi.");
  1522.                 } else
  1523.                     throw e;
  1524.             }

  1526.             /* --- Validazione XSD (ora che sono sicuro che non ho un 404) -- */
  1527.             try{
  1528.                 this.validatoreRegistro.valida(urlXMLSoggetto);  
  1529.             }catch (Exception e) {
  1530.                 throw new DriverRegistroServiziException("[getSoggetto] Riscontrato errore durante la validazione XSD del Registro dei Servizi XML di OpenSPCoop: "+e.getMessage(),e);
  1531.             }

  1533.             // parsing
  1534.             bin = new ByteArrayInputStream(fileXML);
  1535.             org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer();
  1536.             org.openspcoop2.core.registry.RegistroServizi rs = 
  1537.                 (org.openspcoop2.core.registry.RegistroServizi) deserializer.readRegistroServizi(bin);
  1538.             if(rs.sizeSoggettoList()>0)
  1539.                 soggRichiesto = rs.getSoggetto(0);
  1540.             bin.close();
  1541.         }catch(DriverRegistroServiziNotFound e){
  1542.             throw e;
  1543.         }catch(DriverRegistroServiziException e){
  1544.             throw e;
  1545.         }catch(Exception e){
  1546.             try{
  1547.                 if(bin!=null)
  1548.                     bin.close();
  1549.             } catch(Exception eis) {
  1550.                 // close
  1551.             }
  1552.             if(e instanceof DriverRegistroServiziNotFound)
  1553.                 throw (DriverRegistroServiziNotFound)e;
  1554.             else
  1555.                 throw new DriverRegistroServiziException("[getSoggetto] Errore durante il parsing xml: "+e.getMessage(),e);
  1556.         }

  1558.         if(soggRichiesto==null)
  1559.             throw new DriverRegistroServiziNotFound("[getSoggetto] Soggetto non trovato.");

  1561.         return soggRichiesto;
  1562.     }

  1564.     @Override
  1565.     public Soggetto getSoggettoByCredenzialiBasic(
  1566.             String user,String password, 
  1567.             CryptConfig config) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1568.         return this.getEngineSoggettoAutenticato(CredenzialeTipo.BASIC, user, password, 
  1569.                 null, null, null, false,
  1570.                 null,
  1571.                 config,
  1572.                 false);
  1573.     }
  1574.     
  1575.     @Override
  1576.     public Soggetto getSoggettoByCredenzialiApiKey(
  1577.             String user,String password, boolean appId, 
  1578.             CryptConfig config) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1579.         return this.getEngineSoggettoAutenticato(CredenzialeTipo.BASIC, user, password, 
  1580.                 null, null, null, false,
  1581.                 null,
  1582.                 config,
  1583.                 appId);
  1584.     }
  1585.     
  1586.     @Override
  1587.     public Soggetto getSoggettoByCredenzialiSsl(
  1588.             String subject, String issuer) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1589.         return this.getEngineSoggettoAutenticato(CredenzialeTipo.SSL, null, null, 
  1590.                 subject, issuer, null, false,
  1591.                 null,
  1592.                 null,
  1593.                 false);
  1594.     }
  1595.     
  1596.     @Override
  1597.     public Soggetto getSoggettoByCredenzialiSsl(CertificateInfo certificate, boolean strictVerifier) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1598.         return this.getEngineSoggettoAutenticato(CredenzialeTipo.SSL, null, null, 
  1599.                 null, null, certificate, strictVerifier,
  1600.                 null,
  1601.                 null,
  1602.                 false);
  1603.     }
  1604.     
  1605.     @Override
  1606.     public Soggetto getSoggettoByCredenzialiPrincipal(
  1607.             String principal) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  1608.         return this.getEngineSoggettoAutenticato(CredenzialeTipo.PRINCIPAL, null, null, 
  1609.                 null, null, null, false,
  1610.                 principal,
  1611.                 null,
  1612.                 false);
  1613.     }
  1614.     private org.openspcoop2.core.registry.Soggetto getEngineSoggettoAutenticato(CredenzialeTipo tipoCredenziale, String user,String password, 
  1615.             String aSubject, String aIssuer, CertificateInfo aCertificate, boolean aStrictVerifier, 
  1616.             String principal, 
  1617.             CryptConfig config,
  1618.             boolean appId) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1619.         
  1620.         // conrollo consistenza
  1621.         if (tipoCredenziale == null)
  1622.             throw new DriverRegistroServiziException("[getSoggettoAutenticato] Parametro tipoCredenziale is null");

  1624.         switch (tipoCredenziale) {
  1625.         case BASIC:
  1626.             if (user == null || "".equalsIgnoreCase(user))
  1627.                 throw new DriverRegistroServiziException("[getSoggettoAutenticato] Parametro user is null (required for basic auth)");
  1628.             if (password == null || "".equalsIgnoreCase(password))
  1629.                 throw new DriverRegistroServiziException("[getSoggettoAutenticato] Parametro password is null (required for basic auth)");
  1630.             break;
  1631.         case APIKEY:
  1632.             if (user == null || "".equalsIgnoreCase(user))
  1633.                 throw new DriverRegistroServiziException("[getSoggettoAutenticato] Parametro user is null (required for apikey auth)");
  1634.             if (password == null || "".equalsIgnoreCase(password))
  1635.                 throw new DriverRegistroServiziException("[getSoggettoAutenticato] Parametro password is null (required for apikey auth)");
  1636.             break;
  1637.         case SSL:
  1638.             if ( (aSubject == null || "".equalsIgnoreCase(aSubject)) && (aCertificate==null))
  1639.                 throw new DriverRegistroServiziException("[getSoggettoAutenticato] Parametro subject/certificate is null (required for ssl auth)");
  1640.             break;
  1641.         case PRINCIPAL:
  1642.             if (principal == null || "".equalsIgnoreCase(principal))
  1643.                 throw new DriverRegistroServiziException("[getSoggettoAutenticato] Parametro principal is null (required for principal auth)");
  1644.             break;
  1645.         }

  1647.         IDSoggetto idSoggetto = null;
  1648.         try{
  1649.             FiltroRicercaSoggetti filtroRicerca = new FiltroRicercaSoggetti();
  1650.             CredenzialiSoggetto credenzialiSoggetto = new CredenzialiSoggetto();
  1651.             credenzialiSoggetto.setTipo(tipoCredenziale);
  1652.             switch (tipoCredenziale) {
  1653.             case BASIC:
  1654.                 credenzialiSoggetto.setUser(user);
  1655.                 credenzialiSoggetto.setPassword(password);
  1656.                 break;
  1657.             case APIKEY:
  1658.                 credenzialiSoggetto.setUser(user);
  1659.                 credenzialiSoggetto.setPassword(password);
  1660.                 credenzialiSoggetto.setAppId(appId);
  1661.                 break;
  1662.             case SSL:
  1663.                 credenzialiSoggetto.setSubject(aSubject);
  1664.                 credenzialiSoggetto.setIssuer(aIssuer);
  1665.                 if(aCertificate!=null) {
  1666.                     try {
  1667.                         credenzialiSoggetto.setCertificate(aCertificate.getCertificate().getEncoded());
  1668.                     }catch(Exception e) {
  1669.                         throw new DriverRegistroServiziException(e.getMessage(),e);
  1670.                     }
  1671.                 }
  1672.                 credenzialiSoggetto.setCertificateStrictVerification(aStrictVerifier);
  1673.                 break;
  1674.             case PRINCIPAL:
  1675.                 credenzialiSoggetto.setUser(principal);
  1676.                 break;
  1677.             }
  1678.             filtroRicerca.setCredenzialiSoggetto(credenzialiSoggetto, config);
  1679.             List<IDSoggetto> l = this.getAllIdSoggetti(filtroRicerca);
  1680.             if(l.size()>1){
  1681.                 throw new DriverRegistroServiziException("Trovato più di un soggetto che possiede le credenziali '"+tipoCredenziale.toString()+"' fornite");
  1682.             }
  1683.             else if(l.size()==1){
  1684.                 idSoggetto = l.get(0);
  1685.             }
  1686.         }catch(DriverRegistroServiziNotFound notFound){
  1687.             // ignore
  1688.         }
  1689.         
  1690.         if(idSoggetto==null){
  1691.             throw new DriverRegistroServiziNotFound("Nessun soggetto trovato che possiede le credenziali '"+tipoCredenziale.toString()+"' fornite");
  1692.         }
  1693.         else{
  1694.             return this.getSoggetto(idSoggetto);
  1695.         }
  1696.     }
  1697.     
  1698.     /**
  1699.      *  Ritorna gli identificatori dei soggetti che rispettano il parametro di ricerca
  1700.      * 
  1701.      * @param filtroRicerca
  1702.      * @return Una lista di ID dei soggetti trovati
  1703.      * @throws DriverRegistroServiziException
  1704.      * @throws DriverRegistroServiziNotFound
  1705.      */
  1706.     @Override
  1707.     public List<IDSoggetto> getAllIdSoggetti(FiltroRicercaSoggetti filtroRicerca) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1708.         try{
  1709.             if(this.generatoreXML==null)
  1710.                 throw new DriverRegistroServiziException("[getAllIdSoggettiRegistro] Gestore repository XML non istanziato. Necessario per l'implementazione di questo metodo.");

  1712.             org.openspcoop2.core.registry.Soggetto[] ssList = this.generatoreXML.getSoggetti(); 
  1713.             if(ssList==null)
  1714.                 throw new DriverRegistroServiziNotFound("Soggetti non esistenti nel repository WEB");

  1716.             boolean testInChiaro = false;
  1717.             ICrypt crypt = null;
  1718.             if(filtroRicerca!=null && filtroRicerca.getCredenzialiSoggetto()!=null && filtroRicerca.getCredenzialiSoggetto().getPassword()!=null){
  1719.                 CredenzialeTipo cTipo = filtroRicerca.getCredenzialiSoggetto().getTipo();
  1720.                 if(CredenzialeTipo.BASIC.equals(cTipo)){
  1721.                     CryptConfig config = filtroRicerca.getCryptConfig();
  1722.                     if(config==null || config.isBackwardCompatibility()) {
  1723.                         testInChiaro = true;
  1724.                     }
  1725.                     if(config!=null) {
  1726.                         try {
  1727.                             crypt = CryptFactory.getCrypt(this.log, config);
  1728.                         }catch(Exception e) {
  1729.                             throw new DriverRegistroServiziException(e.getMessage(),e);
  1730.                         }
  1731.                     }
  1732.                 }
  1733.                 else if(CredenzialeTipo.APIKEY.equals(cTipo)){
  1734.                     CryptConfig config = filtroRicerca.getCryptConfig();
  1735.                     if(config!=null) {
  1736.                         try {
  1737.                             crypt = CryptFactory.getCrypt(this.log, config);
  1738.                         }catch(Exception e) {
  1739.                             throw new DriverRegistroServiziException(e.getMessage(),e);
  1740.                         }
  1741.                     }
  1742.                     else {
  1743.                         testInChiaro = true;
  1744.                     }
  1745.                 }
  1746.             }
  1747.             
  1748.             // Esamina dei soggetti
  1749.             List<IDSoggetto> idSoggetti = new ArrayList<IDSoggetto>();
  1750.             for(int i=0; i<ssList.length; i++){

  1752.                 String idSoggettoXML = ssList[i].getTipo() + ssList[i].getNome();
  1753.                 String urlXMLSoggetto = this.urlPrefix + idSoggettoXML +CostantiRegistroServizi.URL_SEPARATOR  + idSoggettoXML + ".xml";

  1755.                 /* --- Validazione XSD -- */
  1756.                 try{
  1757.                     this.validatoreRegistro.valida(urlXMLSoggetto);  
  1758.                 }catch (Exception e) {
  1759.                     throw new DriverRegistroServiziException("[getAllIdSoggettiRegistro] Riscontrato errore durante la validazione XSD ("+urlXMLSoggetto+"): "+e.getMessage(),e);
  1760.                 }

  1762.                 if(filtroRicerca!=null){
  1763.                     // Filtro By Data
  1764.                     if(filtroRicerca.getMinDate()!=null){
  1765.                         if(ssList[i].getOraRegistrazione()==null){
  1766.                             this.log.debug("[getAllIdSoggettiRegistro](FiltroByMinDate) Soggetto ["+ssList[i].getTipo()+"/"+ssList[i].getNome()+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  1767.                             continue;
  1768.                         }else if(ssList[i].getOraRegistrazione().before(filtroRicerca.getMinDate())){
  1769.                             continue;
  1770.                         }
  1771.                     }
  1772.                     if(filtroRicerca.getMaxDate()!=null){
  1773.                         if(ssList[i].getOraRegistrazione()==null){
  1774.                             this.log.debug("[getAllIdSoggettiRegistro](FiltroByMaxDate) Soggetto ["+ssList[i].getTipo()+"/"+ssList[i].getNome()+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  1775.                             continue;
  1776.                         }else if(ssList[i].getOraRegistrazione().after(filtroRicerca.getMaxDate())){
  1777.                             continue;
  1778.                         }
  1779.                     }
  1780.                     // Filtro By Tipo e Nome
  1781.                     if(filtroRicerca.getTipo()!=null){
  1782.                         if(ssList[i].getTipo().equals(filtroRicerca.getTipo()) == false){
  1783.                             continue;
  1784.                         }
  1785.                     }
  1786.                     if(filtroRicerca.getNome()!=null){
  1787.                         if(ssList[i].getNome().equals(filtroRicerca.getNome()) == false){
  1788.                             continue;
  1789.                         }
  1790.                     }
  1791.                     // Filtro By Pdd
  1792.                     if(filtroRicerca.getNomePdd()!=null){
  1793.                         if(ssList[i].getPortaDominio().equals(filtroRicerca.getNomePdd()) == false){
  1794.                             continue;
  1795.                         }
  1796.                     }
  1797.                     // ProtocolProperties
  1798.                     if(ProtocolPropertiesUtilities.isMatch(ssList[i], filtroRicerca.getProtocolProperties())==false){
  1799.                         continue;
  1800.                     }
  1801.                     // Filtro By Ruoli
  1802.                     if(filtroRicerca.getIdRuolo()!=null && filtroRicerca.getIdRuolo().getNome()!=null){
  1803.                         if(ssList[i].getRuoli()==null){
  1804.                             continue;
  1805.                         }
  1806.                         boolean contains = false;
  1807.                         for (int j = 0; j < ssList[i].getRuoli().sizeRuoloList(); j++) {
  1808.                             if(filtroRicerca.getIdRuolo().getNome().equals(ssList[i].getRuoli().getRuolo(j).getNome())){
  1809.                                 contains = true;
  1810.                                 break;
  1811.                             }
  1812.                         }
  1813.                         if(!contains){
  1814.                             continue;
  1815.                         }
  1816.                     }
  1817.                     // Filtro By Credenziali
  1818.                     if(filtroRicerca.getCredenzialiSoggetto()!=null){
  1819.                         CredenzialiSoggetto credenziali = (ssList[i].sizeCredenzialiList() > 0 ? ssList[i].getCredenziali(0) : null);
  1820.                         if(credenziali==null){
  1821.                             continue;
  1822.                         }
  1823.                         if(filtroRicerca.getCredenzialiSoggetto().getTipo()!=null){
  1824.                             if(credenziali.getTipo()==null){
  1825.                                 if(filtroRicerca.getCredenzialiSoggetto().getTipo().equals(CredenzialeTipo.SSL) == false){ // ssl è il default
  1826.                                     continue;
  1827.                                 }   
  1828.                             }
  1829.                             else{
  1830.                                 if(filtroRicerca.getCredenzialiSoggetto().getTipo().equals(credenziali.getTipo())==false){
  1831.                                     continue;
  1832.                                 }
  1833.                                 if(CredenzialeTipo.APIKEY.equals(filtroRicerca.getCredenzialiSoggetto().getTipo())){
  1834.                                     if(filtroRicerca.getCredenzialiSoggetto().isAppId()) {
  1835.                                         if(!credenziali.isAppId()) {
  1836.                                             continue;
  1837.                                         }
  1838.                                     }
  1839.                                     else {
  1840.                                         if(credenziali.isAppId()) {
  1841.                                             continue;
  1842.                                         }
  1843.                                     }
  1844.                                 }
  1845.                             }
  1846.                         }
  1847.                         if(filtroRicerca.getCredenzialiSoggetto().getUser()!=null){
  1848.                             if(filtroRicerca.getCredenzialiSoggetto().getUser().equals(credenziali.getUser())==false){
  1849.                                 continue;
  1850.                             }
  1851.                         }
  1852.                         if(filtroRicerca.getCredenzialiSoggetto().getPassword()!=null){
  1853.                             String passwordSaved =  credenziali.getPassword();
  1854.                             boolean found = false;
  1855.                             if(testInChiaro) {
  1856.                                 found = filtroRicerca.getCredenzialiSoggetto().getPassword().equals(passwordSaved);
  1857.                             }
  1858.                             if(!found && crypt!=null) {
  1859.                                 found = crypt.check(filtroRicerca.getCredenzialiSoggetto().getPassword(), passwordSaved);
  1860.                             }
  1861.                             
  1862.                             if( !found ) {
  1863.                                 continue;
  1864.                             }
  1865.                         }
  1866.                         if(filtroRicerca.getCredenzialiSoggetto().getSubject()!=null){
  1867.                             try{
  1868.                                 if(credenziali.getSubject()==null){
  1869.                                     continue;
  1870.                                 }
  1871.                                 boolean subjectValid = CertificateUtils.sslVerify(credenziali.getSubject(), filtroRicerca.getCredenzialiSoggetto().getSubject(), PrincipalType.SUBJECT, this.log);
  1872.                                 boolean issuerValid = true;
  1873.                                 if(filtroRicerca.getCredenzialiSoggetto().getIssuer()!=null) {
  1874.                                     issuerValid = CertificateUtils.sslVerify(credenziali.getIssuer(), filtroRicerca.getCredenzialiSoggetto().getIssuer(), PrincipalType.ISSUER, this.log);
  1875.                                 }
  1876.                                 else {
  1877.                                     issuerValid = (credenziali.getIssuer() == null);
  1878.                                 }
  1879.                                 if(!subjectValid || !issuerValid){
  1880.                                     continue;
  1881.                                 }
  1882.                             }catch(Exception e){
  1883.                                 throw new DriverRegistroServiziException(e.getMessage(),e);
  1884.                             }
  1885.                         }
  1886.                         if(filtroRicerca.getCredenzialiSoggetto().getCnSubject()!=null && filtroRicerca.getCredenzialiSoggetto().getCertificate()!=null) {
  1887.                             if(filtroRicerca.getCredenzialiSoggetto().getCnSubject().equals(credenziali.getCnSubject())==false) {
  1888.                                 continue;
  1889.                             }
  1890.                             // Possono esistere piu' soggetti che hanno un CN con subject e issuer diverso.
  1891.                             Certificate certificato = ArchiveLoader.load(ArchiveType.CER, credenziali.getCertificate(), 0, null);
  1892.                             Certificate certificatoFiltro = ArchiveLoader.load(ArchiveType.CER, filtroRicerca.getCredenzialiSoggetto().getCertificate(), 0, null);                          
  1893.                             if(!certificatoFiltro.getCertificate().equals(certificato.getCertificate(),filtroRicerca.getCredenzialiSoggetto().isCertificateStrictVerification())) {
  1894.                                 continue;
  1895.                             }
  1896.                         }
  1897.                     }
  1898.                 }
  1899.                 IDSoggetto idS = new IDSoggetto(ssList[i].getTipo(),ssList[i].getNome());
  1900.                 idSoggetti.add(idS);
  1901.             }
  1902.             if(idSoggetti.size()==0){
  1903.                 throw new DriverRegistroServiziNotFound("Soggetti non trovati che rispettano il filtro di ricerca selezionato: "+filtroRicerca.toString());
  1904.             }else{
  1905.                 return idSoggetti;
  1906.             }
  1907.         }catch(Exception e){
  1908.             if(e instanceof DriverRegistroServiziNotFound)
  1909.                 throw (DriverRegistroServiziNotFound)e;
  1910.             else
  1911.                 throw new DriverRegistroServiziException("getAllIdSoggettiRegistro error",e);
  1912.         }
  1913.     }

  1915.     
  1916.     
  1917.     
  1918.     
  1919.     
  1920.     /* Accordi di Servizio Parte Specifica */
  1921.     
  1922.     /**
  1923.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.AccordoServizioParteSpecifica}
  1924.      * contenente le informazioni sulle funzionalita' associate
  1925.      * al servizio  identificato grazie ai fields Soggetto,
  1926.      * 'Servizio','TipoServizio' e 'Azione' impostati
  1927.      * all'interno del parametro <var>idService</var> di tipo {@link org.openspcoop2.core.id.IDServizio}. 
  1928.      *
  1929.      * @param idService Identificatore del Servizio di tipo {@link org.openspcoop2.core.id.IDServizio}.
  1930.      * @return l'oggetto di tipo {@link org.openspcoop2.core.registry.AccordoServizioParteSpecifica}
  1931.      * 
  1932.      */
  1933.     @Override
  1934.     public org.openspcoop2.core.registry.AccordoServizioParteSpecifica getAccordoServizioParteSpecifica(IDServizio idService) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1935.         if(idService == null)
  1936.             throw new DriverRegistroServiziException("[getAccordoServizioParteSpecifica] Parametro Non Valido");
  1937.         String servizio = idService.getNome();
  1938.         String tipoServizio = idService.getTipo();
  1939.         Integer versioneServizio = idService.getVersione();
  1940.         String uri = this.idServizioFactory.getUriFromIDServizio(idService);
  1941.         if(servizio == null || tipoServizio == null)
  1942.             throw new DriverRegistroServiziException("[getAccordoServizioParteSpecifica] Parametri (Servizio) Non Validi");
  1943.         String tipoSogg = idService.getSoggettoErogatore().getTipo();
  1944.         String nomeSogg = idService.getSoggettoErogatore().getNome();
  1945.         if(tipoSogg == null || nomeSogg == null)
  1946.             throw new DriverRegistroServiziException("[getAccordoServizioParteSpecifica] Parametri (Soggetto) Non Validi");


  1949.         org.openspcoop2.core.registry.AccordoServizioParteSpecifica servRichiesto = null;
  1950.         // get URL XML Servizio
  1951.         String idSoggettoXML = tipoSogg + nomeSogg;
  1952.         String idServizioXML = tipoServizio + servizio + versioneServizio;
  1953.         String urlXMLServizio = this.urlPrefix + idSoggettoXML + CostantiRegistroServizi.URL_SEPARATOR+CostantiXMLRepository.SERVIZI+
  1954.         CostantiRegistroServizi.URL_SEPARATOR + idServizioXML  + ".xml";

  1956.         ByteArrayInputStream bin = null;
  1957.         try{
  1958.             byte[] fileXML = null;
  1959.             try{
  1960.                 fileXML = HttpUtilities.requestHTTPFile(urlXMLServizio);
  1961.             }catch(UtilsException e){
  1962.                 // Controllo pre-esistenza dell'accordo
  1963.                 if( "404".equals(e.getMessage()) ){
  1964.                     throw new DriverRegistroServiziNotFound("[getServizio] Il servizio ["+uri+"] non risulta gia' registrato nel registro");
  1965.                 } else
  1966.                     throw e;
  1967.             }

  1969.             /* --- Validazione XSD (ora che sono sicuro che non ho un 404) -- */
  1970.             try{
  1971.                 this.validatoreRegistro.valida(urlXMLServizio);  
  1972.             }catch (Exception e) {
  1973.                 throw new DriverRegistroServiziException("[getAccordoServizioParteSpecifica] Riscontrato errore durante la validazione XSD del Registro dei Servizi XML di OpenSPCoop: "+e.getMessage(),e);
  1974.             }

  1976.             // parsing
  1977.             bin = new ByteArrayInputStream(fileXML);
  1978.             org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer();
  1979.             org.openspcoop2.core.registry.RegistroServizi rs = 
  1980.                 (org.openspcoop2.core.registry.RegistroServizi) deserializer.readRegistroServizi(bin);
  1981.             if(rs.sizeSoggettoList()>0){
  1982.                 if(rs.getSoggetto(0).sizeAccordoServizioParteSpecificaList()>0){
  1983.                     servRichiesto = rs.getSoggetto(0).getAccordoServizioParteSpecifica(0);
  1984.                     servRichiesto.setNomeSoggettoErogatore(idService.getSoggettoErogatore().getNome());
  1985.                     servRichiesto.setTipoSoggettoErogatore(idService.getSoggettoErogatore().getTipo());
  1986.                 }
  1987.             }
  1988.             bin.close();
  1989.         }catch(DriverRegistroServiziNotFound e){
  1990.             throw e;
  1991.         }catch(DriverRegistroServiziException e){
  1992.             throw e;
  1993.         }catch(Exception e){
  1994.             try{
  1995.                 if(bin!=null)
  1996.                     bin.close();
  1997.             } catch(Exception eis) {
  1998.                 // close
  1999.             }
  2000.             if(e instanceof DriverRegistroServiziNotFound)
  2001.                 throw (DriverRegistroServiziNotFound)e;
  2002.             else
  2003.                 throw new DriverRegistroServiziException("[getServizio] Errore durante il parsing xml: "+e.getMessage(),e);
  2004.         }

  2006.         if(servRichiesto==null)
  2007.             throw new DriverRegistroServiziNotFound("[getServizio] Servizio non trovato.");

  2009.         return servRichiesto;
  2010.     }
  2011.     

  2013.     /**
  2014.      * Si occupa di ritornare l'oggetto {@link org.openspcoop2.core.registry.AccordoServizioParteSpecifica}
  2015.      * contenente le informazioni sulle funzionalita' associate
  2016.      * al servizio  correlato identificato grazie ai fields Soggetto
  2017.      * e nomeAccordo
  2018.      * 
  2019.      * @param idSoggetto Identificatore del Soggetto di tipo {@link org.openspcoop2.core.id.IDSoggetto}.
  2020.      * @param idAccordo ID dell'accordo che deve implementare il servizio correlato
  2021.      * @return l'oggetto di tipo {@link org.openspcoop2.core.registry.AccordoServizioParteSpecifica}
  2022.      * 
  2023.      */
  2024.     @Override
  2025.     public org.openspcoop2.core.registry.AccordoServizioParteSpecifica getAccordoServizioParteSpecifica_ServizioCorrelato(IDSoggetto idSoggetto, IDAccordo idAccordo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{

  2027.         if(idSoggetto == null)
  2028.             throw new DriverRegistroServiziException("[getAccordoServizioParteSpecifica_ServizioCorrelato] Parametro Non Valido");
  2029.         String nomeSoggetto = idSoggetto.getNome();
  2030.         String tipoSoggetto = idSoggetto.getTipo();
  2031.         if(nomeSoggetto == null || tipoSoggetto == null)
  2032.             throw new DriverRegistroServiziException("[getAccordoServizioParteSpecifica_ServizioCorrelato] Parametri (Soggetto) Non Validi");
  2033.         if(idAccordo == null || idAccordo.getNome()==null)
  2034.             throw new DriverRegistroServiziException("[getAccordoServizioParteSpecifica_ServizioCorrelato] Parametri (Accordo) Non Valido");

  2036.         org.openspcoop2.core.registry.AccordoServizioParteSpecifica servRichiesto = null;

  2038.         // get URL XML Index
  2039.         String idSoggettoXML = tipoSoggetto + nomeSoggetto;
  2040.         String urlXMLIndexServizi = this.urlPrefix + idSoggettoXML + CostantiRegistroServizi.URL_SEPARATOR+CostantiXMLRepository.SERVIZI+
  2041.         CostantiRegistroServizi.URL_SEPARATOR + CostantiXMLRepository.INDEX_SERVIZI;

  2043.         String uriAccordo = this.idAccordoFactory.getUriFromIDAccordo(idAccordo);

  2045.         IDServizio [] lista = null;
  2046.         try{
  2047.             byte[] fileXML = null;
  2048.             try{
  2049.                 fileXML = HttpUtilities.requestHTTPFile(urlXMLIndexServizi);
  2050.             }catch(UtilsException e){
  2051.                 // Controllo pre-esistenza dell'accordo
  2052.                 if( "404".equals(e.getMessage()) ){
  2053.                     throw new DriverRegistroServiziNotFound("[getAccordoServizioParteSpecifica_ServizioCorrelato] Il soggetto ["+idSoggetto+"] non possiede un index dei servizi erogati");
  2054.                 } else
  2055.                     throw e;
  2056.             }
  2057.             lista = XMLLib.mappingIndexServizi(new String(fileXML));
  2058.             if(lista==null){
  2059.                 throw new DriverRegistroServiziNotFound("[getAccordoServizioParteSpecifica_ServizioCorrelato] Il soggetto ["+idSoggetto+"] non possiede una lista di servizi erogati");
  2060.             }

  2062.         }catch(DriverRegistroServiziNotFound e){
  2063.             throw e;
  2064.         }catch(DriverRegistroServiziException e){
  2065.             throw e;
  2066.         }catch(Exception e){
  2067.             throw new DriverRegistroServiziException("[getAccordoServizioParteSpecifica_ServizioCorrelato] Errore durante la get Servizi List Index: "+e.getMessage(),e);
  2068.         }

  2070.         // leggo index file
  2071.         String urlXMLServizio = null;
  2072.         String tipoServizio = null;
  2073.         String nomeServizio = null;
  2074.         Integer versioneServizio = null;
  2075.         try{
  2076.             for(int i=0;i<lista.length;i++){
  2077.                 if(uriAccordo.equals(lista[i].getUriAccordoServizioParteComune()) &&
  2078.                         TipologiaServizio.CORRELATO.getValue().equals(lista[i].getTipologia().getValue()) &&
  2079.                         idSoggetto.getTipo().equals(lista[i].getSoggettoErogatore().getTipo()) &&
  2080.                         idSoggetto.getNome().equals(lista[i].getSoggettoErogatore().getNome())
  2081.                 ){
  2082.                     urlXMLServizio = this.urlPrefix + idSoggettoXML + CostantiRegistroServizi.URL_SEPARATOR+CostantiXMLRepository.SERVIZI+
  2083.                     CostantiRegistroServizi.URL_SEPARATOR + lista[i].getTipo()+lista[i].getNome()+lista[i].getVersione()+ ".xml";
  2084.                     tipoServizio = lista[i].getTipo();
  2085.                     nomeServizio = lista[i].getNome();
  2086.                     versioneServizio = lista[i].getVersione();
  2087.                     break;
  2088.                 }
  2089.             }
  2090.             if(urlXMLServizio==null){
  2091.                 throw new DriverRegistroServiziNotFound("[getAccordoServizioParteSpecifica_ServizioCorrelato] Il soggetto ["+idSoggetto+"] non possiede un servizio correlato che implementa l'accordo con uri ["+uriAccordo+"]");
  2092.             }

  2094.         }catch(DriverRegistroServiziNotFound e){
  2095.             throw e;
  2096.         }catch(Exception e){
  2097.             throw new DriverRegistroServiziException("[getAccordoServizioParteSpecifica_ServizioCorrelato] Errore durante la ricerca: "+e.getMessage(),e);  
  2098.         }

  2100.         ByteArrayInputStream bin = null;
  2101.         try{
  2102.             byte[] fileXML = null;
  2103.             try{
  2104.                 fileXML = HttpUtilities.requestHTTPFile(urlXMLServizio);
  2105.             }catch(UtilsException e){
  2106.                 // Controllo pre-esistenza dell'accordo
  2107.                 if( "404".equals(e.getMessage()) ){
  2108.                     throw new DriverRegistroServiziNotFound("[getAccordoServizioParteSpecifica_ServizioCorrelato] Il servizio ["+tipoServizio+"/"+nomeServizio+":"+versioneServizio
  2109.                             +"] erogato dal soggetto ["+idSoggetto+"] non risulta gia' registrato nel registro");
  2110.                 } else
  2111.                     throw e;
  2112.             }

  2114.             /* --- Validazione XSD (ora che sono sicuro che non ho un 404) -- */
  2115.             try{
  2116.                 this.validatoreRegistro.valida(urlXMLServizio);  
  2117.             }catch (Exception e) {
  2118.                 throw new DriverRegistroServiziException("[getAccordoServizioParteSpecifica_ServizioCorrelato] Riscontrato errore durante la validazione XSD del Registro dei Servizi XML di OpenSPCoop: "+e.getMessage(),e);
  2119.             }

  2121.             // parsing
  2122.             bin = new ByteArrayInputStream(fileXML);
  2123.             org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer();
  2124.             org.openspcoop2.core.registry.RegistroServizi rs = 
  2125.                 (org.openspcoop2.core.registry.RegistroServizi) deserializer.readRegistroServizi(bin);
  2126.             if(rs.sizeSoggettoList()>0){
  2127.                 if(rs.getSoggetto(0).sizeAccordoServizioParteSpecificaList()>0){
  2128.                     servRichiesto = rs.getSoggetto(0).getAccordoServizioParteSpecifica(0);
  2129.                     servRichiesto.setNomeSoggettoErogatore(idSoggetto.getNome());
  2130.                     servRichiesto.setTipoSoggettoErogatore(idSoggetto.getTipo());
  2131.                 }
  2132.             }
  2133.             bin.close();
  2134.         }catch(DriverRegistroServiziNotFound e){
  2135.             throw e;
  2136.         }catch(DriverRegistroServiziException e){
  2137.             throw e;
  2138.         }catch(Exception e){
  2139.             try{
  2140.                 if(bin!=null)
  2141.                     bin.close();
  2142.             } catch(Exception eis) {
  2143.                 // close
  2144.             }
  2145.             if(e instanceof DriverRegistroServiziNotFound)
  2146.                 throw (DriverRegistroServiziNotFound)e;
  2147.             else
  2148.                 throw new DriverRegistroServiziException("[getServizioCorrelatoByAccordo] Errore durante il parsing xml: "+e.getMessage(),e);
  2149.         }

  2151.         if(servRichiesto==null)
  2152.             throw new DriverRegistroServiziNotFound("[getServizioCorrelatoByAccordo] Servizio non trovato.");

  2154.         return servRichiesto;

  2156.     }

  2158.     
  2159.     @Override
  2160.     public List<IDServizio> getAllIdServizi(FiltroRicercaServizi filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  2161.         
  2162.         List<IDServizio> list = new ArrayList<IDServizio>();
  2163.         _fillAllIdServiziEngine("getAllIdServizi", filtroRicerca, list);
  2164.         return list;
  2165.         
  2166.     }
  2167.     
  2168.     @Override
  2169.     public List<IDFruizione> getAllIdFruizioniServizio(
  2170.             FiltroRicercaFruizioniServizio filtroRicerca) throws DriverRegistroServiziException, DriverRegistroServiziNotFound{
  2171.     
  2172.         List<IDFruizione> list = new ArrayList<IDFruizione>();
  2173.         _fillAllIdServiziEngine("getAllIdFruizioniServizio", filtroRicerca, list);
  2174.         return list;
  2175.         
  2176.     }
  2177.     
  2178.     @SuppressWarnings("unchecked")
  2179.     public <T> void _fillAllIdServiziEngine(String nomeMetodo, 
  2180.             FiltroRicercaServizi filtroRicerca,
  2181.             List<T> listReturn) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2182.         
  2183.     
  2184.         try{

  2186.             FiltroRicercaFruizioniServizio filtroFruizioni = null;
  2187.             if(filtroRicerca instanceof FiltroRicercaFruizioniServizio){
  2188.                 filtroFruizioni = (FiltroRicercaFruizioniServizio) filtroRicerca;
  2189.             }
  2190.             
  2191.             if(this.generatoreXML==null)
  2192.                 throw new DriverRegistroServiziException("["+nomeMetodo+"] Gestore repository XML non istanziato. Necessario per l'implementazione di questo metodo.");

  2194.             org.openspcoop2.core.registry.AccordoServizioParteSpecifica[] servList = this.generatoreXML.getAccordiServiziParteSpecifica();
  2195.             if(servList==null)
  2196.                 throw new DriverRegistroServiziNotFound("Servizi non esistenti nel repository WEB");

  2198.             // Esamina dei servizi
  2199.             for(int i=0; i<servList.length; i++){

  2201.                 String idSoggettoXML = servList[i].getTipoSoggettoErogatore() + servList[i].getNomeSoggettoErogatore();
  2202.                 String idServizioXML = servList[i].getTipo() + servList[i].getNome() + servList[i].getVersione();
  2203.                 String urlXMLServizio = this.urlPrefix + idSoggettoXML + CostantiRegistroServizi.URL_SEPARATOR+CostantiXMLRepository.SERVIZI+
  2204.                 CostantiRegistroServizi.URL_SEPARATOR + idServizioXML  + ".xml";


  2207.                 /* --- Validazione XSD -- */
  2208.                 try{
  2209.                     this.validatoreRegistro.valida(urlXMLServizio);  
  2210.                 }catch (Exception e) {
  2211.                     throw new DriverRegistroServiziException("["+nomeMetodo+"] Riscontrato errore durante la validazione XSD URL("+urlXMLServizio+"): "+e.getMessage(),e);
  2212.                 }

  2214.                 if(filtroRicerca!=null){
  2215.                     // Filtro By Tipo e Nome Soggetto Erogatore
  2216.                     if(filtroRicerca.getTipoSoggettoErogatore()!=null){
  2217.                         if(servList[i].getTipoSoggettoErogatore().equals(filtroRicerca.getTipoSoggettoErogatore()) == false){
  2218.                             continue;
  2219.                         }
  2220.                     }
  2221.                     if(filtroRicerca.getNomeSoggettoErogatore()!=null){
  2222.                         if(servList[i].getNomeSoggettoErogatore().equals(filtroRicerca.getNomeSoggettoErogatore()) == false){
  2223.                             continue;
  2224.                         }
  2225.                     }
  2226.                     // Filtro By Data
  2227.                     if(filtroRicerca.getMinDate()!=null){
  2228.                         if(servList[i].getOraRegistrazione()==null){
  2229.                             this.log.debug("["+nomeMetodo+"](FiltroByMinDate) Servizio["+this.idServizioFactory.getUriFromAccordo(servList[i])+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  2230.                             continue;
  2231.                         }else if(servList[i].getOraRegistrazione().before(filtroRicerca.getMinDate())){
  2232.                             continue;
  2233.                         }
  2234.                     }
  2235.                     if(filtroRicerca.getMaxDate()!=null){
  2236.                         if(servList[i].getOraRegistrazione()==null){
  2237.                             this.log.debug("["+nomeMetodo+"](FiltroByMaxDate) Servizio["+this.idServizioFactory.getUriFromAccordo(servList[i])+"] non valorizzato nell'ora-registrazione. Non inserito nella lista ritornata.");
  2238.                             continue;
  2239.                         }else if(servList[i].getOraRegistrazione().after(filtroRicerca.getMaxDate())){
  2240.                             continue;
  2241.                         }
  2242.                     }
  2243.                     // Filtro By Tipo, Nome e Versione
  2244.                     if(filtroRicerca.getTipo()!=null){
  2245.                         if(servList[i].getTipo().equals(filtroRicerca.getTipo()) == false){
  2246.                             continue;
  2247.                         }
  2248.                     }
  2249.                     if(filtroRicerca.getNome()!=null){
  2250.                         if(servList[i].getNome().equals(filtroRicerca.getNome()) == false){
  2251.                             continue;
  2252.                         }
  2253.                     }
  2254.                     if(filtroRicerca.getVersione()!=null){
  2255.                         if(servList[i].getVersione().intValue() != filtroRicerca.getVersione().intValue()){
  2256.                             continue;
  2257.                         }
  2258.                     }
  2259.                     if(filtroRicerca.getPortType()!=null){
  2260.                         if(servList[i].getPortType().equals(filtroRicerca.getPortType()) == false){
  2261.                             continue;
  2262.                         }
  2263.                     }
  2264.                     // Filtro by Accordo
  2265.                     if(filtroRicerca.getIdAccordoServizioParteComune()!=null){
  2266.                         String uriAccordo = this.idAccordoFactory.getUriFromIDAccordo(filtroRicerca.getIdAccordoServizioParteComune());
  2267.                         if(servList[i].getAccordoServizioParteComune().equals(uriAccordo) == false){
  2268.                             continue;
  2269.                         }
  2270.                     }
  2271.                     // ProtocolProperties
  2272.                     if(ProtocolPropertiesUtilities.isMatch(servList[i], filtroRicerca.getProtocolProperties())==false){
  2273.                         continue;
  2274.                     }
  2275.                     // Filtro By Tipo e/o Nome Soggetto Fruitore
  2276.                     if(filtroRicerca.getTipoSoggettoFruitore()!=null || filtroRicerca.getNomeSoggettoFruitore()!=null){
  2277.                         if(servList[i].sizeFruitoreList()<=0){
  2278.                             continue;
  2279.                         }
  2280.                         boolean found = false;
  2281.                         for (int k = 0; k < servList[i].sizeFruitoreList(); k++) {
  2282.                             Fruitore fruitore = servList[i].getFruitore(k);
  2283.                             if(filtroRicerca.getTipoSoggettoFruitore()!=null){
  2284.                                 if(fruitore.getTipo().equals(filtroRicerca.getTipoSoggettoFruitore()) == false){
  2285.                                     continue;
  2286.                                 }
  2287.                             }
  2288.                             if(filtroRicerca.getNomeSoggettoFruitore()!=null){
  2289.                                 if(fruitore.getNome().equals(filtroRicerca.getNomeSoggettoFruitore()) == false){
  2290.                                     continue;
  2291.                                 }
  2292.                             }
  2293.                             found = true;
  2294.                             break;
  2295.                         }
  2296.                         if(!found){
  2297.                             continue;
  2298.                         }
  2299.                     }
  2300.                 }
  2301.                 
  2302.                 IDServizio idServ = this.idServizioFactory.getIDServizioFromAccordo(servList[i]);
  2303.                 
  2304.                 if(filtroFruizioni!=null){
  2305.                     
  2306.                     for (Fruitore fruitore : servList[i].getFruitoreList()) {
  2307.                         
  2308.                         // Tipo
  2309.                         if(filtroFruizioni.getTipoSoggettoFruitore()!=null){
  2310.                             if(fruitore.getTipo().equals(filtroFruizioni.getTipoSoggettoFruitore()) == false){
  2311.                                 continue;
  2312.                             }
  2313.                         }
  2314.                         // Nome
  2315.                         if(filtroFruizioni.getNomeSoggettoFruitore()!=null){
  2316.                             if(fruitore.getNome().equals(filtroFruizioni.getNomeSoggettoFruitore()) == false){
  2317.                                 continue;
  2318.                             }
  2319.                         }
  2320.                         // ProtocolProperties
  2321.                         if(ProtocolPropertiesUtilities.isMatch(fruitore, filtroFruizioni.getProtocolPropertiesFruizione())==false){
  2322.                             continue;
  2323.                         }
  2324.                         
  2325.                         IDFruizione idFruizione = new IDFruizione();
  2326.                         idFruizione.setIdServizio(idServ);
  2327.                         idFruizione.setIdFruitore(new IDSoggetto(fruitore.getTipo(), fruitore.getNome()));
  2328.                         listReturn.add((T)idFruizione);
  2329.                     }
  2330.                     
  2331.                 }
  2332.                 else{
  2333.                     listReturn.add((T)idServ);
  2334.                 }
  2335.             }
  2336.             if(listReturn.size()<=0){
  2337.                 String msgFiltro = "Elementi non trovati che rispettano il filtro di ricerca selezionato: ";
  2338.                 if(filtroFruizioni!=null){
  2339.                     throw new DriverRegistroServiziNotFound(msgFiltro+filtroFruizioni.toString());
  2340.                 }
  2341.                 else if(filtroRicerca!=null){
  2342.                     throw new DriverRegistroServiziNotFound(msgFiltro+filtroRicerca.toString());
  2343.                 }
  2344.                 else
  2345.                     throw new DriverRegistroServiziNotFound("Elementi non trovati");
  2346.             }

  2348.         }catch(Exception e){
  2349.             if(e instanceof DriverRegistroServiziNotFound)
  2350.                 throw (DriverRegistroServiziNotFound)e;
  2351.             else
  2352.                 throw new DriverRegistroServiziException("["+nomeMetodo+"] error",e);
  2353.         }
  2354.     }

  2356.     
  2357.     @Override
  2358.     public Documento getAllegato(IDServizio idASPS, String nome)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2359.         throw new DriverRegistroServiziException("Not Implemented");
  2360.     }
  2361.     @Override
  2362.     public Documento getSpecificaSemiformale(IDServizio idASPS, TipiDocumentoSemiformale tipo, String nome)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2363.         throw new DriverRegistroServiziException("Not Implemented");
  2364.     }
  2365.     @Override
  2366.     public Documento getSpecificaSicurezza(IDServizio idASPS, TipiDocumentoSicurezza tipo, String nome)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2367.         throw new DriverRegistroServiziException("Not Implemented");
  2368.     }
  2369.     @Override
  2370.     public Documento getSpecificaLivelloServizio(IDServizio idASPS, TipiDocumentoLivelloServizio tipo, String nome)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2371.         throw new DriverRegistroServiziException("Not Implemented");
  2372.     }
















  2389.     /* ********  INTERFACCIA IDriverRegistroServiziCRUD ******** */ 
  2390.     
  2391.     /**
  2392.      * Crea un nuovo AccordoCooperazione
  2393.      * 
  2394.      * @param accordoCooperazione
  2395.      * @throws DriverRegistroServiziException
  2396.      */
  2397.     @Override
  2398.     public void createAccordoCooperazione(AccordoCooperazione accordoCooperazione) throws DriverRegistroServiziException{
  2399.         
  2400.         if( accordoCooperazione == null)
  2401.             throw new DriverRegistroServiziException("[createAccordoCooperazione] Parametro Non Valido");

  2403.         IDAccordoCooperazione idAccordo = null;
  2404.         try {

  2406.             idAccordo = this.idAccordoCooperazioneFactory.getIDAccordoFromAccordo(accordoCooperazione);

  2408.             // Controllo elementi obbligatori
  2409.             if( accordoCooperazione.getNome() == null  ){
  2410.                 throw new DriverRegistroServiziException("Accordo Cooperazione non completamente definito nei parametri obbligatori");
  2411.             }

  2413.             // Controllo pre-esistenza dell'accordo
  2414.             if( this.generatoreXML.existsAccordoCooperazione(idAccordo) == true){
  2415.                 throw new DriverRegistroServiziException("L'accordo di cooperazione ["+idAccordo.toString()
  2416.                         +"] risulta gia' inserito nel registro dei servizi.");
  2417.             } 

  2419.             // Generazione XML
  2420.             this.generatoreXML.createAccordoCooperazione(idAccordo,accordoCooperazione);

  2422.         }catch (Exception e) {
  2423.             throw new DriverRegistroServiziException("[createAccordoCooperazione] Errore generatosi durante la creazione di un nuovo accordo di cooperazione ["+idAccordo+"]: "+e.getMessage(),e);
  2424.         }
  2425.     }
  2426.     
  2427.     /**
  2428.      * Verifica l'esistenza di un accordo registrato.
  2429.      *
  2430.      * @param idAccordo dell'accordo da verificare
  2431.      * @return true se l'accordo esiste, false altrimenti
  2432.      * @throws DriverRegistroServiziException
  2433.      */    
  2434.     @Override
  2435.     public boolean existsAccordoCooperazione(IDAccordoCooperazione idAccordo) throws DriverRegistroServiziException{
  2436.         if( idAccordo == null)
  2437.             return false;
  2438.         if( idAccordo.getNome() == null)
  2439.             return false;

  2441.         try{
  2442.             return this.generatoreXML.existsAccordoCooperazione(idAccordo);
  2443.         }catch(Exception e){
  2444.             this.log.error("[existsAccordoCooperazione] Accordo non trovato: "+e.getMessage());
  2445.             return false;
  2446.         }
  2447.     }
  2448.     
  2449.     /**
  2450.      * Aggiorna l'AccordoCooperazione con i nuovi valori.
  2451.      *  
  2452.      * @param accordoCooperazione
  2453.      * @throws DriverRegistroServiziException
  2454.      */
  2455.     @Override
  2456.     public void updateAccordoCooperazione(AccordoCooperazione accordoCooperazione) throws DriverRegistroServiziException{
  2457.         if( accordoCooperazione == null)
  2458.             throw new DriverRegistroServiziException("[updateAccordoCooperazione] Parametro Non Valido");

  2460.         IDAccordoCooperazione idAccordoOLD = null;
  2461.         if(accordoCooperazione.getOldIDAccordoForUpdate()!=null){
  2462.             idAccordoOLD = accordoCooperazione.getOldIDAccordoForUpdate();
  2463.         }else{
  2464.             idAccordoOLD = this.idAccordoCooperazioneFactory.getIDAccordoFromAccordo(accordoCooperazione);
  2465.         }

  2467.         try {

  2469.             // Controllo  dell'accordo da Modificare
  2470.             if(idAccordoOLD==null){
  2471.                 throw new DriverRegistroServiziException("Accordo Cooperazione da modificare non definito");
  2472.             }

  2474.             // Controllo elementi obbligatori dell'accordo modificato
  2475.             if( accordoCooperazione.getNome() == null ){
  2476.                 throw new DriverRegistroServiziException("Accordo Cooperazione modificato non completamente definito nei parametri obbligatori");
  2477.             }

  2479.             // Controllo pre-esistenza dell'accordo da modificare
  2480.             if( this.generatoreXML.existsAccordoCooperazione(idAccordoOLD) == false){
  2481.                 throw new DriverRegistroServiziException("L'accordo di cooperazione ["+idAccordoOLD
  2482.                         +"] non risulta gia' inserito nel registro dei servizi.");
  2483.             } 

  2485.             // Controllo non esistenza della nuova identita dell'accordo (se da modificare)
  2486.             IDAccordoCooperazione idAccordoNEW = this.idAccordoCooperazioneFactory.getIDAccordoFromAccordo(accordoCooperazione);
  2487.             if(idAccordoOLD.equals(idAccordoNEW) == false){
  2488.                 if( this.generatoreXML.existsAccordoCooperazione(idAccordoNEW) == true){
  2489.                     throw new DriverRegistroServiziException("L'accordo di cooperazione ["+idAccordoNEW
  2490.                             +"] risulta gia' inserito nel registro dei servizi.");
  2491.                 } 
  2492.             }

  2494.             // Ri-Generazione XML
  2495.             this.generatoreXML.createAccordoCooperazione(idAccordoOLD,accordoCooperazione);

  2497.         }catch (Exception e) {
  2498.             throw new DriverRegistroServiziException("[updateAccordoCooperazione] Errore generatosi durante la modifica dell'accordo di cooperazione ["+idAccordoOLD+"]: "+e,e);
  2499.         }
  2500.     }
  2501.     
  2502.     /**
  2503.      * Elimina un AccordoCooperazione 
  2504.      *  
  2505.      * @param accordoCooperazione
  2506.      * @throws DriverRegistroServiziException
  2507.      */
  2508.     @Override
  2509.     public void deleteAccordoCooperazione(AccordoCooperazione accordoCooperazione) throws DriverRegistroServiziException{
  2510.         if( accordoCooperazione == null)
  2511.             throw new DriverRegistroServiziException("[deleteAccordoCooperazione] Parametro Non Valido");

  2513.         IDAccordoCooperazione idAccordo = null;
  2514.         try {
  2515.             idAccordo = this.idAccordoCooperazioneFactory.getIDAccordoFromAccordo(accordoCooperazione);

  2517.             // Controllo id dell'accordo da eliminare
  2518.             if(accordoCooperazione.getNome()==null){
  2519.                 throw new DriverRegistroServiziException("Accordo Cooperazione da eliminare non definito");
  2520.             }

  2522.             // Controllo pre-esistenza dell'accordo da eliminare
  2523.             if( this.generatoreXML.existsAccordoCooperazione(idAccordo) == false){
  2524.                 throw new DriverRegistroServiziException("L'accordo di cooperazione ["+idAccordo
  2525.                         +"] non risulta gia' inserito nel registro dei servizi.");
  2526.             } 

  2528.             // Delete from Repository
  2529.             this.generatoreXML.deleteAccordoCooperazione(idAccordo);

  2531.         }catch (Exception e) {
  2532.             throw new DriverRegistroServiziException("[deleteAccordoCooperazione] Errore generatosi durante l'eliminazione dell'accordo di cooperazione ["+idAccordo+"]: "+e.getMessage(),e);
  2533.         }
  2534.     }
  2535.     
  2536.     
  2537.     /**
  2538.      * Crea un nuovo AccordoServizio 
  2539.      * 
  2540.      * @param accordoServizio
  2541.      * @throws DriverRegistroServiziException
  2542.      */
  2543.     @Override
  2544.     public void createAccordoServizioParteComune(AccordoServizioParteComune accordoServizio) throws DriverRegistroServiziException{
  2545.         if( accordoServizio == null)
  2546.             throw new DriverRegistroServiziException("[createAccordoServizioParteComune] Parametro Non Valido");

  2548.         IDAccordo idAccordo = null;
  2549.         try {

  2551.             idAccordo = this.idAccordoFactory.getIDAccordoFromAccordo(accordoServizio);

  2553.             // Controllo elementi obbligatori
  2554.             if( (accordoServizio.getNome() == null) ||
  2555.                     (accordoServizio.getProfiloCollaborazione() == null) ){
  2556.                 throw new DriverRegistroServiziException("Accordo Servizio Parte Comune non completamente definito nei parametri obbligatori");
  2557.             }

  2559.             // Controllo pre-esistenza dell'accordo
  2560.             if( this.generatoreXML.existsAccordoServizioParteComune(idAccordo) == true){
  2561.                 throw new DriverRegistroServiziException("L'accordo di servizio ["+idAccordo.toString()
  2562.                         +"] risulta gia' inserito nel registro dei servizi.");
  2563.             } 

  2565.             // Generazione XML
  2566.             this.generatoreXML.createAccordoServizioParteComune(idAccordo,accordoServizio);

  2568.         }catch (Exception e) {
  2569.             throw new DriverRegistroServiziException("[createAccordoServizioParteComune] Errore generatosi durante la creazione di un nuovo accordo di servizio ["+idAccordo+"]: "+e.getMessage(),e);
  2570.         }
  2571.     }

  2573.     /**
  2574.      * Verifica l'esistenza di un accordo registrato.
  2575.      *
  2576.      * @param idAccordo dell'accordo da verificare
  2577.      * @return true se l'accordo esiste, false altrimenti
  2578.      * @throws DriverRegistroServiziException
  2579.      */    
  2580.     @Override
  2581.     public boolean existsAccordoServizioParteComune(IDAccordo idAccordo) throws DriverRegistroServiziException{
  2582.         if( idAccordo == null)
  2583.             return false;
  2584.         if( idAccordo.getNome() == null)
  2585.             return false;

  2587.         try{
  2588.             return this.generatoreXML.existsAccordoServizioParteComune(idAccordo);
  2589.         }catch(Exception e){
  2590.             this.log.error("[existsAccordoServizioParteComune] Accordo non trovato: "+e.getMessage());
  2591.             return false;
  2592.         }
  2593.     }

  2595.     /**
  2596.      * Aggiorna l'AccordoServizio con i nuovi valori.
  2597.      *  
  2598.      * @param accordoServizio
  2599.      * @throws DriverRegistroServiziException
  2600.      */
  2601.     @Override
  2602.     public void updateAccordoServizioParteComune(AccordoServizioParteComune accordoServizio) throws DriverRegistroServiziException{
  2603.         if( accordoServizio == null)
  2604.             throw new DriverRegistroServiziException("[updateAccordoServizioParteComune] Parametro Non Valido");

  2606.         IDAccordo idAccordoOLD = null;
  2607.         if(accordoServizio.getOldIDAccordoForUpdate()!=null){
  2608.             idAccordoOLD = accordoServizio.getOldIDAccordoForUpdate();
  2609.         }else{
  2610.             idAccordoOLD = this.idAccordoFactory.getIDAccordoFromAccordo(accordoServizio);
  2611.         }

  2613.         try {

  2615.             // Controllo  dell'accordo da Modificare
  2616.             if(idAccordoOLD==null){
  2617.                 throw new DriverRegistroServiziException("Accordo Servizio Parte Comune da modificare non definito");
  2618.             }

  2620.             // Controllo elementi obbligatori dell'accordo modificato
  2621.             if( (accordoServizio.getNome() == null) ||
  2622.                     (accordoServizio.getProfiloCollaborazione() == null) ){
  2623.                 throw new DriverRegistroServiziException("Accordo Servizio Parte Comune modificato non completamente definito nei parametri obbligatori");
  2624.             }

  2626.             // Controllo pre-esistenza dell'accordo da modificare
  2627.             if( this.generatoreXML.existsAccordoServizioParteComune(idAccordoOLD) == false){
  2628.                 throw new DriverRegistroServiziException("L'accordo di servizio ["+idAccordoOLD
  2629.                         +"] non risulta gia' inserito nel registro dei servizi.");
  2630.             } 

  2632.             // Controllo non esistenza della nuova identita dell'accordo (se da modificare)
  2633.             IDAccordo idAccordoNEW = this.idAccordoFactory.getIDAccordoFromAccordo(accordoServizio);
  2634.             if(idAccordoOLD.equals(idAccordoNEW) == false){
  2635.                 if( this.generatoreXML.existsAccordoServizioParteComune(idAccordoNEW) == true){
  2636.                     throw new DriverRegistroServiziException("L'accordo di servizio ["+idAccordoNEW
  2637.                             +"] risulta gia' inserito nel registro dei servizi.");
  2638.                 } 
  2639.             }

  2641.             // Ri-Generazione XML
  2642.             this.generatoreXML.createAccordoServizioParteComune(idAccordoOLD,accordoServizio);

  2644.         }catch (Exception e) {
  2645.             throw new DriverRegistroServiziException("[updateAccordoServizioParteComune] Errore generatosi durante la modifica dell'accordo di servizio ["+idAccordoOLD+"]: "+e,e);
  2646.         }
  2647.     }

  2649.     /**
  2650.      * Elimina un AccordoServizio 
  2651.      *  
  2652.      * @param accordoServizio
  2653.      * @throws DriverRegistroServiziException
  2654.      */
  2655.     @Override
  2656.     public void deleteAccordoServizioParteComune(AccordoServizioParteComune accordoServizio) throws DriverRegistroServiziException{
  2657.         if( accordoServizio == null)
  2658.             throw new DriverRegistroServiziException("[deleteAccordoServizioParteComune] Parametro Non Valido");

  2660.         IDAccordo idAccordo = null;
  2661.         try {
  2662.             idAccordo = this.idAccordoFactory.getIDAccordoFromAccordo(accordoServizio);

  2664.             // Controllo id dell'accordo da eliminare
  2665.             if(accordoServizio.getNome()==null){
  2666.                 throw new DriverRegistroServiziException("Accordo Servizio Parte Comune da eliminare non definito");
  2667.             }

  2669.             // Controllo pre-esistenza dell'accordo da eliminare
  2670.             if( this.generatoreXML.existsAccordoServizioParteComune(idAccordo) == false){
  2671.                 throw new DriverRegistroServiziException("L'accordo di servizio ["+idAccordo
  2672.                         +"] non risulta gia' inserito nel registro dei servizi.");
  2673.             } 

  2675.             // Delete from Repository
  2676.             this.generatoreXML.deleteAccordoServizioParteComune(idAccordo);

  2678.         }catch (Exception e) {
  2679.             throw new DriverRegistroServiziException("[deleteAccordoServizioParteComune] Errore generatosi durante l'eliminazione dell'accordo di servizio ["+idAccordo+"]: "+e.getMessage(),e);
  2680.         }
  2681.     }





  2687.     /**
  2688.      * Crea una nuova Porta di Dominio 
  2689.      * 
  2690.      * @param pdd
  2691.      * @throws DriverRegistroServiziException
  2692.      */
  2693.     @Override
  2694.     public void createPortaDominio(PortaDominio pdd) throws DriverRegistroServiziException{
  2695.         if( pdd == null)
  2696.             throw new DriverRegistroServiziException("[createPortaDominio] Parametro Non Valido");

  2698.         try {

  2700.             // Controllo elementi obbligatori
  2701.             if( (pdd.getNome() == null) ){
  2702.                 throw new DriverRegistroServiziException("Porta di dominio non completamente definita nei parametri obbligatori");
  2703.             }

  2705.             // Controllo pre-esistenza della pdd
  2706.             if( this.generatoreXML.existsPortaDominio(pdd.getNome()) == true){
  2707.                 throw new DriverRegistroServiziException("La porta di dominio ["+pdd.getNome()
  2708.                         +"] risulta gia' inserita nel registro dei servizi.");
  2709.             } 

  2711.             // Generazione XML
  2712.             this.generatoreXML.createPortaDominio(pdd.getNome(),pdd);

  2714.         }catch (Exception e) {
  2715.             throw new DriverRegistroServiziException("[createPortaDominio] Errore generatosi durante la creazione di una nuova porta di dominio ["+pdd.getNome()+"]: "+e.getMessage(),e);
  2716.         }
  2717.     }

  2719.     /**
  2720.      * Verifica l'esistenza di una Porta di Dominio.
  2721.      *
  2722.      * @param nome della porta di dominio da verificare
  2723.      * @return true se la porta di dominio esiste, false altrimenti
  2724.      * @throws DriverRegistroServiziException
  2725.      */    
  2726.     @Override
  2727.     public boolean existsPortaDominio(String nome) throws DriverRegistroServiziException{
  2728.         if( nome == null)
  2729.             return false;

  2731.         try{
  2732.             return this.generatoreXML.existsPortaDominio(nome);
  2733.         }catch(Exception e){
  2734.             this.log.error("[existsPortaDominio] Porta di dominio non trovata: "+e.getMessage());
  2735.             return false;
  2736.         }
  2737.     }

  2739.     /**
  2740.      * Aggiorna la Porta di Dominio con i nuovi valori.
  2741.      *  
  2742.      * @param pdd
  2743.      * @throws DriverRegistroServiziException
  2744.      */
  2745.     @Override
  2746.     public void updatePortaDominio(PortaDominio pdd) throws DriverRegistroServiziException{
  2747.         if( pdd == null)
  2748.             throw new DriverRegistroServiziException("[updatePortaDominio] Parametro Non Valido");

  2750.         String pddOLD = null;
  2751.         //pddOLD = pdd.getOldNomeForUpdate();
  2752.         //if(pddOLD==null)
  2753.         pddOLD = pdd.getNome();

  2755.         try {

  2757.             // Controllo  dell'accordo da Modificare
  2758.             if(pddOLD==null){
  2759.                 throw new DriverRegistroServiziException("Porta di dominio da modificare non definita");
  2760.             }

  2762.             // Controllo elementi obbligatori dell'accordo modificato
  2763.             if( (pdd.getNome() == null) ){
  2764.                 throw new DriverRegistroServiziException("Porta di dominio modificata non completamente definita nei parametri obbligatori");
  2765.             }

  2767.             // Controllo pre-esistenza della pdd da modificare
  2768.             if( this.generatoreXML.existsPortaDominio(pddOLD) == false){
  2769.                 throw new DriverRegistroServiziException("La porta di dominio ["+pddOLD
  2770.                         +"] non risulta gia' inserita nel registro dei servizi.");
  2771.             } 

  2773.             // Controllo non esistenza della nuova identita della pdd (se da modificare)
  2774.             String pddNEW = pdd.getNome();
  2775.             if(pddOLD.equals(pddNEW) == false){
  2776.                 if( this.generatoreXML.existsPortaDominio(pddNEW) == true){
  2777.                     throw new DriverRegistroServiziException("La porta di dominio ["+pddNEW
  2778.                             +"] risulta gia' inserita nel registro dei servizi.");
  2779.                 } 
  2780.             }

  2782.             // Ri-Generazione XML
  2783.             this.generatoreXML.createPortaDominio(pddOLD,pdd);

  2785.         }catch (Exception e) {
  2786.             throw new DriverRegistroServiziException("[updatePortaDominio] Errore generatosi durante la modifica della porta di dominio ["+pddOLD+"]: "+e,e);
  2787.         }
  2788.     }

  2790.     /**
  2791.      * Elimina una Porta di Dominio 
  2792.      *  
  2793.      * @param pdd
  2794.      * @throws DriverRegistroServiziException
  2795.      */
  2796.     @Override
  2797.     public void deletePortaDominio(PortaDominio pdd) throws DriverRegistroServiziException{
  2798.         if( pdd == null)
  2799.             throw new DriverRegistroServiziException("[deletePortaDominio] Parametro Non Valido");

  2801.         try {
  2802.             // Controllo id dell'accordo da eliminare
  2803.             if(pdd.getNome()==null){
  2804.                 throw new DriverRegistroServiziException("Porta di dominio da eliminare non definita");
  2805.             }

  2807.             // Controllo pre-esistenza della porta di dominio da eliminare
  2808.             if( this.generatoreXML.existsPortaDominio(pdd.getNome()) == false){
  2809.                 throw new DriverRegistroServiziException("La porta di dominio ["+pdd.getNome()
  2810.                         +"] non risulta gia' inserita nel registro dei servizi.");
  2811.             } 

  2813.             // Delete from Repository
  2814.             this.generatoreXML.deletePortaDominio(pdd.getNome());

  2816.         }catch (Exception e) {
  2817.             throw new DriverRegistroServiziException("[deletePortaDominio] Errore generatosi durante l'eliminazione della porta di dominio ["+pdd.getNome()+"]: "+e.getMessage(),e);
  2818.         }
  2819.     }





  2825.     
  2826.     
  2827.     
  2828.     
  2829.     
  2830.     
  2831.     
  2832.     /**
  2833.      * Crea un nuovo Gruppo
  2834.      * 
  2835.      * @param gruppo
  2836.      * @throws DriverRegistroServiziException
  2837.      */
  2838.     @Override
  2839.     public void createGruppo(Gruppo gruppo) throws DriverRegistroServiziException{
  2840.         if( gruppo == null)
  2841.             throw new DriverRegistroServiziException("[createGruppo] Parametro Non Valido");

  2843.         try {

  2845.             // Controllo elementi obbligatori
  2846.             if( (gruppo.getNome() == null) ){
  2847.                 throw new DriverRegistroServiziException("Gruppo non completamente definita nei parametri obbligatori");
  2848.             }

  2850.             // Controllo pre-esistenza del gruppo
  2851.             if( this.generatoreXML.existsGruppo(gruppo.getNome()) == true){
  2852.                 throw new DriverRegistroServiziException("Il Gruppo ["+gruppo.getNome()
  2853.                         +"] risulta gia' inserita nel registro dei servizi.");
  2854.             } 

  2856.             // Generazione XML
  2857.             this.generatoreXML.createGruppo(gruppo.getNome(),gruppo);

  2859.         }catch (Exception e) {
  2860.             throw new DriverRegistroServiziException("[createGruppo] Errore generatosi durante la creazione di un nuovo gruppo ["+gruppo.getNome()+"]: "+e.getMessage(),e);
  2861.         }
  2862.     }
  2863.     
  2864.     /**
  2865.      * Verifica l'esistenza di un Gruppo
  2866.      *
  2867.      * @param idGruppo idGruppo del gruppo da verificare
  2868.      * @return true se il gruppo esiste, false altrimenti
  2869.      * @throws DriverRegistroServiziException
  2870.      */    
  2871.     @Override
  2872.     public boolean existsGruppo(IDGruppo idGruppo) throws DriverRegistroServiziException{
  2873.         if( idGruppo == null || idGruppo.getNome()==null)
  2874.             return false;

  2876.         try{
  2877.             return this.generatoreXML.existsGruppo(idGruppo.getNome());
  2878.         }catch(Exception e){
  2879.             this.log.error("[existsGruppo] Gruppo non trovato: "+e.getMessage());
  2880.             return false;
  2881.         }
  2882.     }
  2883.     
  2884.     /**
  2885.      * Aggiorna il Gruppo con i nuovi valori.
  2886.      *  
  2887.      * @param gruppo
  2888.      * @throws DriverRegistroServiziException
  2889.      */
  2890.     @Override
  2891.     public void updateGruppo(Gruppo gruppo) throws DriverRegistroServiziException{
  2892.         if( gruppo == null)
  2893.             throw new DriverRegistroServiziException("[updateGruppo] Parametro Non Valido");

  2895.         IDGruppo idGruppoOLD = null;
  2896.         //idGruppoOLD = gruppo.getOldIDGruppoForUpdate();
  2897.         //if(idGruppoOLD==null)
  2898.         idGruppoOLD = new IDGruppo(gruppo.getNome());

  2900.         try {

  2902.             // Controllo  dell'accordo da Modificare
  2903.             if(idGruppoOLD==null || idGruppoOLD.getNome()==null){
  2904.                 throw new DriverRegistroServiziException("Gruppo da modificare non definito");
  2905.             }

  2907.             // Controllo elementi obbligatori del gruppo modificato
  2908.             if( (gruppo.getNome() == null) ){
  2909.                 throw new DriverRegistroServiziException("Gruppo modificato non completamente definito nei parametri obbligatori");
  2910.             }

  2912.             // Controllo pre-esistenza del gruppo da modificare
  2913.             if( this.generatoreXML.existsGruppo(idGruppoOLD.getNome()) == false){
  2914.                 throw new DriverRegistroServiziException("Il Gruppo ["+idGruppoOLD
  2915.                         +"] non risulta gia' inserita nel registro dei servizi.");
  2916.             } 

  2918.             // Controllo non esistenza della nuova identita del gruppo (se da modificare)
  2919.             IDGruppo idGruppoNEW = new IDGruppo(gruppo.getNome());
  2920.             if(idGruppoOLD.equals(idGruppoNEW) == false){
  2921.                 if( this.generatoreXML.existsGruppo(idGruppoNEW.getNome()) == true){
  2922.                     throw new DriverRegistroServiziException("Il Gruppo ["+idGruppoNEW
  2923.                             +"] risulta gia' inserita nel registro dei servizi.");
  2924.                 } 
  2925.             }

  2927.             // Ri-Generazione XML
  2928.             this.generatoreXML.createGruppo(idGruppoOLD.getNome(),gruppo);

  2930.         }catch (Exception e) {
  2931.             throw new DriverRegistroServiziException("[updateGruppo] Errore generatosi durante la modifica della porta di dominio ["+idGruppoOLD+"]: "+e,e);
  2932.         }
  2933.     }
  2934.     
  2935.     /**
  2936.      * Elimina un Gruppo
  2937.      *  
  2938.      * @param gruppo
  2939.      * @throws DriverRegistroServiziException
  2940.      */
  2941.     @Override
  2942.     public void deleteGruppo(Gruppo gruppo) throws DriverRegistroServiziException{
  2943.         if( gruppo == null)
  2944.             throw new DriverRegistroServiziException("[deleteGruppo] Parametro Non Valido");

  2946.         try {
  2947.             // Controllo id del gruppo da eliminare
  2948.             if(gruppo.getNome()==null){
  2949.                 throw new DriverRegistroServiziException("Gruppo da eliminare non definito");
  2950.             }

  2952.             // Controllo pre-esistenza del gruppo da eliminare
  2953.             if( this.generatoreXML.existsGruppo(gruppo.getNome()) == false){
  2954.                 throw new DriverRegistroServiziException("Il Gruppo ["+gruppo.getNome()
  2955.                         +"] non risulta gia' inserito nel registro dei servizi.");
  2956.             } 

  2958.             // Delete from Repository
  2959.             this.generatoreXML.deleteGruppo(gruppo.getNome());

  2961.         }catch (Exception e) {
  2962.             throw new DriverRegistroServiziException("[deleteGruppo] Errore generatosi durante l'eliminazione del gruppo ["+gruppo.getNome()+"]: "+e.getMessage(),e);
  2963.         }
  2964.     }
  2965.     
  2966.     
  2967.     
  2968.     
  2969.     
  2970.     

  2972.     
  2973.     
  2974.     
  2975.     
  2976.     /**
  2977.      * Crea un nuovo Ruolo
  2978.      * 
  2979.      * @param ruolo
  2980.      * @throws DriverRegistroServiziException
  2981.      */
  2982.     @Override
  2983.     public void createRuolo(Ruolo ruolo) throws DriverRegistroServiziException{
  2984.         if( ruolo == null)
  2985.             throw new DriverRegistroServiziException("[createRuolo] Parametro Non Valido");

  2987.         try {

  2989.             // Controllo elementi obbligatori
  2990.             if( (ruolo.getNome() == null) ){
  2991.                 throw new DriverRegistroServiziException("Ruolo non completamente definita nei parametri obbligatori");
  2992.             }

  2994.             // Controllo pre-esistenza del ruolo
  2995.             if( this.generatoreXML.existsRuolo(ruolo.getNome()) == true){
  2996.                 throw new DriverRegistroServiziException("Il Ruolo ["+ruolo.getNome()
  2997.                         +"] risulta gia' inserita nel registro dei servizi.");
  2998.             } 

  3000.             // Generazione XML
  3001.             this.generatoreXML.createRuolo(ruolo.getNome(),ruolo);

  3003.         }catch (Exception e) {
  3004.             throw new DriverRegistroServiziException("[createRuolo] Errore generatosi durante la creazione di un nuovo ruolo ["+ruolo.getNome()+"]: "+e.getMessage(),e);
  3005.         }
  3006.     }
  3007.     
  3008.     /**
  3009.      * Verifica l'esistenza di un Ruolo
  3010.      *
  3011.      * @param idRuolo idRuolo del ruolo da verificare
  3012.      * @return true se il ruolo esiste, false altrimenti
  3013.      * @throws DriverRegistroServiziException
  3014.      */    
  3015.     @Override
  3016.     public boolean existsRuolo(IDRuolo idRuolo) throws DriverRegistroServiziException{
  3017.         if( idRuolo == null || idRuolo.getNome()==null)
  3018.             return false;

  3020.         try{
  3021.             return this.generatoreXML.existsRuolo(idRuolo.getNome());
  3022.         }catch(Exception e){
  3023.             this.log.error("[existsRuolo] Ruolo non trovato: "+e.getMessage());
  3024.             return false;
  3025.         }
  3026.     }
  3027.     
  3028.     /**
  3029.      * Aggiorna il Ruolo con i nuovi valori.
  3030.      *  
  3031.      * @param ruolo
  3032.      * @throws DriverRegistroServiziException
  3033.      */
  3034.     @Override
  3035.     public void updateRuolo(Ruolo ruolo) throws DriverRegistroServiziException{
  3036.         if( ruolo == null)
  3037.             throw new DriverRegistroServiziException("[updateRuolo] Parametro Non Valido");

  3039.         IDRuolo idRuoloOLD = null;
  3040.         //idRuoloOLD = ruolo.getOldIDRuoloForUpdate();
  3041.         //if(idRuoloOLD==null)
  3042.         idRuoloOLD = new IDRuolo(ruolo.getNome());

  3044.         try {

  3046.             // Controllo  dell'accordo da Modificare
  3047.             if(idRuoloOLD==null || idRuoloOLD.getNome()==null){
  3048.                 throw new DriverRegistroServiziException("Ruolo da modificare non definito");
  3049.             }

  3051.             // Controllo elementi obbligatori del ruolo modificato
  3052.             if( (ruolo.getNome() == null) ){
  3053.                 throw new DriverRegistroServiziException("Ruolo modificato non completamente definito nei parametri obbligatori");
  3054.             }

  3056.             // Controllo pre-esistenza del ruolo da modificare
  3057.             if( this.generatoreXML.existsRuolo(idRuoloOLD.getNome()) == false){
  3058.                 throw new DriverRegistroServiziException("Il Ruolo ["+idRuoloOLD
  3059.                         +"] non risulta gia' inserita nel registro dei servizi.");
  3060.             } 

  3062.             // Controllo non esistenza della nuova identita del ruolo (se da modificare)
  3063.             IDRuolo idRuoloNEW = new IDRuolo(ruolo.getNome());
  3064.             if(idRuoloOLD.equals(idRuoloNEW) == false){
  3065.                 if( this.generatoreXML.existsRuolo(idRuoloNEW.getNome()) == true){
  3066.                     throw new DriverRegistroServiziException("Il Ruolo ["+idRuoloNEW
  3067.                             +"] risulta gia' inserita nel registro dei servizi.");
  3068.                 } 
  3069.             }

  3071.             // Ri-Generazione XML
  3072.             this.generatoreXML.createRuolo(idRuoloOLD.getNome(),ruolo);

  3074.         }catch (Exception e) {
  3075.             throw new DriverRegistroServiziException("[updateRuolo] Errore generatosi durante la modifica della porta di dominio ["+idRuoloOLD+"]: "+e,e);
  3076.         }
  3077.     }
  3078.     
  3079.     /**
  3080.      * Elimina un Ruolo
  3081.      *  
  3082.      * @param ruolo
  3083.      * @throws DriverRegistroServiziException
  3084.      */
  3085.     @Override
  3086.     public void deleteRuolo(Ruolo ruolo) throws DriverRegistroServiziException{
  3087.         if( ruolo == null)
  3088.             throw new DriverRegistroServiziException("[deleteRuolo] Parametro Non Valido");

  3090.         try {
  3091.             // Controllo id del ruolo da eliminare
  3092.             if(ruolo.getNome()==null){
  3093.                 throw new DriverRegistroServiziException("Ruolo da eliminare non definito");
  3094.             }

  3096.             // Controllo pre-esistenza del ruolo da eliminare
  3097.             if( this.generatoreXML.existsRuolo(ruolo.getNome()) == false){
  3098.                 throw new DriverRegistroServiziException("Il Ruolo ["+ruolo.getNome()
  3099.                         +"] non risulta gia' inserito nel registro dei servizi.");
  3100.             } 

  3102.             // Delete from Repository
  3103.             this.generatoreXML.deleteRuolo(ruolo.getNome());

  3105.         }catch (Exception e) {
  3106.             throw new DriverRegistroServiziException("[deleteRuolo] Errore generatosi durante l'eliminazione del ruolo ["+ruolo.getNome()+"]: "+e.getMessage(),e);
  3107.         }
  3108.     }
  3109.     
  3110.     
  3111.     
  3112.     
  3113.     
  3114.     
  3115.     
  3116.     
  3117.     
  3118.     
  3119.     
  3120.     
  3121.     
  3122.     
  3123.     

  3125.     /**
  3126.      * Crea un nuovo Scope
  3127.      * 
  3128.      * @param scope
  3129.      * @throws DriverRegistroServiziException
  3130.      */
  3131.     @Override
  3132.     public void createScope(Scope scope) throws DriverRegistroServiziException{
  3133.         if( scope == null)
  3134.             throw new DriverRegistroServiziException("[createScope] Parametro Non Valido");

  3136.         try {

  3138.             // Controllo elementi obbligatori
  3139.             if( (scope.getNome() == null) ){
  3140.                 throw new DriverRegistroServiziException("Scope non completamente definita nei parametri obbligatori");
  3141.             }

  3143.             // Controllo pre-esistenza del scope
  3144.             if( this.generatoreXML.existsScope(scope.getNome()) == true){
  3145.                 throw new DriverRegistroServiziException("Il Scope ["+scope.getNome()
  3146.                         +"] risulta gia' inserita nel registro dei servizi.");
  3147.             } 

  3149.             // Generazione XML
  3150.             this.generatoreXML.createScope(scope.getNome(),scope);

  3152.         }catch (Exception e) {
  3153.             throw new DriverRegistroServiziException("[createScope] Errore generatosi durante la creazione di un nuovo scope ["+scope.getNome()+"]: "+e.getMessage(),e);
  3154.         }
  3155.     }
  3156.     
  3157.     /**
  3158.      * Verifica l'esistenza di un Scope
  3159.      *
  3160.      * @param idScope idScope del scope da verificare
  3161.      * @return true se il scope esiste, false altrimenti
  3162.      * @throws DriverRegistroServiziException
  3163.      */    
  3164.     @Override
  3165.     public boolean existsScope(IDScope idScope) throws DriverRegistroServiziException{
  3166.         if( idScope == null || idScope.getNome()==null)
  3167.             return false;

  3169.         try{
  3170.             return this.generatoreXML.existsScope(idScope.getNome());
  3171.         }catch(Exception e){
  3172.             this.log.error("[existsScope] Scope non trovato: "+e.getMessage());
  3173.             return false;
  3174.         }
  3175.     }
  3176.     
  3177.     /**
  3178.      * Aggiorna il Scope con i nuovi valori.
  3179.      *  
  3180.      * @param scope
  3181.      * @throws DriverRegistroServiziException
  3182.      */
  3183.     @Override
  3184.     public void updateScope(Scope scope) throws DriverRegistroServiziException{
  3185.         if( scope == null)
  3186.             throw new DriverRegistroServiziException("[updateScope] Parametro Non Valido");

  3188.         IDScope idScopeOLD = null;
  3189.         //idScopeOLD = scope.getOldIDScopeForUpdate();
  3190.         //if(idScopeOLD==null)
  3191.         idScopeOLD = new IDScope(scope.getNome());

  3193.         try {

  3195.             // Controllo  dell'accordo da Modificare
  3196.             if(idScopeOLD==null || idScopeOLD.getNome()==null){
  3197.                 throw new DriverRegistroServiziException("Scope da modificare non definito");
  3198.             }

  3200.             // Controllo elementi obbligatori del scope modificato
  3201.             if( (scope.getNome() == null) ){
  3202.                 throw new DriverRegistroServiziException("Scope modificato non completamente definito nei parametri obbligatori");
  3203.             }

  3205.             // Controllo pre-esistenza del scope da modificare
  3206.             if( this.generatoreXML.existsScope(idScopeOLD.getNome()) == false){
  3207.                 throw new DriverRegistroServiziException("Il Scope ["+idScopeOLD
  3208.                         +"] non risulta gia' inserita nel registro dei servizi.");
  3209.             } 

  3211.             // Controllo non esistenza della nuova identita del scope (se da modificare)
  3212.             IDScope idScopeNEW = new IDScope(scope.getNome());
  3213.             if(idScopeOLD.equals(idScopeNEW) == false){
  3214.                 if( this.generatoreXML.existsScope(idScopeNEW.getNome()) == true){
  3215.                     throw new DriverRegistroServiziException("Il Scope ["+idScopeNEW
  3216.                             +"] risulta gia' inserita nel registro dei servizi.");
  3217.                 } 
  3218.             }

  3220.             // Ri-Generazione XML
  3221.             this.generatoreXML.createScope(idScopeOLD.getNome(),scope);

  3223.         }catch (Exception e) {
  3224.             throw new DriverRegistroServiziException("[updateScope] Errore generatosi durante la modifica della porta di dominio ["+idScopeOLD+"]: "+e,e);
  3225.         }
  3226.     }
  3227.     
  3228.     /**
  3229.      * Elimina un Scope
  3230.      *  
  3231.      * @param scope
  3232.      * @throws DriverRegistroServiziException
  3233.      */
  3234.     @Override
  3235.     public void deleteScope(Scope scope) throws DriverRegistroServiziException{
  3236.         if( scope == null)
  3237.             throw new DriverRegistroServiziException("[deleteScope] Parametro Non Valido");

  3239.         try {
  3240.             // Controllo id del scope da eliminare
  3241.             if(scope.getNome()==null){
  3242.                 throw new DriverRegistroServiziException("Scope da eliminare non definito");
  3243.             }

  3245.             // Controllo pre-esistenza del scope da eliminare
  3246.             if( this.generatoreXML.existsScope(scope.getNome()) == false){
  3247.                 throw new DriverRegistroServiziException("Il Scope ["+scope.getNome()
  3248.                         +"] non risulta gia' inserito nel registro dei servizi.");
  3249.             } 

  3251.             // Delete from Repository
  3252.             this.generatoreXML.deleteScope(scope.getNome());

  3254.         }catch (Exception e) {
  3255.             throw new DriverRegistroServiziException("[deleteScope] Errore generatosi durante l'eliminazione del scope ["+scope.getNome()+"]: "+e.getMessage(),e);
  3256.         }
  3257.     }
  3258.     
  3259.     
  3260.     
  3261.     
  3262.     
  3263.     
  3264.     




  3269.     /**
  3270.      * Crea un nuovo Soggetto
  3271.      * 
  3272.      * @param soggetto
  3273.      * @throws DriverRegistroServiziException
  3274.      */
  3275.     @Override
  3276.     public void createSoggetto(Soggetto soggetto) throws DriverRegistroServiziException{
  3277.         if( soggetto == null)
  3278.             throw new DriverRegistroServiziException("[createSoggetto] Parametro Non Valido");

  3280.         try {
  3281.             // Controllo elementi obbligatori
  3282.             if( (soggetto.getNome() == null) || 
  3283.                     (soggetto.getTipo() == null) ){
  3284.                 throw new DriverRegistroServiziException("Soggetto non definito");
  3285.             }
  3286.             if(soggetto.getConnettore() !=null && !CostantiRegistroServizi.DISABILITATO.equals(soggetto.getConnettore().getTipo())){
  3287.                 boolean connettoreNonDefinito = false;
  3288.                 if( soggetto.getConnettore().getTipo() == null ){
  3289.                     connettoreNonDefinito = true;
  3290.                 }
  3291.                 if(connettoreNonDefinito){
  3292.                     throw new DriverRegistroServiziException("Definizione del punto di accesso del dominio del soggetto non corretta");
  3293.                 }
  3294.             }

  3296.             //  Definizione dati opzionali
  3297.             if( (soggetto.getIdentificativoPorta() == null) || ("".equals(soggetto.getIdentificativoPorta())) ){
  3298.                 soggetto.setIdentificativoPorta(soggetto.getNome() + "SPCoopIT");
  3299.             }
  3300.             if( (soggetto.getDescrizione() == null) ||  ("".equals(soggetto.getDescrizione())) ){
  3301.                 soggetto.setDescrizione("Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome());
  3302.             }
  3303.             IDSoggetto idSoggetto = new IDSoggetto(soggetto.getTipo(),soggetto.getNome(),soggetto.getIdentificativoPorta());
  3304. //          if( (soggetto.getCodiceIpa() == null) || ("".equals(soggetto.getCodiceIpa())) ){
  3305. //              // GESTIRE TRAMITE FACTORY?             
  3306. //              //soggetto.setCodiceIpa(SICAtoOpenSPCoopUtilities.buildIDSoggettoSica(idSoggetto,false));
  3307. //          }


  3310.             // Controllo pre-esistenza del soggetto
  3311.             String idSoggetto_string = soggetto.getTipo() + soggetto.getNome();
  3312.             if(this.generatoreXML.existsSoggetto(idSoggetto) == true){
  3313.                 throw new DriverRegistroServiziException("Il soggetto ["+idSoggetto_string
  3314.                         +"] risulta gia' inserito nel registro dei servizi.");
  3315.             } 


  3318.             // Generazione XML
  3319.             this.generatoreXML.createSoggetto(idSoggetto,soggetto);

  3321.         }catch (Exception e) {
  3322.             throw new DriverRegistroServiziException("[createSoggetto] Errore generatosi durante la creazione del nuovo Soggetto ["+soggetto.getTipo()+soggetto.getNome()+"]: "+e.getMessage(),e);
  3323.         }
  3324.     }

  3326.     /**
  3327.      * Verifica l'esistenza di un soggetto registrato.
  3328.      *
  3329.      * @param idSoggetto Identificativo del soggetto
  3330.      * @return true se il soggetto esiste, false altrimenti
  3331.      */    
  3332.     @Override
  3333.     public boolean existsSoggetto(IDSoggetto idSoggetto) throws DriverRegistroServiziException{
  3334.         if( idSoggetto == null)
  3335.             return false;
  3336.         try{
  3337.             return this.generatoreXML.existsSoggetto(idSoggetto);
  3338.         }catch(Exception e) {
  3339.             return false;
  3340.         }
  3341.     }

  3343.     /**
  3344.      * Aggiorna un Soggetto
  3345.      * 
  3346.      * @param soggetto
  3347.      * @throws DriverRegistroServiziException
  3348.      */
  3349.     @Override
  3350.     public void updateSoggetto(Soggetto soggetto) throws DriverRegistroServiziException{
  3351.         if( soggetto == null)
  3352.             throw new DriverRegistroServiziException("[updateSoggetto] Parametro Non Valido");

  3354.         String tipoOLD = null;
  3355.         String nomeOLD = null;
  3356.         if(soggetto.getOldIDSoggettoForUpdate()!=null){
  3357.             tipoOLD = soggetto.getOldIDSoggettoForUpdate().getTipo();
  3358.             nomeOLD = soggetto.getOldIDSoggettoForUpdate().getNome();
  3359.         }
  3360.         if(tipoOLD==null||nomeOLD==null){
  3361.             tipoOLD = soggetto.getTipo();
  3362.             nomeOLD = soggetto.getNome();
  3363.         }
  3364.         String idSoggettoOLD_string = tipoOLD + nomeOLD;
  3365.         IDSoggetto idSoggettoOLD = new IDSoggetto(tipoOLD,nomeOLD);

  3367.         try {

  3369.             // Controllo id del soggetto da Modificare
  3370.             if(tipoOLD==null || nomeOLD==null){
  3371.                 throw new DriverRegistroServiziException("Soggetto da modificare non definito");
  3372.             }

  3374.             // Controllo elementi obbligatori del soggetto modificato
  3375.             if( (soggetto.getNome() == null) || 
  3376.                     (soggetto.getTipo() == null) ){
  3377.                 throw new DriverRegistroServiziException("Soggetto modificato non definito");
  3378.             }
  3379.             if(soggetto.getConnettore() !=null && !CostantiRegistroServizi.DISABILITATO.equals(soggetto.getConnettore().getTipo())){
  3380.                 boolean connettoreNonDefinito = false;
  3381.                 if( soggetto.getConnettore().getTipo() == null ){
  3382.                     connettoreNonDefinito = true;
  3383.                 }
  3384.                 if(connettoreNonDefinito){
  3385.                     throw new DriverRegistroServiziException("Definizione del punto di accesso del dominio del soggetto non corretta");
  3386.                 }
  3387.             }

  3389.             // Definizione dati opzionali 
  3390.             if( (soggetto.getIdentificativoPorta() == null) || ("".equals(soggetto.getIdentificativoPorta())) ){
  3391.                 soggetto.setIdentificativoPorta(soggetto.getNome() + "SPCoopIT");
  3392.             }
  3393.             if( (soggetto.getDescrizione() == null) ||  ("".equals(soggetto.getDescrizione())) ){
  3394.                 soggetto.setDescrizione("Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome());
  3395.             }
  3396.             IDSoggetto idSoggettoNEW = new IDSoggetto(soggetto.getTipo(),soggetto.getNome());
  3397. //          if( (soggetto.getCodiceIpa() == null) || ("".equals(soggetto.getCodiceIpa())) ){
  3398. //              // GESTIRE TRAMITE FACTORY?             
  3399. //              //soggetto.setCodiceIpa(SICAtoOpenSPCoopUtilities.buildIDSoggettoSica(idSoggettoNEW,false));
  3400. //          }

  3402.             // Controllo pre-esistenza del soggetto da modificare
  3403.             if( this.generatoreXML.existsSoggetto(idSoggettoOLD) == false){
  3404.                 throw new DriverRegistroServiziException("Il soggetto ["+idSoggettoOLD_string
  3405.                         +"] non risulta gia' inserito nel registro dei servizi.");
  3406.             } 

  3408.             // Controllo non esistenza della nuova identita del soggetto (se da modificare)
  3409.             String idSoggettoNEW_string = soggetto.getTipo() + soggetto.getNome();
  3410.             if(idSoggettoOLD_string.equals(idSoggettoNEW_string) == false){
  3411.                 if( this.generatoreXML.existsSoggetto(idSoggettoNEW) == true){
  3412.                     throw new DriverRegistroServiziException("La nuova identita da associare al soggetto ["+idSoggettoNEW_string
  3413.                             +"] risulta gia' utilizzata nel registro dei servizi.");
  3414.                 } 
  3415.             }

  3417.             // Ri-Generazione XML
  3418.             this.generatoreXML.createSoggetto(idSoggettoOLD,soggetto);

  3420.         }catch (Exception e) {
  3421.             throw new DriverRegistroServiziException("[updateSoggetto] Errore generatosi durante la modifica del Soggetto ["+idSoggettoOLD+"]: "+e.getMessage(),e);
  3422.         }
  3423.     }

  3425.     /**
  3426.      * Cancella un Soggetto
  3427.      * 
  3428.      * @param soggetto
  3429.      * @throws DriverRegistroServiziException
  3430.      */
  3431.     @Override
  3432.     public void deleteSoggetto(Soggetto soggetto) throws DriverRegistroServiziException{
  3433.         if( soggetto == null)
  3434.             throw new DriverRegistroServiziException("[deleteSoggetto] Parametro Non Valido");

  3436.         try {
  3437.             // Controllo id del soggetto da eliminare
  3438.             if(soggetto.getTipo()==null || soggetto.getNome()==null){
  3439.                 throw new DriverRegistroServiziException("Soggetto da eliminare non definito");
  3440.             }

  3442.             // Controllo pre-esistenza del soggetto da modificare
  3443.             IDSoggetto idSoggetto = new IDSoggetto(soggetto.getTipo(),soggetto.getNome());
  3444.             if( this.generatoreXML.existsSoggetto(idSoggetto) == false){
  3445.                 throw new DriverRegistroServiziException("Il soggetto ["+idSoggetto
  3446.                         +"] non risulta gia' inserito nel registro dei servizi.");
  3447.             } 

  3449.             // Delete from Repository
  3450.             this.generatoreXML.deleteSoggetto(idSoggetto);

  3452.         }catch (Exception e) {
  3453.             throw new DriverRegistroServiziException("[deleteSoggetto] Errore generatosi durante l'eliminazione del Soggetto ["+soggetto.getTipo()+soggetto.getNome()+"]: "+e.getMessage(),e);
  3454.         }
  3455.     }







  3463.     /**
  3464.      * Crea un Accordo Servizio Parte Specifica
  3465.      * 
  3466.      * @param asps
  3467.      * @throws DriverRegistroServiziException
  3468.      */
  3469.     @Override
  3470.     public void createAccordoServizioParteSpecifica(AccordoServizioParteSpecifica asps) throws DriverRegistroServiziException{
  3471.         
  3472.         if( asps == null)
  3473.             throw new DriverRegistroServiziException("[createAccordoServizioParteSpecifica] Parametro Non Valido");
  3474.         
  3475.         try {
  3476.             // Controllo elementi obbligatori
  3477.             if( (asps.getNomeSoggettoErogatore() == null) || 
  3478.                     (asps.getTipoSoggettoErogatore() == null) ){
  3479.                 throw new DriverRegistroServiziException("Soggetto, erogatore del servizio, non definito");
  3480.             }
  3481.             if( (asps.getNome() == null) || 
  3482.                     (asps.getTipo() == null)  || 
  3483.                     (asps.getVersione() == null)  ){
  3484.                 throw new DriverRegistroServiziException("Accordo Servizio Parte Specifica, non definito");
  3485.             }
  3486.             if(asps.getAccordoServizioParteComune()==null){
  3487.                 throw new DriverRegistroServiziException("Accordo di Servizio, da associare al servizio, non definito");
  3488.             }
  3489.             if(asps.getConfigurazioneServizio()!=null && asps.getConfigurazioneServizio().getConnettore() !=null && 
  3490.                     !CostantiRegistroServizi.DISABILITATO.equals(asps.getConfigurazioneServizio().getConnettore().getTipo())){
  3491.                 boolean connettoreNonDefinito = false;
  3492.                 if( asps.getConfigurazioneServizio().getConnettore().getTipo() == null ){
  3493.                     connettoreNonDefinito = true;
  3494.                 }
  3495.                 if(connettoreNonDefinito){
  3496.                     throw new DriverRegistroServiziException("Definizione del punto di accesso del dominio del servizio non corretta");
  3497.                 }
  3498.             }
  3499.             for(int i=0;i<asps.sizeFruitoreList();i++){
  3500.                 Fruitore checkFr = asps.getFruitore(i);
  3501.                 if( (checkFr.getNome()==null) || (checkFr.getTipo()==null)){
  3502.                     throw new DriverRegistroServiziException("Definizione di un fruitore senza nome o tipo");
  3503.                 }
  3504.                 for(int j=0;j<checkFr.sizeConfigurazioneAzioneList();j++){
  3505.                     ConfigurazioneServizioAzione checkAz = checkFr.getConfigurazioneAzione(i);
  3506.                     if( (checkAz.sizeAzioneList()<=0) || (checkAz.getConnettore()==null)){
  3507.                         throw new DriverRegistroServiziException("Definizione di un azione senza nome o connettore");
  3508.                     }
  3509.                     // controllo connettore
  3510.                     if(checkAz.getConnettore() !=null && !CostantiRegistroServizi.DISABILITATO.equals(checkAz.getConnettore().getTipo())){
  3511.                         boolean connettoreNonDefinito = false;
  3512.                         if( checkAz.getConnettore().getTipo() == null ){
  3513.                             connettoreNonDefinito = true;
  3514.                         }
  3515.                         if(connettoreNonDefinito){
  3516.                             throw new DriverRegistroServiziException("Definizione del punto di accesso dell'azione "+checkAz.getAzioneList()+" della fruizione del servizio non corretta");
  3517.                         }
  3518.                     }
  3519.                 }
  3520.                 // Controllo pre-esistenza del soggetto fruitore
  3521.                 String idSoggettoFruitore_string = checkFr.getTipo() + checkFr.getNome();
  3522.                 IDSoggetto idSoggettoFruitore = new IDSoggetto(checkFr.getTipo(),checkFr.getNome());
  3523.                 if( this.generatoreXML.existsSoggetto(idSoggettoFruitore) == false){
  3524.                     throw new DriverRegistroServiziException("Il fruitore ["+idSoggettoFruitore_string
  3525.                             +"] non risulta gia' inserito nel registro dei servizi.");
  3526.                 } 
  3527.             }
  3528.             if(asps.getConfigurazioneServizio()!=null){
  3529.                 for(int i=0;i<asps.getConfigurazioneServizio().sizeConfigurazioneAzioneList();i++){
  3530.                     ConfigurazioneServizioAzione checkAz = asps.getConfigurazioneServizio().getConfigurazioneAzione(i);
  3531.                     if( (checkAz.sizeAzioneList()<=0) || (checkAz.getConnettore()==null)){
  3532.                         throw new DriverRegistroServiziException("Definizione di un azione senza nome o connettore");
  3533.                     }
  3534.                     // controllo connettore
  3535.                     if(checkAz.getConnettore() !=null && !CostantiRegistroServizi.DISABILITATO.equals(checkAz.getConnettore().getTipo())){
  3536.                         boolean connettoreNonDefinito = false;
  3537.                         if( checkAz.getConnettore().getTipo() == null ){
  3538.                             connettoreNonDefinito = true;
  3539.                         }
  3540.                         if(connettoreNonDefinito){
  3541.                             throw new DriverRegistroServiziException("Definizione del punto di accesso dell'azione "+checkAz.getAzioneList()+" del servizio non corretta");
  3542.                         }
  3543.                     }
  3544.                 }
  3545.             }

  3547.             // Controllo pre-esistenza del soggetto erogatore
  3548.             IDSoggetto idSoggettoErogatore = new IDSoggetto(asps.getTipoSoggettoErogatore(),asps.getNomeSoggettoErogatore());
  3549.             String idSoggettoErogatore_string = asps.getTipoSoggettoErogatore()+asps.getNomeSoggettoErogatore();
  3550.             if( this.generatoreXML.existsSoggetto(idSoggettoErogatore) == false){
  3551.                 throw new DriverRegistroServiziException("Il soggetto ["+idSoggettoErogatore_string
  3552.                         +"] non risulta gia' inserito nel registro dei servizi.");
  3553.             } 

  3555.             // Controllo pre-esistenza del servizio
  3556.             String idServizio_string = asps.getTipo() + asps.getNome() + asps.getVersione();
  3557.             IDServizio idServizio = this.idServizioFactory.getIDServizioFromAccordo(asps);
  3558.             if (this.generatoreXML.existsAccordoServizioParteSpecifica(idServizio)==true){
  3559.                 throw new DriverRegistroServiziException("Il servizio ["+idServizio_string+"] erogato dal soggetto ["+idSoggettoErogatore_string+"] risulta gia' registrato nel registro");
  3560.             }

  3562.             // Generazione XML
  3563.             this.generatoreXML.createAccordoServizioParteSpecifica(idServizio,asps);

  3565.         }catch (Exception e) {
  3566.             throw new DriverRegistroServiziException("[createAccordoServizioParteSpecifica] Errore generatosi durante la creazione del nuovo Servizio ["+
  3567.                     this.idServizioFactory.getIDServizioFromAccordo(asps)+"]: "+e.getMessage(),e);
  3568.         }
  3569.     }


  3572.     /**
  3573.      * Verifica l'esistenza di un servizio registrato.
  3574.      *
  3575.      * @param idServizio Identificativo del servizio
  3576.      * @return true se il servizio esiste, false altrimenti
  3577.      */    
  3578.     @Override
  3579.     public boolean existsAccordoServizioParteSpecifica(IDServizio idServizio) throws DriverRegistroServiziException{
  3580.         
  3581.         if( idServizio == null)
  3582.             return false;

  3584.         try{
  3585.             this.getAccordoServizioParteSpecifica(idServizio);

  3587.             return true;
  3588.         }catch(DriverRegistroServiziNotFound notFound){
  3589.             return false;
  3590.         }
  3591.         catch(Exception e){
  3592.             this.log.error("[existsAccordoServizioParteSpecifica] Servizio non trovato: "+e.getMessage());
  3593.             return false;
  3594.         }
  3595.     }
  3596.         
  3597.         
  3598.         
  3599.         
  3600.         
  3601.     /**
  3602.      * Aggiorna un Accordo Servizio Parte Specifica
  3603.      * 
  3604.      * @param asps
  3605.      * @throws DriverRegistroServiziException
  3606.      */
  3607.     @Override
  3608.     public void updateAccordoServizioParteSpecifica(AccordoServizioParteSpecifica asps) throws DriverRegistroServiziException{
  3609.         if( asps == null)
  3610.             throw new DriverRegistroServiziException("[updateAccordoServizioParteSpecifica] Parametro Non Valido");
  3611.         
  3612.         String tipoServizioOLD = null;
  3613.         String nomeServizioOLD = null;
  3614.         Integer versioneServizioOLD = null;
  3615.         if(asps.getOldIDServizioForUpdate()!=null){
  3616.             tipoServizioOLD = asps.getOldIDServizioForUpdate().getTipo();
  3617.             nomeServizioOLD = asps.getOldIDServizioForUpdate().getNome();
  3618.             versioneServizioOLD = asps.getOldIDServizioForUpdate().getVersione();
  3619.         }
  3620.         if(tipoServizioOLD==null||nomeServizioOLD==null||versioneServizioOLD==null){
  3621.             tipoServizioOLD = asps.getTipo();
  3622.             nomeServizioOLD = asps.getNome();
  3623.             versioneServizioOLD = asps.getVersione();
  3624.         }
  3625.         String tipoSoggettoOLD = null;
  3626.         String nomeSoggettoOLD = null;
  3627.         if(asps.getOldIDServizioForUpdate()!=null && asps.getOldIDServizioForUpdate().getSoggettoErogatore()!=null){
  3628.             tipoSoggettoOLD = asps.getOldIDServizioForUpdate().getSoggettoErogatore().getTipo();
  3629.             nomeSoggettoOLD = asps.getOldIDServizioForUpdate().getSoggettoErogatore().getNome();
  3630.         }
  3631.         if(tipoSoggettoOLD==null||nomeSoggettoOLD==null){
  3632.             tipoSoggettoOLD = asps.getTipoSoggettoErogatore();
  3633.             nomeSoggettoOLD = asps.getNomeSoggettoErogatore();
  3634.         }
  3635.         String idSoggettoOLD_string = tipoSoggettoOLD+nomeSoggettoOLD;
  3636.         IDSoggetto idSoggettoOLD = new IDSoggetto(tipoSoggettoOLD,nomeSoggettoOLD);
  3637.         String idServizioOLD_string = tipoServizioOLD + nomeServizioOLD+versioneServizioOLD;
  3638.         IDServizio idServizioOLD = this.idServizioFactory.getIDServizioFromValues(tipoServizioOLD,nomeServizioOLD, idSoggettoOLD, versioneServizioOLD);

  3640.         try {

  3642.             // Controllo elementi obbligatori
  3643.             // vecchio ID Soggetto
  3644.             if( (tipoSoggettoOLD == null) || 
  3645.                     (nomeSoggettoOLD == null) ){
  3646.                 throw new DriverRegistroServiziException("Soggetto da modificare, erogatore del servizio, non definito");
  3647.             }
  3648.             // nuovo ID Soggetto
  3649.             if( (asps.getTipoSoggettoErogatore() == null) || 
  3650.                     (asps.getNomeSoggettoErogatore() == null) ){
  3651.                 throw new DriverRegistroServiziException("Soggetto, erogatore del servizio, non definito");
  3652.             }
  3653.             // vecchio ID Servizio
  3654.             if( (tipoServizioOLD == null) || 
  3655.                     (nomeServizioOLD == null) ){
  3656.                 throw new DriverRegistroServiziException("Servizio da modificare non definito");
  3657.             }
  3658.             // nuovo ID Servizio
  3659.             if( (asps.getNome() == null) || 
  3660.                     (asps.getTipo() == null) || 
  3661.                     (asps.getVersione() == null) ){
  3662.                 throw new DriverRegistroServiziException("Dati del nuovo servizio, non definiti");
  3663.             }
  3664.             // accordo
  3665.             if(asps.getAccordoServizioParteComune()==null){
  3666.                 throw new DriverRegistroServiziException("Accordo di Servizio, da associare al servizio, non definito");
  3667.             }
  3668.             // connettore
  3669.             if(asps.getConfigurazioneServizio()!=null && asps.getConfigurazioneServizio().getConnettore() !=null && 
  3670.                     !CostantiRegistroServizi.DISABILITATO.equals(asps.getConfigurazioneServizio().getConnettore().getTipo())){
  3671.                 boolean connettoreNonDefinito = false;
  3672.                 if( asps.getConfigurazioneServizio().getConnettore().getTipo() == null ){
  3673.                     connettoreNonDefinito = true;
  3674.                 }
  3675.                 if(connettoreNonDefinito){
  3676.                     throw new DriverRegistroServiziException("Definizione del punto di accesso del dominio del servizio non corretta");
  3677.                 }
  3678.             }
  3679.             // fruitori
  3680.             for(int i=0;i<asps.sizeFruitoreList();i++){
  3681.                 Fruitore checkFr = asps.getFruitore(i);
  3682.                 if( (checkFr.getNome()==null) || (checkFr.getTipo()==null)){
  3683.                     throw new DriverRegistroServiziException("Definizione di un fruitore senza nome o tipo");
  3684.                 }
  3685.                 for(int j=0;j<checkFr.sizeConfigurazioneAzioneList();j++){
  3686.                     ConfigurazioneServizioAzione checkAz = checkFr.getConfigurazioneAzione(j);
  3687.                     if( (checkAz.sizeAzioneList()<=0) || (checkAz.getConnettore()==null)){
  3688.                         throw new DriverRegistroServiziException("Definizione di un fruitore senza nome o connettore");
  3689.                     }
  3690.                     // controllo connettore
  3691.                     if(checkAz.getConnettore() !=null && !CostantiRegistroServizi.DISABILITATO.equals(checkAz.getConnettore().getTipo())){
  3692.                         boolean connettoreNonDefinito = false;
  3693.                         if( checkAz.getConnettore().getTipo() == null ){
  3694.                             connettoreNonDefinito = true;
  3695.                         }
  3696.                         if(connettoreNonDefinito){
  3697.                             throw new DriverRegistroServiziException("Definizione del punto di accesso dell'azione "+checkAz.getAzioneList()+" della fruizione del servizio non corretta");
  3698.                         }
  3699.                     }
  3700.                 }
  3701.                 // Controllo pre-esistenza del soggetto fruitore
  3702.                 /*String idSoggettoFruitore_string = checkFr.getTipo() + checkFr.getNome();
  3703.                 IDSoggetto idSoggettoFruitore = new IDSoggetto(checkFr.getTipo(),checkFr.getNome());
  3704.                 if( this.generatoreXML.existsSoggetto(idSoggettoFruitore) == false){
  3705.                     throw new DriverRegistroServiziException("Il fruitore ["+idSoggettoFruitore_string
  3706.                     +"] non risulta gia' inserito nel registro dei servizi.");
  3707.                 } */
  3708.             }
  3709.             // azioni-fruitori-connettori
  3710.             if(asps.getConfigurazioneServizio()!=null){
  3711.                 for(int i=0;i<asps.getConfigurazioneServizio().sizeConfigurazioneAzioneList();i++){
  3712.                     ConfigurazioneServizioAzione checkAz = asps.getConfigurazioneServizio().getConfigurazioneAzione(i);
  3713.                     if( (checkAz.sizeAzioneList()<=0) || (checkAz.getConnettore()==null)){
  3714.                         throw new DriverRegistroServiziException("Definizione di un fruitore senza nome o connettore");
  3715.                     }
  3716.                     // controllo connettore
  3717.                     if(checkAz.getConnettore() !=null && !CostantiRegistroServizi.DISABILITATO.equals(checkAz.getConnettore().getTipo())){
  3718.                         boolean connettoreNonDefinito = false;
  3719.                         if( checkAz.getConnettore().getTipo() == null ){
  3720.                             connettoreNonDefinito = true;
  3721.                         }
  3722.                         if(connettoreNonDefinito){
  3723.                             throw new DriverRegistroServiziException("Definizione del punto di accesso dell'azione "+checkAz.getAzioneList()+" del servizio non corretta");
  3724.                         }
  3725.                     }
  3726.                 }
  3727.             }


  3730.             // Controllo pre-esistenza del soggetto erogatore da modificare
  3731.             if( this.generatoreXML.existsSoggetto(idSoggettoOLD) == false){
  3732.                 throw new DriverRegistroServiziException("Il soggetto ["+idSoggettoOLD_string
  3733.                         +"] da modificare, non risulta gia' inserito nel registro dei servizi.");
  3734.             } 

  3736.             // Controllo pre-esistenza del nuovo soggetto erogatore
  3737.             String idSoggettoNEW_string = asps.getTipoSoggettoErogatore() + asps.getNomeSoggettoErogatore();
  3738.             IDSoggetto idSoggettoNEW = new IDSoggetto(asps.getTipoSoggettoErogatore(),asps.getNomeSoggettoErogatore());
  3739.             if( idSoggettoOLD_string.equals(idSoggettoNEW_string) == false ){
  3740.                 if( this.generatoreXML.existsSoggetto(idSoggettoNEW) == false){
  3741.                     throw new DriverRegistroServiziException("Il soggetto ["+idSoggettoNEW_string
  3742.                             +"] a cui re-assegnare il servizio, non risulta gia' inserito nel registro dei servizi.");
  3743.                 } 
  3744.             }

  3746.             // Controllo pre-esistenza del servizio da modificare
  3747.             if (this.generatoreXML.existsAccordoServizioParteSpecifica(idServizioOLD)==false){
  3748.                 throw new DriverRegistroServiziException("Il servizio ["+idServizioOLD_string+"] erogato dal soggetto ["+idSoggettoOLD_string+"] non risulta gia' registrato nel registro");
  3749.             }

  3751.             // check esistenza nuovo servizio
  3752.             IDServizio idServizioNEW = this.idServizioFactory.getIDServizioFromValues(asps.getTipo(),asps.getNome(), idSoggettoNEW, asps.getVersione());
  3753.             String idServizioNEW_string = asps.getTipo() + asps.getNome() + asps.getVersione();
  3754.             if((idServizioOLD_string.equals(idServizioNEW_string) == false) || (idSoggettoOLD_string.equals(idSoggettoNEW_string) == false)){
  3755.                 // Controllo non esistenza del servizio da creare
  3756.                 if (this.generatoreXML.existsAccordoServizioParteSpecifica(idServizioNEW)==true){
  3757.                     throw new DriverRegistroServiziException("Il servizio ["+idServizioNEW_string+"] erogato dal soggetto ["+idSoggettoNEW_string+"] risulta gia' registrato nel registro");
  3758.                 }
  3759.             }


  3762.             if( idSoggettoOLD_string.equals(idSoggettoNEW_string) == true ){
  3763.                 // NON e' CAMBIATO IL SOGGETTO EROGATORE.

  3765.                 // Ri-Generazione XML
  3766.                 this.generatoreXML.createAccordoServizioParteSpecifica(idServizioOLD,asps);

  3768.             }else{
  3769.                 // E' CAMBIATO IL SOGGETTO EROGATORE

  3771.                 // Delete from Repository
  3772.                 this.generatoreXML.deleteAccordoServizioParteSpecifica(idServizioOLD);

  3774.                 // Generazione XML
  3775.                 this.generatoreXML.createAccordoServizioParteSpecifica(idServizioNEW,asps);

  3777.             }

  3779.         }catch (Exception e) {
  3780.             throw new DriverRegistroServiziException("[updateAccordoServizioParteSpecifica] Errore generatosi durante la modifica del Servizio ["+idServizioOLD_string+"] erogato dal soggetto ["+
  3781.                     idSoggettoOLD_string+"]: "+e.getMessage(),e);
  3782.         }
  3783.     }


  3786.     /**
  3787.      * Cancella un Accordo Servizio Parte Specifica
  3788.      * 
  3789.      * @param asps
  3790.      * @throws DriverRegistroServiziException
  3791.      */
  3792.     @Override
  3793.     public void deleteAccordoServizioParteSpecifica(AccordoServizioParteSpecifica asps) throws DriverRegistroServiziException{
  3794.         
  3795.         if( asps == null)
  3796.             throw new DriverRegistroServiziException("[deleteAccordoServizioParteSpecifica] Parametro Non Valido");
  3797.         
  3798.         
  3799.         String idSoggetto_string = asps.getTipoSoggettoErogatore() + asps.getNomeSoggettoErogatore();
  3800.         String idServizio_string = asps.getTipo() + asps.getNome()+ asps.getVersione();

  3802.         try {
  3803.             // Controllo id del soggetto 
  3804.             if(asps.getTipoSoggettoErogatore()==null || asps.getNomeSoggettoErogatore()==null){
  3805.                 throw new DriverRegistroServiziException("Soggetto non definito");
  3806.             }
  3807.             // Controllo id del servizio da eliminare
  3808.             if(asps.getTipo()==null || asps.getNome()==null || asps.getVersione()==null){
  3809.                 throw new DriverRegistroServiziException("Servizio da eliminare non definito");
  3810.             }
  3811.             // Controllo pre-esistenza del soggetto
  3812.             IDSoggetto idSoggetto = new IDSoggetto(asps.getTipoSoggettoErogatore(),asps.getNomeSoggettoErogatore());
  3813.             if( this.generatoreXML.existsSoggetto(idSoggetto) == false){
  3814.                 throw new DriverRegistroServiziException("Il soggetto ["+idSoggetto_string
  3815.                         +"] non risulta gia' inserito nel registro dei servizi.");
  3816.             } 
  3817.             // Controllo pre-esistenza del servizio
  3818.             IDServizio idServizio = this.idServizioFactory.getIDServizioFromValues(asps.getTipo(),asps.getNome(), idSoggetto, asps.getVersione());
  3819.             if (this.generatoreXML.existsAccordoServizioParteSpecifica(idServizio)==false){
  3820.                 throw new DriverRegistroServiziException("Il servizio ["+idServizio_string+"] erogato dal soggetto ["+idSoggetto_string+"] non risulta gia' registrato nel registro");
  3821.             }

  3823.             // Delete from Repository
  3824.             this.generatoreXML.deleteAccordoServizioParteSpecifica(idServizio);

  3826.         }catch (Exception e) {
  3827.             throw new DriverRegistroServiziException("[deleteAccordoServizioParteSpecifica] Errore generatosi durante l'eliminazione del Servizio ["+idServizio_string
  3828.                     +"] erogato dal soggetto ["+idSoggetto_string+"]: "+e.getMessage(),e);
  3829.         }
  3830.     }

  3832.     
  3833.     

  3835.     //RESET
  3836.     @Override
  3837.     public void reset() throws DriverRegistroServiziException{
  3838.         try{
  3839.             AccordoServizioParteComune[] accordiRegistrati = this.generatoreXML.getAccordiServizioParteComune();
  3840.             if(accordiRegistrati!=null){
  3841.                 for(int i=0; i<accordiRegistrati.length;i++){
  3842.                     this.log.info("eliminazione accordo di servizio ["+this.idAccordoFactory.getUriFromAccordo(accordiRegistrati[i])+"] in corso...");
  3843.                     this.deleteAccordoServizioParteComune(accordiRegistrati[i]);
  3844.                     this.log.info("eliminazione accordo di servizio ["+this.idAccordoFactory.getUriFromAccordo(accordiRegistrati[i])+"] effettuata.");
  3845.                 }
  3846.             }
  3847.         }catch (Exception e) {
  3848.             throw new DriverRegistroServiziException("Errore durante la cancellazione degli accordi registrati: "+e.getMessage(),e);
  3849.         }
  3850.         try{
  3851.             AccordoCooperazione[] accordiCooperazioneRegistrati = this.generatoreXML.getAccordiCooperazione();
  3852.             if(accordiCooperazioneRegistrati!=null){
  3853.                 for(int i=0; i<accordiCooperazioneRegistrati.length;i++){
  3854.                     this.log.info("eliminazione accordo di cooperazione ["+this.idAccordoCooperazioneFactory.getUriFromAccordo(accordiCooperazioneRegistrati[i])+"] in corso...");
  3855.                     this.deleteAccordoCooperazione(accordiCooperazioneRegistrati[i]);
  3856.                     this.log.info("eliminazione accordo di cooperazione ["+this.idAccordoCooperazioneFactory.getUriFromAccordo(accordiCooperazioneRegistrati[i])+"] effettuata.");
  3857.                 }
  3858.             }
  3859.         }catch (Exception e) {
  3860.             throw new DriverRegistroServiziException("Errore durante la cancellazione degli accordi di cooperazione registrati: "+e.getMessage(),e);
  3861.         }
  3862.         try{
  3863.             AccordoServizioParteSpecifica[] serviziRegistrati = this.generatoreXML.getAccordiServiziParteSpecifica();
  3864.             if(serviziRegistrati!=null){
  3865.                 for(int i=0; i<serviziRegistrati.length;i++){
  3866.                     this.log.info("eliminazione servizio ["+this.idServizioFactory.getUriFromAccordo(serviziRegistrati[i])+"] in corso...");
  3867.                     this.deleteAccordoServizioParteSpecifica(serviziRegistrati[i]);
  3868.                     this.log.info("eliminazione servizio ["+this.idServizioFactory.getUriFromAccordo(serviziRegistrati[i])+"] effettuata.");
  3869.                 }
  3870.             }
  3871.         }catch (Exception e) {
  3872.             throw new DriverRegistroServiziException("Errore durante la cancellazione dei servizi registrati: "+e.getMessage(),e);
  3873.         }
  3874.         try{
  3875.             Soggetto[] soggettiRegistrati = this.generatoreXML.getSoggetti();
  3876.             if(soggettiRegistrati!=null){
  3877.                 for(int i=0; i<soggettiRegistrati.length;i++){
  3878.                     this.log.info("eliminazione soggetto ["+soggettiRegistrati[i].getTipo()+"/"+soggettiRegistrati[i].getNome()+"] in corso...");
  3879.                     this.deleteSoggetto(soggettiRegistrati[i]);
  3880.                     this.log.info("eliminazione soggetto ["+soggettiRegistrati[i].getTipo()+"/"+soggettiRegistrati[i].getNome()+"] effettuata.");
  3881.                 }
  3882.             }
  3883.         }catch (Exception e) {
  3884.             throw new DriverRegistroServiziException("Errore durante la cancellazione dei soggetti registrati: "+e.getMessage(),e);
  3885.         }
  3886.         try{
  3887.             PortaDominio[] pddRegistrate = this.generatoreXML.getPorteDominio();
  3888.             if(pddRegistrate!=null){
  3889.                 for(int i=0; i<pddRegistrate.length;i++){
  3890.                     this.log.info("eliminazione porta di dominio ["+pddRegistrate[i].getNome()+"] in corso...");
  3891.                     this.deletePortaDominio(pddRegistrate[i]);
  3892.                     this.log.info("eliminazione porta di dominio ["+pddRegistrate[i].getNome()+"] effettuata.");
  3893.                 }
  3894.             }
  3895.         }catch (Exception e) {
  3896.             throw new DriverRegistroServiziException("Errore durante la cancellazione delle porte di dominio registrate: "+e.getMessage(),e);
  3897.         }
  3898.     }
  3899.     
  3900.     //RESET PDD CONSOLE
  3901.     public void resetCtrlstat() throws DriverRegistroServiziException{
  3902.         return;
  3903.     }


  3906.     /**
  3907.      * Metodo che verica la connessione ad una risorsa.
  3908.      * Se la connessione non e' presente, viene lanciata una eccezione che contiene il motivo della mancata connessione
  3909.      * 
  3910.      * @throws DriverException eccezione che contiene il motivo della mancata connessione
  3911.      */
  3912.     @Override
  3913.     public void isAlive() throws CoreException{

  3915.         if(this.create==false)
  3916.             throw new CoreException("Driver non inizializzato");

  3918.         String urlVerifica = this.urlPrefix + CostantiRegistroServizi.URL_SEPARATOR;
  3919.         try{
  3920.             byte[] dir = HttpUtilities.requestHTTPFile(urlVerifica);
  3921.             if(dir==null)
  3922.                 throw new Exception("Directory accordi richiesta non ritornata");
  3923.         }catch(Exception e){
  3924.             throw new CoreException("Connessione al registro non disponibile ["+urlVerifica+"]: "+e.getMessage(),e);
  3925.         }
  3926.     }

  3928. }
Created with JaCoCo 0.8.8.202204050719