/*

  * Copyright 2001-2004 The Apache Software Foundation.

  * 

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  * 

  *      http://www.apache.org/licenses/LICENSE-2.0

  * 

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.ws.scout.registry;

 import java.io.ByteArrayInputStream;

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 import java.io.StringReader;

 import java.net.URI;

 import java.net.URISyntaxException;

 import java.security.AccessController;

 import java.security.PrivilegedAction;

 import java.util.Arrays;

 import java.util.List;

 import java.util.Properties;

 import javax.xml.bind.JAXBContext;

 import javax.xml.bind.JAXBElement;

 import javax.xml.bind.JAXBException;

 import javax.xml.bind.Marshaller;

 import javax.xml.bind.Unmarshaller;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.registry.InvalidRequestException;

 import javax.xml.transform.stream.StreamSource;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.apache.ws.scout.transport.LocalTransport;

 import org.apache.ws.scout.transport.Transport;

 import org.apache.ws.scout.transport.TransportException;

 import org.apache.ws.scout.util.XMLUtils;

 import org.uddi.api_v3.AssertionStatusReport;

 import org.uddi.api_v3.AuthToken;

 import org.uddi.api_v3.BindingDetail;

 import org.uddi.api_v3.BindingTemplate;

 import org.uddi.api_v3.BusinessDetail;

 import org.uddi.api_v3.BusinessEntity;

 import org.uddi.api_v3.BusinessList;

 import org.uddi.api_v3.BusinessService;

 import org.uddi.api_v3.CategoryBag;

 import org.uddi.api_v3.CompletionStatus;

 import org.uddi.api_v3.DeleteBinding;

 import org.uddi.api_v3.DeleteBusiness;

 import org.uddi.api_v3.DeletePublisherAssertions;

 import org.uddi.api_v3.DeleteService;

 import org.uddi.api_v3.DeleteTModel;

 import org.uddi.api_v3.DiscoveryURLs;

 import org.uddi.api_v3.DispositionReport;

 import org.uddi.api_v3.FindBinding;

 import org.uddi.api_v3.FindBusiness;

 import org.uddi.api_v3.FindQualifiers;

 import org.uddi.api_v3.FindService;

 import org.uddi.api_v3.FindTModel;

 import org.uddi.api_v3.GetAssertionStatusReport;

 import org.uddi.api_v3.GetAuthToken;

 import org.uddi.api_v3.GetBusinessDetail;

 import org.uddi.api_v3.GetPublisherAssertions;

 import org.uddi.api_v3.GetRegisteredInfo;

 import org.uddi.api_v3.GetServiceDetail;

 import org.uddi.api_v3.GetTModelDetail;

 import org.uddi.api_v3.IdentifierBag;

 import org.uddi.api_v3.InfoSelection;

 import org.uddi.api_v3.Name;

 import org.uddi.api_v3.ObjectFactory;

 import org.uddi.api_v3.PublisherAssertion;

 import org.uddi.api_v3.PublisherAssertions;

 import org.uddi.api_v3.PublisherAssertionsResponse;

 import org.uddi.api_v3.RegisteredInfo;

 import org.uddi.api_v3.SaveBinding;

 import org.uddi.api_v3.SaveBusiness;

 import org.uddi.api_v3.SaveService;

 import org.uddi.api_v3.SaveTModel;

 import org.uddi.api_v3.ServiceDetail;

 import org.uddi.api_v3.ServiceList;

 import org.uddi.api_v3.SetPublisherAssertions;

 import org.uddi.api_v3.TModel;

 import org.uddi.api_v3.TModelBag;

 import org.uddi.api_v3.TModelDetail;

 import org.uddi.api_v3.TModelList;

 import org.w3c.dom.Document;

 import org.w3c.dom.Element;

 import org.w3c.dom.NodeList;

 import org.xml.sax.SAXException;

 /**

  * RegistryImpl is the implementation of IRegistry.

  * 

  * <p>The execute() function signature has been changed slightly from the jUDDI

  * version, since the URL can no longer be decided dynamically (in an easy

  * enough manner) as we don't use jUDDI data types anymore.</p>

  * 

  * <i>The function code is borrowed from jUDDI, with appropriate modifications so

  * that xmlbeans data types are used intead of jUDDI data types.</i>

  * 

  */

 public class RegistryV3Impl implements IRegistryV3 {

         public static final String DEFAULT_INQUIRY_ENDPOINT  = "org.apache.juddi.v3.client.transport.wrapper.UDDIInquiryService#inquire";;

         public static final String DEFAULT_PUBLISH_ENDPOINT  = "org.apache.juddi.v3.client.transport.wrapper.UDDIPublicationService#publish";

         public static final String DEFAULT_SECURITY_ENDPOINT = "org.apache.juddi.v3.client.transport.wrapper.UDDISecurityService#secure";

         public static final String DEFAULT_ADMIN_ENDPOINT    = "http://localhost/juddiv3/";

         public static final String DEFAULT_TRANSPORT_CLASS   = "org.apache.ws.scout.transport.LocalTransport";

         public static final String DEFAULT_SECURITY_PROVIDER = "com.sun.net.ssl.internal.ssl.Provider";

         public static final String DEFAULT_PROTOCOL_HANDLER  = "com.sun.net.ssl.internal.www.protocol";

         public static final String DEFAULT_UDDI_VERSION      = "3.0";

         public static final String DEFAULT_UDDI_NAMESPACE    = "urn:uddi-org:api_v3";

         private URI adminURI;

         private URI inquiryURI;

         private URI publishURI;

         private URI securityURI;

         private Transport transport;

         private String securityProvider;

         private String protocolHandler;

         private String uddiVersion;

         private String uddiNamespace;

         private String nodeName;

         private String managerName;

         private ObjectFactory objectFactory = new ObjectFactory();

         private Marshaller marshaller = null;

         private Unmarshaller unmarshaller = null;

         private static Log log = LogFactory.getLog(RegistryV3Impl.class);

         /**

          * Creates a new instance of RegistryImpl.

          * @throws InvalidRequestException 

          */

         public RegistryV3Impl(Properties props, String nodeName, String managerName) throws InvalidRequestException {

                 super();

                 this.init(props, nodeName, managerName);

         }

         /**

          * @throws InvalidRequestException 

          * 

          */

         private void init(Properties props, String nodeName, String managerName) throws InvalidRequestException {

             this.nodeName = nodeName;

             this.managerName = managerName;

         // We need to have a non-null Properties

         // instance so initialization takes place.

         if (props == null) props = new Properties();

         // Override defaults with specific specific values

         try {

             // note that since we are using the juddi-client, these settings are fixed!

             // the URL settings will be passed down to the juddi-client config. 

             // (see the parameters in the "META-INF/jaxr-uddi.xml)

             setInquiryURI(new URI(DEFAULT_INQUIRY_ENDPOINT));

             setPublishURI(new URI(DEFAULT_PUBLISH_ENDPOINT));

             setSecurityURI(new URI(DEFAULT_SECURITY_ENDPOINT));

             setTransport(getTransport(DEFAULT_TRANSPORT_CLASS));

             // the following parameters are still configurable however

             setAdminURI(new URI(props.getProperty(ConnectionFactoryImpl.ADMIN_ENDPOINT_PROPERTY, DEFAULT_ADMIN_ENDPOINT)));

             setSecurityProvider(props.getProperty(ConnectionFactoryImpl.SECURITY_PROVIDER_PROPERTY, DEFAULT_SECURITY_PROVIDER));

             setProtocolHandler(props.getProperty(ConnectionFactoryImpl.PROTOCOL_HANDLER_PROPERTY, DEFAULT_PROTOCOL_HANDLER));

             setUddiVersion(props.getProperty(ConnectionFactoryImpl.UDDI_VERSION_PROPERTY, DEFAULT_UDDI_VERSION));

             setUddiNamespace(props.getProperty(ConnectionFactoryImpl.UDDI_NAMESPACE_PROPERTY, DEFAULT_UDDI_NAMESPACE));

             JAXBContext context = JAXBContextUtil.getContext(JAXBContextUtil.UDDI_V3_VERSION);

             unmarshaller = context.createUnmarshaller(); 

             marshaller = context.createMarshaller();

         } catch (URISyntaxException muex) {

             throw new InvalidRequestException(muex.getMessage(), muex);

         } catch(JAXBException e) {

            throw new RuntimeException(e);

         }

         }

         /**

          * 

          * @param uddiRequest

          * @return String

          * @throws RegistryV3Exception

          */

         public String execute(String uddiRequest, String urltype)

                         throws TransportException {

                 URI endPointURL = null;

                 if (urltype.equalsIgnoreCase("INQUIRY"))

                         endPointURL = this.getInquiryURI();

                 else

                         endPointURL = this.getPublishURI();

                 // A SOAP request is made and a SOAP response

                 // is returned.

                 return transport.send(uddiRequest, endPointURL);

         }

         /**

          * 

          */

         public JAXBElement<?> execute(JAXBElement<?> uddiRequest, URI endPointURI)

                         throws RegistryV3Exception {

                 ByteArrayOutputStream baos = new ByteArrayOutputStream();

         Document doc;

         try {

             DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();

             docBuilderFactory.setNamespaceAware(true);

             DocumentBuilder docBuilder= docBuilderFactory.newDocumentBuilder();

             this.marshaller.marshal(uddiRequest, baos);

             doc = docBuilder.parse(new ByteArrayInputStream(baos.toByteArray()));

         } catch (SAXException saxe) {

             throw (new RegistryV3Exception(saxe));

         } catch (ParserConfigurationException pce) {

             throw (new RegistryV3Exception(pce));

         } catch (IOException ioe) {

             throw (new RegistryV3Exception(ioe));

         } catch (JAXBException ioe) {

             throw (new RegistryV3Exception(ioe));

         }

                 Element request = doc.getDocumentElement();

             request.setAttribute("xmlns", this.getUddiNamespace());

             if (!"3.0".equals(this.getUddiVersion())) {

                     request.setAttribute("generic", this.getUddiVersion());

             }

             //request.setAttributeNS("http://www.w3.org/2000/xmlns/","xmlns", this.getUddiNamespace());

             // A SOAP request is made and a SOAP response

             // is returned.

             if (log.isDebugEnabled()) {

                     String xmlIn = XMLUtils.convertNodeToXMLString(request);

                     log.debug("Request send to UDDI Registry: " + xmlIn);

             }

             Element response;

             try {

                     response = transport.send(request, endPointURI);

             } catch (TransportException te) {

                     throw new RegistryV3Exception(te);

             }

             /* if (response.hasAttributes()) {

                     NamedNodeMap am = response.getAttributes();

                     ArrayList<String> al = new ArrayList<String>();

                     for (int i = 0; i < am.getLength(); i++) {

                             Node n = am.item(i);

                             String attribute = n.getNodeName();

                             if (attribute!= null && attribute.startsWith("xmlns")) {

                                     al.add(attribute);

                             }

                     }

                     for (String attr : al) {

                             response.removeAttribute(attr);

                     }

             }*/

             JAXBElement<?> uddiResponse = null;

             if (response!=null) {

                     if (response.getNamespaceURI()==null) {

                     response.setAttributeNS("http://www.w3.org/2000/xmlns/","xmlns", this.getUddiNamespace());

                 }

                     // If we are getting responses from a UDDI v3, remove the xmlns

                     // First, let's make sure that a response

                     // (any response) is found in the SOAP Body.

                     String responseName = response.getLocalName();

                     if (responseName == null) {

                         throw new RegistryV3Exception("Unsupported response "

                                 + "from registry. A value was not present.");

                         } 

                 // Let's now try to determine which UDDI response

                 // we received and unmarshal it appropriately or

                 // throw a RegistryV3Exception if it's unknown.

                 // Well, we have now determined that something was

                 // returned and it is "a something" that we know

                 // about so let's unmarshal it into a RegistryObject

                 // Next, let's make sure we didn't recieve a SOAP

                 // Fault. If it is a SOAP Fault then throw it

                 // immediately.

                     try {

                             String xml = XMLUtils.convertNodeToXMLString(response);

                         log.debug("Response is: " + xml);

                         StringReader reader = new StringReader(xml);

                         uddiResponse = (JAXBElement<?>) unmarshaller.unmarshal(new StreamSource(reader));

                             //It is probably faster not to go to a String, but JAXB has issues with this

                         //uddiResponse = (JAXBElement<?>) unmarshaller.unmarshal(response);

                     } catch (JAXBException xmle) {

                         throw (new RegistryV3Exception(xmle));

                     }

                         if (responseName.toLowerCase().equals("fault")) {

                                 NodeList nodeList = null;

                                 // Child Elements

                                 String fCode = null;

                                 nodeList = response.getElementsByTagName("faultcode");

                                 if (nodeList.getLength() > 0)

                                         fCode = nodeList.item(0).getNodeValue();

                                 String fString = null;

                                 nodeList = response.getElementsByTagName("faultstring");

                                 if (nodeList.getLength() > 0)

                                         fString = nodeList.item(0).getNodeValue();

                                 String fActor = null;

                                 nodeList = response.getElementsByTagName("faultactor");

                                 if (nodeList.getLength() > 0)

                                         fActor = nodeList.item(0).getNodeValue();

                                 DispositionReport dispRpt = null;

                                 nodeList = response.getElementsByTagName("detail");

                                 if (nodeList.getLength() > 0) {

                                         nodeList = ((Element) nodeList.item(0))

                                                         .getElementsByTagName("dispositionReport");

                                         if (nodeList.getLength() > 0) {

                                                 JAXBElement<DispositionReport> dispRptObj = null;

                                                 try {

                                                         dispRptObj = (JAXBElement<DispositionReport>) unmarshaller.unmarshal((Element) nodeList

                                                                         .item(0));

                                                 } catch (JAXBException xmle) {

                                                         throw (new RegistryV3Exception(xmle));

                                                 }

                             dispRpt = dispRptObj.getValue();

                         }

                                 }

                                 RegistryV3Exception e = new RegistryV3Exception(fCode, fString, fActor, dispRpt);

                                 // Create RegistryV3Exception instance and return

                                 throw e;

                         }

             }

                 return uddiResponse;

         }

         /**

          * @return Returns the adminURL.

          */

         public URI getAdminURI() {

                 return this.adminURI;

         }

         /**

          * @param url

          *            The adminURL to set.

          */

         public void setAdminURI(URI url) {

                 this.adminURI = url;

         }

         /**

          * @return Returns the inquiryURL.

          */

         public URI getInquiryURI() {

                 return this.inquiryURI;

         }

         /**

          * @param inquiryURI

          *            The inquiryURI to set.

          */

         public void setInquiryURI(URI inquiryURI) {

                 this.inquiryURI = inquiryURI;

         }

         /**

          * @return Returns the protocolHandler.

          */

         public String getProtocolHandler() {

                 return this.protocolHandler;

         }

         /**

          * @param protocolHandler

          *            The protocolHandler to set.

          */

         public void setProtocolHandler(String protocolHandler) {

                 this.protocolHandler = protocolHandler;

         }

         /**

          * @return Returns the publishURL.

          */

         public URI getPublishURI() {

                 return this.publishURI;

         }

         /**

          * @return Returns the publishURL.

          */

         public URI getSecurityURI() {

                 return this.securityURI;

         }

         /**

          * @param publishURI

          *            The publishURI to set.

          */

         public void setPublishURI(URI publishURI) {

                 this.publishURI = publishURI;

         }

         /**

          * @param publishURI

          *            The publishURI to set.

          */

         public void setSecurityURI(URI securityURI) {

                 this.securityURI = securityURI;

         }

         /**

          * @return Returns the securityProvider.

          */

         public String getSecurityProvider() {

                 return this.securityProvider;

         }

         /**

          * @param securityProvider

          *            The securityProvider to set.

          */

         public void setSecurityProvider(String securityProvider) {

                 this.securityProvider = securityProvider;

         }

         /**

          * @return Returns the transport.

          */

         public Transport getTransport() {

                 return transport;

         }

         /**

          * @param transport

          *            The transport to set.

          */

         public void setTransport(Transport transport) {

                 this.transport = transport;

         }

         /**

          * @return Returns the uddiNS.

          */

         public String getUddiNamespace() {

                 return this.uddiNamespace;

         }

         /**

          * @param uddiNS

          *            The uddiNS to set.

          */

         public void setUddiNamespace(String uddiNS) {

                 this.uddiNamespace = uddiNS;

         }

         /**

          * @return Returns the uddiVersion.

          */

         public String getUddiVersion() {

                 return this.uddiVersion;

         }

         /**

          * @param uddiVersion

          *            The uddiVersion to set.

          */

         public void setUddiVersion(String uddiVersion) {

                 this.uddiVersion = uddiVersion;

         }

         /**

          * "Used to remove an existing bindingTemplate from the bindingTemplates

          * collection that is part of a specified businessService structure."

          * 

          * @exception RegistryV3Exception;

          */

         public DispositionReport deleteBinding(String authInfo,

                         String[] bindingKeyArray) throws RegistryV3Exception {

                 DeleteBinding request = this.objectFactory.createDeleteBinding();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

                 if (bindingKeyArray != null) {

                         request.getBindingKey().addAll(Arrays.asList(bindingKeyArray));

                 }

         DispositionReport dr = new DispositionReport();

         JAXBElement<?> o = execute(this.objectFactory.createDeleteBinding(request), this.getPublishURI());

         if (o!=null) {

                 dr = (DispositionReport) o.getValue();

         }

         return dr;

         }

         /**

          * "Used to delete registered businessEntity information from the registry."

          * 

          * @exception RegistryV3Exception;

          */

         public DispositionReport deleteBusiness(String authInfo,

                         String[] businessKeyArray) throws RegistryV3Exception {

                 DeleteBusiness request = this.objectFactory.createDeleteBusiness();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

                 if (businessKeyArray != null) {

                         request.getBusinessKey().addAll(Arrays.asList(businessKeyArray));

                 }

         DispositionReport dr = new DispositionReport();

         JAXBElement<?> o = execute(this.objectFactory.createDeleteBusiness(request), this.getPublishURI());

         if (o!=null){

                 dr = (DispositionReport) o.getValue();

         }

         return dr;

         }

         /**

          * @exception RegistryV3Exception;

          */

         public DispositionReport deletePublisherAssertions(String authInfo,

                         PublisherAssertion[] assertionArray) throws RegistryV3Exception {

                 DeletePublisherAssertions request = this.objectFactory.createDeletePublisherAssertions();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

                 if (assertionArray != null) {

                         request.getPublisherAssertion().addAll(Arrays.asList(assertionArray));

                 }

         DispositionReport dr = new DispositionReport();

         JAXBElement<?> o = execute(this.objectFactory.createDeletePublisherAssertions(request), 

                         this.getPublishURI());

         if (o!=null) {

                 dr = (DispositionReport) o.getValue();

         }

         return dr;

         }

         /**

          * "Used to delete an existing businessService from the businessServices

          * collection that is part of a specified businessEntity."

          * 

          * @exception RegistryV3Exception;

          */

         public DispositionReport deleteService(String authInfo,

                         String[] serviceKeyArray) throws RegistryV3Exception {

                 DeleteService request = this.objectFactory.createDeleteService();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

                 if (serviceKeyArray != null) {

                         request.getServiceKey().addAll(Arrays.asList(serviceKeyArray));

                 }

         DispositionReport dr = new DispositionReport();

         JAXBElement<?> o = execute(this.objectFactory.createDeleteService(request), 

                         this.getPublishURI());

         if (o!=null) {

                 dr = (DispositionReport) o.getValue();

         }

         return dr;

         }

         /**

          * "Used to delete registered information about a tModel. If there are any

          * references to a tModel when this call is made, the tModel will be marked

          * deleted instead of being physically removed."

          * 

          * @exception RegistryV3Exception;

          */

         public DispositionReport deleteTModel(String authInfo,

                         String[] tModelKeyArray) throws RegistryV3Exception {

                 DeleteTModel request = this.objectFactory.createDeleteTModel();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

                 if (tModelKeyArray != null) {

                         request.getTModelKey().addAll(Arrays.asList(tModelKeyArray));

                 }

         DispositionReport dr = new DispositionReport();

         JAXBElement<?> o = execute(this.objectFactory.createDeleteTModel(request), 

                         this.getPublishURI());

         if (o!=null) {

                 dr = (DispositionReport) o.getValue();

         }

         return dr;

         }

         /**

          * Used to locate information about one or more businesses. Returns a

          * businessList message that matches the conditions specified.

          * 

          * @exception RegistryV3Exception;

          */

         public BusinessList findBusiness(Name[] nameArray,

                         DiscoveryURLs discoveryURLs, IdentifierBag identifierBag,

                         CategoryBag categoryBag, TModelBag tModelBag,

                         FindQualifiers findQualifiers, int maxRows)

                         throws RegistryV3Exception {

                 FindBusiness request = this.objectFactory.createFindBusiness();

                 if (nameArray != null) {

                         request.getName().addAll(Arrays.asList(nameArray));

                 }

                 if (discoveryURLs != null) {

                         request.setDiscoveryURLs(discoveryURLs);

                 }

                 if (identifierBag != null) {

                         request.setIdentifierBag(identifierBag);

                 }

                 if (categoryBag != null) {

                         request.setCategoryBag(categoryBag);

                 }

                 if (tModelBag != null) {

                         request.setTModelBag(tModelBag);

                 } 

                 if (findQualifiers != null) {

                         request.setFindQualifiers(findQualifiers);

                 }

                 request.setMaxRows(maxRows);

         BusinessList bl = null;

         JAXBElement<?> o = execute(this.objectFactory.createFindBusiness(request),

                         this.getInquiryURI());

         if (o != null) bl = (BusinessList) o.getValue();

         return bl;

         }

         /**

          * "Used to locate specific bindings within a registered businessService.

          * Returns a bindingDetail message."

          * 

          * @exception RegistryV3Exception

          */

         public BindingDetail findBinding(String serviceKey,

                         CategoryBag categoryBag, TModelBag tModelBag,

                         FindQualifiers findQualifiers, int maxRows)

                         throws RegistryV3Exception {

                 // FIXME: Juddi's methods also set category bag (per uddi spec v3).

                 // However, we are sticking to v2 for now, so categorybag doesn't

                 // exist under FindBinding. It is fine for now, since the incoming

                 // parameter value is always null anyways -- but this may change

                 // in the future.

                 FindBinding request = this.objectFactory.createFindBinding();

                 if (serviceKey != null) {

                         request.setServiceKey(serviceKey);

                 }

                 if (categoryBag != null) {

                         request.setCategoryBag(categoryBag);

                 }

                 if (tModelBag != null) {

                         request.setTModelBag(tModelBag);

                 }

                 if (findQualifiers != null) {

                         request.setFindQualifiers(findQualifiers);

                 }

                 request.setMaxRows(maxRows);

         BindingDetail bd = null;

         JAXBElement<?> o = execute(this.objectFactory.createFindBinding(request), 

                         this.getInquiryURI());

         if (o != null) bd = (BindingDetail) o.getValue();

         return bd;

         }

         /**

          * "Used to locate specific services within a registered businessEntity.

          * Return a serviceList message." From the XML spec (API, p18) it appears

          * that the name, categoryBag, and tModelBag arguments are mutually

          * exclusive.

          * 

          * @exception RegistryV3Exception;

          */

         public ServiceList findService(String businessKey, Name[] nameArray,

                         CategoryBag categoryBag, TModelBag tModelBag,

                         FindQualifiers findQualifiers, int maxRows)

                         throws RegistryV3Exception {

                 FindService request = this.objectFactory.createFindService();

                 if (businessKey != null) {

                         request.setBusinessKey(businessKey);

                 }

                 if (nameArray != null) {

                         request.getName().addAll(Arrays.asList(nameArray));

                 }

                 if (categoryBag != null) {

                         request.setCategoryBag(categoryBag);

                 }

                 if (tModelBag != null) {

                         request.setTModelBag(tModelBag);

                 }

                 if (findQualifiers != null) {

                         request.setFindQualifiers(findQualifiers);

                 }

                 request.setMaxRows(maxRows);

         ServiceList sl = null;

         JAXBElement<?> o = execute(this.objectFactory.createFindService(request), 

                         this.getInquiryURI());

         if (o != null) sl = (ServiceList) o.getValue();

         return sl;

         }

         /**

          * "Used to locate one or more tModel information structures. Returns a

          * tModelList structure."

          * 

          * @exception RegistryV3Exception;

          */

         public TModelList findTModel(String name, CategoryBag categoryBag,

                         IdentifierBag identifierBag, FindQualifiers findQualifiers,

                         int maxRows) throws RegistryV3Exception {

                 FindTModel request = this.objectFactory.createFindTModel();

                 Name jaxbName = this.objectFactory.createName();

                 if (name != null) {

                         jaxbName.setValue(name);

                 }

                 request.setName(jaxbName);

                 if (categoryBag != null) {

                         request.setCategoryBag(categoryBag);

                 }

                 if (identifierBag != null) {

                         request.setIdentifierBag(identifierBag);

                 }

                 if (findQualifiers != null) {

                         request.setFindQualifiers(findQualifiers);

                 }

                 request.setMaxRows(maxRows);

         TModelList tml = null;

         JAXBElement<?> o = execute(this.objectFactory.createFindTModel(request), 

                         this.getInquiryURI());

         if (o !=null) tml = (TModelList) o.getValue();

         return tml;

         }

         /**

          * @exception RegistryV3Exception;

          */

         public AssertionStatusReport getAssertionStatusReport(String authInfo,

                         String completionStatus) throws RegistryV3Exception {

                 GetAssertionStatusReport request = this.objectFactory.createGetAssertionStatusReport();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

                 if (completionStatus != null) {

                         CompletionStatus cs = CompletionStatus.fromValue(completionStatus);

                         request.setCompletionStatus(cs);

                 }

         AssertionStatusReport asr = new AssertionStatusReport();

         JAXBElement<?> o = execute(this.objectFactory.createGetAssertionStatusReport(request), 

                         this.getPublishURI());

         asr = (AssertionStatusReport) o.getValue();

         return asr;

         }

         /**

          * "Used to request an authentication token from an Operator Site.

          * Authentication tokens are required to use all other APIs defined in the

          * publishers API. This server serves as the program's equivalent of a login

          * request."

          * 

          * @exception RegistryV3Exception;

          */

         public AuthToken getAuthToken(String userID, String cred)

                         throws RegistryV3Exception {

                 GetAuthToken request = this.objectFactory.createGetAuthToken();

                 if (userID != null) {

                         request.setUserID(userID);

                 }

                 if (cred != null) {

                         request.setCred(cred);

                 }

                 URI getAuthTokenURI = null;

                 if ("3.0".equals(uddiVersion)) {

                         getAuthTokenURI = this.getSecurityURI();

                 } else {

                         getAuthTokenURI = this.getPublishURI();

                 }

         AuthToken at = null;

         JAXBElement<?> o = execute(this.objectFactory.createGetAuthToken(request), 

                         getAuthTokenURI);

         if (o!=null)

         at = (AuthToken) o.getValue();

         return at;

         }

         /**

          * Used to get the full businessEntity information for a particular business

          * entity. Returns a businessDetail message.

          * 

          * @exception RegistryV3Exception;

          */

         public BusinessDetail getBusinessDetail(String businessKey)

                         throws RegistryV3Exception {

                 String[] keys = new String[1];

                 keys[0] = businessKey;

                 return getBusinessDetail(keys);

         }

         /**

          * "Used to get the full businessEntity information for one or more

          * businesses. Returns a businessDetail message."

          * 

          * @exception RegistryV3Exception;

          */

         public BusinessDetail getBusinessDetail(String[] businessKeyArray)

                         throws RegistryV3Exception {

                 GetBusinessDetail request = this.objectFactory.createGetBusinessDetail();

                 if (businessKeyArray != null) {

                         request.getBusinessKey().addAll(Arrays.asList(businessKeyArray));

                 }

         BusinessDetail bd = null;

         JAXBElement<?> o = execute(this.objectFactory.createGetBusinessDetail(request), 

                         this.getInquiryURI());

         bd = (BusinessDetail) o.getValue(); 

         return bd;

         }

         /**

          * @exception RegistryV3Exception;

          */

         public PublisherAssertions getPublisherAssertions(String authInfo)

                         throws RegistryV3Exception {

                 GetPublisherAssertions request = this.objectFactory.createGetPublisherAssertions();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

         PublisherAssertions pa = new PublisherAssertions();

         JAXBElement<?> o = execute(this.objectFactory.createGetPublisherAssertions(request),

                         this.getPublishURI());

         if (o != null) {

             PublisherAssertionsResponse par = (PublisherAssertionsResponse) o.getValue();

             List<PublisherAssertion> assertions = par.getPublisherAssertion();

             for (int i = 0; i < assertions.size(); i++ ) {

                     pa.getPublisherAssertion().add((PublisherAssertion)assertions.get(i));

             }

         }

         return pa;

         }

         /**

          * @exception RegistryV3Exception;

          */

         public RegisteredInfo getRegisteredInfo(String authInfo)

                         throws RegistryV3Exception {

                 GetRegisteredInfo request = this.objectFactory.createGetRegisteredInfo();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

                 request.setInfoSelection(InfoSelection.ALL);

         RegisteredInfo ri = null;

         JAXBElement<?> o = execute(this.objectFactory.createGetRegisteredInfo(request), 

                         this.getPublishURI());

         if (o != null) ri = (RegisteredInfo) o.getValue();

         return ri;

         }

         /**

          * "Used to get full details for a particular registered businessService.

          * Returns a serviceDetail message."

          * 

          * @exception RegistryV3Exception;

          */

         public ServiceDetail getServiceDetail(String serviceKey)

                         throws RegistryV3Exception {

                 String[] keys = new String[1];

                 keys[0] = serviceKey;

                 return getServiceDetail(keys);

         }

         /**

          * "Used to get full details for a given set of registered businessService

          * data. Returns a serviceDetail message."

          * 

          * @exception RegistryV3Exception;

          */

         public ServiceDetail getServiceDetail(String[] serviceKeyArray)

                         throws RegistryV3Exception {

                 GetServiceDetail request = this.objectFactory.createGetServiceDetail();

                 if (serviceKeyArray != null) {

                         request.getServiceKey().addAll(Arrays.asList(serviceKeyArray));

                 }

         ServiceDetail sd = null;

         JAXBElement<?> o = execute(this.objectFactory.createGetServiceDetail(request), 

                         this.getInquiryURI());

         if (o != null) sd = (ServiceDetail) o.getValue();

         return sd;

         }

         /**

          * "Used to get full details for a particular registered TModel. Returns a

          * tModelDetail message."

          * 

          * @exception RegistryV3Exception;

          */

         public TModelDetail getTModelDetail(String tModelKey)

                         throws RegistryV3Exception {

                 String[] keys = new String[1];

                 keys[0] = tModelKey;

                 return getTModelDetail(keys);

         }

         /**

          * "Used to get full details for a given set of registered tModel data.

          * Returns a tModelDetail message."

          * 

          * @exception RegistryV3Exception;

          */

         public TModelDetail getTModelDetail(String[] tModelKeyArray)

                         throws RegistryV3Exception {

                 GetTModelDetail request = this.objectFactory.createGetTModelDetail();

                 if (tModelKeyArray != null) {

                         request.getTModelKey().addAll(Arrays.asList(tModelKeyArray));

                 }

         TModelDetail tmd = null;

         JAXBElement<?> o = execute(this.objectFactory.createGetTModelDetail(request), 

                         this.getInquiryURI());

         if (o != null) tmd = (TModelDetail) o.getValue();

         return tmd;

         }

         /**

          * @exception RegistryV3Exception;

          */

         public PublisherAssertions setPublisherAssertions(String authInfo,

                         PublisherAssertion[] assertionArray) throws RegistryV3Exception {

                 SetPublisherAssertions request = this.objectFactory.createSetPublisherAssertions();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

                 if (assertionArray != null) {

                         request.getPublisherAssertion().addAll(Arrays.asList(assertionArray));

                 }

         PublisherAssertions pa = null;

         JAXBElement<?> o = execute(this.objectFactory.createSetPublisherAssertions(request), 

                         this.getPublishURI());

         if (o!=null) pa = (PublisherAssertions) o.getValue();

         return pa;

         }

         /**

          * "Used to register new bindingTemplate information or update existing

          * bindingTemplate information. Use this to control information about

          * technical capabilities exposed by a registered business."

          * 

          * @exception RegistryV3Exception;

          */

         public BindingDetail saveBinding(String authInfo,

                         BindingTemplate[] bindingArray) throws RegistryV3Exception {

                 SaveBinding request = this.objectFactory.createSaveBinding();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

                 if (bindingArray != null) {

                         request.getBindingTemplate().addAll(Arrays.asList(bindingArray));

                 }

         BindingDetail bd = null;

         JAXBElement<?> o = execute(this.objectFactory.createSaveBinding(request), 

                         this.getPublishURI());

         if (o != null) bd = (BindingDetail) o.getValue();

         return bd;

         }

         /**

          * "Used to register new businessEntity information or update existing

          * businessEntity information. Use this to control the overall information

          * about the entire business. Of the save_x APIs this one has the broadest

          * effect."

          * 

          * @exception RegistryV3Exception;

          */

         public BusinessDetail saveBusiness(String authInfo,

                         BusinessEntity[] businessArray) throws RegistryV3Exception {

                 SaveBusiness request = this.objectFactory.createSaveBusiness();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

                 if (businessArray != null) {

                         for (int i = 0; i < businessArray.length; i++) {

                                 BusinessEntity be = businessArray[i];

                                 if (be.getBusinessServices().getBusinessService().size() == 0) {

                                         be.setBusinessServices(null);

                                 }

                         }

                         request.getBusinessEntity().addAll(Arrays.asList(businessArray));

                 }

         BusinessDetail bd = null;

         JAXBElement<?> o = execute(this.objectFactory.createSaveBusiness(request), 

                         this.getPublishURI());

         if (o != null) bd = (BusinessDetail) o.getValue();

         return bd;

         }

         /**

          * "Used to register or update complete information about a businessService

          * exposed by a specified businessEntity."

          * 

          * @exception RegistryV3Exception;

          */

         public ServiceDetail saveService(String authInfo,

                         BusinessService[] serviceArray) throws RegistryV3Exception {

                 SaveService request = this.objectFactory.createSaveService();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

                 if (serviceArray != null) {

                         request.getBusinessService().addAll(Arrays.asList(serviceArray));

                 }

         ServiceDetail sd = null;

         JAXBElement<?> o = execute(this.objectFactory.createSaveService(request), 

                         this.getPublishURI());

         if (o != null) sd = (ServiceDetail) o.getValue();

         return sd;

         }

         /**

          * "Used to register or update complete information about a tModel."

          * 

          * @exception RegistryV3Exception;

          */

         public TModelDetail saveTModel(String authInfo, TModel[] tModelArray)

                         throws RegistryV3Exception {

                 SaveTModel request = this.objectFactory.createSaveTModel();

                 if (authInfo != null) {

                         request.setAuthInfo(authInfo);

                 }

                 if (tModelArray != null) {

                         request.getTModel().addAll(Arrays.asList(tModelArray));

                 }

         TModelDetail tmd = null;

         JAXBElement<?> o = execute(this.objectFactory.createSaveTModel(request), 

                         this.getPublishURI());

         if (o != null) tmd = (TModelDetail) o.getValue();

         return tmd;

         }

         /**

          * Returns an implementation of Transport based on the className passed in.

          * If a null value is passed then the default Transport implementation

          * "org.apache.ws.scout.transport.AxisTransport" is created and returned.

          * 

          * @return Transport

          */

         public Transport getTransport(String className) {

                 Transport transport = null;

                 Class transportClass = null;

                 // If a Transport class name isn't supplied use

                 // the default Transport implementation.

                 if (className == null)

                         className = DEFAULT_TRANSPORT_CLASS;

                 try {

                         // instruct class loader to load the TransportFactory

                         transportClass = getClassForName(className);

                 } catch (ClassNotFoundException cnfex) {

                         throw new RuntimeException(cnfex);

                 }

                 try {

                         // try to instantiate the TransportFactory

                     if (LocalTransport.class.getName().equals(className) && managerName!=null) {

                         transport = (Transport) transportClass.getConstructor(

                                 new Class[]{String.class,String.class})

                                 .newInstance(nodeName,managerName);

                     } else {

                         transport = (Transport) transportClass.newInstance();

                     }

                 } catch (Exception ex) {

                         throw new RuntimeException(ex);

                 }

                 return transport;

         }

         /**

          * 

          * @param name

          * @return The class object for the name given

          * @throws ClassNotFoundException

          * @throws NoClassDefFoundError

          */

         public static Class getClassForName(String name)

                         throws ClassNotFoundException, NoClassDefFoundError {

                 Class clazz = null;

                 try {

                         // log.info("Using the Context ClassLoader");

                         ClassLoader ccl = AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() 

                     {

                                 public ClassLoader run() {

                                         return Thread.currentThread().getContextClassLoader();

                         }

                         });

                         clazz = Class.forName(name, true, ccl);

                 } catch (Exception e) {

                          log.debug("Failed to load the class " + name + " with context class loader " + e);

                 }

                 if (null == clazz) {

                         ClassLoader scl = AccessController.doPrivileged(new PrivilegedAction<ClassLoader>()

                         { 

                                 public ClassLoader run() {

                                         return ClassLoader.getSystemClassLoader();

                                 }

                         });

                         try {

                                 clazz = Class.forName(name, true, scl);

                         } catch (Exception e) {

                           throw new RuntimeException(e);

                         }

                 }

                 return clazz;

         }

 }