| package org.apache.axis2.description; |
| |
| import org.apache.axis2.AxisFault; |
| import org.apache.axis2.namespace.Constants; |
| import org.apache.axis2.util.PolicyUtil; |
| import org.apache.axis2.wsdl.WSDLConstants; |
| import org.apache.woden.WSDLException; |
| import org.apache.woden.WSDLFactory; |
| import org.apache.woden.WSDLReader; |
| import org.apache.woden.WSDLSource; |
| import org.apache.woden.internal.DOMWSDLFactory; |
| import org.apache.woden.schema.Schema; |
| import org.apache.woden.wsdl20.Binding; |
| import org.apache.woden.wsdl20.Description; |
| import org.apache.woden.wsdl20.Endpoint; |
| import org.apache.woden.wsdl20.Interface; |
| import org.apache.woden.wsdl20.InterfaceFaultReference; |
| import org.apache.woden.wsdl20.InterfaceMessageReference; |
| import org.apache.woden.wsdl20.InterfaceOperation; |
| import org.apache.woden.wsdl20.Service; |
| import org.apache.woden.wsdl20.enumeration.Direction; |
| import org.apache.woden.wsdl20.extensions.ExtensionElement; |
| import org.apache.woden.wsdl20.extensions.UnknownExtensionElement; |
| import org.apache.woden.wsdl20.xml.BindingElement; |
| import org.apache.woden.wsdl20.xml.DescriptionElement; |
| import org.apache.woden.wsdl20.xml.InterfaceElement; |
| import org.apache.woden.wsdl20.xml.InterfaceFaultReferenceElement; |
| import org.apache.woden.wsdl20.xml.InterfaceMessageReferenceElement; |
| import org.apache.woden.wsdl20.xml.InterfaceOperationElement; |
| import org.apache.woden.wsdl20.xml.TypesElement; |
| import org.apache.ws.commons.schema.XmlSchema; |
| import org.apache.ws.commons.schema.utils.NamespaceMap; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| |
| import javax.xml.namespace.QName; |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import java.io.InputStream; |
| import java.net.URI; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| /* |
| * Copyright 2004,2005 The Apache Software Foundation. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| public class WSDL20ToAxisServiceBuilder extends WSDLToAxisServiceBuilder { |
| |
| protected Description description; |
| |
| private String wsdlURI; |
| |
| // FIXME @author Chathura THis shoud be a URI. Find whats used by |
| // woden. |
| private static String RPC = "rpc"; |
| |
| protected String interfaceName; |
| |
| private String savedTargetNamespace; |
| |
| private Map namespacemap; |
| |
| private NamespaceMap stringBasedNamespaceMap; |
| |
| private boolean setupComplete = false; |
| |
| public WSDL20ToAxisServiceBuilder(InputStream in, QName serviceName, |
| String interfaceName) { |
| this.in = in; |
| this.serviceName = serviceName; |
| this.interfaceName = interfaceName; |
| this.axisService = new AxisService(); |
| setPolicyRegistryFromService(axisService); |
| } |
| |
| public WSDL20ToAxisServiceBuilder(String wsdlUri, |
| String name, String interfaceName) throws Exception { |
| WSDLReader wsdlReader = WSDLFactory.newInstance().newWSDLReader(); |
| DescriptionElement descriptionElement = wsdlReader.readWSDL(wsdlUri); |
| savedTargetNamespace = descriptionElement.getTargetNamespace() |
| .toString(); |
| namespacemap = descriptionElement.getNamespaces(); |
| this.description = descriptionElement.toComponent(); |
| this.serviceName = null; |
| if(name != null) { |
| serviceName = new QName(descriptionElement.getTargetNamespace().toString(), name); |
| } |
| this.interfaceName = interfaceName; |
| this.axisService = new AxisService(); |
| setPolicyRegistryFromService(axisService); |
| } |
| |
| public WSDL20ToAxisServiceBuilder(String wsdlUri, QName serviceName) { |
| super(null, serviceName); |
| this.wsdlURI = wsdlUri; |
| } |
| |
| public WSDL20ToAxisServiceBuilder(String wsdlUri, AxisService service) { |
| super(null, service); |
| this.wsdlURI = wsdlUri; |
| } |
| |
| public AxisService populateService() throws AxisFault { |
| |
| try { |
| setup(); |
| // Setting wsdl4jdefintion to axisService , so if some one want |
| // to play with it he can do that by getting the parameter |
| Parameter wsdlDescriptionParamter = new Parameter(); |
| wsdlDescriptionParamter.setName(WSDLConstants.WSDL_20_DESCRIPTION); |
| wsdlDescriptionParamter.setValue(description); |
| axisService.addParameter(wsdlDescriptionParamter); |
| |
| if (description == null) { |
| return null; |
| } |
| // setting target name space |
| axisService.setTargetNamespace(savedTargetNamespace); |
| |
| // if there are documentation elements in the root. Lets add them as the service description |
| // but since there can be multiple documentation elements, lets only add the first one |
| // DocumentationElement[] documentationElements = description.toElement().getDocumentationElements(); |
| // if (documentationElements != null && documentationElements.length > 0) { |
| // axisService.setServiceDescription(documentationElements[0].getContent().toString()); |
| // } |
| |
| // adding ns in the original WSDL |
| // processPoliciesInDefintion(wsdl4jDefinition); TODO : Defering policy handling for now - Chinthaka |
| // policy support |
| |
| // schema generation |
| |
| // Create the namespacemap |
| |
| axisService.setNameSpacesMap(stringBasedNamespaceMap); |
| // TypeDefinition[] typeDefinitions = |
| // description.getTypeDefinitions(); |
| // for(int i=0; i<typeDefinitions.length; i++){ |
| // if("org.apache.ws.commons.schema".equals(typeDefinitions[i].getContentModel())){ |
| // axisService.addSchema((XmlSchema)typeDefinitions[i].getContent()); |
| // }else |
| // if("org.w3c.dom".equals(typeDefinitions[i].getContentModel())){ |
| // axisService.addSchema(getXMLSchema((Element)typeDefinitions[i].getContent(), |
| // null)); |
| // } |
| // |
| // } |
| |
| TypesElement typesElement = description.toElement() |
| .getTypesElement(); |
| if (typesElement != null) { |
| Schema[] schemas = typesElement.getSchemas(); |
| for (int i = 0; i < schemas.length; i++) { |
| XmlSchema schemaDefinition = schemas[i].getSchemaDefinition(); |
| |
| |
| // WSDL 2.0 spec requires that even the built-in schema should be returned |
| // once asked for schema definitions. But for data binding purposes we can ignore that |
| if (schemaDefinition != null && !Constants.URI_2001_SCHEMA_XSD.equals(schemaDefinition.getTargetNamespace())) { |
| axisService.addSchema(schemaDefinition); |
| } |
| } |
| } |
| |
| Binding binding = findBinding(description); |
| // //////////////////(1.2) ///////////////////////////// |
| // // create new Schema extensions element for wrapping |
| // Element[] schemaElements = |
| // generateWrapperSchema(descriptionElement, |
| // binding); |
| // if (schemaElements != null && schemaElements.length > 0) { |
| // for (int i = 0; i < schemaElements.length; i++) { |
| // Element schemaElement = schemaElements[i]; |
| // if (schemaElement != null) { |
| // axisService.addSchema(getXMLSchema(schemaElement, null)); |
| // } |
| // } |
| // } |
| processBinding(binding, description); |
| return axisService; |
| } catch (Exception e) { |
| throw new AxisFault(e); |
| } |
| } |
| |
| /** |
| * contains all code which gathers non-service specific information from the |
| * wsdl. |
| * <p> |
| * After all the setup completes successfully, the setupComplete field is |
| * set so that any subsequent calls to setup() will result in a no-op. Note |
| * that subclass WSDL20ToAllAxisServicesBuilder will call populateService |
| * for each endpoint in the WSDL. Separating the non-service specific |
| * information here allows WSDL20ToAllAxisServicesBuilder to only do this |
| * work 1 time per WSDL, instead of for each endpoint on each service. |
| * |
| * @throws AxisFault |
| */ |
| protected void setup() throws AxisFault { |
| if (setupComplete) { // already setup, just do nothing and return |
| return; |
| } |
| try { |
| if (description == null) { |
| |
| DescriptionElement descriptionElement = null; |
| if (wsdlURI != null && !"".equals(wsdlURI)) { |
| descriptionElement = readInTheWSDLFile(wsdlURI); |
| } else if (in != null) { |
| |
| DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory |
| .newInstance(); |
| documentBuilderFactory.setNamespaceAware(true); |
| DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder(); |
| Document document = documentBuilder.parse(in); |
| |
| WSDLReader reader = DOMWSDLFactory.newInstance().newWSDLReader(); |
| WSDLSource wsdlSource = reader.createWSDLSource(); |
| wsdlSource.setSource(document.getDocumentElement()); |
| // wsdlSource.setBaseURI(new URI(getBaseUri())); |
| descriptionElement = reader.readWSDL(wsdlSource); |
| } else { |
| throw new AxisFault("No resources found to read the wsdl"); |
| } |
| |
| savedTargetNamespace = descriptionElement.getTargetNamespace().toString(); |
| namespacemap = descriptionElement.getNamespaces(); |
| this.description = descriptionElement.toComponent(); |
| |
| } |
| // Create the namespacemap |
| |
| stringBasedNamespaceMap = new NamespaceMap(); |
| Iterator iterator = namespacemap.keySet().iterator(); |
| while (iterator.hasNext()) { |
| String key = (String) iterator.next(); |
| stringBasedNamespaceMap.put(key, (namespacemap.get(key)).toString()); |
| } |
| |
| setupComplete = true; |
| } catch (AxisFault e) { |
| throw e; // just rethrow AxisFaults |
| } catch (Exception e) { |
| throw new AxisFault(e); |
| } |
| } |
| |
| private void processBinding(Binding binding, Description description) |
| throws Exception { |
| if (binding != null) { |
| |
| // TODO @author Chathura have to copy policy elements. |
| // copyExtensibleElements(binding.getExtensibilityElements(), dif, |
| // axisService, BINDING); |
| |
| Interface serviceInterface = binding.getInterface(); |
| |
| processInterface(serviceInterface, description); |
| |
| } |
| } |
| |
| private void processInterface(Interface serviceInterface, Description dif) |
| throws Exception { |
| |
| // TODO @author Chathura copy the policy elements |
| // copyExtensionAttributes(wsdl4jPortType.getExtensionAttributes(), |
| // axisService, PORT_TYPE); |
| |
| InterfaceOperation[] interfaceOperations = serviceInterface |
| .getInterfaceOperations(); |
| for (int i = 0; i < interfaceOperations.length; i++) { |
| axisService.addOperation(populateOperations(interfaceOperations[i], |
| description)); |
| } |
| |
| } |
| |
| private AxisOperation populateOperations(InterfaceOperation operation, |
| Description description) throws Exception { |
| QName opName = operation.getName(); |
| // Copy Name Attribute |
| AxisOperation axisOperation = axisService.getOperation(opName); |
| if (axisOperation == null) { |
| String MEP = operation.getMessageExchangePattern().toString(); |
| axisOperation = AxisOperationFactory.getOperationDescription(MEP); |
| axisOperation.setName(opName); |
| |
| // All policy includes must share same registry |
| PolicyInclude pi = axisOperation.getPolicyInclude(); |
| if (pi == null) { |
| pi = new PolicyInclude(); |
| axisOperation.setPolicyInclude(pi); |
| } |
| pi.setPolicyRegistry(registry); |
| } |
| |
| // assuming the style of the operations of WSDL 2.0 is always document. |
| axisOperation.setStyle("document"); |
| |
| // copyExtensibleElements(wsdl4jOperation.getExtensibilityElements(), |
| // dif, |
| // axisOperation, PORT_TYPE_OPERATION); |
| |
| InterfaceMessageReference[] interfaceMessageReferences = operation |
| .getInterfaceMessageReferences(); |
| for (int i = 0; i < interfaceMessageReferences.length; i++) { |
| InterfaceMessageReferenceElement messageReference = interfaceMessageReferences[i].toElement(); |
| if (messageReference.getMessageLabel().equals( |
| messageReference.getMessageLabel().IN)) { |
| // Its an input message |
| |
| if (isServerSide) { |
| AxisMessage inMessage = axisOperation |
| .getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE); |
| |
| inMessage.setElementQName(messageReference.getElementName()); |
| inMessage.setName(messageReference.getElementName().getLocalPart()); |
| // TODO copy policy elements |
| } else { |
| AxisMessage inMessage = axisOperation |
| .getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE); |
| |
| inMessage.setElementQName(messageReference.getElementName()); |
| inMessage.setName(messageReference.getElementName().getLocalPart()); |
| // TODO copy policy elements |
| } |
| } else if (messageReference.getMessageLabel().equals( |
| messageReference.getMessageLabel().OUT)) { |
| if (isServerSide) { |
| AxisMessage outMessage = axisOperation |
| .getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE); |
| |
| outMessage.setElementQName(messageReference.getElementName()); |
| outMessage.setName(messageReference.getElementName().getLocalPart()); |
| // TODO copy policy elements |
| } else { |
| AxisMessage outMessage = axisOperation |
| .getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE); |
| |
| outMessage.setElementQName(messageReference.getElementName()); |
| outMessage.setName(messageReference.getElementName().getLocalPart()); |
| // TODO copy policy elements |
| } |
| } |
| |
| } |
| |
| |
| // add operation level faults |
| InterfaceFaultReference[] faults = operation.getInterfaceFaultReferences(); |
| for (int i = 0; i < faults.length; i++) { |
| AxisMessage faultMessage = new AxisMessage(); |
| |
| InterfaceFaultReferenceElement interfaceFaultReferenceElement = faults[i].toElement(); |
| faultMessage.setDirection(interfaceFaultReferenceElement.getDirection().toString()); |
| |
| faultMessage.setElementQName(interfaceFaultReferenceElement.getInterfaceFaultElement().getElementName()); |
| faultMessage.setName(interfaceFaultReferenceElement.getRef().getLocalPart()); |
| axisOperation.setFaultMessages(faultMessage); |
| } |
| |
| |
| return axisOperation; |
| } |
| |
| private void copyExtensibleElements(ExtensionElement[] extensionElement, |
| DescriptionElement descriptionElement, AxisDescription description, |
| String originOfExtensibilityElements) { |
| for (int i = 0; i < extensionElement.length; i++) { |
| ExtensionElement element = extensionElement[i]; |
| |
| if (element instanceof UnknownExtensionElement) { |
| UnknownExtensionElement unknown = (UnknownExtensionElement) element; |
| |
| // look for the SOAP 1.2 stuff here. WSDL4j does not understand |
| // SOAP 1.2 things |
| // TODO this is wrong. Compare this with WSDL 2.0 QName |
| if (WSDLConstants.WSDL11Constants.SOAP_12_OPERATION.equals(unknown |
| .getExtensionType())) { |
| Element unknownElement = unknown.getElement(); |
| if (description instanceof AxisOperation) { |
| AxisOperation axisOperation = (AxisOperation) description; |
| String style = unknownElement.getAttribute("style"); |
| if (style != null) { |
| axisOperation.setStyle(style); |
| } |
| axisOperation.setSoapAction(unknownElement |
| .getAttribute("soapAction")); |
| } |
| } else if (WSDLConstants.WSDL11Constants.SOAP_12_HEADER.equals(unknown |
| .getExtensionType())) { |
| // TODO : implement thid |
| } else if (WSDLConstants.WSDL11Constants.SOAP_12_BINDING.equals(unknown |
| .getExtensionType())) { |
| style = unknown.getElement().getAttribute("style"); |
| axisService.setSoapNsUri(element.getExtensionType() |
| .getNamespaceURI()); |
| } else if (WSDLConstants.WSDL11Constants.SOAP_12_ADDRESS.equals(unknown |
| .getExtensionType())) { |
| axisService.setEndpoint(unknown.getElement().getAttribute( |
| "location")); |
| } else if (WSDLConstants.WSDL11Constants.POLICY.equals(unknown |
| .getExtensionType())) { |
| // TODO |
| |
| |
| } else if (WSDLConstants.WSDL11Constants.POLICY_REFERENCE.equals(unknown |
| .getExtensionType())) { |
| // TODO |
| |
| |
| |
| } else { |
| // TODO : we are ignored that. |
| } |
| |
| // } else if (element instanceof SOAPAddress) { |
| // SOAPAddress soapAddress = (SOAPAddress) wsdl4jElement; |
| // axisService.setEndpoint(soapAddress.getLocationURI()); |
| // } else if (wsdl4jElement instanceof Schema) { |
| // Schema schema = (Schema) wsdl4jElement; |
| // //just add this schema - no need to worry about the imported |
| // ones |
| // axisService.addSchema(getXMLSchema(schema.getElement(), |
| // wsdl4jDefinition.getDocumentBaseURI())); |
| // } else if |
| // (SOAPConstants.Q_ELEM_SOAP_OPERATION.equals(wsdl4jElement |
| // .getElementType())) { |
| // SOAPOperation soapOperation = (SOAPOperation) wsdl4jElement; |
| // if (description instanceof AxisOperation) { |
| // AxisOperation axisOperation = (AxisOperation) description; |
| // if (soapOperation.getStyle() != null) { |
| // axisOperation.setStyle(soapOperation.getStyle()); |
| // } |
| // axisOperation.setSoapAction(soapOperation |
| // .getSoapActionURI()); |
| // } |
| // } else if |
| // (SOAPConstants.Q_ELEM_SOAP_HEADER.equals(wsdl4jElement |
| // .getElementType())) { |
| // SOAPHeader soapHeader = (SOAPHeader) wsdl4jElement; |
| // SOAPHeaderMessage headerMessage = new SOAPHeaderMessage(); |
| // headerMessage.setNamespaceURI(soapHeader.getNamespaceURI()); |
| // headerMessage.setUse(soapHeader.getUse()); |
| // Boolean required = soapHeader.getRequired(); |
| // if (null != required) { |
| // headerMessage.setRequired(required.booleanValue()); |
| // } |
| // if (null != wsdl4jDefinition) { |
| // //find the relevant schema part from the messages |
| // Message msg = wsdl4jDefinition.getMessage(soapHeader |
| // .getMessage()); |
| // Part msgPart = msg.getPart(soapHeader.getPart()); |
| // headerMessage.setElement(msgPart.getElementName()); |
| // } |
| // headerMessage.setMessage(soapHeader.getMessage()); |
| // |
| // headerMessage.setPart(soapHeader.getPart()); |
| // if (description instanceof AxisMessage) { |
| // ((AxisMessage) description).addSoapHeader(headerMessage); |
| // } |
| // } else if |
| // (SOAPConstants.Q_ELEM_SOAP_BINDING.equals(wsdl4jElement |
| // .getElementType())) { |
| // SOAPBinding soapBinding = (SOAPBinding) wsdl4jElement; |
| // style = soapBinding.getStyle(); |
| // axisService.setSoapNsUri(soapBinding.getElementType() |
| // .getNamespaceURI()); |
| // } |
| } |
| } |
| } |
| |
| private Binding findBinding(Description discription) throws AxisFault { |
| Service[] services = discription.getServices(); |
| Service service = null; |
| Endpoint endpoint = null; |
| Binding binding = null; |
| |
| if (services.length == 0) { |
| throw new AxisFault("No service found in the WSDL"); |
| } |
| |
| if (serviceName != null) { |
| for (int i = 0; i < services.length; i++) { |
| if (serviceName.equals(services[i].getName())) { |
| service = services[i]; |
| break; // found it. Stop looking. |
| } |
| } |
| if (service == null) { |
| throw new AxisFault("Service not found the WSDL " |
| + serviceName.getLocalPart()); |
| } |
| } else { |
| // If no particular service is mentioned select the first one. |
| service = services[0]; |
| } |
| // FIXME @author Chathura get the policy stuff to be copied |
| // copyExtensibleElements(service.getExtensibilityElements(), dif, |
| // axisService, SERVICE); |
| Endpoint[] endpoints = service.getEndpoints(); |
| if (this.interfaceName != null) { |
| |
| if (endpoints.length == 0) { |
| throw new AxisFault("No Endpoints/Ports found in the service:" |
| + service.getName().getLocalPart()); |
| } |
| |
| for (int i = 0; i < endpoints.length; ++i) { |
| if (this.interfaceName.equals(endpoints[i].getName().toString())) { |
| endpoint = endpoints[i]; |
| break; // found it. Stop looking |
| } |
| } |
| if (endpoint == null) { |
| throw new AxisFault("No port found for the given name :" |
| + this.interfaceName); |
| } |
| } else { |
| // if no particular endpoint is specified use the first one. |
| endpoint = endpoints[0]; |
| |
| } |
| axisService.setName(service.getName().getLocalPart()); |
| if (endpoint != null) { |
| // FIXME @author Chathura copy in the policy stuff |
| // copyExtensibleElements(port.getExtensibilityElements(), dif, |
| // axisService, PORT); |
| axisService.setEndpoint(endpoint.getAddress().toString()); |
| binding = endpoint.getBinding(); |
| } |
| return binding; |
| } |
| |
| private Element[] generateWrapperSchema( |
| DescriptionElement wodenDescription, BindingElement binding) { |
| |
| List schemaElementList = new ArrayList(); |
| String targetNamespaceUri = wodenDescription.getTargetNamespace() |
| .toString(); |
| |
| // /////////////////////////////////////////////////////////////////////////////////////////// |
| // if there are any bindings present then we have to process them. we |
| // have to generate a schema |
| // per binding (that is the safest option). if not we just resolve to |
| // the good old port type |
| // list, in which case we'll generate a schema per porttype |
| // ////////////////////////////////////////////////////////////////////////////////////////// |
| |
| // FIXME @author Chathura Once this method is done we could run the |
| // basic codgen |
| schemaElementList.add(createSchemaForInterface(binding |
| .getInterfaceElement(), targetNamespaceUri, |
| findWrapForceable(binding))); |
| return (Element[]) schemaElementList |
| .toArray(new Element[schemaElementList.size()]); |
| } |
| |
| private Element createSchemaForInterface(InterfaceElement interfaceElement, |
| String targetNamespaceUri, boolean forceWrapping) { |
| |
| // loop through the messages. We'll populate things map with the |
| // relevant |
| // messages |
| // from the operations |
| |
| // this will have name (QName) as the key and |
| // InterfaceMessageReferenceElement as the value |
| Map messagesMap = new HashMap(); |
| |
| // this will have operation name (a QName) as the key and |
| // InterfaceMessageReferenceElement as the value |
| Map inputOperationsMap = new HashMap(); |
| |
| // this will have operation name (a QName) as the key and |
| // InterfaceMessageReferenceElement as the value |
| Map outputOperationsMap = new HashMap(); |
| |
| Map faultyOperationsMap = new HashMap(); |
| // this contains the required namespace imports. the key in this |
| // map would be the namaspace URI |
| Map namespaceImportsMap = new HashMap(); |
| // generated complextypes. Keep in the list for writing later |
| // the key for the complexType map is the message QName |
| Map complexTypeElementsMap = new HashMap(); |
| // generated Elements. Kep in the list for later writing |
| List elementElementsList = new ArrayList(); |
| // list namespace prefix map. This map will include uri -> prefix |
| Map namespacePrefixMap = new HashMap(); |
| |
| // ////////////////////////////////////////////////////////////////////////////////////////////////// |
| // First thing is to populate the message map with the messages to |
| // process. |
| // ////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| // we really need to do this for a single porttype! |
| InterfaceOperationElement[] operationElements = interfaceElement |
| .getInterfaceOperationElements(); |
| InterfaceOperationElement opElement; |
| for (int k = 0; k < operationElements.length; k++) { |
| opElement = operationElements[k]; |
| InterfaceMessageReferenceElement[] interfaceMessageReferenceElements = opElement |
| .getInterfaceMessageReferenceElements(); |
| |
| for (int i = 0; i < interfaceMessageReferenceElements.length; i++) { |
| InterfaceMessageReferenceElement interfaceMessageReferenceElement = interfaceMessageReferenceElements[i]; |
| String direction = interfaceMessageReferenceElement |
| .getDirection().toString(); |
| messagesMap.put(interfaceMessageReferenceElement |
| .getElementName(), interfaceMessageReferenceElement); |
| if (Direction.IN.toString().equalsIgnoreCase(direction)) { |
| inputOperationsMap.put(opElement.getName(), |
| interfaceMessageReferenceElement); |
| } else if (Direction.OUT.toString().equalsIgnoreCase(direction)) { |
| outputOperationsMap.put(opElement.getName(), |
| interfaceMessageReferenceElement); |
| } |
| } |
| |
| InterfaceFaultReferenceElement[] interfaceFaultReferenceElements = opElement |
| .getInterfaceFaultReferenceElements(); |
| |
| for (int i = 0; i < interfaceFaultReferenceElements.length; i++) { |
| InterfaceFaultReferenceElement interfaceFaultReferenceElement = interfaceFaultReferenceElements[i]; |
| String direction = interfaceFaultReferenceElement |
| .getDirection().toString(); |
| messagesMap.put(interfaceFaultReferenceElement.getRef(), |
| interfaceFaultReferenceElement); |
| faultyOperationsMap.put(interfaceFaultReferenceElement |
| .getInterfaceFaultElement(), |
| interfaceFaultReferenceElement); |
| } |
| |
| } |
| |
| // ///////////////////////////////////////////////////////////////////////////////////////////////////////////// |
| // check whether there are messages that are wrappable. If there are no |
| // messages that are wrappable we'll |
| // just return null and endup this process. However we need to take the |
| // force flag into account here |
| // ///////////////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| QName[] keys; |
| if (forceWrapping) { |
| // just take all the messages and wrap them, we've been told to |
| // force wrapping! |
| keys = (QName[]) messagesMap.keySet().toArray( |
| new QName[messagesMap.size()]); |
| } else { |
| // |
| QName[] allKeys = (QName[]) messagesMap.keySet().toArray( |
| new QName[messagesMap.size()]); |
| List wrappableMessageNames = new ArrayList(); |
| boolean noMessagesTobeProcessed = true; |
| |
| // TODO Fix this |
| // for (int i = 0; i < allKeys.length; i++) { |
| // if (findWrapppable((Message) messagesMap.get(allKeys[i]))) { |
| // noMessagesTobeProcessed = false; |
| // //add that message to the list |
| // wrappableMessageNames.add(allKeys[i]); |
| // } |
| // } |
| if (noMessagesTobeProcessed) { |
| return null; |
| } |
| |
| keys = (QName[]) wrappableMessageNames |
| .toArray(new QName[wrappableMessageNames.size()]); |
| } |
| |
| // ///////////////////////////////////////////////////////////////////////////////////////////////////////////// |
| // Now we have the message list to process - Process the whole list of |
| // messages at once |
| // since we need to generate one single schema |
| // ///////////////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| // List resolvedMessageQNames = new ArrayList(); |
| // //find the xsd prefix |
| // String xsdPrefix = findSchemaPrefix(); |
| // Message wsdl4jMessage; |
| // //DOM document that will be the ultimate creator |
| // Document document = getDOMDocumentBuilder().newDocument(); |
| // for (int i = 0; i < keys.length; i++) { |
| // wsdl4jMessage = (Message) messagesMap.get(keys[i]); |
| // //No need to check the wrappable, |
| // |
| // //This message is wrappabel. However we need to see whether the |
| // // message is already |
| // //resolved! |
| // if (!resolvedMessageQNames.contains(wsdl4jMessage.getQName())) { |
| // //This message has not been touched before!. So we can go ahead |
| // // now |
| // Map parts = wsdl4jMessage.getParts(); |
| // //add the complex type |
| // String name = wsdl4jMessage.getQName().getLocalPart(); |
| // Element newComplexType = document.createElementNS( |
| // XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":" |
| // + XML_SCHEMA_COMPLEX_TYPE_LOCAL_NAME); |
| // newComplexType.setAttribute(XSD_NAME, name); |
| // |
| // Element cmplxContentSequence = document.createElementNS( |
| // XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":" |
| // + XML_SCHEMA_SEQUENCE_LOCAL_NAME); |
| // Element child; |
| // Iterator iterator = parts.keySet().iterator(); |
| // while (iterator.hasNext()) { |
| // Part part = (Part) parts.get(iterator.next()); |
| // //the part name |
| // String elementName = part.getName(); |
| // boolean isTyped = true; |
| // //the type name |
| // QName schemaTypeName; |
| // if (part.getTypeName() != null) { |
| // schemaTypeName = part.getTypeName(); |
| // } else if (part.getElementName() != null) { |
| // schemaTypeName = part.getElementName(); |
| // isTyped = false; |
| // } else { |
| // throw new RuntimeException(" Unqualified Message part!"); |
| // } |
| // |
| // child = document.createElementNS(XMLSCHEMA_NAMESPACE_URI, |
| // xsdPrefix + ":" + XML_SCHEMA_ELEMENT_LOCAL_NAME); |
| // |
| // String prefix; |
| // if (XMLSCHEMA_NAMESPACE_URI.equals(schemaTypeName |
| // .getNamespaceURI())) { |
| // prefix = xsdPrefix; |
| // } else { |
| // //this schema is a third party one. So we need to have |
| // // an import statement in our generated schema |
| // String uri = schemaTypeName.getNamespaceURI(); |
| // if (!namespaceImportsMap.containsKey(uri)) { |
| // //create Element for namespace import |
| // Element namespaceImport = document.createElementNS( |
| // XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":" |
| // + XML_SCHEMA_IMPORT_LOCAL_NAME); |
| // namespaceImport.setAttribute("namespace", uri); |
| // //add this to the map |
| // namespaceImportsMap.put(uri, namespaceImport); |
| // //we also need to associate this uri with a prefix |
| // // and include that prefix |
| // //in the schema's namspace declarations. So add |
| // // theis particular namespace to the |
| // //prefix map as well |
| // prefix = getTemporaryNamespacePrefix(); |
| // namespacePrefixMap.put(uri, prefix); |
| // } else { |
| // //this URI should be already in the namspace prefix |
| // // map |
| // prefix = (String) namespacePrefixMap.get(uri); |
| // } |
| // |
| // } |
| // // If it's from a type the element we need to add a name and |
| // // the type |
| // //if not it's the element reference |
| // if (isTyped) { |
| // child.setAttribute(XSD_NAME, elementName); |
| // child.setAttribute(XSD_TYPE, prefix + ":" |
| // + schemaTypeName.getLocalPart()); |
| // } else { |
| // child.setAttribute(XSD_REF, prefix + ":" |
| // + schemaTypeName.getLocalPart()); |
| // } |
| // cmplxContentSequence.appendChild(child); |
| // } |
| // newComplexType.appendChild(cmplxContentSequence); |
| // //add this newly created complextype to the list |
| // complexTypeElementsMap.put(wsdl4jMessage.getQName(), |
| // newComplexType); |
| // resolvedMessageQNames.add(wsdl4jMessage.getQName()); |
| // } |
| // |
| // } |
| // |
| // Element elementDeclaration; |
| // |
| // //loop through the input op map and generate the elements |
| // String[] inputOperationtNames = (String[]) |
| // inputOperationsMap.keySet() |
| // .toArray(new String[inputOperationsMap.size()]); |
| // for (int j = 0; j < inputOperationtNames.length; j++) { |
| // String inputOpName = inputOperationtNames[j]; |
| // elementDeclaration = document.createElementNS( |
| // XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":" |
| // + XML_SCHEMA_ELEMENT_LOCAL_NAME); |
| // elementDeclaration.setAttribute(XSD_NAME, inputOpName); |
| // |
| // String typeValue = ((Message) inputOperationsMap.get(inputOpName)) |
| // .getQName().getLocalPart(); |
| // elementDeclaration.setAttribute(XSD_TYPE, AXIS2WRAPPED + ":" |
| // + typeValue); |
| // elementElementsList.add(elementDeclaration); |
| // resolvedRpcWrappedElementMap.put(inputOpName, new QName( |
| // targetNamespaceUri, inputOpName, AXIS2WRAPPED)); |
| // } |
| // |
| // //loop through the output op map and generate the elements |
| // String[] outputOperationtNames = (String[]) outputOperationsMap |
| // .keySet().toArray(new String[outputOperationsMap.size()]); |
| // for (int j = 0; j < outputOperationtNames.length; j++) { |
| // |
| // String baseoutputOpName = outputOperationtNames[j]; |
| // String outputOpName = baseoutputOpName + "Response"; |
| // elementDeclaration = document.createElementNS( |
| // XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":" |
| // + XML_SCHEMA_ELEMENT_LOCAL_NAME); |
| // elementDeclaration.setAttribute(XSD_NAME, outputOpName); |
| // String typeValue = ((Message) outputOperationsMap |
| // .get(baseoutputOpName)).getQName().getLocalPart(); |
| // elementDeclaration.setAttribute(XSD_TYPE, AXIS2WRAPPED + ":" |
| // + typeValue); |
| // elementElementsList.add(elementDeclaration); |
| // resolvedRpcWrappedElementMap.put(outputOpName, new QName( |
| // targetNamespaceUri, outputOpName, AXIS2WRAPPED)); |
| // |
| // } |
| // |
| // //loop through the faultoutput op map and generate the elements |
| // String[] faultyOperationtNames = (String[]) faultyOperationsMap |
| // .keySet().toArray(new String[faultyOperationsMap.size()]); |
| // for (int j = 0; j < faultyOperationtNames.length; j++) { |
| // |
| // String baseFaultOpName = faultyOperationtNames[j]; |
| // elementDeclaration = document.createElementNS( |
| // XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":" |
| // + XML_SCHEMA_ELEMENT_LOCAL_NAME); |
| // elementDeclaration.setAttribute(XSD_NAME, baseFaultOpName); |
| // String typeValue = ((Message) faultyOperationsMap |
| // .get(baseFaultOpName)).getQName().getLocalPart(); |
| // elementDeclaration.setAttribute(XSD_TYPE, AXIS2WRAPPED + ":" |
| // + typeValue); |
| // elementElementsList.add(elementDeclaration); |
| // resolvedRpcWrappedElementMap.put(baseFaultOpName, new QName( |
| // targetNamespaceUri, baseFaultOpName, AXIS2WRAPPED)); |
| // |
| // } |
| // |
| // ////////////////////////////////////////////////////////////////////////////////////////////// |
| // // Now we are done with processing the messages and generating the |
| // right |
| // // schema object model |
| // // time to write out the schema |
| // ////////////////////////////////////////////////////////////////////////////////////////////// |
| // |
| // Element schemaElement = document.createElementNS( |
| // XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":" |
| // + XML_SCHEMA_LOCAL_NAME); |
| // |
| // //loop through the namespace declarations first |
| // String[] nameSpaceDeclarationArray = (String[]) namespacePrefixMap |
| // .keySet().toArray(new String[namespacePrefixMap.size()]); |
| // for (int i = 0; i < nameSpaceDeclarationArray.length; i++) { |
| // String s = nameSpaceDeclarationArray[i]; |
| // schemaElement.setAttributeNS("http://www.w3.org/2000/xmlns/", |
| // "xmlns:" + namespacePrefixMap.get(s).toString(), s); |
| // |
| // } |
| // |
| // //add the targetNamespace |
| // |
| // schemaElement.setAttributeNS("http://www.w3.org/2000/xmlns/", |
| // XMLNS_AXIS2WRAPPED, targetNamespaceUri); |
| // schemaElement.setAttribute(XSD_TARGETNAMESPACE, targetNamespaceUri); |
| // schemaElement.setAttribute(XSD_ELEMENT_FORM_DEFAULT, |
| // XSD_UNQUALIFIED); |
| // |
| // Element[] namespaceImports = (Element[]) namespaceImportsMap.values() |
| // .toArray(new Element[namespaceImportsMap.size()]); |
| // for (int i = 0; i < namespaceImports.length; i++) { |
| // schemaElement.appendChild(namespaceImports[i]); |
| // |
| // } |
| // |
| // Element[] complexTypeElements = (Element[]) complexTypeElementsMap |
| // .values().toArray(new Element[complexTypeElementsMap.size()]); |
| // for (int i = 0; i < complexTypeElements.length; i++) { |
| // schemaElement.appendChild(complexTypeElements[i]); |
| // |
| // } |
| // |
| // Element[] elementDeclarations = (Element[]) elementElementsList |
| // .toArray(new Element[elementElementsList.size()]); |
| // for (int i = 0; i < elementDeclarations.length; i++) { |
| // schemaElement.appendChild(elementDeclarations[i]); |
| // |
| // } |
| |
| // return schemaElement; |
| |
| return null; |
| } |
| |
| private boolean findWrapForceable(BindingElement binding) { |
| boolean retVal = false; |
| if (RPC.equalsIgnoreCase(binding.getInterfaceElement() |
| .getStyleDefault().toString())) { |
| return true; |
| } |
| if (!retVal) { |
| InterfaceOperationElement[] operations = binding |
| .getInterfaceElement().getInterfaceOperationElements(); |
| for (int i = 0; i < operations.length; i++) { |
| URI[] styles = operations[i].getStyle(); |
| for (int j = 0; j < styles.length; j++) { |
| if (RPC.equalsIgnoreCase(styles[j].toString())) { |
| return true; |
| } |
| |
| } |
| } |
| } |
| return false; |
| } |
| |
| private DescriptionElement readInTheWSDLFile(String wsdlURI) |
| throws WSDLException { |
| |
| WSDLReader reader = WSDLFactory.newInstance().newWSDLReader(); |
| |
| // TODO : I can not find a constant for this feature in WSDLReader |
| // reader.setFeature("javax.wsdl.importDocuments", false); |
| |
| // reader.setFeature(WSDLReader.FEATURE_VERBOSE, false); |
| return reader.readWSDL(wsdlURI); |
| } |
| |
| } |
