/******************************************************************************* | |
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved. | |
* This program and the accompanying materials are made available under the | |
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 | |
* which accompanies this distribution. | |
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html | |
* and the Eclipse Distribution License is available at | |
* http://www.eclipse.org/org/documents/edl-v10.php. | |
* | |
* Contributors: | |
* Oracle - initial API and implementation from Oracle TopLink | |
******************************************************************************/ | |
package org.eclipse.persistence.tools.dbws; | |
//javase imports | |
import java.io.OutputStream; | |
//Java extension imports | |
import javax.wsdl.Binding; | |
import javax.wsdl.BindingFault; | |
import javax.wsdl.BindingInput; | |
import javax.wsdl.BindingOperation; | |
import javax.wsdl.BindingOutput; | |
import javax.wsdl.Definition; | |
import javax.wsdl.Fault; | |
import javax.wsdl.Input; | |
import javax.wsdl.Message; | |
import javax.wsdl.Output; | |
import javax.wsdl.Part; | |
import javax.wsdl.Port; | |
import javax.wsdl.PortType; | |
import javax.wsdl.Service; | |
import javax.wsdl.Types; | |
import javax.wsdl.WSDLException; | |
import javax.wsdl.extensions.ExtensibilityElement; | |
import javax.wsdl.extensions.ExtensionRegistry; | |
import javax.wsdl.extensions.soap.SOAPAddress; | |
import javax.wsdl.extensions.soap.SOAPBinding; | |
import javax.wsdl.extensions.soap.SOAPBody; | |
import javax.wsdl.extensions.soap.SOAPFault; | |
import javax.wsdl.extensions.soap.SOAPOperation; | |
import javax.wsdl.extensions.soap12.SOAP12Address; | |
import javax.wsdl.extensions.soap12.SOAP12Binding; | |
import javax.wsdl.extensions.soap12.SOAP12Body; | |
import javax.wsdl.extensions.soap12.SOAP12Fault; | |
import javax.wsdl.extensions.soap12.SOAP12Operation; | |
import javax.wsdl.factory.WSDLFactory; | |
import javax.wsdl.xml.WSDLWriter; | |
import javax.xml.namespace.QName; | |
import static javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI; | |
//import static | |
//EclipseLink imports | |
import org.eclipse.persistence.internal.oxm.schema.SchemaModelProject; | |
import org.eclipse.persistence.internal.oxm.schema.model.Any; | |
import org.eclipse.persistence.internal.oxm.schema.model.ComplexType; | |
import org.eclipse.persistence.internal.oxm.schema.model.Element; | |
import org.eclipse.persistence.internal.oxm.schema.model.Import; | |
import org.eclipse.persistence.internal.oxm.schema.model.Schema; | |
import org.eclipse.persistence.internal.oxm.schema.model.Sequence; | |
import org.eclipse.persistence.internal.xr.Operation; | |
import org.eclipse.persistence.internal.xr.Parameter; | |
import org.eclipse.persistence.internal.xr.QueryOperation; | |
import org.eclipse.persistence.internal.xr.XRServiceModel; | |
import org.eclipse.persistence.oxm.NamespaceResolver; | |
import org.eclipse.persistence.oxm.XMLContext; | |
import org.eclipse.persistence.oxm.XMLDescriptor; | |
import org.eclipse.persistence.oxm.XMLMarshaller; | |
import static org.eclipse.persistence.internal.xr.Util.DBWS_SCHEMA_XML; | |
import static org.eclipse.persistence.internal.xr.Util.TARGET_NAMESPACE_PREFIX; | |
import static org.eclipse.persistence.internal.xr.Util.SERVICE_SUFFIX; | |
import static org.eclipse.persistence.tools.dbws.Util.THE_INSTANCE_NAME; | |
import static org.eclipse.persistence.tools.dbws.Util.WSI_SWAREF; | |
import static org.eclipse.persistence.tools.dbws.Util.WSI_SWAREF_PREFIX; | |
import static org.eclipse.persistence.tools.dbws.Util.WSI_SWAREF_URI; | |
import static org.eclipse.persistence.tools.dbws.Util.WSI_SWAREF_XSD_FILE; | |
public class WSDLGenerator { | |
public static final String BINDING_SUFFIX = "_SOAP_HTTP"; | |
public static final String EMPTY_RESPONSE = "EmptyResponse"; | |
public static final String EXCEPTION_SUFFIX = "Exception"; | |
public static final String FAULT_SUFFIX = "Fault"; | |
public static final String NS_SCHEMA_PREFIX = "xsd"; | |
public static final String NS_TNS_PREFIX = "tns"; | |
public static final String SOAP_11_NAMESPACE_URI = "http://schemas.xmlsoap.org/wsdl/soap/"; | |
public static final String SOAP_11_NAMESPACE_PREFIX = "soap"; | |
public static final String SOAP_12_NAMESPACE_URI = "http://schemas.xmlsoap.org/wsdl/soap12/"; | |
public static final String SOAP_12_NAMESPACE_PREFIX = "soap12"; | |
public static final String PORT_SUFFIX = "_Interface"; | |
public static final String REQUEST_SUFFIX = "Request"; | |
public static final String RESPONSE_SUFFIX = "Response"; | |
public static final String SOAP_STYLE = "document"; | |
public static final String SOAP_HTTP_TRANSPORT = "http://schemas.xmlsoap.org/soap/http"; | |
public static final String SOAP_USE = "literal"; | |
public static final String TAG_SCHEMA = "schema"; | |
public static final String TAG_SOAP_ADDRESS = "address"; | |
public static final String TAG_SOAP_BINDING = "binding"; | |
public static final String TAG_SOAP_BODY = "body"; | |
public static final String TAG_SOAP_FAULT = "fault"; | |
public static final String TAG_SOAP_OPERATION = "operation"; | |
public static final String TYPE_SUFFIX = "Type"; | |
protected XRServiceModel xrServiceModel; | |
protected NamingConventionTransformer nct; | |
protected String serviceName; | |
protected String serviceNameSpace; | |
protected String importedSchemaNameSpace; | |
protected String wsdlLocationURI; | |
protected boolean hasAttachments; | |
protected OutputStream os; | |
public WSDLGenerator(XRServiceModel xrServiceModel, NamingConventionTransformer nct, | |
String wsdlLocationURI, boolean hasAttachments, String importedSchemaNameSpace, | |
OutputStream os) { | |
this.xrServiceModel = xrServiceModel; | |
this.nct = nct; | |
this.wsdlLocationURI = wsdlLocationURI; | |
this.hasAttachments = hasAttachments; | |
this.os = os; | |
this.importedSchemaNameSpace = importedSchemaNameSpace; | |
serviceName = xrServiceModel.getName() + SERVICE_SUFFIX; | |
serviceNameSpace = importedSchemaNameSpace + SERVICE_SUFFIX; | |
} | |
public Definition generateWSDL() throws WSDLException { | |
return generateWSDL(false); | |
} | |
public Definition generateWSDL(boolean useSOAP12) throws WSDLException { | |
WSDLFactory factory = WSDLFactory.newInstance(); | |
ExtensionRegistry registry = factory.newPopulatedExtensionRegistry(); | |
Definition def = factory.newDefinition(); | |
if (useSOAP12) { | |
def.addNamespace(SOAP_12_NAMESPACE_PREFIX, SOAP_12_NAMESPACE_URI); | |
} | |
else { | |
def.addNamespace(SOAP_11_NAMESPACE_PREFIX, SOAP_11_NAMESPACE_URI); | |
} | |
def.setTargetNamespace(serviceNameSpace); | |
def.setQName(new QName(serviceNameSpace, serviceName)); | |
def.addNamespace(NS_TNS_PREFIX, serviceNameSpace); | |
def.addNamespace(TARGET_NAMESPACE_PREFIX, importedSchemaNameSpace); | |
def.addNamespace(NS_SCHEMA_PREFIX, W3C_XML_SCHEMA_NS_URI); | |
Types types = def.createTypes(); | |
javax.wsdl.extensions.schema.Schema schema = | |
(javax.wsdl.extensions.schema.Schema)registry.createExtension(Types.class, new QName( | |
W3C_XML_SCHEMA_NS_URI, TAG_SCHEMA)); | |
schema.setElement(createInlineSchema()); | |
types.addExtensibilityElement(schema); | |
def.setTypes(types); | |
PortType portType = def.createPortType(); | |
portType.setUndefined(false); | |
portType.setQName(new QName(serviceNameSpace, serviceName + PORT_SUFFIX)); | |
def.addPortType(portType); | |
ExtensibilityElement soap = null; | |
if (useSOAP12) { | |
soap = registry.createExtension(Binding.class, new QName( | |
SOAP_12_NAMESPACE_URI, TAG_SOAP_BINDING)); | |
((SOAP12Binding)soap).setStyle(SOAP_STYLE); | |
((SOAP12Binding)soap).setTransportURI(SOAP_HTTP_TRANSPORT); | |
} | |
else { | |
soap = registry.createExtension(Binding.class, new QName(SOAP_11_NAMESPACE_URI, | |
TAG_SOAP_BINDING)); | |
((SOAPBinding)soap).setStyle(SOAP_STYLE); | |
((SOAPBinding)soap).setTransportURI(SOAP_HTTP_TRANSPORT); | |
} | |
Binding binding = def.createBinding(); | |
binding.setUndefined(false); | |
binding.setQName(new QName(serviceNameSpace, serviceName + BINDING_SUFFIX)); | |
binding.setPortType(portType); | |
binding.addExtensibilityElement(soap); | |
def.addBinding(binding); | |
ExtensibilityElement sa = null; | |
if (useSOAP12) { | |
sa = registry.createExtension(Port.class, new QName(SOAP_12_NAMESPACE_URI, | |
TAG_SOAP_ADDRESS)); | |
((SOAP12Address)sa).setLocationURI(wsdlLocationURI); | |
} | |
else { | |
sa = registry.createExtension(Port.class, new QName(SOAP_11_NAMESPACE_URI, | |
TAG_SOAP_ADDRESS)); | |
((SOAPAddress)sa).setLocationURI(wsdlLocationURI); | |
} | |
Service ws = def.createService(); | |
ws.setQName(new QName(serviceNameSpace, serviceName)); | |
Port port = def.createPort(); | |
port.setName(serviceName + "Port"); | |
port.setBinding(binding); | |
port.addExtensibilityElement(sa); | |
ws.addPort(port); | |
def.addService(ws); | |
boolean requireEmptyResponseMessages = false; | |
for (Operation op : xrServiceModel.getOperationsList()) { | |
if (!(op instanceof QueryOperation)) { | |
requireEmptyResponseMessages = true; | |
break; | |
} | |
} | |
if (requireEmptyResponseMessages) { | |
/* | |
* Add in empty response message | |
* <wsdl:message name="EmptyResponse"> | |
* <wsdl:part name="emptyResponse" element="tns:EmptyResponse"></wsdl:part> | |
* </wsdl:message> | |
*/ | |
Message emptyResponseMessage = def.createMessage(); | |
emptyResponseMessage.setUndefined(false); | |
emptyResponseMessage.setQName(new QName(serviceNameSpace, EMPTY_RESPONSE)); | |
Part responsePart = def.createPart(); | |
responsePart.setName("emptyResponse"); | |
responsePart.setElementName(new QName(serviceNameSpace, EMPTY_RESPONSE)); | |
emptyResponseMessage.addPart(responsePart); | |
def.addMessage(emptyResponseMessage); | |
/* | |
* Add in Fault message | |
* <wsdl:message name="FaultType"> | |
* <wsdl:part name="fault" element="tns:FaultType"></wsdl:part> | |
* </wsdl:message> | |
*/ | |
Message faultMessage = def.createMessage(); | |
faultMessage.setUndefined(false); | |
faultMessage.setQName(new QName(serviceNameSpace, FAULT_SUFFIX + TYPE_SUFFIX)); | |
Part faultPart = def.createPart(); | |
faultPart.setName("fault"); | |
faultPart.setElementName(new QName(serviceNameSpace, FAULT_SUFFIX + TYPE_SUFFIX)); | |
faultMessage.addPart(faultPart); | |
def.addMessage(faultMessage); | |
} | |
for (Operation op : xrServiceModel.getOperationsList()) { | |
createMethodDefinition(factory, registry, def, op, useSOAP12); | |
} | |
if (os != null) { | |
WSDLWriter writer = factory.newWSDLWriter(); | |
writer.writeWSDL(def, os); | |
} | |
return def; | |
} | |
private void createMethodDefinition(WSDLFactory factory, ExtensionRegistry registry, | |
Definition def, Operation operation, boolean useSOAP12) throws WSDLException { | |
Message requestMessage = def.createMessage(); | |
requestMessage.setUndefined(false); | |
requestMessage.setQName(new QName(serviceNameSpace, operation.getName() + REQUEST_SUFFIX)); | |
Part requestPart = def.createPart(); | |
requestPart.setName(operation.getName() + REQUEST_SUFFIX); | |
requestPart.setElementName(new QName(serviceNameSpace, operation.getName())); | |
requestMessage.addPart(requestPart); | |
def.addMessage(requestMessage); | |
Message responseMessage = null; | |
if (operation.hasResponse()) { | |
responseMessage = def.createMessage(); | |
responseMessage.setUndefined(false); | |
responseMessage.setQName(new QName(serviceNameSpace, operation.getName() | |
+ RESPONSE_SUFFIX)); | |
Part responsePart = def.createPart(); | |
responsePart.setName(operation.getName() + RESPONSE_SUFFIX); | |
responsePart.setElementName(new QName(serviceNameSpace, operation.getName() | |
+ RESPONSE_SUFFIX)); | |
responseMessage.addPart(responsePart); | |
def.addMessage(responseMessage); | |
} | |
PortType portType = | |
def.getPortType(new QName(serviceNameSpace, serviceName + PORT_SUFFIX)); | |
javax.wsdl.Operation op = def.createOperation(); | |
op.setUndefined(false); | |
op.setName(operation.getName()); | |
Input input = def.createInput(); | |
input.setMessage(requestMessage); | |
op.setInput(input); | |
if (operation.hasResponse()) { | |
Output output = def.createOutput(); | |
output.setMessage(responseMessage); | |
op.setOutput(output); | |
} | |
portType.addOperation(op); | |
Binding binding = | |
def.getBinding(new QName(serviceNameSpace, serviceName + BINDING_SUFFIX)); | |
BindingOperation bop = def.createBindingOperation(); | |
bop.setName(operation.getName()); | |
ExtensibilityElement so = null; | |
if (useSOAP12) { | |
so = registry.createExtension(BindingOperation.class, new QName( | |
SOAP_12_NAMESPACE_URI, TAG_SOAP_OPERATION)); | |
((SOAP12Operation)so).setSoapActionURI(serviceNameSpace + ":" + op.getName()); | |
} | |
else { | |
so = registry.createExtension(BindingOperation.class, new QName( | |
SOAP_11_NAMESPACE_URI, TAG_SOAP_OPERATION)); | |
((SOAPOperation)so).setSoapActionURI(serviceNameSpace + ":" + op.getName()); | |
} | |
bop.addExtensibilityElement(so); | |
BindingInput bi = def.createBindingInput(); | |
ExtensibilityElement soapInputBody = null; | |
if (useSOAP12) { | |
soapInputBody = registry.createExtension(BindingInput.class, new QName( | |
SOAP_12_NAMESPACE_URI, TAG_SOAP_BODY)); | |
((SOAP12Body)soapInputBody).setUse(SOAP_USE); | |
} | |
else { | |
soapInputBody = registry.createExtension(BindingInput.class, new QName( | |
SOAP_11_NAMESPACE_URI, TAG_SOAP_BODY)); | |
((SOAPBody)soapInputBody).setUse(SOAP_USE); | |
} | |
bi.addExtensibilityElement(soapInputBody); | |
bop.setBindingInput(bi); | |
if (operation.hasResponse()) { | |
BindingOutput bo = def.createBindingOutput(); | |
ExtensibilityElement soapOutputBody = null; | |
if (useSOAP12) { | |
soapOutputBody = registry.createExtension(BindingOutput.class, new QName( | |
SOAP_12_NAMESPACE_URI, TAG_SOAP_BODY)); | |
((SOAP12Body)soapOutputBody).setUse(SOAP_USE); | |
} | |
else { | |
soapOutputBody = registry.createExtension(BindingOutput.class, new QName( | |
SOAP_11_NAMESPACE_URI, TAG_SOAP_BODY)); | |
((SOAPBody)soapOutputBody).setUse(SOAP_USE); | |
} | |
bo.addExtensibilityElement(soapOutputBody); | |
bop.setBindingOutput(bo); | |
} | |
if (!(operation instanceof QueryOperation)) { | |
// non-QueryOperations don't have Responses, but the fault requirements | |
// mean we have to create 'dummy' WSDL outputs | |
BindingOutput bo = def.createBindingOutput(); | |
ExtensibilityElement soapOutputBody = null; | |
if (useSOAP12) { | |
soapOutputBody = registry.createExtension(BindingOutput.class, new QName( | |
SOAP_12_NAMESPACE_URI, TAG_SOAP_BODY)); | |
((SOAP12Body)soapOutputBody).setUse(SOAP_USE); | |
} | |
else { | |
soapOutputBody = registry.createExtension(BindingOutput.class, new QName( | |
SOAP_11_NAMESPACE_URI, TAG_SOAP_BODY)); | |
((SOAPBody)soapOutputBody).setUse(SOAP_USE); | |
} | |
bo.addExtensibilityElement(soapOutputBody); | |
bop.setBindingOutput(bo); | |
// add WSDL fault to binding operations | |
BindingFault bindingFault = def.createBindingFault(); | |
String exceptionName = FAULT_SUFFIX + EXCEPTION_SUFFIX; | |
bindingFault.setName(exceptionName); | |
ExtensibilityElement soapFaultBody = null; | |
if (useSOAP12) { | |
soapFaultBody = registry.createExtension(BindingFault.class, new QName( | |
SOAP_12_NAMESPACE_URI, TAG_SOAP_FAULT)); | |
((SOAP12Fault)soapFaultBody).setUse(SOAP_USE); | |
((SOAP12Fault)soapFaultBody).setName(exceptionName); | |
} | |
else { | |
soapFaultBody = registry.createExtension(BindingFault.class, new QName( | |
SOAP_11_NAMESPACE_URI, TAG_SOAP_FAULT)); | |
((SOAPFault)soapFaultBody).setUse(SOAP_USE); | |
((SOAPFault)soapFaultBody).setName(exceptionName); | |
} | |
bindingFault.addExtensibilityElement(soapFaultBody); | |
bop.addBindingFault(bindingFault); | |
Message emptyResponseMessage = def.getMessage(new QName(serviceNameSpace, EMPTY_RESPONSE)); | |
Output output = def.createOutput(); | |
output.setName(operation.getName() + EMPTY_RESPONSE); | |
output.setMessage(emptyResponseMessage); | |
op.setOutput(output); | |
Message faultMessage = def.getMessage(new QName(serviceNameSpace, | |
FAULT_SUFFIX + TYPE_SUFFIX)); | |
Fault fault = def.createFault(); | |
fault.setMessage(faultMessage); | |
fault.setName(exceptionName); | |
op.addFault(fault); | |
} | |
binding.addBindingOperation(bop); | |
} | |
/** | |
* Build the inline schema that will make up the content of the | |
* <wsdl:types> section of the WSDL. | |
* @return | |
*/ | |
@SuppressWarnings("unchecked") | |
private org.w3c.dom.Element createInlineSchema() { | |
SchemaModelProject project = new SchemaModelProject(); | |
XMLContext context = new XMLContext(project); | |
XMLMarshaller marshaller = context.createMarshaller(); | |
XMLDescriptor descriptor = (XMLDescriptor) project.getClassDescriptor(Schema.class); | |
if (descriptor.getNamespaceResolver() == null) { | |
descriptor.setNamespaceResolver(new NamespaceResolver()); | |
} | |
descriptor.getNamespaceResolver().put(NS_TNS_PREFIX, serviceNameSpace); | |
descriptor.getNamespaceResolver().put(NS_SCHEMA_PREFIX, W3C_XML_SCHEMA_NS_URI); | |
if (hasAttachments) { | |
descriptor.getNamespaceResolver().put(WSI_SWAREF_PREFIX, WSI_SWAREF_URI); | |
} | |
Schema schema = new Schema(); | |
schema.setTargetNamespace(serviceNameSpace); | |
schema.setElementFormDefault(true); | |
Import parent = new Import(); | |
parent.setNamespace(importedSchemaNameSpace); | |
parent.setSchemaLocation(DBWS_SCHEMA_XML); | |
schema.getImports().add(parent); | |
if (hasAttachments) { | |
Import ref = new Import(); | |
ref.setNamespace(WSI_SWAREF_URI); | |
// ref.setSchemaLocation("http://ws-i.org/profiles/basic/1.1/swaref.xsd"); // later version | |
ref.setSchemaLocation(WSI_SWAREF_XSD_FILE); | |
schema.getImports().add(ref); | |
} | |
boolean requireFaultTypeEmptyResponse = false; | |
for (Operation op : xrServiceModel.getOperationsList()) { | |
String opName = op.getName(); | |
ComplexType requestType = new ComplexType(); | |
// may need to extract tableNameAlias from operation name - everything after first | |
// underscore '_' character (for cases where a QueryOperation is not user defined) | |
// i.e. String tableNameAlias = opName.substring(opName.indexOf('_') + 1); | |
requestType.setName(opName + REQUEST_SUFFIX + TYPE_SUFFIX); | |
Sequence requestSequence = null; | |
if (op.getParameters().size() > 0) { | |
requestSequence = new Sequence(); | |
for (Parameter p : op.getParameters()) { | |
Element arg = new Element(); | |
if (p.isOptional()) { | |
arg.setMinOccurs("0"); | |
} | |
arg.setName(p.getName()); | |
if (THE_INSTANCE_NAME.equals(p.getName())) { | |
ComplexType nestedComplexType = new ComplexType(); | |
Sequence nestedSequence = new Sequence(); | |
nestedComplexType.setSequence(nestedSequence); | |
Element nestedElement = new Element(); | |
nestedElement.setRef(TARGET_NAMESPACE_PREFIX + ":" + p.getType().getLocalPart()); | |
// here we may need to use 'tableNameAlias' instead, i.e. | |
// nestedElement.setRef(TARGET_NAMESPACE_PREFIX + ":" + tableNameAlias); | |
nestedSequence.addElement(nestedElement); | |
arg.setComplexType(nestedComplexType); | |
} else { | |
arg.setName(p.getName()); | |
if (p.getType().getNamespaceURI().equals(W3C_XML_SCHEMA_NS_URI)) { | |
arg.setType(NS_SCHEMA_PREFIX + ":" + p.getType().getLocalPart()); | |
} else if (p.getType().getNamespaceURI().equals(importedSchemaNameSpace)) { | |
arg.setType(TARGET_NAMESPACE_PREFIX + ":" + p.getType().getLocalPart()); | |
} else { | |
arg.setType(p.getType().getLocalPart()); | |
} | |
} | |
requestSequence.addElement(arg); | |
} | |
requestType.setSequence(requestSequence); | |
} | |
schema.addTopLevelComplexTypes(requestType); | |
Element requestElement = new Element(); | |
requestElement.setName(op.getName()); | |
requestElement.setType(NS_TNS_PREFIX + ":" + requestType.getName()); | |
schema.addTopLevelElement(requestElement); | |
// build response message based on operation type | |
if (op instanceof QueryOperation) { | |
QueryOperation q = (QueryOperation) op; | |
ComplexType responseType = new ComplexType(); | |
responseType.setName(op.getName() + RESPONSE_SUFFIX + TYPE_SUFFIX); | |
Sequence responseSequence = new Sequence(); | |
Element result = new Element(); | |
result.setName("result"); | |
if (q.isAttachment()) { | |
result.setType(WSI_SWAREF_PREFIX + ":" + WSI_SWAREF); | |
} else if (q.isSimpleXMLFormat() || q.getResultType().equals(new QName(W3C_XML_SCHEMA_NS_URI, "any"))) { | |
ComplexType anyType = new ComplexType(); | |
Sequence anySequence = new Sequence(); | |
anySequence.addAny(new Any()); | |
anyType.setSequence(anySequence); | |
result.setComplexType(anyType); | |
} else { | |
if (q.getResultType().getNamespaceURI().equals(W3C_XML_SCHEMA_NS_URI)) { | |
result.setType(NS_SCHEMA_PREFIX + ":" + q.getResultType().getLocalPart()); | |
} else { | |
ComplexType nestedComplexType = new ComplexType(); | |
Sequence nestedSequence = new Sequence(); | |
nestedComplexType.setSequence(nestedSequence); | |
Element nestedElement = new Element(); | |
// may need if/else based on if the operation is/isn't user defined, i.e. | |
//if (!q.isUserDefined()) { | |
// nestedElement.setRef(TARGET_NAMESPACE_PREFIX + ":" + tableNameAlias); | |
//} else { | |
// nestedElement.setRef(TARGET_NAMESPACE_PREFIX + ":" + q.getResultType().getLocalPart()); | |
//} | |
nestedElement.setRef(TARGET_NAMESPACE_PREFIX + ":" + q.getResultType().getLocalPart()); | |
nestedElement.setMinOccurs("0"); | |
if (q.isCollection()) { | |
nestedElement.setMaxOccurs("unbounded"); | |
} | |
nestedSequence.addElement(nestedElement); | |
result.setComplexType(nestedComplexType); | |
} | |
} | |
responseSequence.addElement(result); | |
responseType.setSequence(responseSequence); | |
schema.addTopLevelComplexTypes(responseType); | |
Element responseElement = new Element(); | |
responseElement.setName(op.getName() + RESPONSE_SUFFIX); | |
responseElement.setType(NS_TNS_PREFIX + ":" + responseType.getName()); | |
schema.addTopLevelElement(responseElement); | |
} else { | |
requireFaultTypeEmptyResponse = true; | |
} | |
} | |
if (requireFaultTypeEmptyResponse) { | |
// <element name="EmptyResponse"> | |
// <xsd:complexType/> | |
// </element> | |
Element emptyResponseElement = new Element(); | |
emptyResponseElement.setName(EMPTY_RESPONSE); | |
ComplexType emptyResponseComplexType = new ComplexType(); | |
emptyResponseElement.setComplexType(emptyResponseComplexType); | |
schema.addTopLevelElement(emptyResponseElement); | |
// <xsd:element name="FaultType"> | |
// <xsd:complexType> | |
// <xsd:sequence> | |
// <xsd:element name="faultCode" type="xsd:string"/> | |
// <xsd:element name="faultString" type="xsd:string"/> | |
// </xsd:sequence> | |
// </xsd:complexType> | |
// </element> | |
Element elementFaultType = new Element(); | |
elementFaultType.setName(FAULT_SUFFIX + TYPE_SUFFIX); | |
ComplexType faultComplexType = new ComplexType(); | |
elementFaultType.setComplexType(faultComplexType); | |
Sequence nestedSequence = new Sequence(); | |
faultComplexType.setSequence(nestedSequence); | |
Element faultCodeElement = new Element(); | |
faultCodeElement.setName("faultCode"); | |
faultCodeElement.setMinOccurs("1"); | |
faultCodeElement.setType(NS_SCHEMA_PREFIX + ":string"); | |
nestedSequence.addElement(faultCodeElement); | |
Element faultStringElement = new Element(); | |
faultStringElement.setMinOccurs("1"); | |
faultStringElement.setName("faultString"); | |
faultStringElement.setType(NS_SCHEMA_PREFIX + ":string"); | |
nestedSequence.addElement(faultStringElement); | |
schema.addTopLevelElement(elementFaultType); | |
} | |
return marshaller.objectToXML(schema).getDocumentElement(); | |
} | |
/** | |
* Return the name of the service. | |
*/ | |
public String getServiceName() { | |
return serviceName; | |
} | |
/** | |
* Return the namespace of the service. | |
*/ | |
public String getServiceNameSpace() { | |
return serviceNameSpace; | |
} | |
} |