| /* |
| * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package com.sun.tools.internal.ws.processor.modeler.wsdl; |
| |
| import com.sun.codemodel.internal.JType; |
| import com.sun.istack.internal.NotNull; |
| import com.sun.istack.internal.SAXParseException2; |
| import com.sun.tools.internal.ws.api.wsdl.TWSDLExtensible; |
| import com.sun.tools.internal.ws.processor.generator.Names; |
| import com.sun.tools.internal.ws.processor.model.*; |
| import com.sun.tools.internal.ws.processor.model.Fault; |
| import com.sun.tools.internal.ws.processor.model.Operation; |
| import com.sun.tools.internal.ws.processor.model.Port; |
| import com.sun.tools.internal.ws.processor.model.Service; |
| import com.sun.tools.internal.ws.processor.model.java.*; |
| import com.sun.tools.internal.ws.processor.model.jaxb.*; |
| import com.sun.tools.internal.ws.processor.modeler.JavaSimpleTypeCreator; |
| import com.sun.tools.internal.ws.processor.util.ClassNameCollector; |
| import com.sun.tools.internal.ws.resources.ModelerMessages; |
| import com.sun.tools.internal.ws.wscompile.ErrorReceiver; |
| import com.sun.tools.internal.ws.wscompile.WsimportOptions; |
| import com.sun.tools.internal.ws.wsdl.document.*; |
| import com.sun.tools.internal.ws.wsdl.document.Message; |
| import com.sun.tools.internal.ws.wsdl.document.jaxws.CustomName; |
| import com.sun.tools.internal.ws.wsdl.document.jaxws.JAXWSBinding; |
| import com.sun.tools.internal.ws.wsdl.document.mime.MIMEContent; |
| import com.sun.tools.internal.ws.wsdl.document.schema.SchemaKinds; |
| import com.sun.tools.internal.ws.wsdl.document.soap.*; |
| import com.sun.tools.internal.ws.wsdl.framework.*; |
| import com.sun.tools.internal.ws.wsdl.parser.MetadataFinder; |
| import com.sun.tools.internal.ws.wsdl.parser.WSDLParser; |
| import com.sun.tools.internal.xjc.api.S2JJAXBModel; |
| import com.sun.tools.internal.xjc.api.TypeAndAnnotation; |
| import com.sun.tools.internal.xjc.api.XJC; |
| import com.sun.xml.internal.ws.spi.db.BindingHelper; |
| import com.sun.xml.internal.ws.util.xml.XmlUtil; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.Locator; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.SAXParseException; |
| import org.xml.sax.helpers.LocatorImpl; |
| |
| import javax.jws.WebParam.Mode; |
| import javax.xml.namespace.QName; |
| import java.util.*; |
| import java.io.IOException; |
| |
| |
| /** |
| * The WSDLModeler processes a WSDL to create a Model. |
| * |
| * @author WS Development Team |
| */ |
| public class WSDLModeler extends WSDLModelerBase { |
| |
| //map of wsdl:operation QName to <soapenv:Body> child, as per BP it must be unique in a port |
| private final Map<QName, Operation> uniqueBodyBlocks = new HashMap<QName, Operation>(); |
| private final QName VOID_BODYBLOCK = new QName(""); |
| private final ClassNameCollector classNameCollector; |
| private final String explicitDefaultPackage; |
| |
| public WSDLModeler(WsimportOptions options, ErrorReceiver receiver, MetadataFinder forest) { |
| super(options, receiver,forest); |
| this.classNameCollector = new ClassNameCollector(); |
| this.explicitDefaultPackage = options.defaultPackage; |
| } |
| |
| |
| protected enum StyleAndUse { |
| RPC_LITERAL, DOC_LITERAL |
| } |
| |
| private JAXBModelBuilder jaxbModelBuilder; |
| |
| @Override |
| public Model buildModel() { |
| try { |
| parser = new WSDLParser(options, errReceiver, forest); |
| parser.addParserListener(new ParserListener() { |
| @Override |
| public void ignoringExtension(Entity entity, QName name, QName parent) { |
| if (parent.equals(WSDLConstants.QNAME_TYPES)) { |
| // check for a schema element with the wrong namespace URI |
| if (name.getLocalPart().equals("schema") |
| && !name.getNamespaceURI().equals("")) { |
| warning(entity, ModelerMessages.WSDLMODELER_WARNING_IGNORING_UNRECOGNIZED_SCHEMA_EXTENSION(name.getNamespaceURI())); |
| } |
| } |
| |
| } |
| |
| @Override |
| public void doneParsingEntity(QName element, Entity entity) { |
| } |
| }); |
| |
| document = parser.parse(); |
| if (document == null || document.getDefinitions() == null) { |
| return null; |
| } |
| |
| document.validateLocally(); |
| Model model = internalBuildModel(document); |
| if (model == null || errReceiver.hadError()) { |
| return null; |
| } |
| //ClassNameCollector classNameCollector = new ClassNameCollector(); |
| classNameCollector.process(model); |
| if (classNameCollector.getConflictingClassNames().isEmpty()) { |
| if (errReceiver.hadError()) { |
| return null; |
| } |
| return model; |
| } |
| // do another pass, this time with conflict resolution enabled |
| model = internalBuildModel(document); |
| |
| classNameCollector.process(model); |
| if (classNameCollector.getConflictingClassNames().isEmpty()) { |
| // we're done |
| if (errReceiver.hadError()) { |
| return null; |
| } |
| return model; |
| } |
| // give up |
| StringBuilder conflictList = new StringBuilder(); |
| boolean first = true; |
| for (Iterator iter = |
| classNameCollector.getConflictingClassNames().iterator(); |
| iter.hasNext(); |
| ) { |
| if (!first) { |
| conflictList.append(", "); |
| } else { |
| first = false; |
| } |
| conflictList.append((String) iter.next()); |
| } |
| error(document.getDefinitions(), ModelerMessages.WSDLMODELER_UNSOLVABLE_NAMING_CONFLICTS(conflictList.toString())); |
| } catch (ModelException e) { |
| reportError(document.getDefinitions(), e.getMessage(), e); |
| } catch (ParseException e) { |
| errReceiver.error(e); |
| } catch (ValidationException e) { |
| errReceiver.error(e.getMessage(), e); |
| } catch (SAXException e) { |
| errReceiver.error(e); |
| } catch (IOException e) { |
| errReceiver.error(e); |
| } |
| //should never reach here |
| return null; |
| } |
| |
| private Model internalBuildModel(WSDLDocument document) { |
| numPasses++; |
| |
| //build the jaxbModel to be used latter |
| buildJAXBModel(document); |
| |
| QName modelName = |
| new QName( |
| document.getDefinitions().getTargetNamespaceURI(), |
| document.getDefinitions().getName() == null |
| ? "model" |
| : document.getDefinitions().getName()); |
| Model model = new Model(modelName, document.getDefinitions()); |
| model.setJAXBModel(getJAXBModelBuilder().getJAXBModel()); |
| |
| // This fails with the changed classname (WSDLModeler to WSDLModeler11 etc.) |
| // with this source comaptibility change the WSDL Modeler class name is changed. Right now hardcoding the |
| // modeler class name to the same one being checked in WSDLGenerator. |
| |
| model.setProperty( |
| ModelProperties.PROPERTY_MODELER_NAME, |
| ModelProperties.WSDL_MODELER_NAME); |
| |
| _javaExceptions = new HashMap<String, JavaException>(); |
| _bindingNameToPortMap = new HashMap<QName, Port>(); |
| |
| // grab target namespace |
| model.setTargetNamespaceURI(document.getDefinitions().getTargetNamespaceURI()); |
| |
| setDocumentationIfPresent(model, |
| document.getDefinitions().getDocumentation()); |
| |
| boolean hasServices = document.getDefinitions().services().hasNext(); |
| if (hasServices) { |
| for (Iterator iter = document.getDefinitions().services(); |
| iter.hasNext(); |
| ) { |
| processService((com.sun.tools.internal.ws.wsdl.document.Service) iter.next(), |
| model, document); |
| } |
| } else { |
| // emit a warning if there are no service definitions |
| warning(model.getEntity(), ModelerMessages.WSDLMODELER_WARNING_NO_SERVICE_DEFINITIONS_FOUND()); |
| } |
| |
| return model; |
| } |
| |
| /* (non-Javadoc) |
| * @see WSDLModelerBase#processService(Service, Model, WSDLDocument) |
| */ |
| protected void processService(com.sun.tools.internal.ws.wsdl.document.Service wsdlService, Model model, WSDLDocument document) { |
| QName serviceQName = getQNameOf(wsdlService); |
| String serviceInterface = getServiceInterfaceName(serviceQName, wsdlService); |
| if (isConflictingServiceClassName(serviceInterface)) { |
| serviceInterface += "_Service"; |
| } |
| Service service = |
| new Service( |
| serviceQName, |
| new JavaInterface(serviceInterface, serviceInterface + "Impl"), wsdlService); |
| |
| setDocumentationIfPresent(service, wsdlService.getDocumentation()); |
| boolean hasPorts = false; |
| for (Iterator iter = wsdlService.ports(); iter.hasNext();) { |
| boolean processed = |
| processPort( |
| (com.sun.tools.internal.ws.wsdl.document.Port) iter.next(), |
| service, |
| document); |
| hasPorts = hasPorts || processed; |
| } |
| if (!hasPorts) { |
| // emit a warning if there are no ports |
| warning(wsdlService, ModelerMessages.WSDLMODELER_WARNING_NO_PORTS_IN_SERVICE(wsdlService.getName())); |
| } else { |
| model.addService(service); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see WSDLModelerBase#processPort(WSDLPort, Service, WSDLDocument) |
| */ |
| protected boolean processPort(com.sun.tools.internal.ws.wsdl.document.Port wsdlPort, |
| Service service, WSDLDocument document) { |
| try { |
| |
| //clear the unique block map |
| uniqueBodyBlocks.clear(); |
| |
| QName portQName = getQNameOf(wsdlPort); |
| Port port = new Port(portQName, wsdlPort); |
| |
| setDocumentationIfPresent(port, wsdlPort.getDocumentation()); |
| |
| SOAPAddress soapAddress = |
| (SOAPAddress) getExtensionOfType(wsdlPort, SOAPAddress.class); |
| if (soapAddress == null) { |
| if(options.isExtensionMode()){ |
| warning(wsdlPort, ModelerMessages.WSDLMODELER_WARNING_NO_SOAP_ADDRESS(wsdlPort.getName())); |
| }else{ |
| // not a SOAP port, ignore it |
| warning(wsdlPort, ModelerMessages.WSDLMODELER_WARNING_IGNORING_NON_SOAP_PORT_NO_ADDRESS(wsdlPort.getName())); |
| return false; |
| } |
| } |
| if (soapAddress != null) { |
| port.setAddress(soapAddress.getLocation()); |
| } |
| Binding binding = wsdlPort.resolveBinding(document); |
| QName bindingName = getQNameOf(binding); |
| PortType portType = binding.resolvePortType(document); |
| |
| port.setProperty( |
| ModelProperties.PROPERTY_WSDL_PORT_NAME, |
| getQNameOf(wsdlPort)); |
| port.setProperty( |
| ModelProperties.PROPERTY_WSDL_PORT_TYPE_NAME, |
| getQNameOf(portType)); |
| port.setProperty( |
| ModelProperties.PROPERTY_WSDL_BINDING_NAME, |
| bindingName); |
| |
| boolean isProvider = isProvider(wsdlPort); |
| if (_bindingNameToPortMap.containsKey(bindingName) && !isProvider) { |
| // this binding has been processed before |
| Port existingPort = |
| _bindingNameToPortMap.get(bindingName); |
| port.setOperations(existingPort.getOperations()); |
| port.setJavaInterface(existingPort.getJavaInterface()); |
| port.setStyle(existingPort.getStyle()); |
| port.setWrapped(existingPort.isWrapped()); |
| } else { |
| // find out the SOAP binding extension, if any |
| SOAPBinding soapBinding = |
| (SOAPBinding) getExtensionOfType(binding, SOAPBinding.class); |
| |
| if (soapBinding == null) { |
| soapBinding = |
| (SOAPBinding) getExtensionOfType(binding, SOAP12Binding.class); |
| if (soapBinding == null) { |
| if(!options.isExtensionMode()){ |
| // cannot deal with non-SOAP ports |
| warning(wsdlPort, ModelerMessages.WSDLMODELER_WARNING_IGNORING_NON_SOAP_PORT(wsdlPort.getName())); |
| return false; |
| }else{ |
| warning(wsdlPort, ModelerMessages.WSDLMODELER_WARNING_NON_SOAP_PORT(wsdlPort.getName())); |
| } |
| }else{ |
| // we can only do soap1.2 if extensions are on |
| if (options.isExtensionMode()) { |
| warning(wsdlPort, ModelerMessages.WSDLMODELER_WARNING_PORT_SOAP_BINDING_12(wsdlPort.getName())); |
| } else { |
| warning(wsdlPort, ModelerMessages.WSDLMODELER_WARNING_IGNORING_SOAP_BINDING_12(wsdlPort.getName())); |
| return false; |
| } |
| } |
| } |
| |
| if (soapBinding != null && (soapBinding.getTransport() == null |
| || (!soapBinding.getTransport().equals( |
| SOAPConstants.URI_SOAP_TRANSPORT_HTTP) && !soapBinding.getTransport().equals( |
| SOAP12Constants.URI_SOAP_TRANSPORT_HTTP)))) { |
| if (!options.isExtensionMode()) { |
| // cannot deal with non-HTTP ports |
| warning(wsdlPort, ModelerMessages.WSDLMODELER_WARNING_IGNORING_SOAP_BINDING_NON_HTTP_TRANSPORT(wsdlPort.getName())); |
| return false; |
| } |
| |
| } |
| |
| /** |
| * validate wsdl:binding uniqueness in style, e.g. rpclit or doclit |
| * ref: WSI BP 1.1 R 2705 |
| */ |
| if (soapBinding != null && !validateWSDLBindingStyle(binding)) { |
| if (options.isExtensionMode()) { |
| warning(wsdlPort, ModelerMessages.WSDLMODELER_WARNING_PORT_SOAP_BINDING_MIXED_STYLE(wsdlPort.getName())); |
| } else { |
| error(wsdlPort, ModelerMessages.WSDLMODELER_WARNING_IGNORING_SOAP_BINDING_MIXED_STYLE(wsdlPort.getName())); |
| } |
| } |
| |
| if(soapBinding != null){ |
| port.setStyle(soapBinding.getStyle()); |
| } |
| |
| boolean hasOverloadedOperations = false; |
| Set<String> operationNames = new HashSet<String>(); |
| for (Iterator iter = portType.operations(); iter.hasNext();) { |
| com.sun.tools.internal.ws.wsdl.document.Operation operation = |
| (com.sun.tools.internal.ws.wsdl.document.Operation) iter.next(); |
| |
| if (operationNames.contains(operation.getName())) { |
| hasOverloadedOperations = true; |
| break; |
| } |
| operationNames.add(operation.getName()); |
| |
| for (Iterator itr = binding.operations(); |
| iter.hasNext(); |
| ) { |
| BindingOperation bindingOperation = |
| (BindingOperation) itr.next(); |
| if (operation |
| .getName() |
| .equals(bindingOperation.getName())) { |
| break; |
| } else if (!itr.hasNext()) { |
| error(bindingOperation, ModelerMessages.WSDLMODELER_INVALID_BINDING_OPERATION_NOT_FOUND(operation.getName(), bindingOperation.getName())); |
| } |
| } |
| } |
| |
| Map headers = new HashMap(); |
| boolean hasOperations = false; |
| for (Iterator iter = binding.operations(); iter.hasNext();) { |
| BindingOperation bindingOperation = |
| (BindingOperation) iter.next(); |
| |
| com.sun.tools.internal.ws.wsdl.document.Operation portTypeOperation = |
| null; |
| Set operations = |
| portType.getOperationsNamed(bindingOperation.getName()); |
| if (operations.isEmpty()) { |
| // the WSDL document is invalid |
| error(bindingOperation, ModelerMessages.WSDLMODELER_INVALID_BINDING_OPERATION_NOT_IN_PORT_TYPE(bindingOperation.getName(), binding.getName())); |
| } else if (operations.size() == 1) { |
| portTypeOperation = |
| (com.sun.tools.internal.ws.wsdl.document.Operation) operations |
| .iterator() |
| .next(); |
| } else { |
| boolean found = false; |
| String expectedInputName = |
| bindingOperation.getInput().getName(); |
| String expectedOutputName = |
| bindingOperation.getOutput().getName(); |
| |
| for (Iterator iter2 = operations.iterator(); iter2.hasNext();) { |
| com.sun.tools.internal.ws.wsdl.document.Operation candidateOperation = |
| (com.sun.tools.internal.ws.wsdl.document.Operation) iter2 |
| .next(); |
| |
| if (expectedInputName == null) { |
| // the WSDL document is invalid |
| error(bindingOperation, ModelerMessages.WSDLMODELER_INVALID_BINDING_OPERATION_MISSING_INPUT_NAME(bindingOperation.getName())); |
| } |
| if (expectedOutputName == null) { |
| // the WSDL document is invalid |
| error(bindingOperation, ModelerMessages.WSDLMODELER_INVALID_BINDING_OPERATION_MISSING_OUTPUT_NAME(bindingOperation.getName())); |
| } |
| if (expectedInputName |
| .equals(candidateOperation.getInput().getName()) |
| && expectedOutputName.equals( |
| candidateOperation |
| .getOutput() |
| .getName())) { |
| if (found) { |
| // the WSDL document is invalid |
| error(bindingOperation, ModelerMessages.WSDLMODELER_INVALID_BINDING_OPERATION_MULTIPLE_MATCHING_OPERATIONS(bindingOperation.getName(), bindingOperation.getName())); |
| } |
| // got it! |
| found = true; |
| portTypeOperation = candidateOperation; |
| } |
| } |
| if (!found) { |
| // the WSDL document is invalid |
| error(bindingOperation, ModelerMessages.WSDLMODELER_INVALID_BINDING_OPERATION_NOT_FOUND(bindingOperation.getName(), binding.getName())); |
| } |
| } |
| if (!isProvider) { |
| this.info = |
| new ProcessSOAPOperationInfo( |
| port, |
| wsdlPort, |
| portTypeOperation, |
| bindingOperation, |
| soapBinding, |
| document, |
| hasOverloadedOperations, |
| headers); |
| |
| |
| Operation operation; |
| if (soapBinding != null) { |
| operation = processSOAPOperation(); |
| } else { |
| operation = processNonSOAPOperation(); |
| } |
| if (operation != null) { |
| port.addOperation(operation); |
| hasOperations = true; |
| } |
| } |
| } |
| if (!isProvider && !hasOperations) { |
| // emit a warning if there are no operations, except when its a provider port |
| warning(wsdlPort, ModelerMessages.WSDLMODELER_WARNING_NO_OPERATIONS_IN_PORT(wsdlPort.getName())); |
| return false; |
| } |
| createJavaInterfaceForPort(port, isProvider); |
| PortType pt = binding.resolvePortType(document); |
| String jd = (pt.getDocumentation() != null) ? pt.getDocumentation().getContent() : null; |
| port.getJavaInterface().setJavaDoc(jd); |
| _bindingNameToPortMap.put(bindingName, port); |
| } |
| |
| service.addPort(port); |
| applyPortMethodCustomization(port, wsdlPort); |
| applyWrapperStyleCustomization(port, binding.resolvePortType(document)); |
| |
| return true; |
| |
| } catch (NoSuchEntityException e) { |
| warning(document.getDefinitions(), e.getMessage()); |
| // should not happen |
| return false; |
| } |
| } |
| |
| /** |
| * Returns an operation purely from abstract operation |
| */ |
| private Operation processNonSOAPOperation() { |
| Operation operation = |
| new Operation(new QName(null, info.bindingOperation.getName()), info.bindingOperation); |
| |
| setDocumentationIfPresent( |
| operation, |
| info.portTypeOperation.getDocumentation()); |
| |
| if (info.portTypeOperation.getStyle() |
| != OperationStyle.REQUEST_RESPONSE |
| && info.portTypeOperation.getStyle() != OperationStyle.ONE_WAY) { |
| if (options.isExtensionMode()) { |
| warning(info.portTypeOperation, ModelerMessages.WSDLMODELER_WARNING_IGNORING_OPERATION_NOT_SUPPORTED_STYLE(info.portTypeOperation.getName())); |
| return null; |
| } else { |
| error(info.portTypeOperation, ModelerMessages.WSDLMODELER_INVALID_OPERATION_NOT_SUPPORTED_STYLE(info.portTypeOperation.getName(), |
| info.port.resolveBinding(document).resolvePortType(document).getName())); |
| } |
| } |
| |
| boolean isRequestResponse = info.portTypeOperation.getStyle() == OperationStyle.REQUEST_RESPONSE; |
| Message inputMessage = getInputMessage(); |
| Request request = new Request(inputMessage, errReceiver); |
| request.setErrorReceiver(errReceiver); |
| info.operation = operation; |
| info.operation.setWSDLPortTypeOperation(info.portTypeOperation); |
| |
| Response response; |
| |
| Message outputMessage = null; |
| if (isRequestResponse) { |
| outputMessage = getOutputMessage(); |
| response = new Response(outputMessage, errReceiver); |
| }else{ |
| response = new Response(null, errReceiver); |
| } |
| |
| //set the style based on heuristic that message has either all parts defined |
| // using type(RPC) or element(DOCUMENT) |
| setNonSoapStyle(inputMessage, outputMessage); |
| |
| // Process parameterOrder and get the parameterList |
| List<MessagePart> parameterList = getParameterOrder(); |
| |
| boolean unwrappable = isUnwrappable(); |
| info.operation.setWrapped(unwrappable); |
| List<Parameter> params = getDoclitParameters(request, response, parameterList); |
| if (!validateParameterName(params)) { |
| return null; |
| } |
| |
| // create a definitive list of parameters to match what we'd like to get |
| // in the java interface (which is generated much later), parameterOrder |
| List<Parameter> definitiveParameterList = new ArrayList<Parameter>(); |
| for (Parameter param : params) { |
| if (param.isReturn()) { |
| info.operation.setProperty(WSDL_RESULT_PARAMETER, param); |
| response.addParameter(param); |
| continue; |
| } |
| if (param.isIN()) { |
| request.addParameter(param); |
| } else if (param.isOUT()) { |
| response.addParameter(param); |
| } else if (param.isINOUT()) { |
| request.addParameter(param); |
| response.addParameter(param); |
| } |
| definitiveParameterList.add(param); |
| } |
| |
| info.operation.setRequest(request); |
| |
| if (isRequestResponse) { |
| info.operation.setResponse(response); |
| } |
| |
| // faults with duplicate names |
| Set duplicateNames = getDuplicateFaultNames(); |
| |
| // handle soap:fault |
| handleLiteralSOAPFault(response, duplicateNames); |
| info.operation.setProperty( |
| WSDL_PARAMETER_ORDER, |
| definitiveParameterList); |
| |
| Binding binding = info.port.resolveBinding(document); |
| PortType portType = binding.resolvePortType(document); |
| if (isAsync(portType, info.portTypeOperation)) { |
| warning(portType, "Can not generate Async methods for non-soap binding!"); |
| } |
| return info.operation; |
| } |
| |
| /** |
| * This method is added to fix one of the use case for j2ee se folks, so that we determine |
| * for non_soap wsdl what could be the style - rpc or document based on parts in the message. |
| * |
| * We assume that the message parts could have either all of them with type attribute (RPC) |
| * or element (DOCUMENT) |
| * |
| * Shall this check if parts are mixed and throw error message? |
| */ |
| private void setNonSoapStyle(Message inputMessage, Message outputMessage) { |
| SOAPStyle style = SOAPStyle.DOCUMENT; |
| for(MessagePart part:inputMessage.getParts()){ |
| if (part.getDescriptorKind() == SchemaKinds.XSD_TYPE) { |
| style = SOAPStyle.RPC; |
| } else { |
| style = SOAPStyle.DOCUMENT; |
| } |
| } |
| |
| //check the outputMessage parts |
| if(outputMessage != null){ |
| for(MessagePart part:outputMessage.getParts()){ |
| if (part.getDescriptorKind() == SchemaKinds.XSD_TYPE) { |
| style = SOAPStyle.RPC; |
| } else { |
| style = SOAPStyle.DOCUMENT; |
| } |
| } |
| } |
| info.modelPort.setStyle(style); |
| } |
| |
| /* (non-Javadoc) |
| * @see WSDLModelerBase#processSOAPOperation() |
| */ |
| protected Operation processSOAPOperation() { |
| Operation operation = |
| new Operation(new QName(null, info.bindingOperation.getName()), info.bindingOperation); |
| |
| setDocumentationIfPresent( |
| operation, |
| info.portTypeOperation.getDocumentation()); |
| |
| if (info.portTypeOperation.getStyle() |
| != OperationStyle.REQUEST_RESPONSE |
| && info.portTypeOperation.getStyle() != OperationStyle.ONE_WAY) { |
| if (options.isExtensionMode()) { |
| warning(info.portTypeOperation, ModelerMessages.WSDLMODELER_WARNING_IGNORING_OPERATION_NOT_SUPPORTED_STYLE(info.portTypeOperation.getName())); |
| return null; |
| } else { |
| error(info.portTypeOperation, ModelerMessages.WSDLMODELER_INVALID_OPERATION_NOT_SUPPORTED_STYLE(info.portTypeOperation.getName(), |
| info.port.resolveBinding(document).resolvePortType(document).getName())); |
| } |
| } |
| |
| SOAPStyle soapStyle = info.soapBinding.getStyle(); |
| |
| // find out the SOAP operation extension, if any |
| SOAPOperation soapOperation = |
| (SOAPOperation) getExtensionOfType(info.bindingOperation, |
| SOAPOperation.class); |
| |
| if (soapOperation != null) { |
| if (soapOperation.getStyle() != null) { |
| soapStyle = soapOperation.getStyle(); |
| } |
| if (soapOperation.getSOAPAction() != null) { |
| operation.setSOAPAction(soapOperation.getSOAPAction()); |
| } |
| } |
| |
| operation.setStyle(soapStyle); |
| |
| String uniqueOperationName = |
| getUniqueName(info.portTypeOperation, info.hasOverloadedOperations); |
| if (info.hasOverloadedOperations) { |
| operation.setUniqueName(uniqueOperationName); |
| } |
| |
| info.operation = operation; |
| |
| //attachment |
| SOAPBody soapRequestBody = getSOAPRequestBody(); |
| if (soapRequestBody == null) { |
| // the WSDL document is invalid |
| error(info.bindingOperation, ModelerMessages.WSDLMODELER_INVALID_BINDING_OPERATION_INPUT_MISSING_SOAP_BODY(info.bindingOperation.getName())); |
| } |
| |
| if (soapStyle == SOAPStyle.RPC) { |
| if (soapRequestBody.isEncoded()) { |
| if(options.isExtensionMode()){ |
| warning(soapRequestBody, ModelerMessages.WSDLMODELER_20_RPCENC_NOT_SUPPORTED()); |
| processNonSOAPOperation(); |
| }else{ |
| error(soapRequestBody, ModelerMessages.WSDLMODELER_20_RPCENC_NOT_SUPPORTED()); |
| } |
| } |
| return processLiteralSOAPOperation(StyleAndUse.RPC_LITERAL); |
| } |
| // document style |
| return processLiteralSOAPOperation(StyleAndUse.DOC_LITERAL); |
| } |
| |
| protected Operation processLiteralSOAPOperation(StyleAndUse styleAndUse) { |
| //returns false if the operation name is not acceptable |
| if (!applyOperationNameCustomization()) { |
| return null; |
| } |
| |
| boolean isRequestResponse = info.portTypeOperation.getStyle() == OperationStyle.REQUEST_RESPONSE; |
| Message inputMessage = getInputMessage(); |
| Request request = new Request(inputMessage, errReceiver); |
| request.setErrorReceiver(errReceiver); |
| info.operation.setUse(SOAPUse.LITERAL); |
| info.operation.setWSDLPortTypeOperation(info.portTypeOperation); |
| SOAPBody soapRequestBody = getSOAPRequestBody(); |
| if ((StyleAndUse.DOC_LITERAL == styleAndUse) && (soapRequestBody.getNamespace() != null)) { |
| warning(soapRequestBody, ModelerMessages.WSDLMODELER_WARNING_R_2716("soapbind:body", info.bindingOperation.getName())); |
| } |
| |
| |
| Response response; |
| |
| SOAPBody soapResponseBody = null; |
| Message outputMessage = null; |
| if (isRequestResponse) { |
| soapResponseBody = getSOAPResponseBody(); |
| if (isOperationDocumentLiteral(styleAndUse) && (soapResponseBody.getNamespace() != null)) { |
| warning(soapResponseBody, ModelerMessages.WSDLMODELER_WARNING_R_2716("soapbind:body", info.bindingOperation.getName())); |
| } |
| outputMessage = getOutputMessage(); |
| response = new Response(outputMessage, errReceiver); |
| }else{ |
| response = new Response(null, errReceiver); |
| } |
| |
| //ignore operation if there are more than one root part |
| if (!validateMimeParts(getMimeParts(info.bindingOperation.getInput())) || |
| !validateMimeParts(getMimeParts(info.bindingOperation.getOutput()))) { |
| return null; |
| } |
| |
| if (!validateBodyParts(info.bindingOperation)) { |
| // BP 1.1 |
| // R2204 A document-literal binding in a DESCRIPTION MUST refer, in each of its soapbind:body element(s), |
| // only to wsdl:part element(s) that have been defined using the element attribute. |
| |
| // R2203 An rpc-literal binding in a DESCRIPTION MUST refer, in its soapbind:body element(s), |
| // only to wsdNl:part element(s) that have been defined using the type attribute. |
| if (isOperationDocumentLiteral(styleAndUse)) { |
| if (options.isExtensionMode()) { |
| warning(info.portTypeOperation, ModelerMessages.WSDLMODELER_WARNING_IGNORING_OPERATION_CANNOT_HANDLE_TYPE_MESSAGE_PART(info.portTypeOperation.getName())); |
| } else { |
| error(info.portTypeOperation, ModelerMessages.WSDLMODELER_INVALID_DOCLITOPERATION(info.portTypeOperation.getName())); |
| } |
| } else if (isOperationRpcLiteral(styleAndUse)) { |
| if (options.isExtensionMode()) { |
| warning(info.portTypeOperation, ModelerMessages.WSDLMODELER_WARNING_IGNORING_OPERATION_CANNOT_HANDLE_ELEMENT_MESSAGE_PART(info.portTypeOperation.getName())); |
| } else { |
| error(info.portTypeOperation, ModelerMessages.WSDLMODELER_INVALID_RPCLITOPERATION(info.portTypeOperation.getName())); |
| } |
| } |
| return null; |
| } |
| |
| // Process parameterOrder and get the parameterList |
| List<MessagePart> parameterList = getParameterOrder(); |
| |
| //binding is invalid in the wsdl, ignore the operation. |
| if (!setMessagePartsBinding(styleAndUse)) { |
| return null; |
| } |
| |
| List<Parameter> params = null; |
| boolean unwrappable = isUnwrappable(); |
| info.operation.setWrapped(unwrappable); |
| if (isOperationDocumentLiteral(styleAndUse)) { |
| params = getDoclitParameters(request, response, parameterList); |
| } else if (isOperationRpcLiteral(styleAndUse)) { |
| String operationName = info.bindingOperation.getName(); |
| Block reqBlock = null; |
| if (inputMessage != null) { |
| QName name = new QName(getRequestNamespaceURI(soapRequestBody), operationName); |
| RpcLitStructure rpcStruct = new RpcLitStructure(name, getJAXBModelBuilder().getJAXBModel()); |
| rpcStruct.setJavaType(new JavaSimpleType("com.sun.xml.internal.ws.encoding.jaxb.RpcLitPayload", null)); |
| reqBlock = new Block(name, rpcStruct, inputMessage); |
| request.addBodyBlock(reqBlock); |
| } |
| |
| Block resBlock = null; |
| if (isRequestResponse && outputMessage != null) { |
| QName name = new QName(getResponseNamespaceURI(soapResponseBody), operationName + "Response"); |
| RpcLitStructure rpcStruct = new RpcLitStructure(name, getJAXBModelBuilder().getJAXBModel()); |
| rpcStruct.setJavaType(new JavaSimpleType("com.sun.xml.internal.ws.encoding.jaxb.RpcLitPayload", null)); |
| resBlock = new Block(name, rpcStruct, outputMessage); |
| response.addBodyBlock(resBlock); |
| } |
| params = getRpcLitParameters(request, response, reqBlock, resBlock, parameterList); |
| } |
| |
| |
| if (!validateParameterName(params)) { |
| return null; |
| } |
| |
| // create a definitive list of parameters to match what we'd like to get |
| // in the java interface (which is generated much later), parameterOrder |
| List<Parameter> definitiveParameterList = new ArrayList<Parameter>(); |
| for (Parameter param : params) { |
| if (param.isReturn()) { |
| info.operation.setProperty(WSDL_RESULT_PARAMETER, param); |
| response.addParameter(param); |
| continue; |
| } |
| if (param.isIN()) { |
| request.addParameter(param); |
| } else if (param.isOUT()) { |
| response.addParameter(param); |
| } else if (param.isINOUT()) { |
| request.addParameter(param); |
| response.addParameter(param); |
| } |
| definitiveParameterList.add(param); |
| } |
| |
| info.operation.setRequest(request); |
| |
| if (isRequestResponse) { |
| info.operation.setResponse(response); |
| } |
| |
| Iterator<Block> bb = request.getBodyBlocks(); |
| QName body; |
| Operation thatOp; |
| if (bb.hasNext()) { |
| body = bb.next().getName(); |
| thatOp = uniqueBodyBlocks.get(body); |
| } else { |
| //there is no body block |
| body = VOID_BODYBLOCK; |
| thatOp = uniqueBodyBlocks.get(VOID_BODYBLOCK); |
| } |
| |
| if(thatOp != null){ |
| if(options.isExtensionMode()){ |
| warning(info.port, ModelerMessages.WSDLMODELER_NON_UNIQUE_BODY_WARNING(info.port.getName(), info.operation.getName(), thatOp.getName(), body)); |
| }else{ |
| error(info.port, ModelerMessages.WSDLMODELER_NON_UNIQUE_BODY_ERROR(info.port.getName(), info.operation.getName(), thatOp.getName(), body)); |
| } |
| }else{ |
| uniqueBodyBlocks.put(body, info.operation); |
| } |
| |
| //Add additional headers |
| if (options.additionalHeaders) { |
| List<Parameter> additionalHeaders = new ArrayList<Parameter>(); |
| if (inputMessage != null) { |
| for (MessagePart part : getAdditionHeaderParts(info.bindingOperation, inputMessage, true)) { |
| QName name = part.getDescriptor(); |
| JAXBType jaxbType = getJAXBType(part); |
| Block block = new Block(name, jaxbType, part); |
| Parameter param = ModelerUtils.createParameter(part.getName(), jaxbType, block); |
| additionalHeaders.add(param); |
| request.addHeaderBlock(block); |
| request.addParameter(param); |
| definitiveParameterList.add(param); |
| } |
| } |
| |
| if (isRequestResponse && outputMessage != null) { |
| List<Parameter> outParams = new ArrayList<Parameter>(); |
| for (MessagePart part : getAdditionHeaderParts(info.bindingOperation,outputMessage, false)) { |
| QName name = part.getDescriptor(); |
| JAXBType jaxbType = getJAXBType(part); |
| Block block = new Block(name, jaxbType, part); |
| Parameter param = ModelerUtils.createParameter(part.getName(), jaxbType, block); |
| param.setMode(Mode.OUT); |
| outParams.add(param); |
| response.addHeaderBlock(block); |
| response.addParameter(param); |
| } |
| for (Parameter outParam : outParams) { |
| for (Parameter inParam : additionalHeaders) { |
| if (inParam.getName().equals(outParam.getName()) && |
| inParam.getBlock().getName().equals(outParam.getBlock().getName())) { |
| //it is INOUT |
| inParam.setMode(Mode.INOUT); |
| outParam.setMode(Mode.INOUT); |
| break; |
| } |
| } |
| if (outParam.isOUT()) { |
| definitiveParameterList.add(outParam); |
| } |
| } |
| } |
| } |
| |
| // faults with duplicate names |
| Set duplicateNames = getDuplicateFaultNames(); |
| |
| // handle soap:fault |
| handleLiteralSOAPFault(response, duplicateNames); |
| info.operation.setProperty( |
| WSDL_PARAMETER_ORDER, |
| definitiveParameterList); |
| |
| //set Async property |
| Binding binding = info.port.resolveBinding(document); |
| PortType portType = binding.resolvePortType(document); |
| if (isAsync(portType, info.portTypeOperation)) { |
| addAsyncOperations(info.operation, styleAndUse); |
| } |
| |
| return info.operation; |
| } |
| |
| |
| private boolean validateParameterName(List<Parameter> params) { |
| if (options.isExtensionMode()) { |
| return true; |
| } |
| |
| Message msg = getInputMessage(); |
| for (Parameter param : params) { |
| if (param.isOUT()) { |
| continue; |
| } |
| if (param.getCustomName() != null) { |
| if (Names.isJavaReservedWord(param.getCustomName())) { |
| error(param.getEntity(), ModelerMessages.WSDLMODELER_INVALID_OPERATION_JAVA_RESERVED_WORD_NOT_ALLOWED_CUSTOM_NAME(info.operation.getName(), param.getCustomName())); |
| return false; |
| } |
| return true; |
| } |
| //process doclit wrapper style |
| if (param.isEmbedded() && !(param.getBlock().getType() instanceof RpcLitStructure)) { |
| if (Names.isJavaReservedWord(param.getName())) { |
| error(param.getEntity(), ModelerMessages.WSDLMODELER_INVALID_OPERATION_JAVA_RESERVED_WORD_NOT_ALLOWED_WRAPPER_STYLE(info.operation.getName(), param.getName(), param.getBlock().getName())); |
| return false; |
| } |
| } else { |
| //non-wrapper style and rpclit |
| if (Names.isJavaReservedWord(param.getName())) { |
| error(param.getEntity(), ModelerMessages.WSDLMODELER_INVALID_OPERATION_JAVA_RESERVED_WORD_NOT_ALLOWED_NON_WRAPPER_STYLE(info.operation.getName(), msg.getName(), param.getName())); |
| return false; |
| } |
| } |
| } |
| |
| boolean isRequestResponse = info.portTypeOperation.getStyle() == OperationStyle.REQUEST_RESPONSE; |
| if (isRequestResponse) { |
| msg = getOutputMessage(); |
| for (Parameter param : params) { |
| if (param.isIN()) { |
| continue; |
| } |
| if (param.getCustomName() != null) { |
| if (Names.isJavaReservedWord(param.getCustomName())) { |
| error(param.getEntity(), ModelerMessages.WSDLMODELER_INVALID_OPERATION_JAVA_RESERVED_WORD_NOT_ALLOWED_CUSTOM_NAME(info.operation.getName(), param.getCustomName())); |
| return false; |
| } |
| return true; |
| } |
| //process doclit wrapper style |
| if (param.isEmbedded() && !(param.getBlock().getType() instanceof RpcLitStructure)) { |
| if (param.isReturn()) { |
| continue; |
| } |
| if (!param.getName().equals("return") && Names.isJavaReservedWord(param.getName())) { |
| error(param.getEntity(), ModelerMessages.WSDLMODELER_INVALID_OPERATION_JAVA_RESERVED_WORD_NOT_ALLOWED_WRAPPER_STYLE(info.operation.getName(), param.getName(), param.getBlock().getName())); |
| return false; |
| } |
| } else { |
| if (param.isReturn()) { |
| continue; |
| } |
| |
| //non-wrapper style and rpclit |
| if (Names.isJavaReservedWord(param.getName())) { |
| error(param.getEntity(), ModelerMessages.WSDLMODELER_INVALID_OPERATION_JAVA_RESERVED_WORD_NOT_ALLOWED_NON_WRAPPER_STYLE(info.operation.getName(), msg.getName(), param.getName())); |
| return false; |
| } |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| private boolean enableMimeContent() { |
| //first we look at binding operation |
| JAXWSBinding jaxwsCustomization = (JAXWSBinding) getExtensionOfType(info.bindingOperation, JAXWSBinding.class); |
| Boolean mimeContentMapping = (jaxwsCustomization != null) ? jaxwsCustomization.isEnableMimeContentMapping() : null; |
| if (mimeContentMapping != null) { |
| return mimeContentMapping; |
| } |
| |
| //then in wsdl:binding |
| Binding binding = info.port.resolveBinding(info.document); |
| jaxwsCustomization = (JAXWSBinding) getExtensionOfType(binding, JAXWSBinding.class); |
| mimeContentMapping = (jaxwsCustomization != null) ? jaxwsCustomization.isEnableMimeContentMapping() : null; |
| if (mimeContentMapping != null) { |
| return mimeContentMapping; |
| } |
| |
| //at last look in wsdl:definitions |
| jaxwsCustomization = (JAXWSBinding) getExtensionOfType(info.document.getDefinitions(), JAXWSBinding.class); |
| mimeContentMapping = (jaxwsCustomization != null) ? jaxwsCustomization.isEnableMimeContentMapping() : null; |
| if (mimeContentMapping != null) { |
| return mimeContentMapping; |
| } |
| return false; |
| } |
| |
| private boolean applyOperationNameCustomization() { |
| JAXWSBinding jaxwsCustomization = (JAXWSBinding) getExtensionOfType(info.portTypeOperation, JAXWSBinding.class); |
| String operationName = (jaxwsCustomization != null) ? ((jaxwsCustomization.getMethodName() != null) ? jaxwsCustomization.getMethodName().getName() : null) : null; |
| if (operationName != null) { |
| if (Names.isJavaReservedWord(operationName)) { |
| if (options.isExtensionMode()) { |
| warning(info.portTypeOperation, ModelerMessages.WSDLMODELER_WARNING_IGNORING_OPERATION_JAVA_RESERVED_WORD_NOT_ALLOWED_CUSTOMIZED_OPERATION_NAME(info.operation.getName(), operationName)); |
| } else { |
| error(info.portTypeOperation, ModelerMessages.WSDLMODELER_INVALID_OPERATION_JAVA_RESERVED_WORD_NOT_ALLOWED_CUSTOMIZED_OPERATION_NAME(info.operation.getName(), operationName)); |
| } |
| return false; |
| } |
| |
| info.operation.setCustomizedName(operationName); |
| } |
| |
| if (Names.isJavaReservedWord(info.operation.getJavaMethodName())) { |
| if (options.isExtensionMode()) { |
| warning(info.portTypeOperation, ModelerMessages.WSDLMODELER_WARNING_IGNORING_OPERATION_JAVA_RESERVED_WORD_NOT_ALLOWED_OPERATION_NAME(info.operation.getName())); |
| } else { |
| error(info.portTypeOperation, ModelerMessages.WSDLMODELER_INVALID_OPERATION_JAVA_RESERVED_WORD_NOT_ALLOWED_OPERATION_NAME(info.operation.getName())); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| protected String getAsyncOperationName(Operation operation) { |
| String name = operation.getCustomizedName(); |
| if (name == null) { |
| name = operation.getUniqueName(); |
| } |
| return name; |
| } |
| |
| /** |
| * @param styleAndUse |
| */ |
| private void addAsyncOperations(Operation syncOperation, StyleAndUse styleAndUse) { |
| Operation operation = createAsyncOperation(syncOperation, styleAndUse, AsyncOperationType.POLLING); |
| if (operation != null) { |
| info.modelPort.addOperation(operation); |
| } |
| |
| operation = createAsyncOperation(syncOperation, styleAndUse, AsyncOperationType.CALLBACK); |
| if (operation != null) { |
| info.modelPort.addOperation(operation); |
| } |
| } |
| |
| private Operation createAsyncOperation(Operation syncOperation, StyleAndUse styleAndUse, AsyncOperationType asyncType) { |
| boolean isRequestResponse = info.portTypeOperation.getStyle() == OperationStyle.REQUEST_RESPONSE; |
| if (!isRequestResponse) { |
| return null; |
| } |
| |
| //create async operations |
| AsyncOperation operation = new AsyncOperation(info.operation, info.bindingOperation); |
| |
| //creation the async operation name: operationName+Async or customized name |
| //operation.setName(new QName(operation.getName().getNamespaceURI(), getAsyncOperationName(info.portTypeOperation, operation))); |
| if (asyncType.equals(AsyncOperationType.CALLBACK)) { |
| operation.setUniqueName(info.operation.getUniqueName() + "_async_callback"); |
| } else if (asyncType.equals(AsyncOperationType.POLLING)) { |
| operation.setUniqueName(info.operation.getUniqueName() + "_async_polling"); |
| } |
| |
| setDocumentationIfPresent( |
| operation, |
| info.portTypeOperation.getDocumentation()); |
| |
| operation.setAsyncType(asyncType); |
| operation.setSOAPAction(info.operation.getSOAPAction()); |
| boolean unwrappable = info.operation.isWrapped(); |
| operation.setWrapped(unwrappable); |
| SOAPBody soapRequestBody = getSOAPRequestBody(); |
| |
| Message inputMessage = getInputMessage(); |
| Request request = new Request(inputMessage, errReceiver); |
| |
| SOAPBody soapResponseBody = getSOAPResponseBody(); |
| Message outputMessage = getOutputMessage(); |
| Response response = new Response(outputMessage, errReceiver); |
| |
| // Process parameterOrder and get the parameterList |
| java.util.List<String> parameterList = getAsynParameterOrder(); |
| |
| List<Parameter> inParameters = null; |
| if (isOperationDocumentLiteral(styleAndUse)) { |
| inParameters = getRequestParameters(request, parameterList); |
| // outParameters = getResponseParameters(response); |
| // re-create parameterList with unwrapped parameters |
| if (unwrappable) { |
| List<String> unwrappedParameterList = new ArrayList<String>(); |
| if (inputMessage != null) { |
| Iterator<MessagePart> parts = inputMessage.parts(); |
| if (parts.hasNext()) { |
| MessagePart part = parts.next(); |
| JAXBType jaxbType = getJAXBType(part); |
| List<JAXBProperty> memberList = jaxbType.getWrapperChildren(); |
| Iterator<JAXBProperty> props = memberList.iterator(); |
| while (props.hasNext()) { |
| JAXBProperty prop = props.next(); |
| unwrappedParameterList.add(prop.getElementName().getLocalPart()); |
| } |
| } |
| } |
| |
| parameterList.clear(); |
| parameterList.addAll(unwrappedParameterList); |
| } |
| } else if (isOperationRpcLiteral(styleAndUse)) { |
| String operationName = info.bindingOperation.getName(); |
| Block reqBlock = null; |
| if (inputMessage != null) { |
| QName name = new QName(getRequestNamespaceURI(soapRequestBody), operationName); |
| RpcLitStructure rpcStruct = new RpcLitStructure(name, getJAXBModelBuilder().getJAXBModel()); |
| rpcStruct.setJavaType(new JavaSimpleType("com.sun.xml.internal.ws.encoding.jaxb.RpcLitPayload", null)); |
| reqBlock = new Block(name, rpcStruct, inputMessage); |
| request.addBodyBlock(reqBlock); |
| } |
| inParameters = createRpcLitRequestParameters(request, parameterList, reqBlock); |
| } |
| |
| // add response blocks, we dont need to create respnse parameters, just blocks will be fine, lets |
| // copy them from sync optraions |
| //copy the response blocks from the sync operation |
| Iterator<Block> blocks = info.operation.getResponse().getBodyBlocks(); |
| |
| while (blocks.hasNext()) { |
| response.addBodyBlock(blocks.next()); |
| } |
| |
| blocks = info.operation.getResponse().getHeaderBlocks(); |
| while (blocks.hasNext()) { |
| response.addHeaderBlock(blocks.next()); |
| } |
| |
| blocks = info.operation.getResponse().getAttachmentBlocks(); |
| while (blocks.hasNext()) { |
| response.addAttachmentBlock(blocks.next()); |
| } |
| |
| List<MessagePart> outputParts = outputMessage.getParts(); |
| |
| // handle headers |
| int numOfOutMsgParts = outputParts.size(); |
| |
| if (numOfOutMsgParts == 1) { |
| MessagePart part = outputParts.get(0); |
| if (isOperationDocumentLiteral(styleAndUse)) { |
| JAXBType type = getJAXBType(part); |
| operation.setResponseBean(type); |
| } else if (isOperationRpcLiteral(styleAndUse)) { |
| String operationName = info.bindingOperation.getName(); |
| Block resBlock = info.operation.getResponse().getBodyBlocksMap().get(new QName(getResponseNamespaceURI(soapResponseBody), |
| operationName + "Response")); |
| |
| RpcLitStructure resBean = (RpcLitStructure) resBlock.getType(); |
| List<RpcLitMember> members = resBean.getRpcLitMembers(); |
| operation.setResponseBean(members.get(0)); |
| } |
| } else { |
| //create response bean |
| String nspace = ""; |
| QName responseBeanName = new QName(nspace, getAsyncOperationName(info.operation) + "Response"); |
| JAXBType responseBeanType = getJAXBModelBuilder().getJAXBType(responseBeanName); |
| if (responseBeanType == null) { |
| error(info.operation.getEntity(), ModelerMessages.WSDLMODELER_RESPONSEBEAN_NOTFOUND(info.operation.getName())); |
| } |
| operation.setResponseBean(responseBeanType); |
| } |
| |
| QName respBeanName = new QName(soapResponseBody.getNamespace(), getAsyncOperationName(info.operation) + "Response"); |
| Block block = new Block(respBeanName, operation.getResponseBeanType(), outputMessage); |
| JavaType respJavaType = operation.getResponseBeanJavaType(); |
| JAXBType respType = new JAXBType(respBeanName, respJavaType); |
| Parameter respParam = ModelerUtils.createParameter(info.operation.getName() + "Response", respType, block); |
| respParam.setParameterIndex(-1); |
| response.addParameter(respParam); |
| operation.setProperty(WSDL_RESULT_PARAMETER, respParam.getName()); |
| |
| |
| int parameterOrderPosition = 0; |
| for (String name : parameterList) { |
| Parameter inParameter = ModelerUtils.getParameter(name, inParameters); |
| if (inParameter == null) { |
| if (options.isExtensionMode()) { |
| warning(info.operation.getEntity(), ModelerMessages.WSDLMODELER_WARNING_IGNORING_OPERATION_PART_NOT_FOUND(info.operation.getName().getLocalPart(), name)); |
| } else { |
| error(info.operation.getEntity(), ModelerMessages.WSDLMODELER_ERROR_PART_NOT_FOUND(info.operation.getName().getLocalPart(), name)); |
| } |
| return null; |
| } |
| request.addParameter(inParameter); |
| inParameter.setParameterIndex(parameterOrderPosition); |
| parameterOrderPosition++; |
| } |
| |
| operation.setResponse(response); |
| |
| // add callback handlerb Parameter to request |
| if (operation.getAsyncType().equals(AsyncOperationType.CALLBACK)) { |
| JavaType cbJavaType = operation.getCallBackType(); |
| JAXBType callbackType = new JAXBType(respBeanName, cbJavaType); |
| Parameter cbParam = ModelerUtils.createParameter("asyncHandler", callbackType, block); |
| request.addParameter(cbParam); |
| } |
| |
| operation.setRequest(request); |
| |
| return operation; |
| } |
| |
| protected boolean isAsync(com.sun.tools.internal.ws.wsdl.document.PortType portType, com.sun.tools.internal.ws.wsdl.document.Operation wsdlOperation) { |
| //First look into wsdl:operation |
| JAXWSBinding jaxwsCustomization = (JAXWSBinding) getExtensionOfType(wsdlOperation, JAXWSBinding.class); |
| Boolean isAsync = (jaxwsCustomization != null) ? jaxwsCustomization.isEnableAsyncMapping() : null; |
| |
| if (isAsync != null) { |
| return isAsync; |
| } |
| |
| // then into wsdl:portType |
| jaxwsCustomization = (JAXWSBinding) getExtensionOfType(portType, JAXWSBinding.class); |
| isAsync = (jaxwsCustomization != null) ? jaxwsCustomization.isEnableAsyncMapping() : null; |
| if (isAsync != null) { |
| return isAsync; |
| } |
| |
| //then wsdl:definitions |
| jaxwsCustomization = (JAXWSBinding) getExtensionOfType(document.getDefinitions(), JAXWSBinding.class); |
| isAsync = (jaxwsCustomization != null) ? jaxwsCustomization.isEnableAsyncMapping() : null; |
| if (isAsync != null) { |
| return isAsync; |
| } |
| return false; |
| } |
| |
| protected void handleLiteralSOAPHeaders(Request request, Response response, Iterator headerParts, Set duplicateNames, @NotNull List<String> definitiveParameterList, boolean processRequest) { |
| QName headerName; |
| Block headerBlock; |
| JAXBType jaxbType; |
| int parameterOrderPosition = definitiveParameterList.size(); |
| while (headerParts.hasNext()) { |
| MessagePart part = (MessagePart) headerParts.next(); |
| headerName = part.getDescriptor(); |
| jaxbType = getJAXBType(part); |
| headerBlock = new Block(headerName, jaxbType, part); |
| TWSDLExtensible ext; |
| if (processRequest) { |
| ext = info.bindingOperation.getInput(); |
| } else { |
| ext = info.bindingOperation.getOutput(); |
| } |
| Message headerMessage = getHeaderMessage(part, ext); |
| |
| if (processRequest) { |
| request.addHeaderBlock(headerBlock); |
| } else { |
| response.addHeaderBlock(headerBlock); |
| } |
| |
| Parameter parameter = ModelerUtils.createParameter(part.getName(), jaxbType, headerBlock); |
| parameter.setParameterIndex(parameterOrderPosition); |
| setCustomizedParameterName(info.bindingOperation, headerMessage, part, parameter, false); |
| if (processRequest) { |
| request.addParameter(parameter); |
| definitiveParameterList.add(parameter.getName()); |
| } else { |
| for (String inParamName : definitiveParameterList) { |
| if (inParamName.equals(parameter.getName())) { |
| Parameter inParam = request.getParameterByName(inParamName); |
| parameter.setLinkedParameter(inParam); |
| inParam.setLinkedParameter(parameter); |
| //its in/out parameter, input and output parameter have the same order position. |
| parameter.setParameterIndex(inParam.getParameterIndex()); |
| } |
| } |
| if (!definitiveParameterList.contains(parameter.getName())) { |
| definitiveParameterList.add(parameter.getName()); |
| } |
| response.addParameter(parameter); |
| } |
| parameterOrderPosition++; |
| } |
| |
| } |
| |
| protected void handleLiteralSOAPFault(Response response, Set duplicateNames) { |
| for (BindingFault bindingFault : info.bindingOperation.faults()) { |
| com.sun.tools.internal.ws.wsdl.document.Fault portTypeFault = null; |
| for (com.sun.tools.internal.ws.wsdl.document.Fault aFault : info.portTypeOperation.faults()) { |
| if (aFault.getName().equals(bindingFault.getName())) { |
| if (portTypeFault != null) { |
| // the WSDL document is invalid, a wsld:fault in a wsdl:operation of a portType can be bound only once |
| error(portTypeFault, ModelerMessages.WSDLMODELER_INVALID_BINDING_FAULT_NOT_UNIQUE(bindingFault.getName(), info.bindingOperation.getName())); |
| } |
| portTypeFault = aFault; |
| } |
| } |
| |
| // The WSDL document is invalid, the wsdl:fault in abstract operation is does not have any binding |
| if (portTypeFault == null) { |
| error(bindingFault, ModelerMessages.WSDLMODELER_INVALID_BINDING_FAULT_NOT_FOUND(bindingFault.getName(), info.bindingOperation.getName())); |
| |
| } |
| } |
| for ( com.sun.tools.internal.ws.wsdl.document.Fault portTypeFault : info.portTypeOperation.faults()) { |
| |
| BindingFault bindingFault = null ; |
| for(BindingFault bFault: info.bindingOperation.faults()) { |
| if (bFault.getName().equals(portTypeFault.getName())) { |
| bindingFault = bFault; |
| } |
| } |
| |
| if(bindingFault == null) { |
| warning(portTypeFault,ModelerMessages.WSDLMODELER_INVALID_PORT_TYPE_FAULT_NOT_FOUND(portTypeFault.getName(),info.portTypeOperation.getName())); |
| } |
| // wsdl:fault message name is used to create the java exception name later on |
| String faultName = getFaultClassName(portTypeFault); |
| Fault fault = new Fault(faultName, portTypeFault); |
| fault.setWsdlFaultName(portTypeFault.getName()); |
| setDocumentationIfPresent(fault, portTypeFault.getDocumentation()); |
| if (bindingFault != null) { |
| //get the soapbind:fault from wsdl:fault in the binding |
| SOAPFault soapFault = (SOAPFault) getExtensionOfType(bindingFault, SOAPFault.class); |
| |
| // The WSDL document is invalid, can't have wsdl:fault without soapbind:fault |
| if (soapFault == null) { |
| if (options.isExtensionMode()) { |
| warning(bindingFault, ModelerMessages.WSDLMODELER_INVALID_BINDING_FAULT_OUTPUT_MISSING_SOAP_FAULT(bindingFault.getName(), info.bindingOperation.getName())); |
| soapFault = new SOAPFault(new LocatorImpl()); |
| } else { |
| error(bindingFault, ModelerMessages.WSDLMODELER_INVALID_BINDING_FAULT_OUTPUT_MISSING_SOAP_FAULT(bindingFault.getName(), info.bindingOperation.getName())); |
| } |
| } |
| |
| //the soapbind:fault must have use="literal" or no use attribute, in that case its assumed "literal" |
| if (!soapFault.isLiteral()) { |
| if (options.isExtensionMode()) { |
| warning(soapFault, ModelerMessages.WSDLMODELER_WARNING_IGNORING_FAULT_NOT_LITERAL(bindingFault.getName(), info.bindingOperation.getName())); |
| } else { |
| error(soapFault, ModelerMessages.WSDLMODELER_INVALID_OPERATION_FAULT_NOT_LITERAL(bindingFault.getName(), info.bindingOperation.getName())); |
| } |
| continue; |
| } |
| |
| // the soapFault name must be present |
| if (soapFault.getName() == null) { |
| warning(bindingFault, ModelerMessages.WSDLMODELER_INVALID_BINDING_FAULT_NO_SOAP_FAULT_NAME(bindingFault.getName(), info.bindingOperation.getName())); |
| } else if (!soapFault.getName().equals(bindingFault.getName())) { |
| warning(soapFault, ModelerMessages.WSDLMODELER_INVALID_BINDING_FAULT_WRONG_SOAP_FAULT_NAME(soapFault.getName(), bindingFault.getName(), info.bindingOperation.getName())); |
| } else if (soapFault.getNamespace() != null) { |
| warning(soapFault, ModelerMessages.WSDLMODELER_WARNING_R_2716_R_2726("soapbind:fault", soapFault.getName())); |
| } |
| |
| } |
| |
| com.sun.tools.internal.ws.wsdl.document.Message faultMessage = portTypeFault.resolveMessage(info.document); |
| Iterator iter2 = faultMessage.parts(); |
| if (!iter2.hasNext()) { |
| // the WSDL document is invalid |
| error(faultMessage, ModelerMessages.WSDLMODELER_INVALID_BINDING_FAULT_EMPTY_MESSAGE(portTypeFault.getName(), faultMessage.getName())); |
| } |
| MessagePart faultPart = (MessagePart) iter2.next(); |
| QName faultQName = faultPart.getDescriptor(); |
| |
| // Don't include fault messages with non-unique soap:fault names |
| if (duplicateNames.contains(faultQName)) { |
| warning(faultPart, ModelerMessages.WSDLMODELER_DUPLICATE_FAULT_SOAP_NAME(portTypeFault.getName(), info.portTypeOperation.getName(), faultPart.getName())); |
| continue; |
| } |
| |
| if (iter2.hasNext()) { |
| // the WSDL document is invalid |
| error(faultMessage, ModelerMessages.WSDLMODELER_INVALID_BINDING_FAULT_MESSAGE_HAS_MORE_THAN_ONE_PART(portTypeFault.getName(), faultMessage.getName())); |
| } |
| |
| if (faultPart.getDescriptorKind() != SchemaKinds.XSD_ELEMENT) { |
| if (options.isExtensionMode()) { |
| warning(faultPart, ModelerMessages.WSDLMODELER_INVALID_MESSAGE_PART_MUST_HAVE_ELEMENT_DESCRIPTOR(faultMessage.getName(), faultPart.getName())); |
| } else { |
| error(faultPart, ModelerMessages.WSDLMODELER_INVALID_MESSAGE_PART_MUST_HAVE_ELEMENT_DESCRIPTOR(faultMessage.getName(), faultPart.getName())); |
| } |
| } |
| |
| JAXBType jaxbType = getJAXBType(faultPart); |
| |
| fault.setElementName(faultPart.getDescriptor()); |
| fault.setJavaMemberName(Names.getExceptionClassMemberName()); |
| |
| Block faultBlock = new Block(faultQName, jaxbType, faultPart); |
| fault.setBlock(faultBlock); |
| //createParentFault(fault); |
| //createSubfaults(fault); |
| if (!response.getFaultBlocksMap().containsKey(faultBlock.getName())) { |
| response.addFaultBlock(faultBlock); |
| } |
| info.operation.addFault(fault); |
| } |
| } |
| |
| private String getFaultClassName(com.sun.tools.internal.ws.wsdl.document.Fault portTypeFault) { |
| JAXWSBinding jaxwsBinding = (JAXWSBinding) getExtensionOfType(portTypeFault, JAXWSBinding.class); |
| if (jaxwsBinding != null) { |
| CustomName className = jaxwsBinding.getClassName(); |
| if (className != null) { |
| return makePackageQualified(className.getName()); |
| } |
| } |
| return makePackageQualified(BindingHelper.mangleNameToClassName(portTypeFault.getMessage().getLocalPart())); |
| } |
| |
| protected boolean setMessagePartsBinding(StyleAndUse styleAndUse) { |
| SOAPBody inBody = getSOAPRequestBody(); |
| Message inMessage = getInputMessage(); |
| if (!setMessagePartsBinding(inBody, inMessage, styleAndUse, true)) { |
| return false; |
| } |
| |
| if (isRequestResponse()) { |
| SOAPBody outBody = getSOAPResponseBody(); |
| Message outMessage = getOutputMessage(); |
| if (!setMessagePartsBinding(outBody, outMessage, styleAndUse, false)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| //returns false if the wsdl is invalid and operation should be ignored |
| protected boolean setMessagePartsBinding(SOAPBody body, Message message, StyleAndUse styleAndUse, boolean isInput) { |
| |
| //get Mime parts |
| List<MessagePart> mimeParts; |
| List<MessagePart> headerParts; |
| List<MessagePart> bodyParts = getBodyParts(body, message); |
| |
| if (isInput) { |
| headerParts = getHeaderPartsFromMessage(message, isInput); |
| mimeParts = getMimeContentParts(message, info.bindingOperation.getInput()); |
| } else { |
| headerParts = getHeaderPartsFromMessage(message, isInput); |
| mimeParts = getMimeContentParts(message, info.bindingOperation.getOutput()); |
| } |
| |
| //As of now WSDL MIME binding is not supported, so throw the exception when such binding is encounterd |
| // if(mimeParts.size() > 0){ |
| // fail("wsdlmodeler.unsupportedBinding.mime", new Object[]{}); |
| // } |
| |
| //if soap:body parts attribute not there, then all unbounded message parts will |
| // belong to the soap body |
| if (bodyParts == null) { |
| bodyParts = new ArrayList<MessagePart>(); |
| for (Iterator<MessagePart> iter = message.parts(); iter.hasNext();) { |
| MessagePart mPart = iter.next(); |
| //Its a safe assumption that the parts in the message not belonging to header or mime will |
| // belong to the body? |
| if (mimeParts.contains(mPart) || headerParts.contains(mPart) || boundToFault(mPart.getName())) { |
| //throw error that a part cant be bound multiple times, not ignoring operation, if there |
| //is conflict it will fail latter |
| if (options.isExtensionMode()) { |
| warning(mPart, ModelerMessages.WSDLMODELER_WARNING_BINDING_OPERATION_MULTIPLE_PART_BINDING(info.bindingOperation.getName(), mPart.getName())); |
| } else { |
| error(mPart, ModelerMessages.WSDLMODELER_INVALID_BINDING_OPERATION_MULTIPLE_PART_BINDING(info.bindingOperation.getName(), mPart.getName())); |
| } |
| } |
| bodyParts.add(mPart); |
| } |
| } |
| |
| //now build the final parts list with header, mime parts and body parts |
| for (Iterator iter = message.parts(); iter.hasNext();) { |
| MessagePart mPart = (MessagePart) iter.next(); |
| if (mimeParts.contains(mPart)) { |
| mPart.setBindingExtensibilityElementKind(MessagePart.WSDL_MIME_BINDING); |
| } else if (headerParts.contains(mPart)) { |
| mPart.setBindingExtensibilityElementKind(MessagePart.SOAP_HEADER_BINDING); |
| } else if (bodyParts.contains(mPart)) { |
| mPart.setBindingExtensibilityElementKind(MessagePart.SOAP_BODY_BINDING); |
| } else { |
| mPart.setBindingExtensibilityElementKind(MessagePart.PART_NOT_BOUNDED); |
| } |
| } |
| |
| if (isOperationDocumentLiteral(styleAndUse) && bodyParts.size() > 1) { |
| if (options.isExtensionMode()) { |
| warning(message, ModelerMessages.WSDLMODELER_WARNING_OPERATION_MORE_THAN_ONE_PART_IN_MESSAGE(info.portTypeOperation.getName())); |
| } else { |
| error(message, ModelerMessages.WSDLMODELER_INVALID_OPERATION_MORE_THAN_ONE_PART_IN_MESSAGE(info.portTypeOperation.getName())); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| private boolean boundToFault(String partName) { |
| for (BindingFault bindingFault : info.bindingOperation.faults()) { |
| if (partName.equals(bindingFault.getName())) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| //get MessagePart(s) referenced by parts attribute of soap:body element |
| private List<MessagePart> getBodyParts(SOAPBody body, Message message) { |
| String bodyParts = body.getParts(); |
| if (bodyParts != null) { |
| List<MessagePart> partsList = new ArrayList<MessagePart>(); |
| StringTokenizer in = new StringTokenizer(bodyParts.trim(), " "); |
| while (in.hasMoreTokens()) { |
| String part = in.nextToken(); |
| MessagePart mPart = message.getPart(part); |
| if (null == mPart) { |
| error(message, ModelerMessages.WSDLMODELER_ERROR_PARTS_NOT_FOUND(part, message.getName())); |
| } |
| mPart.setBindingExtensibilityElementKind(MessagePart.SOAP_BODY_BINDING); |
| partsList.add(mPart); |
| } |
| return partsList; |
| } |
| return null; |
| } |
| |
| List<MessagePart> getAdditionHeaderParts(BindingOperation bindingOperation,Message message, boolean isInput){ |
| List<MessagePart> headerParts = new ArrayList<MessagePart>(); |
| List<MessagePart> parts = message.getParts(); |
| List<MessagePart> headers = getHeaderParts(bindingOperation, isInput); |
| |
| for(MessagePart part: headers){ |
| if (parts.contains(part)) { |
| continue; |
| } |
| headerParts.add(part); |
| } |
| return headerParts; |
| } |
| |
| private List<MessagePart> getHeaderPartsFromMessage(Message message, boolean isInput) { |
| List<MessagePart> headerParts = new ArrayList<MessagePart>(); |
| Iterator<MessagePart> parts = message.parts(); |
| List<MessagePart> headers = getHeaderParts(info.bindingOperation, isInput); |
| while (parts.hasNext()) { |
| MessagePart part = parts.next(); |
| if (headers.contains(part)) { |
| headerParts.add(part); |
| } |
| } |
| return headerParts; |
| } |
| |
| private Message getHeaderMessage(MessagePart part, TWSDLExtensible ext) { |
| Iterator<SOAPHeader> headers = getHeaderExtensions(ext).iterator(); |
| while (headers.hasNext()) { |
| SOAPHeader header = headers.next(); |
| if (!header.isLiteral()) { |
| continue; |
| } |
| com.sun.tools.internal.ws.wsdl.document.Message headerMessage = findMessage(header.getMessage(), document); |
| if (headerMessage == null) { |
| continue; |
| } |
| |
| MessagePart headerPart = headerMessage.getPart(header.getPart()); |
| if (headerPart == part) { |
| return headerMessage; |
| } |
| } |
| return null; |
| } |
| |
| private List<MessagePart> getHeaderParts(BindingOperation bindingOperation, boolean isInput) { |
| TWSDLExtensible ext; |
| if (isInput) { |
| ext = bindingOperation.getInput(); |
| } else { |
| ext = bindingOperation.getOutput(); |
| } |
| |
| List<MessagePart> parts = new ArrayList<MessagePart>(); |
| Iterator<SOAPHeader> headers = getHeaderExtensions(ext).iterator(); |
| while (headers.hasNext()) { |
| SOAPHeader header = headers.next(); |
| if (!header.isLiteral()) { |
| error(header, ModelerMessages.WSDLMODELER_INVALID_HEADER_NOT_LITERAL(header.getPart(), bindingOperation.getName())); |
| } |
| |
| if (header.getNamespace() != null) { |
| warning(header, ModelerMessages.WSDLMODELER_WARNING_R_2716_R_2726("soapbind:header", bindingOperation.getName())); |
| } |
| com.sun.tools.internal.ws.wsdl.document.Message headerMessage = findMessage(header.getMessage(),document); |
| if (headerMessage == null) { |
| error(header, ModelerMessages.WSDLMODELER_INVALID_HEADER_CANT_RESOLVE_MESSAGE(header.getMessage(), bindingOperation.getName())); |
| } |
| |
| MessagePart part = headerMessage.getPart(header.getPart()); |
| if (part == null) { |
| error(header, ModelerMessages.WSDLMODELER_INVALID_HEADER_NOT_FOUND(header.getPart(), bindingOperation.getName())); |
| } |
| if (part.getDescriptorKind() != SchemaKinds.XSD_ELEMENT) { |
| if (options.isExtensionMode()) { |
| warning(part, ModelerMessages.WSDLMODELER_INVALID_HEADER_MESSAGE_PART_MUST_HAVE_ELEMENT_DESCRIPTOR(part.getName(), bindingOperation.getName())); |
| } else { |
| error(part, ModelerMessages.WSDLMODELER_INVALID_HEADER_MESSAGE_PART_MUST_HAVE_ELEMENT_DESCRIPTOR(part.getName(), bindingOperation.getName())); |
| } |
| } |
| part.setBindingExtensibilityElementKind(MessagePart.SOAP_HEADER_BINDING); |
| parts.add(part); |
| } |
| return parts; |
| } |
| |
| private boolean isOperationDocumentLiteral(StyleAndUse styleAndUse) { |
| return StyleAndUse.DOC_LITERAL == styleAndUse; |
| } |
| |
| private boolean isOperationRpcLiteral(StyleAndUse styleAndUse) { |
| return StyleAndUse.RPC_LITERAL == styleAndUse; |
| } |
| |
| /** |
| * @param part |
| * @return Returns a JAXBType object |
| */ |
| private JAXBType getJAXBType(MessagePart part) { |
| JAXBType type; |
| QName name = part.getDescriptor(); |
| if (part.getDescriptorKind().equals(SchemaKinds.XSD_ELEMENT)) { |
| type = getJAXBModelBuilder().getJAXBType(name); |
| if(type == null){ |
| error(part, ModelerMessages.WSDLMODELER_JAXB_JAVATYPE_NOTFOUND(name, part.getName())); |
| } |
| } else { |
| S2JJAXBModel jaxbModel = getJAXBModelBuilder().getJAXBModel().getS2JJAXBModel(); |
| TypeAndAnnotation typeAnno = jaxbModel.getJavaType(name); |
| if (typeAnno == null) { |
| error(part, ModelerMessages.WSDLMODELER_JAXB_JAVATYPE_NOTFOUND(name, part.getName())); |
| } |
| JavaType javaType = new JavaSimpleType(new JAXBTypeAndAnnotation(typeAnno)); |
| type = new JAXBType(new QName("", part.getName()), javaType); |
| } |
| return type; |
| } |
| |
| private List<Parameter> getDoclitParameters(Request req, Response res, List<MessagePart> parameterList) { |
| if (parameterList.isEmpty()) { |
| return new ArrayList<Parameter>(); |
| } |
| List<Parameter> params = new ArrayList<Parameter>(); |
| Message inMsg = getInputMessage(); |
| Message outMsg = getOutputMessage(); |
| boolean unwrappable = isUnwrappable(); |
| List<Parameter> outParams = null; |
| int pIndex = 0; |
| for (MessagePart part : parameterList) { |
| QName reqBodyName = part.getDescriptor(); |
| JAXBType jaxbType = getJAXBType(part); |
| Block block = new Block(reqBodyName, jaxbType, part); |
| if (unwrappable) { |
| //So build body and header blocks and set to request and response |
| JAXBStructuredType jaxbStructType = ModelerUtils.createJAXBStructureType(jaxbType); |
| block = new Block(reqBodyName, jaxbStructType, part); |
| if (ModelerUtils.isBoundToSOAPBody(part)) { |
| if (part.isIN()) { |
| req.addBodyBlock(block); |
| } else if (part.isOUT()) { |
| res.addBodyBlock(block); |
| } else if (part.isINOUT()) { |
| req.addBodyBlock(block); |
| res.addBodyBlock(block); |
| } |
| } else if (ModelerUtils.isUnbound(part)) { |
| if (part.isIN()) { |
| req.addUnboundBlock(block); |
| } else if (part.isOUT()) { |
| res.addUnboundBlock(block); |
| } else if (part.isINOUT()) { |
| req.addUnboundBlock(block); |
| res.addUnboundBlock(block); |
| } |
| } |
| if (part.isIN() || part.isINOUT()) { |
| params = ModelerUtils.createUnwrappedParameters(jaxbStructType, block); |
| int index = 0; |
| Mode mode = part.isINOUT() ? Mode.INOUT : Mode.IN; |
| for (Parameter param : params) { |
| param.setParameterIndex(index++); |
| param.setMode(mode); |
| setCustomizedParameterName(info.portTypeOperation, inMsg, part, param, unwrappable); |
| } |
| } else if (part.isOUT()) { |
| outParams = ModelerUtils.createUnwrappedParameters(jaxbStructType, block); |
| for (Parameter param : outParams) { |
| param.setMode(Mode.OUT); |
| setCustomizedParameterName(info.portTypeOperation, outMsg, part, param, unwrappable); |
| } |
| } |
| } else { |
| if (ModelerUtils.isBoundToSOAPBody(part)) { |
| if (part.isIN()) { |
| req.addBodyBlock(block); |
| } else if (part.isOUT()) { |
| res.addBodyBlock(block); |
| } else if (part.isINOUT()) { |
| req.addBodyBlock(block); |
| res.addBodyBlock(block); |
| } |
| } else if (ModelerUtils.isBoundToSOAPHeader(part)) { |
| if (part.isIN()) { |
| req.addHeaderBlock(block); |
| } else if (part.isOUT()) { |
| res.addHeaderBlock(block); |
| } else if (part.isINOUT()) { |
| req.addHeaderBlock(block); |
| res.addHeaderBlock(block); |
| } |
| } else if (ModelerUtils.isBoundToMimeContent(part)) { |
| List<MIMEContent> mimeContents; |
| |
| if (part.isIN()) { |
| mimeContents = getMimeContents(info.bindingOperation.getInput(), |
| getInputMessage(), part.getName()); |
| jaxbType = getAttachmentType(mimeContents, part); |
| block = new Block(jaxbType.getName(), jaxbType, part); |
| req.addAttachmentBlock(block); |
| } else if (part.isOUT()) { |
| mimeContents = getMimeContents(info.bindingOperation.getOutput(), |
| getOutputMessage(), part.getName()); |
| jaxbType = getAttachmentType(mimeContents, part); |
| block = new Block(jaxbType.getName(), jaxbType, part); |
| res.addAttachmentBlock(block); |
| } else if (part.isINOUT()) { |
| mimeContents = getMimeContents(info.bindingOperation.getInput(), |
| getInputMessage(), part.getName()); |
| jaxbType = getAttachmentType(mimeContents, part); |
| block = new Block(jaxbType.getName(), jaxbType, part); |
| req.addAttachmentBlock(block); |
| res.addAttachmentBlock(block); |
| |
| mimeContents = getMimeContents(info.bindingOperation.getOutput(), |
| getOutputMessage(), part.getName()); |
| JAXBType outJaxbType = getAttachmentType(mimeContents, part); |
| |
| String inType = jaxbType.getJavaType().getType().getName(); |
| String outType = outJaxbType.getJavaType().getType().getName(); |
| |
| TypeAndAnnotation inTa = jaxbType.getJavaType().getType().getTypeAnn(); |
| TypeAndAnnotation outTa = outJaxbType.getJavaType().getType().getTypeAnn(); |
| if ((((inTa != null) && (outTa != null) && inTa.equals(outTa))) && !inType.equals(outType)) { |
| String javaType = "javax.activation.DataHandler"; |
| |
| //S2JJAXBModel jaxbModel = getJAXBModelBuilder().getJAXBModel().getS2JJAXBModel(); |
| //JCodeModel cm = jaxbModel.generateCode(null, errReceiver); |
| JType jt = options.getCodeModel().ref(javaType); |
| JAXBTypeAndAnnotation jaxbTa = jaxbType.getJavaType().getType(); |
| jaxbTa.setType(jt); |
| } |
| } |
| } else if (ModelerUtils.isUnbound(part)) { |
| if (part.isIN()) { |
| req.addUnboundBlock(block); |
| } else if (part.isOUT()) { |
| res.addUnboundBlock(block); |
| } else if (part.isINOUT()) { |
| req.addUnboundBlock(block); |
| res.addUnboundBlock(block); |
| } |
| } |
| Parameter param = ModelerUtils.createParameter(part.getName(), jaxbType, block); |
| param.setMode(part.getMode()); |
| if (part.isReturn()) { |
| param.setParameterIndex(-1); |
| } else { |
| param.setParameterIndex(pIndex++); |
| } |
| |
| if (part.isIN()) { |
| setCustomizedParameterName(info.bindingOperation, inMsg, part, param, false); |
| } else if (outMsg != null) { |
| setCustomizedParameterName(info.bindingOperation, outMsg, part, param, false); |
| } |
| |
| params.add(param); |
| } |
| } |
| if (unwrappable && (outParams != null)) { |
| int index = params.size(); |
| for (Parameter param : outParams) { |
| if (BindingHelper.mangleNameToVariableName(param.getName()).equals("return")) { |
| param.setParameterIndex(-1); |
| } else { |
| Parameter inParam = ModelerUtils.getParameter(param.getName(), params); |
| if ((inParam != null) && inParam.isIN()) { |
| QName inElementName = inParam.getType().getName(); |
| QName outElementName = param.getType().getName(); |
| String inJavaType = inParam.getTypeName(); |
| String outJavaType = param.getTypeName(); |
| TypeAndAnnotation inTa = inParam.getType().getJavaType().getType().getTypeAnn(); |
| TypeAndAnnotation outTa = param.getType().getJavaType().getType().getTypeAnn(); |
| QName inRawTypeName = ModelerUtils.getRawTypeName(inParam); |
| QName outRawTypeName = ModelerUtils.getRawTypeName(param); |
| if (inElementName.getLocalPart().equals(outElementName.getLocalPart()) && |
| inJavaType.equals(outJavaType) && |
| (inTa == null || outTa == null || inTa.equals(outTa)) && |
| (inRawTypeName == null || outRawTypeName == null || inRawTypeName.equals(outRawTypeName))) { |
| inParam.setMode(Mode.INOUT); |
| continue; |
| } |
| } |
| if (outParams.size() == 1) { |
| param.setParameterIndex(-1); |
| } else { |
| param.setParameterIndex(index++); |
| } |
| } |
| params.add(param); |
| } |
| } |
| return params; |
| } |
| |
| private List<Parameter> getRpcLitParameters(Request req, Response res, Block reqBlock, Block resBlock, List<MessagePart> paramList) { |
| List<Parameter> params = new ArrayList<Parameter>(); |
| Message inMsg = getInputMessage(); |
| Message outMsg = getOutputMessage(); |
| S2JJAXBModel jaxbModel = ((RpcLitStructure) reqBlock.getType()).getJaxbModel().getS2JJAXBModel(); |
| List<Parameter> inParams = ModelerUtils.createRpcLitParameters(inMsg, reqBlock, jaxbModel, errReceiver); |
| List<Parameter> outParams = null; |
| if (outMsg != null) { |
| outParams = ModelerUtils.createRpcLitParameters(outMsg, resBlock, jaxbModel, errReceiver); |
| } |
| |
| //create parameters for header and mime parts |
| int index = 0; |
| for (MessagePart part : paramList) { |
| Parameter param = null; |
| if (ModelerUtils.isBoundToSOAPBody(part)) { |
| if (part.isIN()) { |
| param = ModelerUtils.getParameter(part.getName(), inParams); |
| } else if (outParams != null) { |
| param = ModelerUtils.getParameter(part.getName(), outParams); |
| } |
| } else if (ModelerUtils.isBoundToSOAPHeader(part)) { |
| QName headerName = part.getDescriptor(); |
| JAXBType jaxbType = getJAXBType(part); |
| Block headerBlock = new Block(headerName, jaxbType, part); |
| param = ModelerUtils.createParameter(part.getName(), jaxbType, headerBlock); |
| if (part.isIN()) { |
| req.addHeaderBlock(headerBlock); |
| } else if (part.isOUT()) { |
| res.addHeaderBlock(headerBlock); |
| } else if (part.isINOUT()) { |
| req.addHeaderBlock(headerBlock); |
| res.addHeaderBlock(headerBlock); |
| } |
| } else if (ModelerUtils.isBoundToMimeContent(part)) { |
| List<MIMEContent> mimeContents; |
| if (part.isIN() || part.isINOUT()) { |
| mimeContents = getMimeContents(info.bindingOperation.getInput(), |
| getInputMessage(), part.getName()); |
| } else { |
| mimeContents = getMimeContents(info.bindingOperation.getOutput(), |
| getOutputMessage(), part.getName()); |
| } |
| |
| JAXBType type = getAttachmentType(mimeContents, part); |
| //create Parameters in request or response |
| //Block mimeBlock = new Block(new QName(part.getName()), type); |
| Block mimeBlock = new Block(type.getName(), type, part); |
| param = ModelerUtils.createParameter(part.getName(), type, mimeBlock); |
| if (part.isIN()) { |
| req.addAttachmentBlock(mimeBlock); |
| } else if (part.isOUT()) { |
| res.addAttachmentBlock(mimeBlock); |
| } else if (part.isINOUT()) { |
| mimeContents = getMimeContents(info.bindingOperation.getOutput(), |
| getOutputMessage(), part.getName()); |
| JAXBType outJaxbType = getAttachmentType(mimeContents, part); |
| |
| String inType = type.getJavaType().getType().getName(); |
| String outType = outJaxbType.getJavaType().getType().getName(); |
| if (!inType.equals(outType)) { |
| String javaType = "javax.activation.DataHandler"; |
| JType jt = options.getCodeModel().ref(javaType); |
| JAXBTypeAndAnnotation jaxbTa = type.getJavaType().getType(); |
| jaxbTa.setType(jt); |
| } |
| req.addAttachmentBlock(mimeBlock); |
| res.addAttachmentBlock(mimeBlock); |
| } |
| } else if (ModelerUtils.isUnbound(part)) { |
| QName name = part.getDescriptor(); |
| JAXBType type = getJAXBType(part); |
| Block unboundBlock = new Block(name, type, part); |
| if (part.isIN()) { |
| req.addUnboundBlock(unboundBlock); |
| } else if (part.isOUT()) { |
| res.addUnboundBlock(unboundBlock); |
| } else if (part.isINOUT()) { |
| req.addUnboundBlock(unboundBlock); |
| res.addUnboundBlock(unboundBlock); |
| } |
| param = ModelerUtils.createParameter(part.getName(), type, unboundBlock); |
| } |
| if (param != null) { |
| if (part.isReturn()) { |
| param.setParameterIndex(-1); |
| } else { |
| param.setParameterIndex(index++); |
| } |
| param.setMode(part.getMode()); |
| params.add(param); |
| } |
| } |
| for (Parameter param : params) { |
| if (param.isIN()) { |
| setCustomizedParameterName(info.portTypeOperation, inMsg, inMsg.getPart(param.getName()), param, false); |
| } else if (outMsg != null) { |
| setCustomizedParameterName(info.portTypeOperation, outMsg, outMsg.getPart(param.getName()), param, false); |
| } |
| } |
| return params; |
| } |
| |
| private List<Parameter> getRequestParameters(Request request, List<String> parameterList) { |
| Message inputMessage = getInputMessage(); |
| //there is no input message, return zero parameters |
| if (inputMessage != null && !inputMessage.parts().hasNext()) { |
| return new ArrayList<Parameter>(); |
| } |
| |
| List<Parameter> inParameters = null; |
| QName reqBodyName; |
| Block reqBlock; |
| JAXBType jaxbReqType; |
| boolean unwrappable = isUnwrappable(); |
| boolean doneSOAPBody = false; |
| //setup request parameters |
| for (String inParamName : parameterList) { |
| MessagePart part = inputMessage.getPart(inParamName); |
| if (part == null) { |
| continue; |
| } |
| reqBodyName = part.getDescriptor(); |
| jaxbReqType = getJAXBType(part); |
| if (unwrappable) { |
| //So build body and header blocks and set to request and response |
| JAXBStructuredType jaxbRequestType = ModelerUtils.createJAXBStructureType(jaxbReqType); |
| reqBlock = new Block(reqBodyName, jaxbRequestType, part); |
| if (ModelerUtils.isBoundToSOAPBody(part)) { |
| request.addBodyBlock(reqBlock); |
| } else if (ModelerUtils.isUnbound(part)) { |
| request.addUnboundBlock(reqBlock); |
| } |
| inParameters = ModelerUtils.createUnwrappedParameters(jaxbRequestType, reqBlock); |
| for (Parameter param : inParameters) { |
| setCustomizedParameterName(info.portTypeOperation, inputMessage, part, param, unwrappable); |
| } |
| } else { |
| reqBlock = new Block(reqBodyName, jaxbReqType, part); |
| if (ModelerUtils.isBoundToSOAPBody(part) && !doneSOAPBody) { |
| doneSOAPBody = true; |
| request.addBodyBlock(reqBlock); |
| } else if (ModelerUtils.isBoundToSOAPHeader(part)) { |
| request.addHeaderBlock(reqBlock); |
| } else if (ModelerUtils.isBoundToMimeContent(part)) { |
| List<MIMEContent> mimeContents = getMimeContents(info.bindingOperation.getInput(), |
| getInputMessage(), part.getName()); |
| jaxbReqType = getAttachmentType(mimeContents, part); |
| //reqBlock = new Block(new QName(part.getName()), jaxbReqType); |
| reqBlock = new Block(jaxbReqType.getName(), jaxbReqType, part); |
| request.addAttachmentBlock(reqBlock); |
| } else if (ModelerUtils.isUnbound(part)) { |
| request.addUnboundBlock(reqBlock); |
| } |
| if (inParameters == null) { |
| inParameters = new ArrayList<Parameter>(); |
| } |
| Parameter param = ModelerUtils.createParameter(part.getName(), jaxbReqType, reqBlock); |
| setCustomizedParameterName(info.portTypeOperation, inputMessage, part, param, false); |
| inParameters.add(param); |
| } |
| } |
| return inParameters; |
| } |
| |
| /** |
| * @param part |
| * @param param |
| * @param wrapperStyle TODO |
| */ |
| private void setCustomizedParameterName(TWSDLExtensible extension, Message msg, MessagePart part, Parameter param, boolean wrapperStyle) { |
| JAXWSBinding jaxwsBinding = (JAXWSBinding) getExtensionOfType(extension, JAXWSBinding.class); |
| if (jaxwsBinding == null) { |
| return; |
| } |
| String paramName = part.getName(); |
| QName elementName = part.getDescriptor(); |
| if (wrapperStyle) { |
| elementName = param.getType().getName(); |
| } |
| String customName = jaxwsBinding.getParameterName(msg.getName(), paramName, elementName, wrapperStyle); |
| if (customName != null && !customName.equals("")) { |
| param.setCustomName(customName); |
| } |
| } |
| |
| @Override |
| protected boolean isConflictingPortClassName(String name) { |
| return false; |
| } |
| |
| protected boolean isUnwrappable() { |
| if (!getWrapperStyleCustomization()) { |
| return false; |
| } |
| |
| com.sun.tools.internal.ws.wsdl.document.Message inputMessage = getInputMessage(); |
| com.sun.tools.internal.ws.wsdl.document.Message outputMessage = getOutputMessage(); |
| |
| // Wrapper style if the operation's input and output messages each contain |
| // only a single part |
| if ((inputMessage != null && inputMessage.numParts() != 1) |
| || (outputMessage != null && outputMessage.numParts() != 1)) { |
| return false; |
| } |
| |
| MessagePart inputPart = inputMessage != null |
| ? inputMessage.parts().next() : null; |
| MessagePart outputPart = outputMessage != null |
| ? outputMessage.parts().next() : null; |
| String operationName = info.portTypeOperation.getName(); |
| |
| // Wrapper style if the input message part refers to a global element declaration whose localname |
| // is equal to the operation name |
| // Wrapper style if the output message part refers to a global element declaration |
| if ((inputPart != null && !inputPart.getDescriptor().getLocalPart().equals(operationName)) || |
| (outputPart != null && outputPart.getDescriptorKind() != SchemaKinds.XSD_ELEMENT)) { |
| return false; |
| } |
| |
| //check to see if either input or output message part not bound to soapbing:body |
| //in that case the operation is not wrapper style |
| if (((inputPart != null) && (inputPart.getBindingExtensibilityElementKind() != MessagePart.SOAP_BODY_BINDING)) || |
| ((outputPart != null) && (outputPart.getBindingExtensibilityElementKind() != MessagePart.SOAP_BODY_BINDING))) { |
| return false; |
| } |
| |
| // Wrapper style if the elements referred to by the input and output message parts |
| // (henceforth referred to as wrapper elements) are both complex types defined |
| // using the xsd:sequence compositor |
| // Wrapper style if the wrapper elements only contain child elements, they must not |
| // contain other structures such as xsd:choice, substitution groups1 or attributes |
| //These checkins are done by jaxb, we just check if jaxb has wrapper children. If there |
| // are then its wrapper style |
| //if(inputPart != null && outputPart != null){ |
| if (inputPart != null) { |
| boolean inputWrappable = false; |
| JAXBType inputType = getJAXBType(inputPart); |
| if (inputType != null) { |
| inputWrappable = inputType.isUnwrappable(); |
| } |
| //if there are no output part (oneway), the operation can still be wrapper style |
| if (outputPart == null) { |
| return inputWrappable; |
| } |
| JAXBType outputType = getJAXBType(outputPart); |
| if ((inputType != null) && (outputType != null)) { |
| return inputType.isUnwrappable() && outputType.isUnwrappable(); |
| } |
| } |
| |
| return false; |
| } |
| |
| private boolean getWrapperStyleCustomization() { |
| //first we look into wsdl:portType/wsdl:operation |
| com.sun.tools.internal.ws.wsdl.document.Operation portTypeOperation = info.portTypeOperation; |
| JAXWSBinding jaxwsBinding = (JAXWSBinding) getExtensionOfType(portTypeOperation, JAXWSBinding.class); |
| if (jaxwsBinding != null) { |
| Boolean isWrappable = jaxwsBinding.isEnableWrapperStyle(); |
| if (isWrappable != null) { |
| return isWrappable; |
| } |
| } |
| |
| //then into wsdl:portType |
| PortType portType = info.port.resolveBinding(document).resolvePortType(document); |
| jaxwsBinding = (JAXWSBinding) getExtensionOfType(portType, JAXWSBinding.class); |
| if (jaxwsBinding != null) { |
| Boolean isWrappable = jaxwsBinding.isEnableWrapperStyle(); |
| if (isWrappable != null) { |
| return isWrappable; |
| } |
| } |
| |
| //then wsdl:definitions |
| jaxwsBinding = (JAXWSBinding) getExtensionOfType(document.getDefinitions(), JAXWSBinding.class); |
| if (jaxwsBinding != null) { |
| Boolean isWrappable = jaxwsBinding.isEnableWrapperStyle(); |
| if (isWrappable != null) { |
| return isWrappable; |
| } |
| } |
| return true; |
| } |
| |
| /* (non-Javadoc) |
| * @see WSDLModelerBase#isSingleInOutPart(Set, MessagePart) |
| */ |
| protected boolean isSingleInOutPart(Set inputParameterNames, |
| MessagePart outputPart) { |
| // As of now, we dont have support for in/out in doc-lit. So return false. |
| SOAPOperation soapOperation = |
| (SOAPOperation) getExtensionOfType(info.bindingOperation, |
| SOAPOperation.class); |
| if ((soapOperation != null) && (soapOperation.isDocument() || info.soapBinding.isDocument())) { |
| Iterator iter = getInputMessage().parts(); |
| while (iter.hasNext()) { |
| MessagePart part = (MessagePart) iter.next(); |
| if (outputPart.getName().equals(part.getName()) && outputPart.getDescriptor().equals(part.getDescriptor())) { |
| return true; |
| } |
| } |
| } else if (soapOperation != null && soapOperation.isRPC() || info.soapBinding.isRPC()) { |
| com.sun.tools.internal.ws.wsdl.document.Message inputMessage = getInputMessage(); |
| if (inputParameterNames.contains(outputPart.getName())) { |
| if (inputMessage.getPart(outputPart.getName()).getDescriptor().equals(outputPart.getDescriptor())) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| private List<Parameter> createRpcLitRequestParameters(Request request, List<String> parameterList, Block block) { |
| Message message = getInputMessage(); |
| S2JJAXBModel jaxbModel = ((RpcLitStructure) block.getType()).getJaxbModel().getS2JJAXBModel(); |
| List<Parameter> parameters = ModelerUtils.createRpcLitParameters(message, block, jaxbModel, errReceiver); |
| |
| //create parameters for header and mime parts |
| for (String paramName : parameterList) { |
| MessagePart part = message.getPart(paramName); |
| if (part == null) { |
| continue; |
| } |
| if (ModelerUtils.isBoundToSOAPHeader(part)) { |
| if (parameters == null) { |
| parameters = new ArrayList<Parameter>(); |
| } |
| QName headerName = part.getDescriptor(); |
| JAXBType jaxbType = getJAXBType(part); |
| Block headerBlock = new Block(headerName, jaxbType, part); |
| request.addHeaderBlock(headerBlock); |
| Parameter param = ModelerUtils.createParameter(part.getName(), jaxbType, headerBlock); |
| if (param != null) { |
| parameters.add(param); |
| } |
| } else if (ModelerUtils.isBoundToMimeContent(part)) { |
| if (parameters == null) { |
| parameters = new ArrayList<Parameter>(); |
| } |
| List<MIMEContent> mimeContents = getMimeContents(info.bindingOperation.getInput(), |
| getInputMessage(), paramName); |
| |
| JAXBType type = getAttachmentType(mimeContents, part); |
| //create Parameters in request or response |
| //Block mimeBlock = new Block(new QName(part.getName()), type); |
| Block mimeBlock = new Block(type.getName(), type, part); |
| request.addAttachmentBlock(mimeBlock); |
| Parameter param = ModelerUtils.createParameter(part.getName(), type, mimeBlock); |
| if (param != null) { |
| parameters.add(param); |
| } |
| } else if (ModelerUtils.isUnbound(part)) { |
| if (parameters == null) { |
| parameters = new ArrayList<Parameter>(); |
| } |
| QName name = part.getDescriptor(); |
| JAXBType type = getJAXBType(part); |
| Block unboundBlock = new Block(name, type, part); |
| request.addUnboundBlock(unboundBlock); |
| Parameter param = ModelerUtils.createParameter(part.getName(), type, unboundBlock); |
| if (param != null) { |
| parameters.add(param); |
| } |
| } |
| } |
| for (Parameter param : parameters) { |
| setCustomizedParameterName(info.portTypeOperation, message, message.getPart(param.getName()), param, false); |
| } |
| return parameters; |
| } |
| |
| private String getJavaTypeForMimeType(String mimeType) { |
| if (mimeType.equals("image/jpeg") || mimeType.equals("image/gif")) { |
| return "java.awt.Image"; |
| } else if (mimeType.equals("text/xml") || mimeType.equals("application/xml")) { |
| return "javax.xml.transform.Source"; |
| } |
| return "javax.activation.DataHandler"; |
| } |
| |
| private JAXBType getAttachmentType(List<MIMEContent> mimeContents, MessagePart part) { |
| if (!enableMimeContent()) { |
| return getJAXBType(part); |
| } |
| String javaType; |
| List<String> mimeTypes = getAlternateMimeTypes(mimeContents); |
| if (mimeTypes.size() > 1) { |
| javaType = "javax.activation.DataHandler"; |
| } else { |
| javaType = getJavaTypeForMimeType(mimeTypes.get(0)); |
| } |
| |
| S2JJAXBModel jaxbModel = getJAXBModelBuilder().getJAXBModel().getS2JJAXBModel(); |
| JType jt = options.getCodeModel().ref(javaType); |
| QName desc = part.getDescriptor(); |
| TypeAndAnnotation typeAnno = null; |
| |
| if (part.getDescriptorKind() == SchemaKinds.XSD_TYPE) { |
| typeAnno = jaxbModel.getJavaType(desc); |
| desc = new QName("", part.getName()); |
| } else if (part.getDescriptorKind() == SchemaKinds.XSD_ELEMENT) { |
| typeAnno = getJAXBModelBuilder().getElementTypeAndAnn(desc); |
| if(typeAnno == null){ |
| error(part, ModelerMessages.WSDLMODELER_JAXB_JAVATYPE_NOTFOUND(part.getDescriptor(), part.getName())); |
| } |
| for (String mimeType : mimeTypes) { |
| if ((!mimeType.equals("text/xml") && !mimeType.equals("application/xml"))) { |
| //According to AP 1.0, |
| //RZZZZ: In a DESCRIPTION, if a wsdl:part element refers to a |
| //global element declaration (via the element attribute of the wsdl:part |
| //element) then the value of the type attribute of a mime:content element |
| //that binds that part MUST be a content type suitable for carrying an |
| //XML serialization. |
| //should we throw warning? |
| //type = MimeHelper.javaType.DATA_HANDLER_JAVATYPE; |
| warning(part, ModelerMessages.MIMEMODELER_ELEMENT_PART_INVALID_ELEMENT_MIME_TYPE(part.getName(), mimeType)); |
| } |
| } |
| } |
| if (typeAnno == null) { |
| error(part, ModelerMessages.WSDLMODELER_JAXB_JAVATYPE_NOTFOUND(desc, part.getName())); |
| } |
| return new JAXBType(desc, new JavaSimpleType(new JAXBTypeAndAnnotation(typeAnno, jt)), |
| null, getJAXBModelBuilder().getJAXBModel()); |
| } |
| |
| protected void buildJAXBModel(WSDLDocument wsdlDocument) { |
| JAXBModelBuilder tempJaxbModelBuilder = new JAXBModelBuilder(options, classNameCollector, forest, errReceiver); |
| //set the java package where wsdl artifacts will be generated |
| //if user provided package name using -p switch (or package property on wsimport ant task) |
| //ignore the package customization in the wsdl and schema bidnings |
| //formce the -p option only in the first pass |
| if (explicitDefaultPackage != null) { |
| tempJaxbModelBuilder.getJAXBSchemaCompiler().forcePackageName(options.defaultPackage); |
| } else { |
| options.defaultPackage = getJavaPackage(); |
| } |
| |
| //create pseudo schema for async operations(if any) response bean |
| List<InputSource> schemas = PseudoSchemaBuilder.build(this, options, errReceiver); |
| for (InputSource schema : schemas) { |
| tempJaxbModelBuilder.getJAXBSchemaCompiler().parseSchema(schema); |
| } |
| tempJaxbModelBuilder.bind(); |
| this.jaxbModelBuilder = tempJaxbModelBuilder; |
| } |
| |
| protected String getJavaPackage() { |
| String jaxwsPackage = null; |
| JAXWSBinding jaxwsCustomization = (JAXWSBinding) getExtensionOfType(document.getDefinitions(), JAXWSBinding.class); |
| if (jaxwsCustomization != null && jaxwsCustomization.getJaxwsPackage() != null) { |
| jaxwsPackage = jaxwsCustomization.getJaxwsPackage().getName(); |
| } |
| if (jaxwsPackage != null) { |
| return jaxwsPackage; |
| } |
| String wsdlUri = document.getDefinitions().getTargetNamespaceURI(); |
| return XJC.getDefaultPackageName(wsdlUri); |
| |
| } |
| |
| protected void createJavaInterfaceForProviderPort(Port port) { |
| String interfaceName = "javax.xml.ws.Provider"; |
| JavaInterface intf = new JavaInterface(interfaceName); |
| port.setJavaInterface(intf); |
| } |
| |
| protected void createJavaInterfaceForPort(Port port, boolean isProvider) { |
| if (isProvider) { |
| createJavaInterfaceForProviderPort(port); |
| return; |
| } |
| String interfaceName = getJavaNameOfSEI(port); |
| |
| if (isConflictingPortClassName(interfaceName)) { |
| interfaceName += "_PortType"; |
| } |
| |
| JavaInterface intf = new JavaInterface(interfaceName); |
| for (Operation operation : port.getOperations()) { |
| createJavaMethodForOperation( |
| port, |
| operation, |
| intf); |
| |
| for (JavaParameter jParam : operation.getJavaMethod().getParametersList()) { |
| Parameter param = jParam.getParameter(); |
| if (param.getCustomName() != null) { |
| jParam.setName(param.getCustomName()); |
| } |
| } |
| } |
| |
| port.setJavaInterface(intf); |
| } |
| |
| protected String getServiceInterfaceName(QName serviceQName, com.sun.tools.internal.ws.wsdl.document.Service wsdlService) { |
| String serviceName = wsdlService.getName(); |
| JAXWSBinding jaxwsCust = (JAXWSBinding) getExtensionOfType(wsdlService, JAXWSBinding.class); |
| if (jaxwsCust != null && jaxwsCust.getClassName() != null) { |
| CustomName name = jaxwsCust.getClassName(); |
| if (name != null && !name.getName().equals("")) { |
| return makePackageQualified(name.getName()); |
| } |
| } |
| return makePackageQualified(BindingHelper.mangleNameToClassName(serviceName)); |
| } |
| |
| protected String getJavaNameOfSEI(Port port) { |
| QName portTypeName = |
| (QName) port.getProperty( |
| ModelProperties.PROPERTY_WSDL_PORT_TYPE_NAME); |
| PortType pt = (PortType) document.find(Kinds.PORT_TYPE, portTypeName); |
| //populate the portType map here. We should get rid of all these properties |
| // lets not do it as it may break NB |
| //TODO: clean all these stuff part of NB RFE |
| port.portTypes.put(portTypeName, pt); |
| JAXWSBinding jaxwsCust = (JAXWSBinding) getExtensionOfType(pt, JAXWSBinding.class); |
| if (jaxwsCust != null && jaxwsCust.getClassName() != null) { |
| CustomName name = jaxwsCust.getClassName(); |
| if (name != null && !name.getName().equals("")) { |
| return makePackageQualified(name.getName()); |
| } |
| } |
| |
| String interfaceName; |
| if (portTypeName != null) { |
| // got portType information from WSDL, use it to name the interface |
| interfaceName = |
| makePackageQualified(BindingHelper.mangleNameToClassName(portTypeName.getLocalPart())); |
| } else { |
| // somehow we only got the port name, so we use that |
| interfaceName = |
| makePackageQualified(BindingHelper.mangleNameToClassName(port.getName().getLocalPart())); |
| } |
| return interfaceName; |
| } |
| |
| private void createJavaMethodForAsyncOperation(Port port, Operation operation, |
| JavaInterface intf) { |
| String candidateName = getJavaNameForOperation(operation); |
| JavaMethod method = new JavaMethod(candidateName, options, errReceiver); |
| |
| assert (operation.getRequest() != null); |
| Response response = operation.getResponse(); |
| |
| // build a signature of the form "opName%arg1type%arg2type%...%argntype so that we |
| // detect overloading conflicts in the generated java interface/classes |
| for (Iterator iter = operation.getRequest().getParameters(); iter.hasNext();) { |
| Parameter parameter = (Parameter) iter.next(); |
| |
| if (parameter.getJavaParameter() != null) { |
| error(operation.getEntity(), ModelerMessages.WSDLMODELER_INVALID_OPERATION(operation.getName().getLocalPart())); |
| } |
| |
| JavaType parameterType = parameter.getType().getJavaType(); |
| JavaParameter javaParameter = |
| new JavaParameter( |
| BindingHelper.mangleNameToVariableName(parameter.getName()), |
| parameterType, |
| parameter, |
| parameter.getLinkedParameter() != null); |
| if (javaParameter.isHolder()) { |
| javaParameter.setHolderName(javax.xml.ws.Holder.class.getName()); |
| } |
| method.addParameter(javaParameter); |
| parameter.setJavaParameter(javaParameter); |
| |
| } |
| |
| if (response != null) { |
| String resultParameterName = |
| (String) operation.getProperty(WSDL_RESULT_PARAMETER); |
| Parameter resultParameter = |
| response.getParameterByName(resultParameterName); |
| JavaType returnType = resultParameter.getType().getJavaType(); |
| method.setReturnType(returnType); |
| |
| } |
| operation.setJavaMethod(method); |
| intf.addMethod(method); |
| } |
| |
| /* (non-Javadoc) |
| * @see WSDLModelerBase#createJavaMethodForOperation(WSDLPort, WSDLOperation, JavaInterface, Set, Set) |
| */ |
| protected void createJavaMethodForOperation(Port port, Operation operation, JavaInterface intf) { |
| if ((operation instanceof AsyncOperation)) { |
| createJavaMethodForAsyncOperation(port, operation, intf); |
| return; |
| } |
| String candidateName = getJavaNameForOperation(operation); |
| JavaMethod method = new JavaMethod(candidateName, options, errReceiver); |
| Parameter returnParam = (Parameter) operation.getProperty(WSDL_RESULT_PARAMETER); |
| if (returnParam != null) { |
| JavaType parameterType = returnParam.getType().getJavaType(); |
| method.setReturnType(parameterType); |
| } else { |
| method.setReturnType(JavaSimpleTypeCreator.VOID_JAVATYPE); |
| } |
| List<Parameter> parameterOrder = (List<Parameter>) operation.getProperty(WSDL_PARAMETER_ORDER); |
| for (Parameter param : parameterOrder) { |
| JavaType parameterType = param.getType().getJavaType(); |
| String name = (param.getCustomName() != null) ? param.getCustomName() : param.getName(); |
| name = BindingHelper.mangleNameToVariableName(name); |
| //if its a java keyword after name mangling, then we simply put underscore as there is no |
| //need to ask user to customize the parameter name if its java keyword |
| if(Names.isJavaReservedWord(name)){ |
| name = "_"+name; |
| } |
| JavaParameter javaParameter = |
| new JavaParameter( |
| name, |
| parameterType, |
| param, |
| param.isINOUT() || param.isOUT()); |
| if (javaParameter.isHolder()) { |
| javaParameter.setHolderName(javax.xml.ws.Holder.class.getName()); |
| } |
| method.addParameter(javaParameter); |
| param.setJavaParameter(javaParameter); |
| } |
| operation.setJavaMethod(method); |
| intf.addMethod(method); |
| |
| String opName = BindingHelper.mangleNameToVariableName(operation.getName().getLocalPart()); |
| for (Iterator iter = operation.getFaults(); |
| iter != null && iter.hasNext(); |
| ) { |
| Fault fault = (Fault) iter.next(); |
| createJavaExceptionFromLiteralType(fault, port, opName); |
| } |
| JavaException javaException; |
| Fault fault; |
| for (Iterator iter = operation.getFaults(); iter.hasNext();) { |
| fault = (Fault) iter.next(); |
| javaException = fault.getJavaException(); |
| method.addException(javaException.getName()); |
| } |
| |
| } |
| |
| protected boolean createJavaExceptionFromLiteralType(Fault fault, com.sun.tools.internal.ws.processor.model.Port port, String operationName) { |
| JAXBType faultType = (JAXBType) fault.getBlock().getType(); |
| |
| String exceptionName = fault.getName(); |
| |
| // use fault namespace attribute |
| JAXBStructuredType jaxbStruct = new JAXBStructuredType(new QName( |
| fault.getBlock().getName().getNamespaceURI(), |
| fault.getName())); |
| |
| QName memberName = fault.getElementName(); |
| JAXBElementMember jaxbMember = |
| new JAXBElementMember(memberName, faultType); |
| //jaxbMember.setNillable(faultType.isNillable()); |
| |
| String javaMemberName = getLiteralJavaMemberName(fault); |
| JavaStructureMember javaMember = new JavaStructureMember( |
| javaMemberName, |
| faultType.getJavaType(), |
| jaxbMember); |
| jaxbMember.setJavaStructureMember(javaMember); |
| javaMember.setReadMethod(Names.getJavaMemberReadMethod(javaMember)); |
| javaMember.setInherited(false); |
| jaxbMember.setJavaStructureMember(javaMember); |
| jaxbStruct.add(jaxbMember); |
| |
| if (isConflictingExceptionClassName(exceptionName)) { |
| exceptionName += "_Exception"; |
| } |
| |
| JavaException existingJavaException = _javaExceptions.get(exceptionName); |
| if (existingJavaException != null) { |
| if (existingJavaException.getName().equals(exceptionName)) { |
| if (((JAXBType) existingJavaException.getOwner()).getName().equals(jaxbStruct.getName()) |
| || ModelerUtils.isEquivalentLiteralStructures(jaxbStruct, (JAXBStructuredType) existingJavaException.getOwner())) { |
| // we have mapped this fault already |
| if (faultType instanceof JAXBStructuredType) { |
| fault.getBlock().setType((JAXBType) existingJavaException.getOwner()); |
| } |
| fault.setJavaException(existingJavaException); |
| return false; |
| } |
| } |
| } |
| |
| JavaException javaException = new JavaException(exceptionName, false, jaxbStruct); |
| javaException.add(javaMember); |
| jaxbStruct.setJavaType(javaException); |
| |
| _javaExceptions.put(javaException.getName(), javaException); |
| |
| fault.setJavaException(javaException); |
| return true; |
| } |
| |
| protected boolean isRequestResponse() { |
| return info.portTypeOperation.getStyle() == OperationStyle.REQUEST_RESPONSE; |
| } |
| |
| protected java.util.List<String> getAsynParameterOrder() { |
| //for async operation ignore the parameterOrder |
| java.util.List<String> parameterList = new ArrayList<String>(); |
| Message inputMessage = getInputMessage(); |
| List<MessagePart> inputParts = inputMessage.getParts(); |
| for (MessagePart part : inputParts) { |
| parameterList.add(part.getName()); |
| } |
| return parameterList; |
| } |
| |
| |
| protected List<MessagePart> getParameterOrder() { |
| List<MessagePart> params = new ArrayList<MessagePart>(); |
| String parameterOrder = info.portTypeOperation.getParameterOrder(); |
| java.util.List<String> parameterList; |
| boolean parameterOrderPresent = false; |
| if ((parameterOrder != null) && !(parameterOrder.trim().equals(""))) { |
| parameterList = XmlUtil.parseTokenList(parameterOrder); |
| parameterOrderPresent = true; |
| } else { |
| parameterList = new ArrayList<String>(); |
| } |
| Message inputMessage = getInputMessage(); |
| Message outputMessage = getOutputMessage(); |
| List<MessagePart> outputParts = null; |
| List<MessagePart> inputParts = inputMessage.getParts(); |
| //reset the mode and ret flag, as MEssagePArts aer shared across ports |
| for (MessagePart part : inputParts) { |
| part.setMode(Mode.IN); |
| part.setReturn(false); |
| } |
| if (isRequestResponse()) { |
| outputParts = outputMessage.getParts(); |
| for (MessagePart part : outputParts) { |
| part.setMode(Mode.OUT); |
| part.setReturn(false); |
| } |
| } |
| |
| if (parameterOrderPresent) { |
| boolean validParameterOrder = true; |
| Iterator<String> paramOrders = parameterList.iterator(); |
| // If any part in the parameterOrder is not present in the request or |
| // response message, we completely ignore the parameterOrder hint |
| while (paramOrders.hasNext()) { |
| String param = paramOrders.next(); |
| boolean partFound = false; |
| for (MessagePart part : inputParts) { |
| if (param.equals(part.getName())) { |
| partFound = true; |
| break; |
| } |
| } |
| // if not found, check in output parts |
| if (!partFound) { |
| for (MessagePart part : outputParts) { |
| if (param.equals(part.getName())) { |
| partFound = true; |
| break; |
| } |
| } |
| } |
| if (!partFound) { |
| warning(info.operation.getEntity(), ModelerMessages.WSDLMODELER_INVALID_PARAMETERORDER_PARAMETER(param, info.operation.getName().getLocalPart())); |
| validParameterOrder = false; |
| } |
| } |
| |
| List<MessagePart> inputUnlistedParts = new ArrayList<MessagePart>(); |
| List<MessagePart> outputUnlistedParts = new ArrayList<MessagePart>(); |
| |
| //gather input Parts |
| if (validParameterOrder) { |
| for (String param : parameterList) { |
| MessagePart part = inputMessage.getPart(param); |
| if (part != null) { |
| params.add(part); |
| continue; |
| } |
| if (isRequestResponse()) { |
| MessagePart outPart = outputMessage.getPart(param); |
| if (outPart != null) { |
| params.add(outPart); |
| } |
| } |
| } |
| |
| for (MessagePart part : inputParts) { |
| if (!parameterList.contains(part.getName())) { |
| inputUnlistedParts.add(part); |
| } |
| } |
| |
| if (isRequestResponse()) { |
| // at most one output part should be unlisted |
| for (MessagePart part : outputParts) { |
| if (!parameterList.contains(part.getName())) { |
| MessagePart inPart = inputMessage.getPart(part.getName()); |
| //dont add inout as unlisted part |
| if ((inPart != null) && inPart.getDescriptor().equals(part.getDescriptor())) { |
| inPart.setMode(Mode.INOUT); |
| } else { |
| outputUnlistedParts.add(part); |
| } |
| } else { |
| //param list may contain it, check if its INOUT |
| MessagePart inPart = inputMessage.getPart(part.getName()); |
| //dont add inout as unlisted part |
| if ((inPart != null) && inPart.getDescriptor().equals(part.getDescriptor())) { |
| inPart.setMode(Mode.INOUT); |
| } else if (!params.contains(part)) { |
| params.add(part); |
| } |
| } |
| } |
| if (outputUnlistedParts.size() == 1) { |
| MessagePart resultPart = outputUnlistedParts.get(0); |
| resultPart.setReturn(true); |
| params.add(resultPart); |
| outputUnlistedParts.clear(); |
| } |
| } |
| |
| //add the input and output unlisted parts |
| for (MessagePart part : inputUnlistedParts) { |
| params.add(part); |
| } |
| |
| for (MessagePart part : outputUnlistedParts) { |
| params.add(part); |
| } |
| return params; |
| |
| } |
| //parameterOrder attribute is not valid, we ignore it |
| warning(info.operation.getEntity(), ModelerMessages.WSDLMODELER_INVALID_PARAMETER_ORDER_INVALID_PARAMETER_ORDER(info.operation.getName().getLocalPart())); |
| parameterList.clear(); |
| } |
| |
| List<MessagePart> outParts = new ArrayList<MessagePart>(); |
| |
| //construct input parameter list with the same order as in input message |
| for (MessagePart part : inputParts) { |
| params.add(part); |
| } |
| |
| if (isRequestResponse()) { |
| for (MessagePart part : outputParts) { |
| MessagePart inPart = inputMessage.getPart(part.getName()); |
| if (inPart != null && part.getDescriptorKind() == inPart.getDescriptorKind() && |
| part.getDescriptor().equals(inPart.getDescriptor())) { |
| inPart.setMode(Mode.INOUT); |
| continue; |
| } |
| outParts.add(part); |
| } |
| |
| //append the out parts to the parameterList |
| for (MessagePart part : outParts) { |
| if (outParts.size() == 1) { |
| part.setReturn(true); |
| } |
| params.add(part); |
| } |
| } |
| return params; |
| } |
| |
| /** |
| * @param port |
| * @param suffix |
| * @return the Java ClassName for a port |
| */ |
| protected String getClassName(Port port, String suffix) { |
| String prefix = BindingHelper.mangleNameToClassName((port.getName().getLocalPart())); |
| return options.defaultPackage + "." + prefix + suffix; |
| } |
| |
| @Override |
| protected boolean isConflictingServiceClassName(String name) { |
| return conflictsWithSEIClass(name) || conflictsWithJAXBClass(name) || conflictsWithExceptionClass(name); |
| } |
| |
| private boolean conflictsWithSEIClass(String name) { |
| Set<String> seiNames = classNameCollector.getSeiClassNames(); |
| return seiNames != null && seiNames.contains(name); |
| } |
| |
| private boolean conflictsWithJAXBClass(String name) { |
| Set<String> jaxbNames = classNameCollector.getJaxbGeneratedClassNames(); |
| return jaxbNames != null && jaxbNames.contains(name); |
| } |
| |
| private boolean conflictsWithExceptionClass(String name) { |
| Set<String> exceptionNames = classNameCollector.getExceptionClassNames(); |
| return exceptionNames != null && exceptionNames.contains(name); |
| } |
| |
| @Override |
| protected boolean isConflictingExceptionClassName(String name) { |
| return conflictsWithSEIClass(name) || conflictsWithJAXBClass(name); |
| } |
| |
| protected JAXBModelBuilder getJAXBModelBuilder() { |
| return jaxbModelBuilder; |
| } |
| |
| protected boolean validateWSDLBindingStyle(Binding binding) { |
| SOAPBinding soapBinding = |
| (SOAPBinding) getExtensionOfType(binding, SOAPBinding.class); |
| |
| //dont process the binding |
| if (soapBinding == null) { |
| soapBinding = (SOAPBinding) getExtensionOfType(binding, SOAP12Binding.class); |
| } |
| if (soapBinding == null) { |
| return false; |
| } |
| |
| //if soapbind:binding has no style attribute, the default is DOCUMENT |
| if (soapBinding.getStyle() == null) { |
| soapBinding.setStyle(SOAPStyle.DOCUMENT); |
| } |
| |
| SOAPStyle opStyle = soapBinding.getStyle(); |
| for (Iterator iter = binding.operations(); iter.hasNext();) { |
| BindingOperation bindingOperation = |
| (BindingOperation) iter.next(); |
| SOAPOperation soapOperation = |
| (SOAPOperation) getExtensionOfType(bindingOperation, |
| SOAPOperation.class); |
| if (soapOperation != null) { |
| SOAPStyle currOpStyle = (soapOperation.getStyle() != null) ? soapOperation.getStyle() : soapBinding.getStyle(); |
| //dont check for the first operation |
| if (!currOpStyle.equals(opStyle)) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * @param port |
| */ |
| private void applyWrapperStyleCustomization(Port port, PortType portType) { |
| JAXWSBinding jaxwsBinding = (JAXWSBinding) getExtensionOfType(portType, JAXWSBinding.class); |
| Boolean wrapperStyle = (jaxwsBinding != null) ? jaxwsBinding.isEnableWrapperStyle() : null; |
| if (wrapperStyle != null) { |
| port.setWrapped(wrapperStyle); |
| } |
| } |
| |
| protected static void setDocumentationIfPresent( |
| ModelObject obj, |
| Documentation documentation) { |
| if (documentation != null && documentation.getContent() != null) { |
| obj.setJavaDoc(documentation.getContent()); |
| } |
| } |
| |
| protected String getJavaNameForOperation(Operation operation) { |
| String name = operation.getJavaMethodName(); |
| if (Names.isJavaReservedWord(name)) { |
| name = "_" + name; |
| } |
| return name; |
| } |
| |
| private void reportError(Entity entity, |
| String formattedMsg, Exception nestedException ) { |
| Locator locator = (entity == null)?null:entity.getLocator(); |
| |
| SAXParseException e = new SAXParseException2( formattedMsg, |
| locator, |
| nestedException ); |
| errReceiver.error(e); |
| } |
| |
| } |