/*
    * 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()!=null)
                                     
                                     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;
 	}
 }