| /******************************************************************************* |
| * Copyright (c) 2000, 2007 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Common Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.wst.wsdl.binding.soap.internal.generator; |
| |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.emf.common.util.BasicEList; |
| import org.eclipse.wst.wsdl.Binding; |
| import org.eclipse.wst.wsdl.BindingFault; |
| import org.eclipse.wst.wsdl.BindingInput; |
| import org.eclipse.wst.wsdl.BindingOperation; |
| import org.eclipse.wst.wsdl.BindingOutput; |
| import org.eclipse.wst.wsdl.ExtensibilityElement; |
| import org.eclipse.wst.wsdl.Fault; |
| import org.eclipse.wst.wsdl.Input; |
| import org.eclipse.wst.wsdl.Operation; |
| import org.eclipse.wst.wsdl.Output; |
| import org.eclipse.wst.wsdl.Port; |
| import org.eclipse.wst.wsdl.PortType; |
| import org.eclipse.wst.wsdl.WSDLElement; |
| import org.eclipse.wst.wsdl.binding.soap.SOAPAddress; |
| import org.eclipse.wst.wsdl.binding.soap.SOAPBinding; |
| import org.eclipse.wst.wsdl.binding.soap.SOAPBody; |
| import org.eclipse.wst.wsdl.binding.soap.SOAPFactory; |
| import org.eclipse.wst.wsdl.binding.soap.SOAPFault; |
| import org.eclipse.wst.wsdl.binding.soap.SOAPOperation; |
| import org.eclipse.wst.wsdl.internal.generator.ContentGenerator; |
| |
| |
| public class SOAPContentGenerator implements ContentGenerator |
| { |
| public static final int OPTION_NOT_SET = -1; |
| |
| public static final int STYLE_DOCUMENT = 1; |
| |
| public static final int STYLE_RPC = 2; |
| |
| public static final int USE_LITERAL = 1; |
| |
| public static final int USE_ENCODED = 2; |
| |
| private int styleOption = OPTION_NOT_SET; |
| |
| private int useOption = OPTION_NOT_SET; |
| |
| protected String namespaceValue = ""; |
| |
| protected String addressLocation = ContentGenerator.ADDRESS_LOCATION; |
| |
| protected final static String[] requiredNamespaces = { "http://schemas.xmlsoap.org/wsdl/soap/" }; |
| |
| protected final static String[] preferredNamespacePrefixes = { "soap" }; |
| |
| public String[] getRequiredNamespaces() |
| { |
| return requiredNamespaces; |
| } |
| |
| public String getPreferredNamespacePrefix(String namespace) |
| { |
| if (namespace.equals("http://schemas.xmlsoap.org/wsdl/soap/")) |
| { |
| return "soap"; |
| } |
| |
| return ""; |
| } |
| |
| public void setStyle(int style) |
| { |
| styleOption = style; |
| } |
| |
| public void setUse(int use) |
| { |
| useOption = use; |
| } |
| |
| public void setAddressLocation(String addressLocation) |
| { |
| this.addressLocation = addressLocation; |
| } |
| |
| public void generatePortContent(Port port) |
| { |
| // We blow away any existing ExtensibilityElements/content before we generate it |
| // Is it worth being smarter? Look for matching content first and create those which aren't found???? |
| List removeList = new ArrayList(port.getEExtensibilityElements()); |
| removeExtensebilityElements(port.getEExtensibilityElements(), removeList); |
| |
| SOAPAddress soapAddress = SOAPFactory.eINSTANCE.createSOAPAddress(); |
| soapAddress.setLocationURI(addressLocation); |
| port.addExtensibilityElement(soapAddress); |
| } |
| |
| public void generateBindingContent(Binding binding, PortType portType) |
| { |
| // We blow away any existing ExtensibilityElements/content before we generate it |
| // Is it worth being smarter? Look for matching content first and create those which aren't found???? |
| List removeList = new ArrayList(binding.getEExtensibilityElements()); |
| removeExtensebilityElements(binding.getEExtensibilityElements(), removeList); |
| |
| SOAPFactory soapFactory = SOAPFactory.eINSTANCE; |
| SOAPBinding soapBinding = soapFactory.createSOAPBinding(); |
| soapBinding.setStyle((getStyleOption(binding) == STYLE_DOCUMENT) ? "document" : "rpc"); |
| soapBinding.setTransportURI("http://schemas.xmlsoap.org/soap/http"); |
| |
| binding.addExtensibilityElement(soapBinding); |
| } |
| |
| public void generateBindingOperationContent(BindingOperation bindingOperation, Operation operation) |
| { |
| // We blow away any existing ExtensibilityElements/content before we generate it |
| // Is it worth being smarter? Look for matching content first and create those which aren't found???? |
| List removeList = new ArrayList(bindingOperation.getEExtensibilityElements()); |
| removeExtensebilityElements(bindingOperation.getEExtensibilityElements(), removeList); |
| |
| SOAPOperation soapOperation = SOAPFactory.eINSTANCE.createSOAPOperation(); |
| |
| String soapActionValue = getNamespace(bindingOperation); |
| if (!soapActionValue.endsWith("/")) |
| { |
| soapActionValue += "/"; |
| } |
| soapActionValue += operation.getName(); |
| |
| soapOperation.setSoapActionURI(soapActionValue); |
| |
| bindingOperation.addExtensibilityElement(soapOperation); |
| } |
| |
| public void generateBindingInputContent(BindingInput bindingInput, Input input) |
| { |
| // We blow away any existing ExtensibilityElements/content before we generate it |
| // Is it worth being smarter? Look for matching content first and create those which aren't found???? |
| List removeList = new ArrayList(bindingInput.getEExtensibilityElements()); |
| removeExtensebilityElements(bindingInput.getEExtensibilityElements(), removeList); |
| |
| SOAPFactory soapFactory = SOAPFactory.eINSTANCE; |
| SOAPBody soapBody = soapFactory.createSOAPBody(); |
| soapBody.setUse((getUseOption(null) == USE_ENCODED) ? "encoded" : "literal"); |
| if (getUseOption(bindingInput) == USE_ENCODED && getStyleOption(bindingInput) == STYLE_RPC) |
| { |
| List encodingList = new BasicEList(); |
| encodingList.add("http://schemas.xmlsoap.org/soap/encoding/"); |
| soapBody.setEncodingStyles(encodingList); |
| soapBody.setNamespaceURI(getNamespace(bindingInput)); |
| } |
| else if (getUseOption(bindingInput) == USE_LITERAL && getStyleOption(bindingInput) == STYLE_RPC) |
| { |
| soapBody.setNamespaceURI(getNamespace(bindingInput)); |
| } |
| |
| bindingInput.addExtensibilityElement(soapBody); |
| } |
| |
| public void generateBindingOutputContent(BindingOutput bindingOutput, Output output) |
| { |
| // We blow away any existing ExtensibilityElements/content before we generate it |
| // Is it worth being smarter? Look for matching content first and create those which aren't found???? |
| List removeList = new ArrayList(bindingOutput.getEExtensibilityElements()); |
| removeExtensebilityElements(bindingOutput.getEExtensibilityElements(), removeList); |
| |
| SOAPFactory soapFactory = SOAPFactory.eINSTANCE; |
| SOAPBody soapBody = soapFactory.createSOAPBody(); |
| soapBody.setUse((getUseOption(bindingOutput) == USE_ENCODED) ? "encoded" : "literal"); |
| if (getUseOption(bindingOutput) == USE_ENCODED && getStyleOption(bindingOutput) == STYLE_RPC) |
| { |
| List encodingList = new BasicEList(); |
| encodingList.add("http://schemas.xmlsoap.org/soap/encoding/"); |
| soapBody.setEncodingStyles(encodingList); |
| soapBody.setNamespaceURI(getNamespace(bindingOutput)); |
| } |
| else if (getUseOption(bindingOutput) == USE_LITERAL && getStyleOption(bindingOutput) == STYLE_RPC) |
| { |
| soapBody.setNamespaceURI(getNamespace(bindingOutput)); |
| } |
| |
| bindingOutput.addExtensibilityElement(soapBody); |
| } |
| |
| public void generateBindingFaultContent(BindingFault bindingFault, Fault fault) |
| { |
| // We blow away any existing ExtensibilityElements/content before we generate it |
| // Is it worth being smarter? Look for matching content first and create those which aren't found???? |
| List removeList = new ArrayList(bindingFault.getEExtensibilityElements()); |
| removeExtensebilityElements(bindingFault.getEExtensibilityElements(), removeList); |
| |
| SOAPFactory soapFactory = SOAPFactory.eINSTANCE; |
| SOAPFault soapFault = soapFactory.createSOAPFault(); |
| soapFault.setUse((getUseOption(bindingFault) == USE_ENCODED) ? "encoded" : "literal"); |
| soapFault.setName(fault.getName()); |
| // soapFault.setNamespaceURI(getNamespace(bindingFault)); |
| |
| if (getUseOption(bindingFault) == USE_ENCODED && getStyleOption(bindingFault) == STYLE_RPC) |
| { |
| List encodingList = new BasicEList(); |
| encodingList.add("http://schemas.xmlsoap.org/soap/encoding/"); |
| soapFault.setEncodingStyles(encodingList); |
| } |
| |
| bindingFault.addExtensibilityElement(soapFault); |
| } |
| |
| private String getNamespace(WSDLElement wsdlElement) |
| { |
| if (namespaceValue.equals("") && wsdlElement != null) |
| { |
| namespaceValue = wsdlElement.getEnclosingDefinition().getTargetNamespace(); |
| } |
| if (namespaceValue == null) |
| { |
| namespaceValue = ""; |
| } |
| |
| return namespaceValue; |
| } |
| |
| private void removeExtensebilityElements(List originalList, List removeList) |
| { |
| Iterator removeIt = removeList.iterator(); |
| while (removeIt.hasNext()) |
| { |
| originalList.remove(removeIt.next()); |
| } |
| } |
| |
| private Binding getBindingObject(Object genericBindingObject) |
| { |
| Object parent = genericBindingObject; |
| |
| int index = 0; |
| while (parent != null && index < 5) |
| { |
| parent = getGenericBindingObjectParent(parent); |
| if (parent instanceof Binding) |
| { |
| break; |
| } |
| index++; |
| } |
| |
| return (parent instanceof Binding) ? (Binding)parent : null; |
| } |
| |
| private Object getGenericBindingObjectParent(Object genericBindingObject) |
| { |
| Object parent = null; |
| |
| if (genericBindingObject != null) |
| { |
| if (genericBindingObject instanceof BindingOperation) |
| { |
| parent = ((BindingOperation)genericBindingObject).getContainer(); |
| } |
| else if (genericBindingObject instanceof BindingInput) |
| { |
| parent = ((BindingInput)genericBindingObject).getContainer(); |
| } |
| else if (genericBindingObject instanceof BindingOutput) |
| { |
| parent = ((BindingOutput)genericBindingObject).getContainer(); |
| } |
| else if (genericBindingObject instanceof BindingFault) |
| { |
| parent = ((BindingFault)genericBindingObject).getContainer(); |
| } |
| } |
| |
| return parent; |
| } |
| |
| private int getStyleOption(Object genericBindingObject) |
| { |
| if (styleOption == OPTION_NOT_SET && genericBindingObject != null) |
| { |
| // init() was never called, try to determine the 'style' based on what we have/know |
| Binding binding = getBindingObject(genericBindingObject); |
| |
| // Try to determine the style from the Binding Object |
| if (binding != null) |
| { |
| List list = binding.getEExtensibilityElements(); |
| Iterator valuesIt = getExtensibilityElementAttributeValue(list, "style").iterator(); |
| |
| while (valuesIt.hasNext()) |
| { |
| String style = (String)valuesIt.next(); |
| |
| if (style.equals("document")) |
| { |
| styleOption = STYLE_DOCUMENT; |
| } |
| else if (style.equals("rpc")) |
| { |
| styleOption = STYLE_RPC; |
| } |
| |
| if (styleOption != OPTION_NOT_SET) |
| { |
| break; |
| } |
| } |
| } |
| } |
| |
| if (styleOption == OPTION_NOT_SET) |
| { |
| styleOption = STYLE_DOCUMENT; |
| } |
| |
| return styleOption; |
| } |
| |
| private int getUseOption(Object genericBindingObject) |
| { |
| if (useOption == OPTION_NOT_SET) |
| { |
| // init() was never called, try to determine the 'use' based on what we have/know |
| Iterator messageRefIt = getMessageReferenceBindingObjects(genericBindingObject).iterator(); |
| |
| // Try to determine the use from the list of BindingInputs, BindingOutputs, and BindingFaults |
| while (messageRefIt.hasNext()) |
| { |
| Object messageRef = messageRefIt.next(); |
| List values = new ArrayList(); |
| |
| if (messageRef instanceof BindingInput) |
| { |
| List list = ((BindingInput)messageRef).getEExtensibilityElements(); |
| values = getExtensibilityElementAttributeValue(list, "use"); |
| } |
| else if (messageRef instanceof BindingOutput) |
| { |
| List list = ((BindingOutput)messageRef).getEExtensibilityElements(); |
| values = getExtensibilityElementAttributeValue(list, "use"); |
| } |
| else if (messageRef instanceof BindingFault) |
| { |
| List list = ((BindingFault)messageRef).getEExtensibilityElements(); |
| values = getExtensibilityElementAttributeValue(list, "use"); |
| } |
| |
| Iterator valuesIt = values.iterator(); |
| while (valuesIt.hasNext()) |
| { |
| String use = (String)valuesIt.next(); |
| |
| if (use.equals("literal")) |
| { |
| useOption = USE_LITERAL; |
| } |
| else if (use.equals("encoded")) |
| { |
| useOption = USE_ENCODED; |
| } |
| } |
| |
| if (useOption != OPTION_NOT_SET) |
| { |
| break; |
| } |
| } |
| } |
| |
| if (useOption == OPTION_NOT_SET) |
| { |
| useOption = USE_LITERAL; |
| } |
| |
| return useOption; |
| } |
| |
| private List getMessageReferenceBindingObjects(Object genericBindingObject) |
| { |
| List list = new ArrayList(); |
| Binding binding = getBindingObject(genericBindingObject); |
| |
| if (binding != null) |
| { |
| Iterator operationsIt = binding.getEBindingOperations().iterator(); |
| |
| while (operationsIt.hasNext()) |
| { |
| BindingOperation op = (BindingOperation)operationsIt.next(); |
| list.add(op.getEBindingInput()); |
| list.add(op.getEBindingOutput()); |
| list.addAll(op.getEBindingFaults()); |
| } |
| } |
| |
| return list; |
| } |
| |
| private List getExtensibilityElementAttributeValue(List eeList, String attributeKey) |
| { |
| List values = new ArrayList(); |
| Iterator eeElementsIt = eeList.iterator(); |
| |
| while (eeElementsIt.hasNext()) |
| { |
| ExtensibilityElement eeElement = (ExtensibilityElement)eeElementsIt.next(); |
| String attributeValue = eeElement.getElement().getAttribute(attributeKey); |
| if (attributeValue != null && !attributeValue.equals("")) |
| { |
| values.add(attributeValue); |
| } |
| } |
| |
| return values; |
| } |
| |
| public String getProtocol() |
| { |
| return "SOAP"; |
| } |
| } |