UDDILib.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */



  23. package org.openspcoop2.core.registry.driver.uddi;

  25. import java.util.Vector;

  27. import org.openspcoop2.core.id.IDAccordo;
  28. import org.openspcoop2.core.id.IDAccordoCooperazione;
  29. import org.openspcoop2.core.id.IDServizio;
  30. import org.openspcoop2.core.id.IDSoggetto;
  31. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  32. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  33. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  34. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  35. import org.uddi4j.UDDIException;
  36. import org.uddi4j.client.UDDIProxy;
  37. import org.uddi4j.datatype.Name;
  38. import org.uddi4j.datatype.OverviewDoc;
  39. import org.uddi4j.datatype.OverviewURL;
  40. import org.uddi4j.datatype.binding.AccessPoint;
  41. import org.uddi4j.datatype.binding.BindingTemplate;
  42. import org.uddi4j.datatype.binding.BindingTemplates;
  43. import org.uddi4j.datatype.binding.TModelInstanceDetails;
  44. import org.uddi4j.datatype.binding.TModelInstanceInfo;
  45. import org.uddi4j.datatype.business.BusinessEntity;
  46. import org.uddi4j.datatype.service.BusinessService;
  47. import org.uddi4j.datatype.service.BusinessServices;
  48. import org.uddi4j.datatype.tmodel.TModel;
  49. import org.uddi4j.response.AuthToken;
  50. import org.uddi4j.response.BindingDetail;
  51. import org.uddi4j.response.BusinessDetail;
  52. import org.uddi4j.response.BusinessInfo;
  53. import org.uddi4j.response.BusinessList;
  54. import org.uddi4j.response.ServiceDetail;
  55. import org.uddi4j.response.ServiceInfo;
  56. import org.uddi4j.response.ServiceList;
  57. import org.uddi4j.response.TModelDetail;
  58. import org.uddi4j.response.TModelInfo;
  59. import org.uddi4j.response.TModelList;
  60. import org.uddi4j.transport.TransportException;
  61. import org.uddi4j.util.CategoryBag;
  62. import org.uddi4j.util.FindQualifier;
  63. import org.uddi4j.util.FindQualifiers;
  64. import org.uddi4j.util.IdentifierBag;
  65. import org.uddi4j.util.KeyedReference;
  66. import org.uddi4j.util.TModelBag;
  67. import org.uddi4j.util.TModelKey;


  70. /**
  71.  * Classe utilizzata per interagire con un registro UDDI che implementa le specifiche SICA.
  72.  *
  73.  * @author Anedda Valentino
  74.  * @author Poli Andrea (apoli@link.it)
  75.  * @author $Author$
  76.  * @version $Rev$, $Date$
  77.  */

  79. public class UDDILib
  80. {
  81.     /* ********  F I E L D S  P R I V A T I  ******** */

  83.     /** Dichiarazione delle chiavi di tassonomia*/  
  84.     protected String tmkID="uuid:b6ba2f0c-b4e5-40c4-a4f4-6212aa8d389f";//chiave di tassonomia per identificazione

  86.     /** Numero massimo di oggetti da ritornare */
  87.     private static int MAX_SEARCH = Integer.MAX_VALUE;
  88.     
  89.     /** UDDI Proxy */
  90.     protected UDDIProxy proxy=null;
  91.     /** Username */
  92.     protected String username;
  93.     /** Password */
  94.     protected String password;


  97.     /** Indicazione di una corretta creazione */
  98.     public boolean create = false;
  99.     /** Motivo di errore di una scorretta creazione */
  100.     protected String error;

  102.     /** TModel di OpenSPCoop */
  103.     public static final String TMODEL_OPENSPCOOP = "OpenSPCoop:SPCoopIdentifier";
  104.     
  105.     public static final String ACCORDO_SERVIZIO = "AccordoServizio";
  106.     public static final String PORTA_DOMINIO = "PortaDominio";
  107.     public static final String PORTA_DOMINIO_PREFIX = "PdD@";
  108.     public static final String GRUPPO = "Gruppo";
  109.     public static final String GRUPPO_PREFIX = "Gruppo@";
  110.     public static final String RUOLO = "Ruolo";
  111.     public static final String RUOLO_PREFIX = "Ruolo@";
  112.     public static final String SCOPE = "Scope";
  113.     public static final String SCOPE_PREFIX = "Scope@";
  114.     public static final String ACCORDO_COOPERAZIONE = "AccordoCooperazione";
  115.     public static final String ACCORDO_COOPERAZIONE_PREFIX = "AccordoCooperazione@";
  116.     
  117.     // Factory
  118.     private IDAccordoFactory idAccordoFactory = IDAccordoFactory.getInstance();
  119.     private IDAccordoCooperazioneFactory idAccordoCooperazioneFactory = IDAccordoCooperazioneFactory.getInstance();

  121.     
  122.     /**
  123.      * In caso di avvenuto errore nel costruttore, questo metodo ritorna il motivo dell'errore.
  124.      *
  125.      * @return motivo dell'errore (se avvenuto in fase di consegna).
  126.      * 
  127.      */
  128.     public String getErrore(){
  129.         return this.error;
  130.     }


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

  135.     /**
  136.      * Costruttore.
  137.      *
  138.      * @param inquiry URL utilizzata per interrogare il registro UDDI.
  139.      * @param publish URL utilizzata per pubblicare sul registro UDDI.
  140.      * @param user UserID necessaria per l'autorizzazione della pubblicazione
  141.      * @param password Password necessaria per l'autorizzazione della pubblicazione
  142.      */    
  143.     public UDDILib(String inquiry, String publish, String user, String password){
  144.         try{
  145.             this.proxy = new UDDIProxy();
  146.             if(inquiry != null)
  147.                 this.proxy.setInquiryURL(inquiry);
  148.             if(publish != null)
  149.                 this.proxy.setPublishURL(publish);

  151.             this.username = user;
  152.             this.password = password;

  154.             // per verificare il corretto funzionamento
  155.             //this.create = checkProxy();
  156.             this.create = true;
  157.         }
  158.         catch (java.net.MalformedURLException e){
  159.             this.error = e.getMessage();
  160.             this.create = false;
  161.         }
  162.         catch (Exception e){
  163.             this.error = e.getMessage();
  164.             this.create = false;
  165.         }
  166.     }   
  167.     /**
  168.      * Costruttore.
  169.      *
  170.      * @param inquiry URL utilizzata per interrogare il registro UDDI.
  171.      * @param user UserID necessaria per l'autorizzazione della pubblicazione
  172.      * @param password Password necessaria per l'autorizzazione della pubblicazione
  173.      */    
  174.     public UDDILib(String inquiry, String user, String password){
  175.         this(inquiry,null,user,password);
  176.     }   
  177.     /**
  178.      * Costruttore.
  179.      *
  180.      * @param inquiry URL utilizzata per interrogare il registro UDDI.
  181.      */
  182.     public UDDILib(String inquiry){
  183.         this(inquiry,null,null,null);
  184.     }   







  192.     
  193.     
  194.     
  195.     
  196.     
  197.     
  198.     
  199.     
  200.     /* ******** UTILITY GENERICHE   ******** */
  201.     
  202.     protected TModel getTModel(String tipoOggetto,String nome) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  203.         if ( nome==null )
  204.             throw new DriverRegistroServiziException("[UDDILib.getTModel("+tipoOggetto+")]: Alcuni parametri non definiti");
  205.         
  206.         TModel tm=null;
  207.         try{
  208.             // Filtro per nome esatto della TModel
  209.             FindQualifiers findQualifiers = new FindQualifiers();
  210.             Vector<FindQualifier> qualifier = new Vector<FindQualifier>();
  211.             qualifier.add(new FindQualifier(FindQualifier.exactNameMatch));
  212.             qualifier.add(new FindQualifier(FindQualifier.caseSensitiveMatch));
  213.             findQualifiers.setFindQualifierVector(qualifier);
  214.             
  215.             TModelList tmodelList = this.proxy.find_tModel(nome,null,null,findQualifiers,1);
  216.             if(tmodelList.getTModelInfos()==null || tmodelList.getTModelInfos().size()==0)
  217.                 throw new DriverRegistroServiziNotFound("TModel("+tipoOggetto+") non trovata");
  218.             Vector<?> tmodelInfoVector = tmodelList.getTModelInfos().getTModelInfoVector();
  219.             TModelInfo tmodelInfo=(TModelInfo) tmodelInfoVector.elementAt(0);
  220.             TModelDetail tmd = this.proxy.get_tModelDetail(tmodelInfo.getTModelKey());
  221.             Vector<?> tmv = tmd.getTModelVector();
  222.             tm = (TModel) tmv.elementAt(0);
  223.         }
  224.         catch (DriverRegistroServiziNotFound e){
  225.             throw e;
  226.         }
  227.         catch (UDDIException e){
  228.             throw new DriverRegistroServiziException("[UDDILib.getTModel("+tipoOggetto+")]: "+e.getMessage(),e);
  229.         }
  230.         catch (TransportException e){
  231.             throw new DriverRegistroServiziException("[UDDILib.getTModel("+tipoOggetto+")]: "+e.getMessage(),e);
  232.         }
  233.         catch (Exception e){
  234.             throw new DriverRegistroServiziException("[UDDILib.getTModel("+tipoOggetto+")]: "+e.getMessage(),e);
  235.         }
  236.         return tm;
  237.     }
  238.     
  239.     private TModel[] getTModelByFilter(String tipoOggetto,String searchNome,String urlRepository,boolean ricercaEsatta) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  240.         try{
  241.             String nomeRicerca = null;
  242.             if(searchNome!=null)
  243.                 nomeRicerca = searchNome;
  244.             else
  245.                 nomeRicerca = "%";
  246.             
  247.             // Filtro per nome esatto della TModel
  248.             FindQualifiers findQualifiers = null;
  249.             if( ricercaEsatta && nomeRicerca.equals("%")==false){
  250.                 findQualifiers = new FindQualifiers();
  251.                 Vector<FindQualifier> qualifier = new Vector<FindQualifier>();
  252.                 qualifier.add(new FindQualifier(FindQualifier.exactNameMatch));
  253.                 qualifier.add(new FindQualifier(FindQualifier.caseSensitiveMatch));
  254.                 findQualifiers.setFindQualifierVector(qualifier);
  255.             }
  256.             
  257.             TModelList tmodelList = this.proxy.find_tModel(nomeRicerca,null,null,findQualifiers,UDDILib.MAX_SEARCH);
  258.             Vector<TModel> tmodels = new Vector<TModel>();
  259.             // TModel vector lista.
  260.             if(tmodelList.getTModelInfos()!=null){
  261.                 Vector<?> tmodelInfoVector = tmodelList.getTModelInfos().getTModelInfoVector();
  262.                 for(int i=0; i<tmodelInfoVector.size(); i++){
  263.                     TModelInfo tmodelInfo=(TModelInfo) tmodelInfoVector.elementAt(i);
  264.                     TModelDetail tmd = this.proxy.get_tModelDetail(tmodelInfo.getTModelKey());
  265.                     Vector<?> tmv = tmd.getTModelVector();
  266.                     TModel t = (TModel) tmv.elementAt(0);
  267.                     // Filtro le tmodel per il repository
  268.                     if(urlRepository!=null){
  269.                         if(t.getOverviewDoc()!=null  && t.getOverviewDoc().getOverviewURLString()!=null &&
  270.                                 t.getOverviewDoc().getOverviewURLString().startsWith(urlRepository) ){
  271.                             if(UDDILib.ACCORDO_SERVIZIO.equals(tipoOggetto)){
  272.                                 if(t.getNameString().startsWith(UDDILib.ACCORDO_COOPERAZIONE_PREFIX)==false  &&  t.getNameString().startsWith(UDDILib.PORTA_DOMINIO_PREFIX)==false){
  273.                                     tmodels.add(t);
  274.                                 }
  275.                             }else{
  276.                                 tmodels.add(t);
  277.                             }
  278.                         }
  279.                     }else{
  280.                         if(UDDILib.ACCORDO_SERVIZIO.equals(tipoOggetto)){
  281.                             if(t.getNameString().startsWith(UDDILib.ACCORDO_COOPERAZIONE_PREFIX)==false  &&  t.getNameString().startsWith(UDDILib.PORTA_DOMINIO_PREFIX)==false){
  282.                                 tmodels.add(t);
  283.                             }
  284.                         }else{
  285.                             tmodels.add(t);
  286.                         }
  287.                     }
  288.                 }
  289.             }
  290.             if(tmodels.size()>0){
  291.                 TModel[] tm = new TModel[1];
  292.                 tm = tmodels.toArray(tm);
  293.                 return tm;
  294.             }else{
  295.                 throw new DriverRegistroServiziNotFound("Non sono state trovate TModelByFilter("+tipoOggetto+") nel registro UDDI con nome: "+searchNome);
  296.             }
  297.         }
  298.         catch (UDDIException e){
  299.             throw new DriverRegistroServiziException("[UDDILib.getTModelByFilter("+tipoOggetto+")]: "+e.getMessage(),e);
  300.         }
  301.         catch (TransportException e){
  302.             throw new DriverRegistroServiziException("[UDDILib.getTModelByFilter("+tipoOggetto+")]: "+e.getMessage(),e);
  303.         }
  304.         catch (DriverRegistroServiziNotFound e){
  305.             throw e;
  306.         }
  307.         catch (Exception e){
  308.             throw new DriverRegistroServiziException("[UDDILib.getTModelByFilter("+tipoOggetto+")]: "+e.getMessage(),e);
  309.         }
  310.     }

  312.     private void createTModel(String tipoOggetto,String nome, String url) throws DriverRegistroServiziException{

  314.         if ( (nome==null) || (url==null) )
  315.             throw new DriverRegistroServiziException("[UDDILib.createTModel("+tipoOggetto+")]: Alcuni parametri non definiti");
  316.         try{
  317.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  319.             Vector<TModel> tms = new Vector<TModel>();
  320.             TModel tm = new TModel("", nome);
  321.             
  322.             OverviewDoc od = new OverviewDoc();
  323.             OverviewURL ou = new OverviewURL();
  324.             ou.setText(url);
  325.             od.setOverviewURL(ou);
  326.             tm.setOverviewDoc(od);

  328.             tms.add(tm);
  329.             this.proxy.save_tModel(token.getAuthInfoString(),tms);
  330.         }
  331.         catch (UDDIException e){
  332.             throw new DriverRegistroServiziException("[UDDILib.createTModel("+tipoOggetto+")]: "+e.getMessage(),e);
  333.         }
  334.         catch (TransportException e){
  335.             throw new DriverRegistroServiziException("[UDDILib.createTModel("+tipoOggetto+")]: "+e.getMessage(),e);
  336.         }
  337.         catch (Exception e){
  338.             throw new DriverRegistroServiziException("[UDDILib.createTModel("+tipoOggetto+")]: "+e.getMessage(),e);
  339.         }
  340.     }
  341.     
  342.     private void updateTModel(String tipoOggetto,String nomeOLD,String nomeNEW,String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  343.         if ( (nomeOLD==null) || (url==null) || (nomeNEW==null))
  344.             throw new DriverRegistroServiziException("[UDDILib.updateTModel("+tipoOggetto+")]: Alcuni parametri non definiti");
  345.     
  346.         TModel tm=null;
  347.         try{
  348.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  350.             tm = getTModel(tipoOggetto, nomeOLD);

  352.             OverviewDoc od = tm.getOverviewDoc();
  353.             OverviewURL ou = od.getOverviewURL();
  354.             ou.setText(url);
  355.             od.setOverviewURL(ou);
  356.             tm.setOverviewDoc(od);

  358.             tm.setName(nomeNEW);
  359.             Vector<TModel> tms = new Vector<TModel>();
  360.             tms.add(tm);
  361.             this.proxy.save_tModel(token.getAuthInfoString(),tms);
  362.         }
  363.         catch(DriverRegistroServiziNotFound e){
  364.             throw e;
  365.         }
  366.         catch (UDDIException e){
  367.             throw new DriverRegistroServiziException("[UDDILib.updateTModel("+tipoOggetto+")]: "+e.getMessage(),e);
  368.         }
  369.         catch (TransportException e){
  370.             throw new DriverRegistroServiziException("[UDDILib.updateTModel("+tipoOggetto+")]: "+e.getMessage(),e);
  371.         }
  372.         catch (Exception e){
  373.             throw new DriverRegistroServiziException("[UDDILib.updateTModel("+tipoOggetto+")]: "+e.getMessage(),e);
  374.         }
  375.     }
  376.     
  377.     private void deleteTModel(String tipoOggetto,String nome) throws DriverRegistroServiziException{

  379.         if ( nome==null )
  380.             throw new DriverRegistroServiziException("[UDDILib.deleteTModel("+tipoOggetto+")]: Alcuni parametri non definiti");
  381.         
  382.         try{
  383.             AuthToken token = this.proxy.get_authToken(this.username,this.password);
  384.             
  385.             // Filtro per nome esatto della TModel
  386.             FindQualifiers findQualifiers = new FindQualifiers();
  387.             Vector<FindQualifier> qualifier = new Vector<FindQualifier>();
  388.             qualifier.add(new FindQualifier(FindQualifier.exactNameMatch));
  389.             qualifier.add(new FindQualifier(FindQualifier.caseSensitiveMatch));
  390.             findQualifiers.setFindQualifierVector(qualifier);
  391.             
  392.             TModelList tmodelList = this.proxy.find_tModel(nome,null,null,findQualifiers,1);
  393.             Vector<?> tmodelInfoVector = tmodelList.getTModelInfos().getTModelInfoVector();
  394.             TModelInfo tmodelInfo=(TModelInfo) tmodelInfoVector.elementAt(0);
  395.             this.proxy.delete_tModel(token.getAuthInfoString(),tmodelInfo.getTModelKey());
  396.         
  397.         }catch(Exception e){
  398.             throw new DriverRegistroServiziException("[UDDILib.deleteTModel("+tipoOggetto+")]: "+e.getMessage(),e);
  399.         }
  400.     }
  401.     
  402.     private void updateUrlXmlTModel(String tipoOggetto,String nome, String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  403.         
  404.         if ( (nome==null) || (url==null) )
  405.             throw new DriverRegistroServiziException("[UDDILib.updateUrlXmlTModel("+tipoOggetto+")]: Alcuni parametri non definiti");
  406.     
  407.         try{
  408.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  410.             TModel tm = getTModel(tipoOggetto,nome);
  411.             Vector<TModel> tms = new Vector<TModel>();
  412.             OverviewDoc od = tm.getOverviewDoc();
  413.             OverviewURL ou = od.getOverviewURL();
  414.             ou.setText(url);
  415.             od.setOverviewURL(ou);
  416.             tm.setOverviewDoc(od);
  417.             tms.add(tm);
  418.             this.proxy.save_tModel(token.getAuthInfoString(),tms);
  419.         }catch(DriverRegistroServiziNotFound e){
  420.             throw e;
  421.         }catch(Exception e){
  422.             throw new DriverRegistroServiziException("[UDDILib.updateUrlXmlTModel("+tipoOggetto+")]: "+e.getMessage(),e);
  423.         }
  424.     }
  425.     
  426.     



  430.     
  431.     
  432.     
  433.     
  434.     
  435.     
  436.     
  437.     /* ******** M E T O D I   A C C O R D O    D I    C O O P E R A Z I O N E   ******** */


  440.     
  441.     /**
  442.      * Si occupa di recuperare il TModel che registra l'accordo di cooperazione con nome <var>nome</var>
  443.      *
  444.      * @param idAccordo ID che identifica l'accordo di cooperazione
  445.      * @return la TModel che registra l'accordo di cooperazione
  446.      */
  447.     public TModel getAccordoCooperazione(IDAccordoCooperazione idAccordo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  448.         String uriAccordo = this.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordo);
  449.         return this.getTModel(UDDILib.ACCORDO_COOPERAZIONE, UDDILib.ACCORDO_COOPERAZIONE_PREFIX+uriAccordo);
  450.     }
  451.     
  452.     /**
  453.      * Si occupa di recuperare le TModels che soddisfano il filtro
  454.      *
  455.      * @param urlRepository Url del Repository
  456.      * @return una lista di TModel che registra l'accordo di cooperazione
  457.      */
  458.     public TModel[] getAccordiCooperazione(String urlRepository) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  459.         return this.getTModelByFilter(UDDILib.ACCORDO_COOPERAZIONE, UDDILib.ACCORDO_COOPERAZIONE_PREFIX, urlRepository,false);
  460.     }
  461.     
  462.     /**
  463.      * Si occupa di registrare come TModel un'accordo di cooperazione con nome <var>nome</var>
  464.      *
  465.      * @param idAccordo ID che identifica l'accordo di cooperazione
  466.      * @param url url del file XML associato all'accordo di cooperazione
  467.      */ 
  468.     public void createAccordoCooperazione(IDAccordoCooperazione idAccordo, String url) throws DriverRegistroServiziException{
  469.         String uriAccordo = this.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordo);
  470.         this.createTModel(UDDILib.ACCORDO_COOPERAZIONE, UDDILib.ACCORDO_COOPERAZIONE_PREFIX+uriAccordo, url);
  471.     }

  473.     /**
  474.      * Il metodo si occupa di verificare se nel registro e' regitrata una TModel identificata dal parametro
  475.      *
  476.      * @param idAccordo ID dell'accordo di cooperazione
  477.      * @return true se la TModel risulta registrata, false altrimenti
  478.      * 
  479.      */
  480.     public boolean existsAccordoCooperazione(IDAccordoCooperazione idAccordo) throws DriverRegistroServiziException{
  481.         
  482.         if ( idAccordo==null )
  483.             throw new DriverRegistroServiziException("[UDDILib.existsAccordoCooperazione]: Alcuni parametri non definiti");
  484.         String uriAccordo = this.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordo);
  485.         try{
  486.             TModel t = getTModel(UDDILib.ACCORDO_COOPERAZIONE,UDDILib.ACCORDO_COOPERAZIONE_PREFIX+uriAccordo);
  487.             if(t == null)
  488.                 throw new Exception("TModel is null");
  489.         }catch(DriverRegistroServiziNotFound e){
  490.             return false;
  491.         }catch(Exception e){
  492.             throw new DriverRegistroServiziException(e.getMessage(),e);
  493.         }
  494.         return true;    
  495.     }

  497.     /**
  498.      * Si occupa di modificare il nome della TModel che registra l'accordo di cooperazione con nome <var>nomeOLD</var>
  499.      *
  500.      * @param idAccordoOLD vecchio id che identifica l'accordo di cooperazione
  501.      * @param idAccordoNEW nuovo id che identifica l'accordo di cooperazione
  502.      * @param url nuova url del file XML associato all'accordo di cooperazione
  503.      */
  504.     public void updateAccordoCooperazione(IDAccordoCooperazione idAccordoOLD,IDAccordoCooperazione idAccordoNEW,String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  505.         String uriAccordoOLD = this.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordoOLD);
  506.         String uriAccordoNEW = this.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordoNEW);
  507.         this.updateTModel(UDDILib.ACCORDO_COOPERAZIONE, UDDILib.ACCORDO_COOPERAZIONE_PREFIX+uriAccordoOLD, UDDILib.ACCORDO_COOPERAZIONE_PREFIX+uriAccordoNEW, url);
  508.     }

  510.     /**
  511.      * Il metodo si occupa di cancellare la TModel identificata dal parametro
  512.      *
  513.      * @param idAccordo ID che identifica l'accordo di cooperazione
  514.      */
  515.     public void deleteAccordoCooperazione(IDAccordoCooperazione idAccordo) throws DriverRegistroServiziException{
  516.         String uriAccordo = this.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordo);
  517.         this.deleteTModel(UDDILib.ACCORDO_COOPERAZIONE, UDDILib.ACCORDO_COOPERAZIONE_PREFIX+uriAccordo);
  518.     }

  520.     /**
  521.      * Il metodo si occupa di impostare la url del file XML della TModel
  522.      *
  523.      * @param idAccordo ID che identifica l'accordo di cooperazione
  524.      * @param url url del file XML associato all'accordo di cooperazione
  525.      */
  526.     public void updateUrlXmlAccordoCooperazione(IDAccordoCooperazione idAccordo, String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  527.         String uriAccordo = this.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordo);
  528.         this.updateUrlXmlTModel(UDDILib.ACCORDO_COOPERAZIONE, UDDILib.ACCORDO_COOPERAZIONE_PREFIX+uriAccordo, url);
  529.     }
  530.     /**
  531.      * Si occupa di recuperare la URL dell'XML associato all'accordo di cooperazione
  532.      * registrato con il nome <var>nome</var>
  533.      *
  534.      * @param idAccordo ID che identifica l'accordo di cooperazione
  535.      * @return la url dell'XML associato all'accordo di cooperazione
  536.      * 
  537.      */
  538.     public String getUrlXmlAccordoCooperazione(IDAccordoCooperazione idAccordo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  539.         if ( idAccordo==null )
  540.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlAccordoCooperazione]: Alcuni parametri non definiti");
  541.         try{
  542.             String uriAccordo = this.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordo);
  543.             TModel tm = getTModel(UDDILib.ACCORDO_COOPERAZIONE, UDDILib.ACCORDO_COOPERAZIONE_PREFIX+uriAccordo);
  544.             return tm.getOverviewDoc().getOverviewURLString();
  545.         }catch(DriverRegistroServiziNotFound e){
  546.             throw e;
  547.         }catch(Exception e){
  548.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlAccordoCooperazione]: "+e.getMessage(),e);
  549.         }
  550.     }
  551.     
  552.     /**
  553.      * Si occupa di recuperare la URL dell'XML associato all'accordo di cooperazione
  554.      * registrato con il nome <var>nome</var>
  555.      *
  556.      * @param idAccordo ID che identifica l'accordo di cooperazione
  557.      * @return la url dell'XML associato all'accordo di cooperazione
  558.      * 
  559.      */
  560.     public String[] getUrlXmlAccordiCooperazione(IDAccordoCooperazione idAccordo,String urlPrefix) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  561.         try{
  562.             TModel[] tm = null;
  563.             if(idAccordo!=null) {
  564.                 String uriAccordo = this.idAccordoCooperazioneFactory.getUriFromIDAccordo(idAccordo);
  565.                 tm = getTModelByFilter(UDDILib.ACCORDO_COOPERAZIONE, UDDILib.ACCORDO_COOPERAZIONE_PREFIX+uriAccordo,urlPrefix,true);
  566.             }else{
  567.                 tm = getTModelByFilter(UDDILib.ACCORDO_COOPERAZIONE, UDDILib.ACCORDO_COOPERAZIONE_PREFIX,urlPrefix,false);
  568.             }
  569.             if(tm!=null){
  570.                 String[] url = new String[tm.length];
  571.                 for(int i=0; i<tm.length; i++){
  572.                     url[i] = tm[i].getOverviewDoc().getOverviewURLString();
  573.                 }
  574.                 return url;
  575.             }else{
  576.                 throw new DriverRegistroServiziNotFound("Accordi di Cooperazione (definizione XML) non trovati");
  577.             }
  578.         }
  579.         catch (DriverRegistroServiziNotFound e){
  580.             throw e;
  581.         }
  582.         catch(Exception e){
  583.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlAccordiCooperazione]: "+e.getMessage(),e);
  584.         }
  585.     }
  586.     
  587.     
  588.     
  589.     
  590.     









  600.     /* ******** M E T O D I   A C C O R D O    D I    S E R V I Z I O   ******** */


  603.     
  604.     /**
  605.      * Si occupa di recuperare il TModel che registra l'accordo di servizio con nome <var>nome</var>
  606.      *
  607.      * @param idAccordo ID che identifica l'accordo di servizio
  608.      * @return la TModel che registra l'accordo di servizio
  609.      */
  610.     public TModel getAccordoServizio(IDAccordo idAccordo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  611.         String uriAccordo = this.idAccordoFactory.getUriFromIDAccordo(idAccordo);
  612.         return this.getTModel(UDDILib.ACCORDO_SERVIZIO, uriAccordo);
  613.     }
  614.     
  615.     /**
  616.      * Si occupa di recuperare le TModels che soddisfano il filtro
  617.      *
  618.      * @param urlRepository Url del Repository
  619.      * @return una lista di TModel che registra l'accordo di servizio
  620.      */
  621.     public TModel[] getAccordiServizio(String urlRepository) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  622.         return this.getTModelByFilter(UDDILib.ACCORDO_SERVIZIO, null, urlRepository,false);
  623.     }
  624.     
  625.     /**
  626.      * Si occupa di registrare come TModel un'accordo di servizio con nome <var>nome</var>
  627.      *
  628.      * @param idAccordo ID che identifica l'accordo di servizio
  629.      * @param url url del file XML associato all'accordo di servizio
  630.      */ 
  631.     public void createAccordoServizio(IDAccordo idAccordo, String url) throws DriverRegistroServiziException{
  632.         String uriAccordo = this.idAccordoFactory.getUriFromIDAccordo(idAccordo);
  633.         this.createTModel(UDDILib.ACCORDO_SERVIZIO, uriAccordo, url);
  634.     }

  636.     /**
  637.      * Il metodo si occupa di verificare se nel registro e' regitrata una TModel identificata dal parametro
  638.      *
  639.      * @param idAccordo ID dell'accordo di servizio
  640.      * @return true se la TModel risulta registrata, false altrimenti
  641.      * 
  642.      */
  643.     public boolean existsAccordoServizio(IDAccordo idAccordo) throws DriverRegistroServiziException{
  644.         
  645.         if ( idAccordo==null )
  646.             throw new DriverRegistroServiziException("[UDDILib.existsAccordoServizio]: Alcuni parametri non definiti");
  647.         String uriAccordo = this.idAccordoFactory.getUriFromIDAccordo(idAccordo);
  648.         try{
  649.             TModel t = getTModel(UDDILib.ACCORDO_SERVIZIO,uriAccordo);
  650.             if(t == null)
  651.                 throw new Exception("TModel is null");
  652.         }catch(DriverRegistroServiziNotFound e){
  653.             return false;
  654.         }catch(Exception e){
  655.             throw new DriverRegistroServiziException(e.getMessage(),e);
  656.         }
  657.         return true;    
  658.     }

  660.     /**
  661.      * Si occupa di modificare il nome della TModel che registra l'accordo di servizio con nome <var>nomeOLD</var>
  662.      *
  663.      * @param idAccordoOLD vecchio id che identifica l'accordo di servizio
  664.      * @param idAccordoNEW nuovo id che identifica l'accordo di servizio
  665.      * @param url nuova url del file XML associato all'accordo di servizio
  666.      */
  667.     public void updateAccordoServizio(IDAccordo idAccordoOLD,IDAccordo idAccordoNEW,String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  668.         String uriAccordoOLD = this.idAccordoFactory.getUriFromIDAccordo(idAccordoOLD);
  669.         String uriAccordoNEW = this.idAccordoFactory.getUriFromIDAccordo(idAccordoNEW);
  670.         this.updateTModel(UDDILib.ACCORDO_SERVIZIO, uriAccordoOLD, uriAccordoNEW, url);
  671.     }

  673.     /**
  674.      * Il metodo si occupa di cancellare la TModel identificata dal parametro
  675.      *
  676.      * @param idAccordo ID che identifica l'accordo di servizio
  677.      */
  678.     public void deleteAccordoServizio(IDAccordo idAccordo) throws DriverRegistroServiziException{
  679.         String uriAccordo = this.idAccordoFactory.getUriFromIDAccordo(idAccordo);
  680.         this.deleteTModel(UDDILib.ACCORDO_SERVIZIO, uriAccordo);
  681.     }

  683.     /**
  684.      * Il metodo si occupa di impostare la url del file XML della TModel
  685.      *
  686.      * @param idAccordo ID che identifica l'accordo di servizio
  687.      * @param url url del file XML associato all'accordo di servizio
  688.      */
  689.     public void updateUrlXmlAccordoServizio(IDAccordo idAccordo, String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  690.         String uriAccordo = this.idAccordoFactory.getUriFromIDAccordo(idAccordo);
  691.         this.updateUrlXmlTModel(UDDILib.ACCORDO_SERVIZIO, uriAccordo, url);
  692.     }
  693.     /**
  694.      * Si occupa di recuperare la URL dell'XML associato all'accordo di servizio
  695.      * registrato con il nome <var>nome</var>
  696.      *
  697.      * @param idAccordo ID che identifica l'accordo di servizio
  698.      * @return la url dell'XML associato all'accordo di servizio
  699.      * 
  700.      */
  701.     public String getUrlXmlAccordoServizio(IDAccordo idAccordo) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  702.         if ( idAccordo==null )
  703.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlAccordoServizio]: Alcuni parametri non definiti");
  704.         try{
  705.             String uriAccordo = this.idAccordoFactory.getUriFromIDAccordo(idAccordo);
  706.             TModel tm = getTModel(UDDILib.ACCORDO_SERVIZIO,uriAccordo);
  707.             return tm.getOverviewDoc().getOverviewURLString();
  708.         }catch(DriverRegistroServiziNotFound e){
  709.             throw e;
  710.         }catch(Exception e){
  711.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlAccordoServizio]: "+e.getMessage(),e);
  712.         }
  713.     }
  714.     
  715.     /**
  716.      * Si occupa di recuperare la URL dell'XML associato all'accordo di servizio
  717.      * registrato con il nome <var>nome</var>
  718.      *
  719.      * @param idAccordo ID che identifica l'accordo di servizio
  720.      * @return la url dell'XML associato all'accordo di servizio
  721.      * 
  722.      */
  723.     public String[] getUrlXmlAccordiServizio(IDAccordo idAccordo,String urlRepository) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  724.         try{
  725.             TModel[] tm = null;
  726.             if(idAccordo!=null) {
  727.                 String uriAccordo = this.idAccordoFactory.getUriFromIDAccordo(idAccordo);
  728.                 tm = getTModelByFilter(UDDILib.ACCORDO_SERVIZIO, uriAccordo,urlRepository,true);
  729.             }else{
  730.                 tm = getTModelByFilter(UDDILib.ACCORDO_SERVIZIO, null,urlRepository,false);
  731.             }
  732.             if(tm!=null){
  733.                 String[] url = new String[tm.length];
  734.                 for(int i=0; i<tm.length; i++){
  735.                     url[i] = tm[i].getOverviewDoc().getOverviewURLString();
  736.                 }
  737.                 return url;
  738.             }else{
  739.                 throw new DriverRegistroServiziNotFound("Accordi di Servizio (definizione XML) non trovati");
  740.             }
  741.         }
  742.         catch (DriverRegistroServiziNotFound e){
  743.             throw e;
  744.         }
  745.         catch(Exception e){
  746.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlAccordoServizio]: "+e.getMessage(),e);
  747.         }
  748.     }

  750.     







  758.     
  759.     
  760.     
  761.     
  762.     
  763.     
  764.     
  765.     
  766.     /* ******** M E T O D I   P D D   ******** */


  769.     
  770.     /**
  771.      * Si occupa di recuperare il TModel che registra la porta di dominio con nome <var>nome</var>
  772.      *
  773.      * @param nome nome che identifica la porta di dominio
  774.      * @return la TModel che registra la porta di dominio
  775.      */
  776.     public TModel getPortaDominio(String nome) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  777.         return this.getTModel(UDDILib.PORTA_DOMINIO, UDDILib.PORTA_DOMINIO_PREFIX+nome);
  778.     }
  779.     
  780.     /**
  781.      * Si occupa di recuperare le TModels che soddisfano il filtro
  782.      *
  783.      * @param urlRepository Url del Repository
  784.      * @return una lista di TModel che registra la porta di dominio
  785.      */
  786.     public TModel[] getPorteDominio(String urlRepository) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  787.         return this.getTModelByFilter(UDDILib.PORTA_DOMINIO, UDDILib.PORTA_DOMINIO_PREFIX, urlRepository, false);
  788.     }
  789.     
  790.     /**
  791.      * Si occupa di registrare come TModel una porta di dominio con nome <var>nome</var>
  792.      *
  793.      * @param nome Nome che identifica la pdd
  794.      * @param url url del file XML associato alla pdd
  795.      */ 
  796.     public void createPortaDominio(String nome, String url) throws DriverRegistroServiziException{
  797.         this.createTModel(UDDILib.PORTA_DOMINIO, UDDILib.PORTA_DOMINIO_PREFIX+ nome, url);
  798.     }

  800.     /**
  801.      * Il metodo si occupa di verificare se nel registro e' regitrata una TModel identificata dal parametro
  802.      *
  803.      * @param nome Nome della porta di dominio
  804.      * @return true se la TModel risulta registrata, false altrimenti
  805.      * 
  806.      */
  807.     public boolean existsPortaDominio(String nome) throws DriverRegistroServiziException{
  808.         
  809.         if ( nome==null )
  810.             throw new DriverRegistroServiziException("[UDDILib.existsPortaDominio]: Alcuni parametri non definiti");
  811.         try{
  812.             TModel t = getTModel(UDDILib.PORTA_DOMINIO, UDDILib.PORTA_DOMINIO_PREFIX+nome);
  813.             if(t == null)
  814.                 throw new Exception("TModel is null");
  815.         }catch(DriverRegistroServiziNotFound e){
  816.             return false;
  817.         }catch(Exception e){
  818.             throw new DriverRegistroServiziException(e.getMessage(),e);
  819.         }
  820.         return true;    
  821.     }

  823.     /**
  824.      * Si occupa di modificare il nome della TModel che registra la porta di dominio con nome <var>nomeOLD</var>
  825.      *
  826.      * @param nomeOLD vecchio nome che identifica la porta di dominio
  827.      * @param nomeNEW nuovo nome che identifica la porta di dominio
  828.      * @param url nuova url del file XML associato all'accordo di servizio
  829.      */
  830.     public void updatePortaDominio(String nomeOLD,String nomeNEW,String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  831.         this.updateTModel(UDDILib.PORTA_DOMINIO, UDDILib.PORTA_DOMINIO_PREFIX+nomeOLD, UDDILib.PORTA_DOMINIO_PREFIX+nomeNEW, url);
  832.     }

  834.     /**
  835.      * Il metodo si occupa di cancellare la TModel identificata dal parametro
  836.      *
  837.      * @param nome nome che identifica la porta di dominio
  838.      */
  839.     public void deletePortaDominio(String nome) throws DriverRegistroServiziException{
  840.         this.deleteTModel(UDDILib.PORTA_DOMINIO, UDDILib.PORTA_DOMINIO_PREFIX+nome);
  841.     }

  843.     /**
  844.      * Il metodo si occupa di impostare la url del file XML della TModel
  845.      *
  846.      * @param nome Nome che identifica la porta di dominio
  847.      * @param url url del file XML associato alla porta di dominio
  848.      */
  849.     public void updateUrlXmlPortaDominio(String nome, String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  850.         this.updateUrlXmlTModel(UDDILib.PORTA_DOMINIO, UDDILib.PORTA_DOMINIO_PREFIX+nome, url);
  851.     }
  852.     /**
  853.      * Si occupa di recuperare la URL dell'XML associato alla porta di dominio
  854.      * registrato con il nome <var>nome</var>
  855.      *
  856.      * @param nome Nome che identifica la porta di dominio
  857.      * @return la url dell'XML associato alla porta di dominio
  858.      * 
  859.      */
  860.     public String getUrlXmlPortaDominio(String nome) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  861.         if ( nome==null )
  862.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlPortaDominio]: Alcuni parametri non definiti");
  863.         try{
  864.             TModel tm = getTModel(UDDILib.PORTA_DOMINIO, UDDILib.PORTA_DOMINIO_PREFIX+nome);
  865.             return tm.getOverviewDoc().getOverviewURLString();
  866.         }catch(DriverRegistroServiziNotFound e){
  867.             throw e;
  868.         }catch(Exception e){
  869.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlPortaDominio]: "+e.getMessage(),e);
  870.         }
  871.     }
  872.     
  873.     /**
  874.      * Si occupa di recuperare la URL dell'XML associato alla porta di dominio
  875.      * registrata con il nome <var>nome</var>
  876.      *
  877.      * @param searchNome Nome che identifica la porta di dominio
  878.      * @return la url dell'XML associato alla porta di dominio
  879.      * 
  880.      */
  881.     public String[] getUrlXmlPortaDominio(String searchNome,String urlRepository) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  882.         try{
  883.             TModel[] tm = null;
  884.             if(searchNome!=null){
  885.                 tm = getTModelByFilter(UDDILib.PORTA_DOMINIO, UDDILib.PORTA_DOMINIO_PREFIX+searchNome,urlRepository,true);
  886.             }else{
  887.                 tm = getTModelByFilter(UDDILib.PORTA_DOMINIO, UDDILib.PORTA_DOMINIO_PREFIX,urlRepository,false);
  888.             }
  889.             
  890.             /*Vector<TModel> tmFiltratePerPdd = new Vector<TModel>(); 
  891.             for(int i=0; i<tm.length; i++){
  892.                 if(tm[i].getNameString().startsWith(PORTA_DOMINIO_PREFIX)){
  893.                     tmFiltratePerPdd.add(tm[i]);
  894.                 }
  895.             }
  896.             if(tmFiltratePerPdd.size()<=0){
  897.                 throw new DriverRegistroServiziNotFound("Porte di dominio non trovate, dopo il filtro per pdd");
  898.             }
  899.             
  900.             String[] url = new String[tmFiltratePerPdd.size()];
  901.             int i=0;
  902.             while(tmFiltratePerPdd.size()>0){
  903.                 TModel t = tmFiltratePerPdd.remove(0);
  904.                 url[i] = t.getOverviewDoc().getOverviewURLString();
  905.                 i++;
  906.             }
  907.             return url;
  908.             */
  909.             
  910.             if(tm!=null){
  911.                 String[] url = new String[tm.length];
  912.                 for(int i=0; i<tm.length; i++){
  913.                     url[i] = tm[i].getOverviewDoc().getOverviewURLString();
  914.                 }
  915.                 return url;
  916.             }else{
  917.                 throw new DriverRegistroServiziNotFound("Porte di Dominio (definizione XML) non trovate");
  918.             }
  919.         }
  920.         catch (DriverRegistroServiziNotFound e){
  921.             throw e;
  922.         }
  923.         catch(Exception e){
  924.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlPortaDominio]: "+e.getMessage(),e);
  925.         }
  926.     }
  927.     
  928.     
  929.     
  930.     
  931.     
  932.     
  933.     
  934.     
  935.     
  936.     
  937.     
  938.     /* ******** M E T O D I   G R U P P I   ******** */


  941.     
  942.     /**
  943.      * Si occupa di recuperare il TModel che registra il gruppo con nome <var>nome</var>
  944.      *
  945.      * @param nome nome che identifica il gruppo
  946.      * @return la TModel che registra il gruppo
  947.      */
  948.     public TModel getGruppo(String nome) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  949.         return this.getTModel(UDDILib.GRUPPO, UDDILib.GRUPPO_PREFIX+nome);
  950.     }
  951.     
  952.     /**
  953.      * Si occupa di recuperare le TModels che soddisfano il filtro
  954.      *
  955.      * @param urlRepository Url del Repository
  956.      * @return una lista di TModel che registra i gruppi
  957.      */
  958.     public TModel[] getGruppi(String urlRepository) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  959.         return this.getTModelByFilter(UDDILib.GRUPPO, UDDILib.GRUPPO_PREFIX, urlRepository, false);
  960.     }
  961.     
  962.     /**
  963.      * Si occupa di registrare come TModel un gruppo con nome <var>nome</var>
  964.      *
  965.      * @param nome Nome che identifica il gruppo
  966.      * @param url url del file XML associato al gruppo
  967.      */ 
  968.     public void createGruppo(String nome, String url) throws DriverRegistroServiziException{
  969.         this.createTModel(UDDILib.GRUPPO, UDDILib.GRUPPO_PREFIX+ nome, url);
  970.     }

  972.     /**
  973.      * Il metodo si occupa di verificare se nel registro e' regitrata una TModel identificata dal parametro
  974.      *
  975.      * @param nome Nome del gruppo
  976.      * @return true se la TModel risulta registrata, false altrimenti
  977.      * 
  978.      */
  979.     public boolean existsGruppo(String nome) throws DriverRegistroServiziException{
  980.         
  981.         if ( nome==null )
  982.             throw new DriverRegistroServiziException("[UDDILib.existsGruppo]: Alcuni parametri non definiti");
  983.         try{
  984.             TModel t = getTModel(UDDILib.GRUPPO, UDDILib.GRUPPO_PREFIX+nome);
  985.             if(t == null)
  986.                 throw new Exception("TModel is null");
  987.         }catch(DriverRegistroServiziNotFound e){
  988.             return false;
  989.         }catch(Exception e){
  990.             throw new DriverRegistroServiziException(e.getMessage(),e);
  991.         }
  992.         return true;    
  993.     }

  995.     /**
  996.      * Si occupa di modificare il nome della TModel che registra il gruppo con nome <var>nomeOLD</var>
  997.      *
  998.      * @param nomeOLD vecchio nome che identifica il gruppo
  999.      * @param nomeNEW nuovo nome che identifica il gruppo
  1000.      * @param url nuova url del file XML associato al gruppo
  1001.      */
  1002.     public void updateGruppo(String nomeOLD,String nomeNEW,String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1003.         this.updateTModel(UDDILib.GRUPPO, UDDILib.GRUPPO_PREFIX+nomeOLD, UDDILib.GRUPPO_PREFIX+nomeNEW, url);
  1004.     }

  1006.     /**
  1007.      * Il metodo si occupa di cancellare la TModel identificata dal parametro
  1008.      *
  1009.      * @param nome nome che identifica il gruppo
  1010.      */
  1011.     public void deleteGruppo(String nome) throws DriverRegistroServiziException{
  1012.         this.deleteTModel(UDDILib.GRUPPO, UDDILib.GRUPPO_PREFIX+nome);
  1013.     }

  1015.     /**
  1016.      * Il metodo si occupa di impostare la url del file XML della TModel
  1017.      *
  1018.      * @param nome Nome che identifica il gruppo
  1019.      * @param url url del file XML associato al gruppo
  1020.      */
  1021.     public void updateUrlXmlGruppo(String nome, String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1022.         this.updateUrlXmlTModel(UDDILib.GRUPPO, UDDILib.GRUPPO_PREFIX+nome, url);
  1023.     }
  1024.     /**
  1025.      * Si occupa di recuperare la URL dell'XML associato al gruppo
  1026.      * registrato con il nome <var>nome</var>
  1027.      *
  1028.      * @param nome Nome che identifica il gruppo
  1029.      * @return la url dell'XML associato al gruppo
  1030.      * 
  1031.      */
  1032.     public String getUrlXmlGruppo(String nome) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1033.         if ( nome==null )
  1034.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlGruppo]: Alcuni parametri non definiti");
  1035.         try{
  1036.             TModel tm = getTModel(UDDILib.GRUPPO, UDDILib.GRUPPO_PREFIX+nome);
  1037.             return tm.getOverviewDoc().getOverviewURLString();
  1038.         }catch(DriverRegistroServiziNotFound e){
  1039.             throw e;
  1040.         }catch(Exception e){
  1041.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlGruppo]: "+e.getMessage(),e);
  1042.         }
  1043.     }
  1044.     
  1045.     /**
  1046.      * Si occupa di recuperare la URL dell'XML associato al gruppo
  1047.      * registrata con il nome <var>nome</var>
  1048.      *
  1049.      * @param searchNome Nome che identifica il gruppo
  1050.      * @return la url dell'XML associato al gruppo
  1051.      * 
  1052.      */
  1053.     public String[] getUrlXmlGruppo(String searchNome,String urlRepository) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1054.         try{
  1055.             TModel[] tm = null;
  1056.             if(searchNome!=null){
  1057.                 tm = getTModelByFilter(UDDILib.GRUPPO, UDDILib.GRUPPO_PREFIX+searchNome,urlRepository,true);
  1058.             }else{
  1059.                 tm = getTModelByFilter(UDDILib.GRUPPO, UDDILib.GRUPPO_PREFIX,urlRepository,false);
  1060.             }
  1061.             
  1062.             if(tm!=null){
  1063.                 String[] url = new String[tm.length];
  1064.                 for(int i=0; i<tm.length; i++){
  1065.                     url[i] = tm[i].getOverviewDoc().getOverviewURLString();
  1066.                 }
  1067.                 return url;
  1068.             }else{
  1069.                 throw new DriverRegistroServiziNotFound("Gruppo (definizione XML) non trovate");
  1070.             }
  1071.         }
  1072.         catch (DriverRegistroServiziNotFound e){
  1073.             throw e;
  1074.         }
  1075.         catch(Exception e){
  1076.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlGruppo]: "+e.getMessage(),e);
  1077.         }
  1078.     }
  1079.     
  1080.     
  1081.     
  1082.     
  1083.     
  1084.     
  1085.     
  1086.     
  1087.     
  1088.     
  1089.     /* ******** M E T O D I   R U O L I   ******** */


  1092.     
  1093.     /**
  1094.      * Si occupa di recuperare il TModel che registra il ruolo con nome <var>nome</var>
  1095.      *
  1096.      * @param nome nome che identifica il ruolo
  1097.      * @return la TModel che registra il ruolo
  1098.      */
  1099.     public TModel getRuolo(String nome) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1100.         return this.getTModel(UDDILib.RUOLO, UDDILib.RUOLO_PREFIX+nome);
  1101.     }
  1102.     
  1103.     /**
  1104.      * Si occupa di recuperare le TModels che soddisfano il filtro
  1105.      *
  1106.      * @param urlRepository Url del Repository
  1107.      * @return una lista di TModel che registra i ruoli
  1108.      */
  1109.     public TModel[] getRuoli(String urlRepository) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1110.         return this.getTModelByFilter(UDDILib.RUOLO, UDDILib.RUOLO_PREFIX, urlRepository, false);
  1111.     }
  1112.     
  1113.     /**
  1114.      * Si occupa di registrare come TModel un ruolo con nome <var>nome</var>
  1115.      *
  1116.      * @param nome Nome che identifica il ruolo
  1117.      * @param url url del file XML associato al ruolo
  1118.      */ 
  1119.     public void createRuolo(String nome, String url) throws DriverRegistroServiziException{
  1120.         this.createTModel(UDDILib.RUOLO, UDDILib.RUOLO_PREFIX+ nome, url);
  1121.     }

  1123.     /**
  1124.      * Il metodo si occupa di verificare se nel registro e' regitrata una TModel identificata dal parametro
  1125.      *
  1126.      * @param nome Nome del ruolo
  1127.      * @return true se la TModel risulta registrata, false altrimenti
  1128.      * 
  1129.      */
  1130.     public boolean existsRuolo(String nome) throws DriverRegistroServiziException{
  1131.         
  1132.         if ( nome==null )
  1133.             throw new DriverRegistroServiziException("[UDDILib.existsRuolo]: Alcuni parametri non definiti");
  1134.         try{
  1135.             TModel t = getTModel(UDDILib.RUOLO, UDDILib.RUOLO_PREFIX+nome);
  1136.             if(t == null)
  1137.                 throw new Exception("TModel is null");
  1138.         }catch(DriverRegistroServiziNotFound e){
  1139.             return false;
  1140.         }catch(Exception e){
  1141.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1142.         }
  1143.         return true;    
  1144.     }

  1146.     /**
  1147.      * Si occupa di modificare il nome della TModel che registra il ruolo con nome <var>nomeOLD</var>
  1148.      *
  1149.      * @param nomeOLD vecchio nome che identifica il ruolo
  1150.      * @param nomeNEW nuovo nome che identifica il ruolo
  1151.      * @param url nuova url del file XML associato al ruolo
  1152.      */
  1153.     public void updateRuolo(String nomeOLD,String nomeNEW,String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1154.         this.updateTModel(UDDILib.RUOLO, UDDILib.RUOLO_PREFIX+nomeOLD, UDDILib.RUOLO_PREFIX+nomeNEW, url);
  1155.     }

  1157.     /**
  1158.      * Il metodo si occupa di cancellare la TModel identificata dal parametro
  1159.      *
  1160.      * @param nome nome che identifica il ruolo
  1161.      */
  1162.     public void deleteRuolo(String nome) throws DriverRegistroServiziException{
  1163.         this.deleteTModel(UDDILib.RUOLO, UDDILib.RUOLO_PREFIX+nome);
  1164.     }

  1166.     /**
  1167.      * Il metodo si occupa di impostare la url del file XML della TModel
  1168.      *
  1169.      * @param nome Nome che identifica il ruolo
  1170.      * @param url url del file XML associato al ruolo
  1171.      */
  1172.     public void updateUrlXmlRuolo(String nome, String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1173.         this.updateUrlXmlTModel(UDDILib.RUOLO, UDDILib.RUOLO_PREFIX+nome, url);
  1174.     }
  1175.     /**
  1176.      * Si occupa di recuperare la URL dell'XML associato al ruolo
  1177.      * registrato con il nome <var>nome</var>
  1178.      *
  1179.      * @param nome Nome che identifica il ruolo
  1180.      * @return la url dell'XML associato al ruolo
  1181.      * 
  1182.      */
  1183.     public String getUrlXmlRuolo(String nome) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1184.         if ( nome==null )
  1185.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlRuolo]: Alcuni parametri non definiti");
  1186.         try{
  1187.             TModel tm = getTModel(UDDILib.RUOLO, UDDILib.RUOLO_PREFIX+nome);
  1188.             return tm.getOverviewDoc().getOverviewURLString();
  1189.         }catch(DriverRegistroServiziNotFound e){
  1190.             throw e;
  1191.         }catch(Exception e){
  1192.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlRuolo]: "+e.getMessage(),e);
  1193.         }
  1194.     }
  1195.     
  1196.     /**
  1197.      * Si occupa di recuperare la URL dell'XML associato al ruolo
  1198.      * registrata con il nome <var>nome</var>
  1199.      *
  1200.      * @param searchNome Nome che identifica il ruolo
  1201.      * @return la url dell'XML associato al ruolo
  1202.      * 
  1203.      */
  1204.     public String[] getUrlXmlRuolo(String searchNome,String urlRepository) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1205.         try{
  1206.             TModel[] tm = null;
  1207.             if(searchNome!=null){
  1208.                 tm = getTModelByFilter(UDDILib.RUOLO, UDDILib.RUOLO_PREFIX+searchNome,urlRepository,true);
  1209.             }else{
  1210.                 tm = getTModelByFilter(UDDILib.RUOLO, UDDILib.RUOLO_PREFIX,urlRepository,false);
  1211.             }
  1212.             
  1213.             if(tm!=null){
  1214.                 String[] url = new String[tm.length];
  1215.                 for(int i=0; i<tm.length; i++){
  1216.                     url[i] = tm[i].getOverviewDoc().getOverviewURLString();
  1217.                 }
  1218.                 return url;
  1219.             }else{
  1220.                 throw new DriverRegistroServiziNotFound("Ruolo (definizione XML) non trovate");
  1221.             }
  1222.         }
  1223.         catch (DriverRegistroServiziNotFound e){
  1224.             throw e;
  1225.         }
  1226.         catch(Exception e){
  1227.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlRuolo]: "+e.getMessage(),e);
  1228.         }
  1229.     }
  1230.     
  1231.     
  1232.     
  1233.     
  1234.     
  1235.     
  1236.     
  1237.     
  1238.     
  1239.     
  1240.     
  1241.     
  1242.     
  1243.     
  1244.     
  1245.     
  1246.     /* ******** M E T O D I   S C O P E   ******** */


  1249.     
  1250.     /**
  1251.      * Si occupa di recuperare il TModel che registra il scope con nome <var>nome</var>
  1252.      *
  1253.      * @param nome nome che identifica il scope
  1254.      * @return la TModel che registra il scope
  1255.      */
  1256.     public TModel getScope(String nome) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1257.         return this.getTModel(UDDILib.SCOPE, UDDILib.SCOPE_PREFIX+nome);
  1258.     }
  1259.     
  1260.     /**
  1261.      * Si occupa di recuperare le TModels che soddisfano il filtro
  1262.      *
  1263.      * @param urlRepository Url del Repository
  1264.      * @return una lista di TModel che registra i scope
  1265.      */
  1266.     public TModel[] getScopes(String urlRepository) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1267.         return this.getTModelByFilter(UDDILib.SCOPE, UDDILib.SCOPE_PREFIX, urlRepository, false);
  1268.     }
  1269.     
  1270.     /**
  1271.      * Si occupa di registrare come TModel un scope con nome <var>nome</var>
  1272.      *
  1273.      * @param nome Nome che identifica il scope
  1274.      * @param url url del file XML associato al scope
  1275.      */ 
  1276.     public void createScope(String nome, String url) throws DriverRegistroServiziException{
  1277.         this.createTModel(UDDILib.SCOPE, UDDILib.SCOPE_PREFIX+ nome, url);
  1278.     }

  1280.     /**
  1281.      * Il metodo si occupa di verificare se nel registro e' regitrata una TModel identificata dal parametro
  1282.      *
  1283.      * @param nome Nome del scope
  1284.      * @return true se la TModel risulta registrata, false altrimenti
  1285.      * 
  1286.      */
  1287.     public boolean existsScope(String nome) throws DriverRegistroServiziException{
  1288.         
  1289.         if ( nome==null )
  1290.             throw new DriverRegistroServiziException("[UDDILib.existsScope]: Alcuni parametri non definiti");
  1291.         try{
  1292.             TModel t = getTModel(UDDILib.SCOPE, UDDILib.SCOPE_PREFIX+nome);
  1293.             if(t == null)
  1294.                 throw new Exception("TModel is null");
  1295.         }catch(DriverRegistroServiziNotFound e){
  1296.             return false;
  1297.         }catch(Exception e){
  1298.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1299.         }
  1300.         return true;    
  1301.     }

  1303.     /**
  1304.      * Si occupa di modificare il nome della TModel che registra il scope con nome <var>nomeOLD</var>
  1305.      *
  1306.      * @param nomeOLD vecchio nome che identifica il scope
  1307.      * @param nomeNEW nuovo nome che identifica il scope
  1308.      * @param url nuova url del file XML associato al scope
  1309.      */
  1310.     public void updateScope(String nomeOLD,String nomeNEW,String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1311.         this.updateTModel(UDDILib.SCOPE, UDDILib.SCOPE_PREFIX+nomeOLD, UDDILib.SCOPE_PREFIX+nomeNEW, url);
  1312.     }

  1314.     /**
  1315.      * Il metodo si occupa di cancellare la TModel identificata dal parametro
  1316.      *
  1317.      * @param nome nome che identifica il scope
  1318.      */
  1319.     public void deleteScope(String nome) throws DriverRegistroServiziException{
  1320.         this.deleteTModel(UDDILib.SCOPE, UDDILib.SCOPE_PREFIX+nome);
  1321.     }

  1323.     /**
  1324.      * Il metodo si occupa di impostare la url del file XML della TModel
  1325.      *
  1326.      * @param nome Nome che identifica il scope
  1327.      * @param url url del file XML associato al scope
  1328.      */
  1329.     public void updateUrlXmlScope(String nome, String url) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1330.         this.updateUrlXmlTModel(UDDILib.SCOPE, UDDILib.SCOPE_PREFIX+nome, url);
  1331.     }
  1332.     /**
  1333.      * Si occupa di recuperare la URL dell'XML associato al scope
  1334.      * registrato con il nome <var>nome</var>
  1335.      *
  1336.      * @param nome Nome che identifica il scope
  1337.      * @return la url dell'XML associato al scope
  1338.      * 
  1339.      */
  1340.     public String getUrlXmlScope(String nome) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1341.         if ( nome==null )
  1342.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlScope]: Alcuni parametri non definiti");
  1343.         try{
  1344.             TModel tm = getTModel(UDDILib.SCOPE, UDDILib.SCOPE_PREFIX+nome);
  1345.             return tm.getOverviewDoc().getOverviewURLString();
  1346.         }catch(DriverRegistroServiziNotFound e){
  1347.             throw e;
  1348.         }catch(Exception e){
  1349.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlScope]: "+e.getMessage(),e);
  1350.         }
  1351.     }
  1352.     
  1353.     /**
  1354.      * Si occupa di recuperare la URL dell'XML associato al scope
  1355.      * registrata con il nome <var>nome</var>
  1356.      *
  1357.      * @param searchNome Nome che identifica il scope
  1358.      * @return la url dell'XML associato al scope
  1359.      * 
  1360.      */
  1361.     public String[] getUrlXmlScope(String searchNome,String urlRepository) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1362.         try{
  1363.             TModel[] tm = null;
  1364.             if(searchNome!=null){
  1365.                 tm = getTModelByFilter(UDDILib.SCOPE, UDDILib.SCOPE_PREFIX+searchNome,urlRepository,true);
  1366.             }else{
  1367.                 tm = getTModelByFilter(UDDILib.SCOPE, UDDILib.SCOPE_PREFIX,urlRepository,false);
  1368.             }
  1369.             
  1370.             if(tm!=null){
  1371.                 String[] url = new String[tm.length];
  1372.                 for(int i=0; i<tm.length; i++){
  1373.                     url[i] = tm[i].getOverviewDoc().getOverviewURLString();
  1374.                 }
  1375.                 return url;
  1376.             }else{
  1377.                 throw new DriverRegistroServiziNotFound("Scope (definizione XML) non trovate");
  1378.             }
  1379.         }
  1380.         catch (DriverRegistroServiziNotFound e){
  1381.             throw e;
  1382.         }
  1383.         catch(Exception e){
  1384.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlScope]: "+e.getMessage(),e);
  1385.         }
  1386.     }
  1387.     
  1388.     
  1389.     
  1390.     
  1391.     
  1392.     
  1393.     
  1394.     
  1395.     
  1396.     
  1397.     
  1398.     
  1399.     
  1400.     




  1405.     /* ------------------- (Business Entity)  --------------------- */

  1407.     /**
  1408.      * Il metodo si occupa di cercare all'interno del registro le businessEntity che hanno un match con
  1409.      * i valori passati per parametro.
  1410.      *
  1411.      * @param idSogg del Soggetto.
  1412.      * @return un oggetto BusinessEntity se la ricerca ha successo, null altrimenti.
  1413.      */
  1414.     protected BusinessEntity getBusinessEntity(IDSoggetto idSogg) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1415.         
  1416.         if ( (idSogg==null) || (idSogg.getNome()==null) || (idSogg.getTipo()==null))
  1417.             throw new DriverRegistroServiziException("[UDDILib.getBusinessEntity]: Alcuni parametri non definiti");
  1418.         
  1419.         String keyBE = idSogg.getTipo() + "/" + idSogg.getNome();

  1421.         BusinessEntity be=null;
  1422.         try{
  1423.             Vector<Name> names = new Vector<Name>();
  1424.             names.add(new Name("%"));
  1425.             IdentifierBag identifierBag= new IdentifierBag();
  1426.             KeyedReference k1 = new KeyedReference();
  1427.             k1.setKeyValue(keyBE);
  1428.             k1.setTModelKey(this.tmkID);
  1429.             Vector<KeyedReference> keyedReferenceVector = new Vector<KeyedReference>();
  1430.             keyedReferenceVector.add(k1);
  1431.             identifierBag.setKeyedReferenceVector(keyedReferenceVector);
  1432.             BusinessList businessList = this.proxy.find_business(names, null, identifierBag, null, null, null, 1);
  1433.             if(businessList.getBusinessInfos()==null || businessList.getBusinessInfos().size()==0)
  1434.                 throw new DriverRegistroServiziNotFound("BusinessEntity non trovata");
  1435.             Vector<?> businessInfoVector  = businessList.getBusinessInfos().getBusinessInfoVector();
  1436.             BusinessInfo bi = (BusinessInfo) businessInfoVector.elementAt(0);
  1437.             BusinessDetail bd = this.proxy.get_businessDetail(bi.getBusinessKey());
  1438.             Vector<?> v = bd.getBusinessEntityVector();
  1439.             be = (BusinessEntity) v.elementAt(0);
  1440.         }
  1441.         catch (UDDIException e){
  1442.             throw new DriverRegistroServiziException("[UDDILib.getBusinessEntity]: "+e.getMessage(),e);
  1443.         }
  1444.         catch (TransportException e){
  1445.             throw new DriverRegistroServiziException("[UDDILib.getBusinessEntity]: "+e.getMessage(),e);
  1446.         }
  1447.         catch (DriverRegistroServiziNotFound e){
  1448.             throw e;
  1449.         }
  1450.         catch (Exception e){
  1451.             throw new DriverRegistroServiziException("[UDDILib.getBusinessEntity]: "+e.getMessage(),e);
  1452.         }
  1453.         
  1454.         return be;
  1455.     }
  1456.     
  1457.     /**
  1458.      * Il metodo si occupa di cercare all'interno del registro le businessEntity che hanno un match con
  1459.      * i valori passati per parametro.
  1460.      *
  1461.      * @return un oggetto BusinessEntity se la ricerca ha successo, null altrimenti.
  1462.      */
  1463.     protected BusinessEntity[] getBusinessEntities() throws DriverRegistroServiziException,DriverRegistroServiziNotFound{

  1465.         try{
  1466.             Vector<Name> names = new Vector<Name>();
  1467.             names.add(new Name("%"));
  1468.             
  1469.             Vector<BusinessEntity> bus = new Vector<BusinessEntity>();
  1470.             BusinessList businessList = this.proxy.find_business(names, null, null, null, null, null, UDDILib.MAX_SEARCH);
  1471.             if(businessList!=null && businessList.getBusinessInfos()!=null){
  1472.                 Vector<?> businessInfoVector  = businessList.getBusinessInfos().getBusinessInfoVector();
  1473.                 for(int i=0; i<businessInfoVector.size(); i++){
  1474.                     BusinessInfo bi = (BusinessInfo) businessInfoVector.elementAt(i);
  1475.                     BusinessDetail bd = this.proxy.get_businessDetail(bi.getBusinessKey());
  1476.                     Vector<?> v = bd.getBusinessEntityVector();
  1477.                     BusinessEntity be = (BusinessEntity) v.elementAt(0);
  1478.                     bus.add(be);
  1479.                 }
  1480.             }
  1481.             
  1482.             if(bus.size()>0){
  1483.                 BusinessEntity[] be = new BusinessEntity[1];
  1484.                 be = bus.toArray(be);
  1485.                 return be;
  1486.             }else{
  1487.                 throw new DriverRegistroServiziNotFound("Non sono state trovate BusinessEntity nel registro UDDI");
  1488.             }
  1489.         }
  1490.         catch (UDDIException e){
  1491.             throw new DriverRegistroServiziException("[UDDILib.getBusinessEntity]: "+e.getMessage(),e);
  1492.         }
  1493.         catch (TransportException e){
  1494.             throw new DriverRegistroServiziException("[UDDILib.getBusinessEntity]: "+e.getMessage(),e);
  1495.         }
  1496.         catch (DriverRegistroServiziNotFound e){
  1497.             throw e;
  1498.         }
  1499.         catch (Exception e){
  1500.             throw new DriverRegistroServiziException("[UDDILib.getBusinessEntity]: "+e.getMessage(),e);
  1501.         }
  1502.     }

  1504.     /**
  1505.      * Il metodo si occupa di aggiungere nel registro una nuova BusinessEntity 
  1506.      * con tipo di identificativo 'tipo' e codice identificativo 'codice'.
  1507.      *  
  1508.      * @param idSogg del Soggetto.
  1509.      * @return la BusinessEntity inserita, se l'inserimento ha successo
  1510.      */
  1511.     protected BusinessEntity addBusinessEntity(IDSoggetto idSogg)throws DriverRegistroServiziException{
  1512.         
  1513.         if ( (idSogg==null) || (idSogg.getNome()==null) || (idSogg.getTipo()==null) || (idSogg.getCodicePorta()==null))
  1514.             throw new DriverRegistroServiziException("[UDDILib.addBusinessEntity]: Alcuni parametri non definiti");

  1516.         String keyBE =  idSogg.getTipo() + "/" + idSogg.getNome();

  1518.         try{
  1519.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  1521.             KeyedReference k1 = new KeyedReference();
  1522.             k1.setKeyName(idSogg.getCodicePorta());
  1523.             k1.setKeyValue(keyBE);  
  1524.             k1.setTModelKey(this.tmkID);

  1526.             Vector<KeyedReference> keyedReferenceVector1 = new Vector<KeyedReference>();
  1527.             keyedReferenceVector1.add(k1);

  1529.             BusinessEntity be = new BusinessEntity("",keyBE);

  1531.             IdentifierBag ib = new IdentifierBag();
  1532.             ib.setKeyedReferenceVector(keyedReferenceVector1);
  1533.             be.setIdentifierBag(ib);

  1535.             CategoryBag cb = new CategoryBag();
  1536.             be.setCategoryBag(cb);

  1538.             Vector<BusinessEntity> entities = new Vector<BusinessEntity>();
  1539.             entities.addElement(be);

  1541.             BusinessDetail bd = this.proxy.save_business(token.getAuthInfoString(),entities);

  1543.             Vector<?> businessEntities = bd.getBusinessEntityVector();
  1544.             be = (BusinessEntity) businessEntities.elementAt(0);

  1546.             return be;
  1547.         }
  1548.         catch (UDDIException e){
  1549.             throw new DriverRegistroServiziException("[UDDILib.addBusinessEntity]: "+e.getMessage(),e);
  1550.         }
  1551.         catch (TransportException e){
  1552.             throw new DriverRegistroServiziException("[UDDILib.addBusinessEntity]: "+e.getMessage(),e);
  1553.         }
  1554.         catch (Exception e){
  1555.             throw new DriverRegistroServiziException("[UDDILib.addBusinessEntity]: "+e.getMessage(),e);
  1556.         }

  1558.     }
  1559.     
  1560.     /**
  1561.      * Si occupa di cancellare la BusinessEntity identificata dai parametri
  1562.      *
  1563.      *@param idSogg Identificativo del soggetto
  1564.      */ 
  1565.     protected void deleteBusinessEntity(IDSoggetto idSogg) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1566.         if ( (idSogg==null) || (idSogg.getNome()==null) || (idSogg.getTipo()==null) )
  1567.             throw new DriverRegistroServiziException("[UDDILib.deleteBusinessEntity]: Alcuni parametri non definiti");

  1569.         try{
  1570.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  1572.             BusinessEntity be = getBusinessEntity(idSogg);
  1573.             this.proxy.delete_business(token.getAuthInfoString(), be.getBusinessKey());
  1574.         }catch (DriverRegistroServiziNotFound e){
  1575.             throw e;
  1576.         }catch(Exception e){
  1577.             throw new DriverRegistroServiziException("[UDDILib.deleteBusinessEntity]: "+e.getMessage(),e);
  1578.         }
  1579.     }
  1580.     
  1581.     /**
  1582.      * Il metodo assegna alla BusinessEntity <var>be</var> la descrizione <var>descrizione</var>
  1583.      * 
  1584.      * @param be Business Entity
  1585.      * @param nome Nome da assegnare alla Business Entity
  1586.      * @return la BusinessEntity modificata, se la modifica ha successo
  1587.      */
  1588.     protected BusinessEntity updateNomeBusinessEntity(BusinessEntity be, String nome)throws DriverRegistroServiziException{
  1589.         if ( (be==null) || (nome==null) )
  1590.             throw new DriverRegistroServiziException("[UDDILib.updateNomeBusinessEntity]: Alcuni parametri non definiti");

  1592.         try{
  1593.             be.setDefaultName(new Name(nome));    
  1594.             Vector<BusinessEntity> entities = new Vector<BusinessEntity>();
  1595.             entities.addElement(be);
  1596.             
  1597.             AuthToken token = this.proxy.get_authToken(this.username,this.password);
  1598.             this.proxy.save_business(token.getAuthInfoString(),entities);
  1599.         }
  1600.         catch (UDDIException e){
  1601.             throw new DriverRegistroServiziException("[UDDILib.updateDescrizioneBusinessEntity]: "+e.getMessage(),e);
  1602.         }
  1603.         catch (TransportException e){
  1604.             throw new DriverRegistroServiziException("[UDDILib.updateDescrizioneBusinessEntity]: "+e.getMessage(),e);
  1605.         }
  1606.         catch (Exception e){
  1607.             throw new DriverRegistroServiziException("[UDDILib.updateDescrizioneBusinessEntity]: "+e.getMessage(),e);
  1608.         }
  1609.         return be;
  1610.     }
  1611.     
  1612.     /**
  1613.      * Il metodo si recuperare il nome della BusinessEntity <var>be</var>.
  1614.      *
  1615.      * @param be Business Entity
  1616.      * @return il nome della BusinessEntity.
  1617.      */
  1618.     protected String getNomeBusinessEntity(BusinessEntity be)throws DriverRegistroServiziException{
  1619.         if (be==null)
  1620.             throw new DriverRegistroServiziException("[UDDILib.getNomeBusinessEntity]: Alcuni parametri non definiti");
  1621.         try{
  1622.             return be.getDefaultName().getText();
  1623.         }catch (Exception e){
  1624.             throw new DriverRegistroServiziException("[UDDILib.getNomeBusinessEntity]: "+e.getMessage(),e);
  1625.         }
  1626.     }
  1627.     
  1628.     /**
  1629.      * Il metodo si occupa di aggiungere alla BusinessEntity <var>be</var> una maggiore descrizione 
  1630.      * passata nel parametro <var>descrizione</var>.
  1631.      * @param be Business Entity
  1632.      * @param descrizione Descrizione associata al Soggetto
  1633.      * @return la BusinessEntity modificata se tutto e' andato bene.
  1634.      */ 
  1635.     protected BusinessEntity updateDescrizioneBusinessEntity(BusinessEntity be, String descrizione)throws DriverRegistroServiziException{
  1636.         if ( (be==null) || (descrizione==null) )
  1637.             throw new DriverRegistroServiziException("[UDDILib.updateDescrizioneBusinessEntity]: Alcuni parametri non definiti");

  1639.         try{
  1640.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  1642.             be.setDefaultDescriptionString(descrizione);

  1644.             Vector<BusinessEntity> entities = new Vector<BusinessEntity>();
  1645.             entities.addElement(be);

  1647.             this.proxy.save_business(token.getAuthInfoString(),entities);
  1648.         }
  1649.         catch (UDDIException e){
  1650.             throw new DriverRegistroServiziException("[UDDILib.updateDescrizioneBusinessEntity]: "+e.getMessage(),e);
  1651.         }
  1652.         catch (TransportException e){
  1653.             throw new DriverRegistroServiziException("[UDDILib.updateDescrizioneBusinessEntity]: "+e.getMessage(),e);
  1654.         }
  1655.         catch (Exception e){
  1656.             throw new DriverRegistroServiziException("[UDDILib.updateDescrizioneBusinessEntity]: "+e.getMessage(),e);
  1657.         }
  1658.         return be;
  1659.     }
  1660.     
  1661.     /**
  1662.      * Il metodo si occupa di settare nella BusinessEntity <var>be</var> una category bag
  1663.      * contenente come valore la url dell'xml associato al Soggetto.
  1664.      *
  1665.      * @param be Business Entity
  1666.      * @param url url del file XML associato al soggetto.
  1667.      * @return la BusinessEntity modificata in caso di successo, null altrimenti.
  1668.      */
  1669.     protected BusinessEntity updateUrlXmlBusinessEntity(BusinessEntity be, String url)throws DriverRegistroServiziException{
  1670.         if ( (be==null) || (url==null))
  1671.             throw new DriverRegistroServiziException("[UDDILib.updateUrlXmlBusinessEntity]: Alcuni parametri non definiti");

  1673.         try{
  1674.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  1676.             KeyedReference k1 = new KeyedReference();
  1677.             k1.setKeyName(org.openspcoop2.utils.Costanti.OPENSPCOOP2);
  1678.             k1.setKeyValue(url);
  1679.             Vector<BusinessEntity> entities = new Vector<BusinessEntity>();
  1680.             CategoryBag ib = be.getCategoryBag();
  1681.             if(ib == null)
  1682.                 ib = new CategoryBag();
  1683.             ib.add(k1); 
  1684.             be.setCategoryBag(ib);
  1685.             entities.addElement(be);
  1686.             this.proxy.save_business(token.getAuthInfoString(),entities);       
  1687.         }
  1688.         catch (UDDIException e){
  1689.             throw new DriverRegistroServiziException("[UDDILib.updateUrlXmlBusinessEntity]: "+e.getMessage(),e);
  1690.         }
  1691.         catch (TransportException e){
  1692.             throw new DriverRegistroServiziException("[UDDILib.updateUrlXmlBusinessEntity]: "+e.getMessage(),e);
  1693.         }
  1694.         catch (Exception e){
  1695.             throw new DriverRegistroServiziException("[UDDILib.updateUrlXmlBusinessEntity]: "+e.getMessage(),e);
  1696.         }

  1698.         return be;
  1699.     }
  1700.     
  1701.     /**
  1702.      * Il metodo si occupa di impostare il keyName della category bag del soggetto
  1703.      *
  1704.      * @param idSogg Identificativo del Soggetto
  1705.      * @param categoryBagName
  1706.      */
  1707.     protected void updateCategoryBagKeyNameBusinessEntity(IDSoggetto idSogg,String categoryBagName) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1708.         if ( (idSogg==null) || (idSogg.getNome()==null) || (idSogg.getTipo()==null) || (categoryBagName==null))
  1709.             throw new DriverRegistroServiziException("[UDDILib.updateCategoryBagKeyNameBusinessEntity]: Alcuni parametri non definiti");

  1711.         try{
  1712.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  1714.             BusinessEntity be = getBusinessEntity(idSogg);  

  1716.             CategoryBag cb = be.getCategoryBag();
  1717.             Vector<?> krv = cb.getKeyedReferenceVector();
  1718.             KeyedReference kr = (KeyedReference) krv.elementAt(0);
  1719.             kr.setKeyName(categoryBagName);
  1720.             cb.setKeyedReferenceVector(krv);
  1721.             be.setCategoryBag(cb);
  1722.             Vector<BusinessEntity> entities = new Vector<BusinessEntity>();
  1723.             entities.addElement(be);

  1725.             this.proxy.save_business(token.getAuthInfoString(),entities);

  1727.         }catch (DriverRegistroServiziNotFound e){
  1728.             throw e;
  1729.         }
  1730.         catch (Exception e){
  1731.             throw new DriverRegistroServiziException("[UDDILib.updateCategoryBagKeyNameBusinessEntity]: "+e.getMessage(),e);
  1732.         }
  1733.     }
  1734.     
  1735.     
  1736.     
  1737.     
  1738.     
  1739.     
  1740.     
  1741.     
  1742.     
  1743.     
  1744.     /* --------------- Soggetto -------------------*/
  1745.     
  1746.     /**
  1747.      * Il metodo si occupa di aggiungere nel registro un nuovo Soggetto. 
  1748.      * 
  1749.      * @param idSogg Identificativo del soggetto
  1750.      * @param descrizione Descrizione da assegnare al Soggetto
  1751.      * @param urlXML url dell'XML associato al Soggetto.
  1752.      */
  1753.     public void createSoggetto(IDSoggetto idSogg, 
  1754.             String descrizione, String urlXML)throws DriverRegistroServiziException{

  1756.         if ( (idSogg==null) || (idSogg.getNome()==null) || (idSogg.getTipo()==null)||
  1757.                 (descrizione==null) ||  (idSogg.getCodicePorta()==null) || (urlXML==null)){
  1758.             throw new DriverRegistroServiziException("[UDDILib.createSoggetto]: Alcuni parametri non definiti");
  1759.         }

  1761.         try{
  1762.             // add BusinessEntity
  1763.             BusinessEntity be = addBusinessEntity(idSogg);
  1764.             
  1765.             // set Descrizione in BusinessEntity
  1766.             try{
  1767.                 be=updateNomeBusinessEntity(be,descrizione);
  1768.             }catch(Exception e){
  1769.                 try{
  1770.                     //rollback quanto fatto prima
  1771.                     deleteBusinessEntity(idSogg);
  1772.                 }catch(Exception rollbackE){
  1773.                     // ignore
  1774.                 }
  1775.                 throw e; // rilancio l'eccezione
  1776.             }

  1778.             // set url XML nella BusinessEntity
  1779.             try{
  1780.                 updateUrlXmlBusinessEntity(be,urlXML);
  1781.             }catch(Exception e){
  1782.                 try{
  1783.                     //rollback quanto fatto prima
  1784.                     deleteBusinessEntity(idSogg);
  1785.                 }catch(Exception rollbackE){
  1786.                     // ignore
  1787.                 }
  1788.                 throw e; // rilancio l'eccezione
  1789.             }

  1791.         }catch(Exception e){
  1792.             throw new DriverRegistroServiziException("[UDDILib.createSoggetto]: "+e.getMessage(),e);
  1793.                     }
  1794.     }
  1795.     
  1796.     /**
  1797.      * Il metodo si occupa di verificare se nel registro e' regitrato un Soggetto identificato dai parametri
  1798.      *
  1799.      * @param idSogg del Soggetto
  1800.      * @return true se il Soggetto risulta registrato, false altrimenti
  1801.      */
  1802.     public boolean existsSoggetto(IDSoggetto idSogg)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1803.         if ( idSogg==null )
  1804.             throw new DriverRegistroServiziException("[UDDILib.existsSoggetto]: Alcuni parametri non definiti");
  1805.         BusinessEntity be = null;
  1806.         try{
  1807.             be = getBusinessEntity(idSogg);
  1808.             if(be == null)
  1809.                 throw new Exception("BusinessEntity is null");
  1810.         }catch (DriverRegistroServiziNotFound e){
  1811.             return false;
  1812.         }
  1813.         catch(Exception e){
  1814.             throw new DriverRegistroServiziException(e.getMessage(),e);
  1815.         }
  1816.         return true;
  1817.     }

  1819.     /**
  1820.      * Il metodo si occupa di recuperare l'url del file XML del Soggetto.
  1821.      *
  1822.      * @param idSogg Identificativo del Soggetto
  1823.      */
  1824.     public String getUrlXmlSoggetto(IDSoggetto idSogg)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1825.         if ( idSogg==null )
  1826.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlSoggetto]: Alcuni parametri non definiti");
  1827.         try
  1828.         {
  1829.             BusinessEntity be =  getBusinessEntity(idSogg);
  1830.             return be.getCategoryBag().get(0).getKeyValue();
  1831.         }
  1832.         catch (DriverRegistroServiziNotFound e){
  1833.             throw e;
  1834.         }
  1835.         catch (Exception e){
  1836.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlSoggetto]: "+e.getMessage(),e);
  1837.         }
  1838.     }       
  1839.     
  1840.     /**
  1841.      * Il metodo si occupa di recuperare l'url del file XML del Soggetto.
  1842.      *
  1843.      */
  1844.     public String[] getUrlXmlSoggetti()throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1845.         try
  1846.         {
  1847.             BusinessEntity[] be =  getBusinessEntities();
  1848.             String [] url = new String[be.length];
  1849.             for(int i=0; i<be.length; i++){
  1850.                 url[i] = be[i].getCategoryBag().get(0).getKeyValue();
  1851.             }
  1852.             return url;
  1853.         }
  1854.         catch (DriverRegistroServiziNotFound e){
  1855.             throw e;
  1856.         }
  1857.         catch (Exception e){
  1858.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlSoggetto]: "+e.getMessage(),e);
  1859.         }
  1860.     }       

  1862.     /**
  1863.      * Il metodo si occupa di impostare la url del file XML associato al Soggetto
  1864.      *
  1865.      * @param idSogg Identificativo del Soggetto
  1866.      * @param url Url da impostare
  1867.      */
  1868.     public void updateUrlXmlSoggetto(IDSoggetto idSogg,String url)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1869.         if ( idSogg==null  || url==null)
  1870.             throw new DriverRegistroServiziException("[UDDILib.updateUrlXmlSoggetto]: Alcuni parametri non definiti");
  1871.     
  1872.         try{
  1873.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  1875.             BusinessEntity be = getBusinessEntity(idSogg);  

  1877.             CategoryBag cb = be.getCategoryBag();
  1878.             Vector<?> krv = cb.getKeyedReferenceVector();
  1879.             KeyedReference kr = (KeyedReference) krv.elementAt(0);
  1880.             kr.setKeyValue(url);
  1881.             cb.setKeyedReferenceVector(krv);
  1882.             be.setCategoryBag(cb);
  1883.             Vector<BusinessEntity> entities = new Vector<BusinessEntity>();
  1884.             entities.addElement(be);

  1886.             this.proxy.save_business(token.getAuthInfoString(),entities);

  1888.         }catch (DriverRegistroServiziNotFound e){
  1889.             throw e;
  1890.         }
  1891.         catch (Exception e){
  1892.             throw new DriverRegistroServiziException("[UDDILib.updateUrlXmlSoggetto]: "+e.getMessage(),e);
  1893.         }
  1894.     }

  1896.     /**
  1897.      * Il metodo si occupa di impostare la descrizione associata al Soggetto
  1898.      *
  1899.      * @param idSogg Identificativo del Soggetto
  1900.      * @param descrizione Descrizione da associare al soggetto
  1901.      */
  1902.     public void updateDescrizioneSoggetto(IDSoggetto idSogg,String descrizione) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1903.         if ( idSogg==null  || descrizione==null)
  1904.             throw new DriverRegistroServiziException("[UDDILib.updateDescrizioneSoggetto]: Alcuni parametri non definiti");

  1906.         try{
  1907.             BusinessEntity be = getBusinessEntity(idSogg);
  1908.             updateNomeBusinessEntity(be,descrizione);
  1909.         }
  1910.         catch (DriverRegistroServiziNotFound e){
  1911.             throw e;
  1912.         }
  1913.         catch (Exception e){
  1914.             throw new DriverRegistroServiziException("[UDDILib.updateDescrizioneSoggetto]: "+e.getMessage(),e);
  1915.         }
  1916.     }

  1918.     /**
  1919.      * Il metodo si occupa di modificare il codice tipo/valore associato al Soggetto
  1920.      *
  1921.      * @param idSoggOLD Vecchio identificativo del Soggetto
  1922.      * @param idSoggNEW Nuovo identificativo del Soggetto
  1923.      */
  1924.     public void updateIdSoggetto(IDSoggetto idSoggOLD,IDSoggetto idSoggNEW)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1925.         if ( (idSoggOLD==null) || (idSoggOLD.getNome()==null) || (idSoggOLD.getTipo()==null) || 
  1926.              (idSoggNEW==null) || (idSoggNEW.getNome()==null) || (idSoggNEW.getTipo()==null))
  1927.             throw new DriverRegistroServiziException("[UDDILib.updateIdSoggetto]: Alcuni parametri non definiti");

  1929.         try{
  1930.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  1932.             BusinessEntity be = getBusinessEntity(idSoggOLD);
  1933.     
  1934.             IdentifierBag ib = be.getIdentifierBag();
  1935.             Vector<?> v = ib.getKeyedReferenceVector();
  1936.             KeyedReference kr = (KeyedReference) v.elementAt(0);

  1938.             String newValue = idSoggNEW.getTipo() + "/" + idSoggNEW.getNome();

  1940.             kr.setKeyValue(newValue);
  1941.             ib.setKeyedReferenceVector(v);
  1942.             be.setIdentifierBag(ib);

  1944.             Vector<BusinessEntity> entities = new Vector<BusinessEntity>();
  1945.             entities.addElement (be);

  1947.             BusinessDetail bd = this.proxy.save_business(token.getAuthInfoString(),entities);

  1949.             Vector<?> businessEntities = bd.getBusinessEntityVector();
  1950.             be = (BusinessEntity) businessEntities.elementAt (0);
  1951.         }
  1952.         catch (DriverRegistroServiziNotFound e){
  1953.             throw e;
  1954.         }
  1955.         catch (Exception e){
  1956.             throw new DriverRegistroServiziException("[UDDILib.updateIdSoggetto]: "+e.getMessage(),e);
  1957.         }
  1958.     }


  1961.     /**
  1962.      * Si occupa di cancellare il Soggetto identificata dai parametri
  1963.      *
  1964.      * @param idSogg Identificativo del soggetto
  1965.      */ 
  1966.     public void deleteSoggetto(IDSoggetto idSogg)throws DriverRegistroServiziException{
  1967.         if ( idSogg==null )
  1968.             throw new DriverRegistroServiziException("[UDDILib.deleteSoggetto]: Alcuni parametri non definiti");
  1969.         try{
  1970.             deleteBusinessEntity(idSogg);
  1971.         }catch(Exception e){
  1972.             throw new DriverRegistroServiziException("[UDDILib.deleteSoggetto]: "+e.getMessage(),e);
  1973.         }
  1974.     }

  1976.     /**
  1977.      * Il metodo si occupa di impostare il codice della porta di dominio associato al Soggetto
  1978.      *
  1979.      * @param idSogg Identificativo del Soggetto
  1980.      * @param newIdentificativoPorta Nuovo codice di dominio associare al soggetto
  1981.      */
  1982.     public void updateIdentificativoPortaSoggetto(IDSoggetto idSogg,String newIdentificativoPorta)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  1983.         if ( idSogg==null || newIdentificativoPorta==null)
  1984.             throw new DriverRegistroServiziException("[UDDILib.updateIdentificativoPortaSoggetto]: Alcuni parametri non definiti");
  1985.     
  1986.         try{
  1987.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  1989.             BusinessEntity be = getBusinessEntity(idSogg);

  1991.             IdentifierBag ib = be.getIdentifierBag();
  1992.             Vector<?> v = ib.getKeyedReferenceVector();
  1993.             KeyedReference kr = (KeyedReference) v.elementAt(0);
  1994.             kr.setKeyName(newIdentificativoPorta);
  1995.             ib.setKeyedReferenceVector(v);
  1996.             be.setIdentifierBag(ib);

  1998.             Vector<BusinessEntity> entities = new Vector<BusinessEntity>();
  1999.             entities.addElement (be);

  2001.             BusinessDetail bd = this.proxy.save_business(token.getAuthInfoString(),entities);

  2003.             Vector<?> businessEntities = bd.getBusinessEntityVector();
  2004.             be = (BusinessEntity) businessEntities.elementAt (0);
  2005.         }
  2006.         catch (DriverRegistroServiziNotFound e){
  2007.             throw e;
  2008.         }
  2009.         catch (Exception e){
  2010.             throw new DriverRegistroServiziException("[UDDILib.updateIdentificativoPortaSoggetto]: Alcuni parametri non definiti");
  2011.         }
  2012.     }
























  2037.     /* ********  M E T O D I   PRIVATI    ******** */

  2039.     /**
  2040.      * Il metodo si occupa di cercare all'interno del registro il servizio associato
  2041.      * ad una BusinessEntity di nome <var>serviceName</var> 
  2042.      * Ritorna null in caso il servizio risulti non registrato.
  2043.      *
  2044.      * @param be BusinessEntity.
  2045.      * @param idServ Identificativo del Servizio
  2046.      * @return un oggetto BusinessService se la ricerca ha successo
  2047.      */
  2048.     protected BusinessService getBusinessService(BusinessEntity be, IDServizio idServ) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2049.         if ( be==null || idServ==null || idServ.getTipo()==null || idServ.getNome()==null || idServ.getVersione()==null)
  2050.             throw new DriverRegistroServiziException("[UDDILib.getBusinessService]: Alcuni parametri non definiti");
  2051.     
  2052.         try{    

  2054.             String keyService = idServ.getTipo() + "/" + idServ.getNome() + ":"+ idServ.getVersione();

  2056.             BusinessService bs=null;

  2058.             Name nome = new Name(keyService);
  2059.             Vector<Name> nomi = new Vector<Name>();
  2060.             nomi.add(nome);
  2061.             
  2062.             FindQualifiers findQualifiers = new FindQualifiers();
  2063.             Vector<FindQualifier> qualifier = new Vector<FindQualifier>();
  2064.             qualifier.add(new FindQualifier(FindQualifier.exactNameMatch));
  2065.             qualifier.add(new FindQualifier(FindQualifier.caseSensitiveMatch));
  2066.             findQualifiers.setFindQualifierVector(qualifier);

  2068.             ServiceList serviceList = this.proxy.find_service(be.getBusinessKey(), nomi, null, null, findQualifiers, 1);
  2069.             if(serviceList.getServiceInfos()==null || serviceList.getServiceInfos().size()==0)
  2070.                 throw new DriverRegistroServiziNotFound("BusinessService non trovata");
  2071.             
  2072.             Vector<?> serviceInfoVector = serviceList.getServiceInfos().getServiceInfoVector();
  2073.             ServiceInfo serviceInfo = (ServiceInfo) serviceInfoVector.elementAt(0);
  2074.             ServiceDetail sd = this.proxy.get_serviceDetail(serviceInfo.getServiceKey());
  2075.             Vector<?> v = sd.getBusinessServiceVector();
  2076.             bs = (BusinessService) v.elementAt(0);

  2078.             return bs;
  2079.         }
  2080.         catch (DriverRegistroServiziNotFound e){
  2081.             throw e;
  2082.         }
  2083.         catch (UDDIException e){
  2084.             throw new DriverRegistroServiziException("[UDDILib.getBusinessService]: "+e.getMessage(),e);
  2085.         }
  2086.         catch (TransportException e){
  2087.             throw new DriverRegistroServiziException("[UDDILib.getBusinessService]: "+e.getMessage(),e);
  2088.         }
  2089.         catch (Exception e){
  2090.             throw new DriverRegistroServiziException("[UDDILib.getBusinessService]: "+e.getMessage(),e);
  2091.         }

  2093.     }
  2094.     
  2095.     

  2097.     /**
  2098.      * Il metodo si occupa di aggiungere nel registro una nuovo servizio con nome <var>serviceName</var> 
  2099.      * associandolo alla businessEntity <var>be</var>
  2100.      * In caso un servizio con lo stesso nome sia gia' registrato non non fa niente e ritorna null.
  2101.      * 
  2102.      * @param be BusinessEntity.
  2103.      * @param idServ Identificativo del Servizio
  2104.      * @return il BusinessService inserito, se l'inserimento ha successo, null altrimenti.
  2105.      */
  2106.     protected BusinessService createBusinessService(BusinessEntity be, IDServizio idServ) throws DriverRegistroServiziException{
  2107.         if ( be==null || idServ==null || idServ.getTipo()==null || idServ.getNome()==null || idServ.getVersione()==null)
  2108.             throw new DriverRegistroServiziException("[UDDILib.createBusinessService]: Alcuni parametri non definiti");
  2109.     
  2110.         BusinessService bs = null;
  2111.         try{
  2112.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  2114.             String keyService = idServ.getTipo() + "/" + idServ.getNome()+ ":"+idServ.getVersione();

  2116.             String businessKey = be.getBusinessKey();   
  2117.             
  2118.             // verifico che non esista gia' un servizio associato a be
  2119.             try{
  2120.                 bs = getBusinessService(be,idServ);
  2121.             }catch(DriverRegistroServiziNotFound e){
  2122.                 // ignore
  2123.             }
  2124.             
  2125.             /*entro solo se il servizio non e' gia stato registrato*/
  2126.             if(bs==null){
  2127.                 bs = new BusinessService("");
  2128.                 bs.setDefaultNameString(keyService,null);
  2129.                 bs.setBusinessKey(businessKey);
  2130.                 Vector<BusinessService> services = new Vector<BusinessService>();
  2131.                 services.addElement(bs);

  2133.                 ServiceDetail sd = this.proxy.save_service(token.getAuthInfoString(),services);

  2135.                 Vector<?> businessServices = sd.getBusinessServiceVector();
  2136.                 bs = (BusinessService) businessServices.elementAt(0);

  2138.                 BusinessServices bds =  be.getBusinessServices();
  2139.                 bds.add(bs); 

  2141.                 be.setBusinessServices(bds);
  2142.                 Vector<BusinessEntity> entities = new Vector<BusinessEntity>();
  2143.                 entities.addElement(be);
  2144.                 this.proxy.save_business(token.getAuthInfoString(),entities);
  2145.             }
  2146.         }
  2147.         catch (UDDIException e){
  2148.             throw new DriverRegistroServiziException("[UDDILib.createBusinessService]: "+e.getMessage(),e);
  2149.         }
  2150.         catch (TransportException e){
  2151.             throw new DriverRegistroServiziException("[UDDILib.createBusinessService]: "+e.getMessage(),e);
  2152.         }
  2153.         catch (Exception e){
  2154.             throw new DriverRegistroServiziException("[UDDILib.createBusinessService]: "+e.getMessage(),e);
  2155.         }
  2156.         return bs;
  2157.     }
  2158.     
  2159.     /**
  2160.      * Si occupa di cancellare il servizio <var>servizio</var> registrato nella BusinessEntity
  2161.      * identificata dai parametri <var>tipo</var> e <var>cod</var>.
  2162.      *
  2163.      * @param idServ Identificativo del Servizio
  2164.      */ 
  2165.     protected void deleteBusinessService(IDServizio idServ) throws DriverRegistroServiziException{
  2166.         if ( idServ==null || idServ.getTipo()==null || idServ.getNome()==null || idServ.getVersione()==null ||
  2167.                 idServ.getSoggettoErogatore()==null || idServ.getSoggettoErogatore().getTipo()==null || idServ.getSoggettoErogatore().getNome()==null)
  2168.             throw new DriverRegistroServiziException("[UDDILib.deleteBusinessService]: Alcuni parametri non definiti");
  2169.     
  2170.         try{
  2171.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  2173.             FindQualifiers findQualifiers = new FindQualifiers();
  2174.             Vector<FindQualifier> qualifier = new Vector<FindQualifier>();
  2175.             qualifier.add(new FindQualifier(FindQualifier.exactNameMatch));
  2176.             qualifier.add(new FindQualifier(FindQualifier.caseSensitiveMatch));
  2177.             findQualifiers.setFindQualifierVector(qualifier);

  2179.             IdentifierBag ib= new IdentifierBag();
  2180.             KeyedReference k1 = new KeyedReference();
  2181.             String keyBE =  idServ.getSoggettoErogatore().getTipo()+ "/" + idServ.getSoggettoErogatore().getNome();
  2182.             k1.setKeyValue(keyBE);
  2183.             k1.setTModelKey(this.tmkID);

  2185.             Vector<KeyedReference> keyedReferenceVector = new Vector<KeyedReference>();
  2186.             keyedReferenceVector.add(k1);
  2187.             ib.setKeyedReferenceVector(keyedReferenceVector);

  2189.             Vector<Name> names = new Vector<Name>();

  2191.             String keyService = idServ.getTipo() + "/" + idServ.getNome()+":"+idServ.getVersione();

  2193.             names.add(new Name(keyService));

  2195.             BusinessList businessList = this.proxy.find_business(null, null, ib, null, null, null,1);
  2196.             Vector<?> businessInfoVector  = businessList.getBusinessInfos().getBusinessInfoVector();
  2197.             BusinessInfo businessInfo = (BusinessInfo) businessInfoVector.elementAt(0);
  2198.             ServiceList serviceList = this.proxy.find_service(businessInfo.getBusinessKey(),names,null,null,findQualifiers,1);
  2199.             Vector<?> serviceInfoVector = serviceList.getServiceInfos().getServiceInfoVector();
  2200.             ServiceInfo serviceInfo = (ServiceInfo)serviceInfoVector.elementAt(0);

  2202.             this.proxy.delete_service(token.getAuthInfoString(), serviceInfo.getServiceKey());

  2204.         }catch(Exception e){
  2205.             throw new DriverRegistroServiziException("[UDDILib.deleteBusinessService]: "+e.getMessage(),e);
  2206.         }
  2207.     }
  2208.     
  2209.     /**
  2210.      * Il metodo si occupa di ritornare il nome del BusinessService <var>bs</var>.
  2211.      * @param bs BusinessService
  2212.      * @return il nome del servizio se la ricerca ha successo.
  2213.      */ 
  2214.     protected String getNomeBusinessService(BusinessService bs)throws DriverRegistroServiziException{
  2215.         if ( bs==null )
  2216.             throw new DriverRegistroServiziException("[UDDILib.getNomeBusinessService]: Alcuni parametri non definiti");
  2217.     
  2218.         try{
  2219.             return bs.getDefaultName().getText();
  2220.         }catch(Exception e){
  2221.             throw new DriverRegistroServiziException("[UDDILib.getNomeBusinessService]: "+e.getMessage(),e);
  2222.         }
  2223.     }
  2224.     
  2225.     /**
  2226.      * Il metodo si occupa di assegnare al servizio <var>bs</var> il nome <var>nome</var>
  2227.      *
  2228.      * @param bs BusinessService
  2229.      * @param idServ Identificativo del Servizio
  2230.      * @return la BusinessService modificata, se la modifica ha successo, null altrimenti.
  2231.      */
  2232.     protected BusinessService updateNomeBusinessService(BusinessService bs, IDServizio idServ)throws DriverRegistroServiziException{
  2233.         if (bs==null || idServ==null || idServ.getTipo()==null || idServ.getNome()==null || idServ.getVersione()==null){
  2234.             throw new DriverRegistroServiziException("[UDDILib.updateNomeBusinessService]: Alcuni parametri non definiti");
  2235.         }

  2237.         try{
  2238.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  2240.             String keyService = idServ.getTipo() + "/" + idServ.getNome() + ":" + idServ.getVersione();


  2243.             bs.setDefaultName(new Name(keyService));

  2245.             Vector<BusinessService> services = new Vector<BusinessService>();
  2246.             services.addElement(bs);
  2247.             this.proxy.save_service(token.getAuthInfoString(),services);
  2248.         }
  2249.         catch (UDDIException e){
  2250.             throw new DriverRegistroServiziException("[UDDILib.updateNomeBusinessService]: "+e.getMessage(),e);
  2251.         }
  2252.         catch (TransportException e){
  2253.             throw new DriverRegistroServiziException("[UDDILib.updateNomeBusinessService]: "+e.getMessage(),e);
  2254.         }
  2255.         catch (Exception e){
  2256.             throw new DriverRegistroServiziException("[UDDILib.updateNomeBusinessService]: "+e.getMessage(),e);
  2257.         }

  2259.         return bs;
  2260.     }
  2261.     
  2262.     /**
  2263.      * Il metodo si occupa di cercare all'interno del registro il bindingTemplate che definisce il servizio <var>bs</var>.
  2264.      * 
  2265.      * @param bs BusinessService.
  2266.      * @return un BindingTemplate
  2267.      */
  2268.     protected BindingTemplate getBindingTemplate(BusinessService bs)throws DriverRegistroServiziException{
  2269.         if ( bs==null )
  2270.             throw new DriverRegistroServiziException("[UDDILib.getBindingTemplate]: Alcuni parametri non definiti");
  2271.     
  2272.         BindingTemplate bt=null;
  2273.         try{
  2274.             
  2275.             BindingDetail bindingDetailReturned = this.proxy.find_binding(null, bs.getServiceKey(), null, 1);
  2276.             Vector<?> bindingTemplatesFound = bindingDetailReturned.getBindingTemplateVector();
  2277.             bt = (BindingTemplate)(bindingTemplatesFound.elementAt(0));
  2278.         }catch (TransportException e){
  2279.             throw new DriverRegistroServiziException("[UDDILib.getBindingTemplate]: "+e.getMessage(),e);
  2280.         }
  2281.         catch (Exception e){
  2282.             throw new DriverRegistroServiziException("[UDDILib.getBindingTemplate]: "+e.getMessage(),e);
  2283.         }
  2284.         return bt;
  2285.     }
  2286.     
  2287.     /**
  2288.      * Il metodo si occupa di aggiungere nel registro una nuovo bindingTemplate associato al servizio <var>bs</var>      
  2289.      * 
  2290.      * @param bs BusinessService.
  2291.      * @return il BindingTemplate inserito, se l'inserimento ha successo
  2292.      */
  2293.     protected BindingTemplate createBindingTemplate(BusinessService bs)throws DriverRegistroServiziException{
  2294.         if ( bs==null )
  2295.             throw new DriverRegistroServiziException("[UDDILib.createBindingTemplate]: Alcuni parametri non definiti");

  2297.         try{
  2298.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  2300.             BindingTemplate bt = null;
  2301.             //BindingTemplates bts = bs.getBindingTemplates();
  2302.             BindingTemplates bts = new BindingTemplates();
  2303.             String serviceKey = bs.getServiceKey();
  2304.             bt = new BindingTemplate();
  2305.             bt.setServiceKey(serviceKey);
  2306.             AccessPoint ap = new AccessPoint();
  2307.             ap.setText("url di default");
  2308.             bt.setAccessPoint(ap);

  2310.             Vector<BindingTemplate> templates = new Vector<BindingTemplate>();
  2311.             templates.addElement(bt);

  2313.             BindingDetail bindingDetail = this.proxy.save_binding(token.getAuthInfoString(),templates);
  2314.             Vector<?> bd = bindingDetail.getBindingTemplateVector();
  2315.             bt = (BindingTemplate) bd.elementAt(bd.size()-1);
  2316.             bts.add(bt);
  2317.             bs.setBindingTemplates(bts);

  2319.             Vector<BusinessService> services = new Vector<BusinessService>();
  2320.             services.addElement(bs);
  2321.             this.proxy.save_service(token.getAuthInfoString(),services);

  2323.             return bt;
  2324.         }
  2325.         catch (UDDIException e){
  2326.             throw new DriverRegistroServiziException("[UDDILib.createBindingTemplate]: "+e.getMessage(),e);
  2327.         }
  2328.         catch (TransportException e){
  2329.             throw new DriverRegistroServiziException("[UDDILib.createBindingTemplate]: "+e.getMessage(),e);
  2330.         }
  2331.         catch (Exception e){
  2332.             throw new DriverRegistroServiziException("[UDDILib.createBindingTemplate]: "+e.getMessage(),e);
  2333.         }
  2334.     }
  2335.     
  2336.     /**
  2337.      * Il metodo si occupa di cercare all'interno del registro il TModel che definisce il servizio a cui e' associato<var>bt</var>
  2338.      * @param bt BindingTemplate.
  2339.      * @return un oggetto Tmodel se la ricerca ha successo
  2340.      */
  2341.     protected TModel getTModel(BindingTemplate bt)throws DriverRegistroServiziException{
  2342.         if ( bt==null )
  2343.             throw new DriverRegistroServiziException("[UDDILib.getTModel]: Alcuni parametri non definiti");
  2344.     
  2345.         TModel tm = null;
  2346.         try{
  2347.             TModelInstanceDetails tmid = bt.getTModelInstanceDetails();
  2348.             TModelInstanceInfo tmii = tmid.get(0);
  2349.             TModelDetail tmd = this.proxy.get_tModelDetail(tmii.getTModelKey());
  2350.             Vector<?> v = tmd.getTModelVector();
  2351.             tm = (TModel) v.elementAt(0);
  2352.         }
  2353.         catch (UDDIException e){
  2354.             throw new DriverRegistroServiziException("[UDDILib.getTModel]: "+e.getMessage(),e);
  2355.         }
  2356.         catch (TransportException e){
  2357.             throw new DriverRegistroServiziException("[UDDILib.getTModel]: "+e.getMessage(),e);
  2358.         }
  2359.         catch (Exception e){
  2360.             throw new DriverRegistroServiziException("[UDDILib.getTModel]: "+e.getMessage(),e);
  2361.         }
  2362.         return tm;
  2363.     }
  2364.     
  2365.     /**
  2366.      * Il metodo si occupa di aggiungere nel registro un TModel associato al bindingTemplate <var>bt</var>
  2367.      * 
  2368.      * @param bt BindingTemplate.
  2369.      * @param idAccordo ID dell'accordo di Servizio
  2370.      */
  2371.     protected void createTModelServizio(BindingTemplate bt,IDAccordo idAccordo)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2372.         if ( bt==null || (idAccordo==null))
  2373.             throw new DriverRegistroServiziException("[UDDILib.createTModelServizio]: Alcuni parametri non definiti");
  2374.     
  2375.         TModel tm = null;
  2376.         try{
  2377.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  2379.             tm = getAccordoServizio(idAccordo);

  2381.             TModelInstanceInfo tmii = new TModelInstanceInfo(tm.getTModelKey());
  2382.             TModelInstanceDetails tmids = new TModelInstanceDetails();
  2383.             tmids.add(tmii);

  2385.             bt.setTModelInstanceDetails(tmids);
  2386.             Vector<BindingTemplate> templates = new Vector<BindingTemplate>();
  2387.             templates.addElement(bt);

  2389.             this.proxy.save_binding(token.getAuthInfoString(),templates);
  2390.         }
  2391.         catch(DriverRegistroServiziNotFound e){
  2392.             throw e;
  2393.         }
  2394.         catch (UDDIException e){
  2395.             throw new DriverRegistroServiziException("[UDDILib.createTModelServizio]: "+e.getMessage(),e);
  2396.         }
  2397.         catch (TransportException e){
  2398.             throw new DriverRegistroServiziException("[UDDILib.createTModelServizio]: "+e.getMessage(),e);
  2399.         }
  2400.         catch (Exception e){
  2401.             throw new DriverRegistroServiziException("[UDDILib.createTModelServizio]: "+e.getMessage(),e);
  2402.         }
  2403.     }
  2404.     
  2405.     /**
  2406.      * Il metodo si occupa di recuperarie l'access point dal BindingTemplate <var>bt</var>.
  2407.      * @param bt BindingTemplate 
  2408.      * @return una stringa contenente l'url all'XML del Servizio.
  2409.      */       
  2410.     protected String getAccessPoint(BindingTemplate bt)throws DriverRegistroServiziException{
  2411.         if ( bt==null  )
  2412.             throw new DriverRegistroServiziException("[UDDILib.getAccessPoint]: Alcuni parametri non definiti");
  2413.     
  2414.         try{
  2415.             return bt.getAccessPoint().getText();
  2416.         }catch(Exception e){
  2417.             throw new DriverRegistroServiziException("[UDDILib.getAccessPoint]: "+e.getMessage(),e);
  2418.         }
  2419.     }   
  2420.     
  2421.     /**
  2422.      * Il metodo si occupa di settare l'access point specificato nel parametro<var>URL</var>  
  2423.      * nel BindingTemplate <var>bt</var>.
  2424.      * @param bt BindingTemplate
  2425.      * @param URL URL dell'XML associato al Servizio
  2426.      * @return l'oggetto bindingTemplate modificato se tutto e' andato bene.
  2427.      */    
  2428.     protected BindingTemplate updateAccessPoint(BindingTemplate bt, String URL)throws DriverRegistroServiziException{
  2429.         if ( bt==null || (URL==null) )
  2430.             throw new DriverRegistroServiziException("[UDDILib.updateAccessPoint]: Alcuni parametri non definiti");
  2431.     
  2432.         try{
  2433.             AuthToken token = this.proxy.get_authToken(this.username,this.password);

  2435.             AccessPoint ap = bt.getAccessPoint();

  2437.             ap.setText(URL);
  2438.             bt.setAccessPoint(ap);

  2440.             Vector<BindingTemplate> templates = new Vector<BindingTemplate>();
  2441.             templates.addElement(bt);
  2442.             this.proxy.save_binding(token.getAuthInfoString(),templates);

  2444.         }
  2445.         catch (UDDIException e){
  2446.             throw new DriverRegistroServiziException("[UDDILib.updateAccessPoint]: "+e.getMessage(),e);
  2447.         }
  2448.         catch (TransportException e){
  2449.             throw new DriverRegistroServiziException("[UDDILib.updateAccessPoint]: "+e.getMessage(),e);
  2450.         }
  2451.         catch (Exception e){
  2452.             throw new DriverRegistroServiziException("[UDDILib.updateAccessPoint]: "+e.getMessage(),e);
  2453.         }

  2455.         return bt;
  2456.     }
  2457.     
  2458.     /**
  2459.      * Il metodo si occupa di rimuovere l'accessoPoint dal BindingTemplate <var>bt</var> passato per parametro.
  2460.      * @param bt BindingTemplate 
  2461.      * @return il BindingTemplate modificato
  2462.      */    
  2463.     protected BindingTemplate deleteAccessPoint(BindingTemplate bt)throws DriverRegistroServiziException{
  2464.         if ( bt==null  )
  2465.             throw new DriverRegistroServiziException("[UDDILib.deleteAccessPoint]: Alcuni parametri non definiti");

  2467.         try{
  2468.             bt = updateAccessPoint(bt,"");
  2469.             return bt;
  2470.         }catch(Exception e){
  2471.             throw new DriverRegistroServiziException("[UDDILib.deleteAccessPoint]: "+e.getMessage(),e);
  2472.         }
  2473.     }
  2474.     
  2475.     
  2476.     
  2477.     
  2478.     
  2479.     
  2480.     
  2481.     
  2482.     
  2483.     /* ********  M E T O D I    S E R V I Z I    ******** */

  2485.     /**
  2486.      * Il metodo si occupa di verificare se alla BusinessEntity identificata dai parametri
  2487.      * e' stato registrato il servizio <var>servizio</var>.
  2488.      *
  2489.      * @param idServ Identificativo del servizio
  2490.      * @return true se il servizio risulta registrato, false altrimenti
  2491.      */
  2492.     public boolean existsServizio(IDServizio idServ) throws DriverRegistroServiziException{
  2493.         if ( idServ==null || idServ.getSoggettoErogatore()==null)
  2494.             throw new DriverRegistroServiziException("[UDDILib.existsServizio]: Alcuni parametri non definiti");
  2495.         
  2496.         BusinessService bs = null;
  2497.         try{
  2498.             BusinessEntity be=getBusinessEntity(idServ.getSoggettoErogatore());
  2499.             if(be==null)
  2500.                 throw new Exception("BusinessEntity is null");
  2501.             bs=getBusinessService(be,idServ);
  2502.             if(bs==null)
  2503.                 throw new Exception("BusinessService is null");
  2504.         }catch (DriverRegistroServiziNotFound e){
  2505.             return false;
  2506.         }
  2507.         catch(Exception e){
  2508.             throw new DriverRegistroServiziException(e.getMessage(),e);
  2509.         }
  2510.         return true;
  2511.             
  2512.     }

  2514.     /**
  2515.      * Il metodo si occupa di aggiungere nel registro un nuovo Servizio 
  2516.      * associato al soggetto identificato dai parametri <var>tipo</var> e <var>codice</var>. 
  2517.      * 
  2518.      * @param idServ Identificativo del servizio
  2519.      * @param urlXML url dell'XML associato al Servizio.
  2520.      * @param idAccordo ID dell'accordo di Servizio
  2521.      */
  2522.     public void createServizio(IDServizio idServ, 
  2523.             String urlXML,IDAccordo idAccordo)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2524.         if ( idServ==null || idServ.getSoggettoErogatore()==null || (urlXML==null) || (idAccordo==null))
  2525.             throw new DriverRegistroServiziException("[UDDILib.createServizio]: Alcuni parametri non definiti");
  2526.         
  2527.         try{

  2529.             // get Business Enity
  2530.             BusinessEntity be = getBusinessEntity(idServ.getSoggettoErogatore());

  2532.             // Add Business Service
  2533.             BusinessService bs = createBusinessService(be,idServ);

  2535.             // Add template (url servizio.xml)
  2536.             BindingTemplate bt = null;
  2537.             try{
  2538.                 bt = createBindingTemplate(bs);
  2539.             }catch(Exception e){
  2540.                 // rollback
  2541.                 try{
  2542.                     deleteBusinessService(idServ);
  2543.                 }catch(Exception eRollback){
  2544.                     // ignore
  2545.                 }
  2546.                 throw e; // rilancio
  2547.             }

  2549.             // set Template (url servizio.xml)
  2550.             try{
  2551.                 bt=updateAccessPoint(bt,urlXML);
  2552.             }catch(Exception e){
  2553.                 // rollback
  2554.                 try{
  2555.                     deleteBusinessService(idServ);
  2556.                 }catch(Exception eRollback){
  2557.                     // ignore
  2558.                 }
  2559.                 throw e; // rilancio
  2560.             }
  2561.             
  2562.             // Add TModel per Accordo di Servizio
  2563.             try{
  2564.                 createTModelServizio(bt,idAccordo);
  2565.             }catch(Exception e){
  2566.                 // rollback
  2567.                 try{
  2568.                     deleteBusinessService(idServ);
  2569.                 }catch(Exception eRollback){
  2570.                     // ignore
  2571.                 }
  2572.                 throw e; // rilancio
  2573.             }

  2575.         }catch (DriverRegistroServiziNotFound e){
  2576.             throw e;
  2577.         }catch(Exception e){
  2578.             throw new DriverRegistroServiziException("[UDDILib.createServizio]: "+e.getMessage(),e);
  2579.         }
  2580.     }

  2582.     /**
  2583.      * Si occupa di recuperare la URL dell'XML associato alla porta di dominio 
  2584.      * registrata con il codice <var>codice</var>
  2585.      *
  2586.      * @param idServ Identificativo del servizio
  2587.      * @return la url dell'XML associato alla porta di dominio
  2588.      */
  2589.     public String getUrlXmlServizio(IDServizio idServ) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2590.         if ( idServ==null || idServ.getSoggettoErogatore()==null )
  2591.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlServizio]: Alcuni parametri non definiti");
  2592.         
  2593.         try{
  2594.         
  2595.             BusinessEntity be = getBusinessEntity(idServ.getSoggettoErogatore());
  2596.             BusinessService bs= getBusinessService(be,idServ);
  2597.             BindingTemplate bt = getBindingTemplate(bs);
  2598.             return getAccessPoint(bt);
  2599.         }catch (DriverRegistroServiziNotFound e){
  2600.             throw e;
  2601.         }catch(Exception e){
  2602.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlServizio]: "+e.getMessage(),e);
  2603.         }
  2604.     }

  2606.     /**
  2607.      * Il metodo si occupa di impostare la url del file XML associato al Servizio
  2608.      *
  2609.      * @param idServ Identificativo del servizio
  2610.      * @param url Url da impostare
  2611.      */
  2612.     public void updateUrlXmlServizio(IDServizio idServ, String url)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2613.         if ( url==null || idServ==null || idServ.getSoggettoErogatore()==null )
  2614.             throw new DriverRegistroServiziException("[UDDILib.updateUrlXmlServizio]: Alcuni parametri non definiti");
  2615.         try{
  2616.             BusinessEntity be = getBusinessEntity(idServ.getSoggettoErogatore());
  2617.             BusinessService bs = getBusinessService(be,idServ);
  2618.             BindingTemplate bt = getBindingTemplate(bs);
  2619.             bt=updateAccessPoint(bt,url);
  2620.         }
  2621.         catch (DriverRegistroServiziNotFound e){
  2622.             throw e;
  2623.         }catch (Exception e){
  2624.             throw new DriverRegistroServiziException("[UDDILib.updateUrlXmlServizio]: "+e.getMessage(),e);
  2625.         }
  2626.     }


  2629.     /**
  2630.      * Il metodo si occupa di modificare il nome di un Servizio
  2631.      *
  2632.      * @param idServOLD Vecchio Identificativo del Servizio
  2633.      * @param idServNEW Nuovo Identificativo del Servizio
  2634.      */
  2635.     public void updateIdServizio(IDServizio idServOLD,IDServizio idServNEW)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2636.         if ( idServOLD==null || idServOLD.getTipo()==null || idServOLD.getNome()==null || idServOLD.getVersione()==null ||
  2637.                 idServOLD.getSoggettoErogatore()==null || idServOLD.getSoggettoErogatore().getTipo()==null || idServOLD.getSoggettoErogatore().getNome()==null)
  2638.             throw new DriverRegistroServiziException("[UDDILib.modificaNomeServizio]: Alcuni parametri non definiti");
  2639.     
  2640.         if ( idServNEW==null || idServNEW.getTipo()==null || idServNEW.getNome()==null || idServNEW.getVersione()==null ||
  2641.                 idServNEW.getSoggettoErogatore()==null || idServNEW.getSoggettoErogatore().getTipo()==null || idServNEW.getSoggettoErogatore().getNome()==null)
  2642.             throw new DriverRegistroServiziException("[UDDILib.modificaNomeServizio]: Alcuni parametri non definiti");
  2643.     
  2644.         try{
  2645.             BusinessEntity be = getBusinessEntity(idServOLD.getSoggettoErogatore());
  2646.             BusinessService bs = getBusinessService(be, idServOLD);
  2647.             updateNomeBusinessService(bs,idServNEW);
  2648.         }      
  2649.         catch (DriverRegistroServiziNotFound e){
  2650.             throw e;
  2651.         }catch (Exception e){
  2652.             throw new DriverRegistroServiziException("[UDDILib.modificaNomeServizio]: "+e.getMessage(),e);
  2653.         }

  2655.     }

  2657.     /**
  2658.      * Si occupa di cancellare il servizio <var>servizio</var> registrato nel registro, 
  2659.      * identificato dai parametri.
  2660.      *
  2661.      * @param idServ Identificativo del servizio
  2662.      */ 
  2663.     public void deleteServizio(IDServizio idServ) throws DriverRegistroServiziException{
  2664.         if ( idServ==null || idServ.getSoggettoErogatore()==null )
  2665.             throw new DriverRegistroServiziException("[UDDILib.deleteServizio]: Alcuni parametri non definiti");
  2666.         try{    
  2667.             deleteBusinessService(idServ);
  2668.         }
  2669.         catch (Exception e){
  2670.             throw new DriverRegistroServiziException("[UDDILib.deleteServizio]: "+e.getMessage(),e);
  2671.         }
  2672.     }


  2675.     
  2676.     
  2677.     
  2678.     
  2679.     
  2680.     
  2681.     /**
  2682.      * Il metodo si occupa di modificare la TModel associata al servizio
  2683.      *
  2684.      * @param idServ Identificativo del servizio
  2685.      * @param newIDAccordoServizio Nuovo accordo di servizio
  2686.      */
  2687.     public void updateAccordoServizio(IDServizio idServ, IDAccordo newIDAccordoServizio)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2688.         if ( idServ==null || idServ.getSoggettoErogatore()==null || newIDAccordoServizio==null)
  2689.             throw new DriverRegistroServiziException("[UDDILib.updateAccordoServizio]: Alcuni parametri non definiti");
  2690.         try{

  2692.             BusinessEntity be = getBusinessEntity(idServ.getSoggettoErogatore());
  2693.             BusinessService bs = getBusinessService(be, idServ);
  2694.             BindingTemplate bt = getBindingTemplate(bs);
  2695.             createTModelServizio(bt,newIDAccordoServizio);
  2696.         }      
  2697.         catch (DriverRegistroServiziNotFound e){
  2698.             throw e;
  2699.         }catch (Exception e){
  2700.             throw new DriverRegistroServiziException("[UDDILib.updateAccordoServizio]: "+e.getMessage(),e);
  2701.         }
  2702.     }

  2704.     /**
  2705.      * Si occupa di recuperare un array di URL che puntano a XML di servizi presente 
  2706.      * nel soggetto identificato dai parametri, che possiedeno l'accordo di servizio <var>accordo</var>.
  2707.      *
  2708.      * @param idSogg Identificativo del Soggetto erogatore
  2709.      * @param idAccordo Accordo di Servizio
  2710.      * @return Array di url di XML dei servizi
  2711.      */
  2712.     public String[] getUrlXmlServizi(IDSoggetto idSogg, IDAccordo idAccordo)throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2713.         if(idSogg==null || idAccordo==null)
  2714.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlServizi]: Alcuni parametri non definiti");
  2715.         
  2716.         try{
  2717.             // Soggetto
  2718.             BusinessEntity be = getBusinessEntity(idSogg);
  2719.     
  2720.             // Filtro per Accordi
  2721.             TModelBag bagAccordo = new TModelBag();
  2722.             TModel accordoS = getAccordoServizio(idAccordo);
  2723.             bagAccordo.add(new TModelKey(accordoS.getTModelKey()));
  2724.         
  2725.             FindQualifiers findQualifiers = new FindQualifiers();
  2726.             Vector<FindQualifier> qualifier = new Vector<FindQualifier>();
  2727.             qualifier.add(new FindQualifier(FindQualifier.exactNameMatch));
  2728.             qualifier.add(new FindQualifier(FindQualifier.caseSensitiveMatch));
  2729.             findQualifiers.setFindQualifierVector(qualifier);
  2730.             
  2731.             // l'ultimo parametro lo lascerei indefinito. 
  2732.             // Richiede un intero che stabilisce il numero di risultati che la ricerca find_service deve produrre. 
  2733.             // Ma noi a priori non lo possiamo sapere (anche se la ricerca dovrebbe essere sempre 1 o 2). 
  2734.             // Effettuo il filtro per bagAccordo
  2735.             ServiceList serviceList = this.proxy.find_service(be.getBusinessKey(), null, null, bagAccordo, findQualifiers, -1);
  2736.             if(serviceList.getServiceInfos()==null || serviceList.getServiceInfos().size()==0)
  2737.                 throw new DriverRegistroServiziNotFound("BusinessServices non trovate");
  2738.             
  2739.             
  2740.             //questo vettore contiene tutti i servizi della businessEntity
  2741.             Vector<?> serviceInfoVector = serviceList.getServiceInfos().getServiceInfoVector();
  2742.          
  2743.             if(serviceInfoVector.size()==0)
  2744.                 throw new Exception("Servizi non trovati");
  2745.             
  2746.             //e ora vado ad analizzare un servizio alla volta
  2747.             String[]url = new String[serviceInfoVector.size()];
  2748.             for (int i=0; i<serviceInfoVector.size(); i++){
  2749.                 ServiceInfo serviceInfo = (ServiceInfo) serviceInfoVector.elementAt(i);
  2750.                 //System.out.println("SERVIZIO ["+serviceInfo.getServiceKey()+"]");
  2751.                 ServiceDetail sd = this.proxy.get_serviceDetail(serviceInfo.getServiceKey());
  2752.                 Vector<?> v = sd.getBusinessServiceVector();
  2753.                 BusinessService bs = (BusinessService) v.elementAt(0);          
  2754.                 BindingTemplate bt=getBindingTemplate(bs);
  2755.                 url[i] = getAccessPoint(bt);
  2756.                 if(url[i]==null)
  2757.                     throw new Exception("access point non presente?");
  2758.             }
  2759.             return url;
  2760.         }
  2761.         catch(DriverRegistroServiziNotFound e){
  2762.             throw e;
  2763.         }
  2764.         catch(TransportException e){
  2765.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlServizi]: "+e.getMessage(),e);
  2766.         }catch(Exception e){
  2767.             throw new DriverRegistroServiziException("[UDDILib.getUrlXmlServizi]: "+e.getMessage(),e);
  2768.         }
  2769.         

  2771.         
  2772.     }


  2775.     /**
  2776.      * @param idAccordo
  2777.      * @param soggettoErogatore
  2778.      * @param tipoServizio
  2779.      * @param nomeServizio
  2780.      * @return URL XML dei servizi che rispettano la ricerca
  2781.      * @throws DriverRegistroServiziException
  2782.      * @throws DriverRegistroServiziNotFound
  2783.      */
  2784.     protected String[] getUrlXMLServiziBySearch(IDAccordo idAccordo,IDSoggetto soggettoErogatore,String tipoServizio,String nomeServizio) throws DriverRegistroServiziException,DriverRegistroServiziNotFound{
  2785.         
  2786.         try{    

  2788.             // Filtro Soggetto
  2789.             String businessKey = null;
  2790.             if(soggettoErogatore!=null && soggettoErogatore.getTipo()!=null && soggettoErogatore.getNome()!=null){
  2791.                 try{
  2792.                     BusinessEntity be = this.getBusinessEntity(soggettoErogatore);
  2793.                     if(be!=null)
  2794.                         businessKey = be.getBusinessKey();
  2795.                 }catch(DriverRegistroServiziNotFound e){
  2796.                     throw new DriverRegistroServiziNotFound("[getBusinessServices] Soggetto ["+soggettoErogatore+"] usato come filtro non presente",e);
  2797.                 }
  2798.             }
  2799.                 
  2800.             // Filtro accordo
  2801.             TModelBag bagAccordo = null;
  2802.             if(idAccordo!=null){
  2803.                 try{
  2804.                     bagAccordo = new TModelBag();
  2805.                     TModel accordoS = getAccordoServizio(idAccordo);
  2806.                     bagAccordo.add(new TModelKey(accordoS.getTModelKey()));
  2807.                 }catch(DriverRegistroServiziNotFound e){
  2808.                     throw new DriverRegistroServiziNotFound("[getBusinessServices] Accordo ["+idAccordo.toString()+"] usato come filtro non presente",e);
  2809.                 }   
  2810.             }
  2811.             
  2812.             // Filtro Servizio
  2813.             String keyService = null;
  2814.             if(tipoServizio!=null && nomeServizio!=null){
  2815.                 keyService = tipoServizio+ "/" + nomeServizio;
  2816.             }else if(tipoServizio!=null){
  2817.                 keyService = tipoServizio+ "/%";
  2818.             }else if(nomeServizio!=null){
  2819.                 keyService = "%/"+nomeServizio;
  2820.             }else{
  2821.                 keyService = "%/%";
  2822.             }
  2823.             Name nome = new Name(keyService);
  2824.             Vector<Name> nomi = new Vector<Name>();
  2825.             nomi.add(nome);
  2826.             
  2827.             // FindQualifiers
  2828.             FindQualifiers findQualifiers = null;
  2829.             if("%/%".equals(keyService)==false){
  2830.                 findQualifiers = new FindQualifiers();
  2831.                 Vector<FindQualifier> qualifier = new Vector<FindQualifier>();
  2832.                 qualifier.add(new FindQualifier(FindQualifier.exactNameMatch));
  2833.                 qualifier.add(new FindQualifier(FindQualifier.caseSensitiveMatch));
  2834.                 findQualifiers.setFindQualifierVector(qualifier);
  2835.             }
  2836.             
  2837.             // l'ultimo parametro lo lascerei indefinito. 
  2838.             // Richiede un intero che stabilisce il numero di risultati che la ricerca find_service deve produrre. 
  2839.             // Ma noi a priori non lo possiamo sapere (anche se la ricerca dovrebbe essere sempre 1 o 2). 
  2840.             // Effettuo il filtro per bagAccordo
  2841.             ServiceList serviceList = this.proxy.find_service(businessKey, nomi, null, bagAccordo, findQualifiers, UDDILib.MAX_SEARCH);
  2842.          
  2843.             //questo vettore contiene tutti i servizi della businessEntity
  2844.             Vector<?> serviceInfoVector = serviceList.getServiceInfos().getServiceInfoVector();
  2845.          
  2846.             if(serviceInfoVector.size()==0){
  2847.                 throw new DriverRegistroServiziNotFound("Non esistono BusinessService che rispettano il filtro selezionato accordo["+idAccordo+"] soggetto["+soggettoErogatore+"] tipo_servizio["+tipoServizio+"] nome_servizio["+nomeServizio+"]");
  2848.             }
  2849.             
  2850.             //e ora vado ad analizzare un servizio alla volta
  2851.             String[]url = new String[serviceInfoVector.size()];
  2852.             for (int i=0; i<serviceInfoVector.size(); i++){
  2853.                 ServiceInfo serviceInfo = (ServiceInfo) serviceInfoVector.elementAt(i);
  2854.                 //System.out.println("SERVIZIO ["+serviceInfo.getServiceKey()+"]");
  2855.                 ServiceDetail sd = this.proxy.get_serviceDetail(serviceInfo.getServiceKey());
  2856.                 Vector<?> v = sd.getBusinessServiceVector();
  2857.                 BusinessService bs = (BusinessService) v.elementAt(0);          
  2858.                 BindingTemplate bt=getBindingTemplate(bs);
  2859.                 url[i] = getAccessPoint(bt);
  2860.                 if(url[i]==null)
  2861.                     throw new Exception("access point non presente?");
  2862.             }
  2863.             return url;
  2864.         }
  2865.         catch (UDDIException e){
  2866.             throw new DriverRegistroServiziException("[UDDILib.getBusinessService]: "+e.getMessage(),e);
  2867.         }
  2868.         catch (TransportException e){
  2869.             throw new DriverRegistroServiziException("[UDDILib.getBusinessService]: "+e.getMessage(),e);
  2870.         }
  2871.         catch( DriverRegistroServiziNotFound de){
  2872.             throw de;
  2873.         }
  2874.         catch (Exception e){
  2875.             throw new DriverRegistroServiziException("[UDDILib.getBusinessService]: "+e.getMessage(),e);
  2876.         }

  2878.     }
  2879.     
  2880. }
Created with JaCoCo 0.8.8.202204050719