| /******************************************************************************* |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse 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.bpel.model.resource; |
| |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.io.StringWriter; |
| import java.lang.reflect.Method; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import javax.wsdl.WSDLException; |
| import javax.wsdl.extensions.ExtensibilityElement; |
| import javax.xml.namespace.QName; |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| |
| import org.apache.xerces.util.DOMUtil; |
| import org.apache.xml.serialize.OutputFormat; |
| import org.apache.xml.serialize.XMLSerializer; |
| import org.eclipse.bpel.model.Activity; |
| import org.eclipse.bpel.model.Assign; |
| import org.eclipse.bpel.model.BPELExtensibleElement; |
| import org.eclipse.bpel.model.BPELFactory; |
| import org.eclipse.bpel.model.BPELPackage; |
| import org.eclipse.bpel.model.Branches; |
| import org.eclipse.bpel.model.Catch; |
| import org.eclipse.bpel.model.CatchAll; |
| import org.eclipse.bpel.model.Compensate; |
| import org.eclipse.bpel.model.CompensateScope; |
| import org.eclipse.bpel.model.CompensationHandler; |
| import org.eclipse.bpel.model.CompletionCondition; |
| import org.eclipse.bpel.model.Condition; |
| import org.eclipse.bpel.model.Copy; |
| import org.eclipse.bpel.model.Correlation; |
| import org.eclipse.bpel.model.CorrelationSet; |
| import org.eclipse.bpel.model.CorrelationSets; |
| import org.eclipse.bpel.model.Correlations; |
| import org.eclipse.bpel.model.Documentation; |
| import org.eclipse.bpel.model.Else; |
| import org.eclipse.bpel.model.ElseIf; |
| import org.eclipse.bpel.model.Empty; |
| import org.eclipse.bpel.model.EventHandler; |
| import org.eclipse.bpel.model.Exit; |
| import org.eclipse.bpel.model.Expression; |
| import org.eclipse.bpel.model.Extension; |
| import org.eclipse.bpel.model.ExtensionActivity; |
| import org.eclipse.bpel.model.Extensions; |
| import org.eclipse.bpel.model.FaultHandler; |
| import org.eclipse.bpel.model.Flow; |
| import org.eclipse.bpel.model.ForEach; |
| import org.eclipse.bpel.model.From; |
| import org.eclipse.bpel.model.FromPart; |
| import org.eclipse.bpel.model.FromParts; |
| import org.eclipse.bpel.model.If; |
| import org.eclipse.bpel.model.Import; |
| import org.eclipse.bpel.model.Invoke; |
| import org.eclipse.bpel.model.Link; |
| import org.eclipse.bpel.model.Links; |
| import org.eclipse.bpel.model.MessageExchange; |
| import org.eclipse.bpel.model.MessageExchanges; |
| import org.eclipse.bpel.model.OnAlarm; |
| import org.eclipse.bpel.model.OnEvent; |
| import org.eclipse.bpel.model.OnMessage; |
| import org.eclipse.bpel.model.OpaqueActivity; |
| import org.eclipse.bpel.model.PartnerLink; |
| import org.eclipse.bpel.model.PartnerLinks; |
| import org.eclipse.bpel.model.Pick; |
| import org.eclipse.bpel.model.Process; |
| import org.eclipse.bpel.model.Query; |
| import org.eclipse.bpel.model.Receive; |
| import org.eclipse.bpel.model.RepeatUntil; |
| import org.eclipse.bpel.model.Reply; |
| import org.eclipse.bpel.model.Rethrow; |
| import org.eclipse.bpel.model.Scope; |
| import org.eclipse.bpel.model.Sequence; |
| import org.eclipse.bpel.model.ServiceRef; |
| import org.eclipse.bpel.model.Source; |
| import org.eclipse.bpel.model.Sources; |
| import org.eclipse.bpel.model.Target; |
| import org.eclipse.bpel.model.Targets; |
| import org.eclipse.bpel.model.TerminationHandler; |
| import org.eclipse.bpel.model.Throw; |
| import org.eclipse.bpel.model.To; |
| import org.eclipse.bpel.model.ToPart; |
| import org.eclipse.bpel.model.ToParts; |
| import org.eclipse.bpel.model.Validate; |
| import org.eclipse.bpel.model.Variable; |
| import org.eclipse.bpel.model.Variables; |
| import org.eclipse.bpel.model.Wait; |
| import org.eclipse.bpel.model.While; |
| import org.eclipse.bpel.model.adapters.INamespaceMap; |
| import org.eclipse.bpel.model.extensions.BPELActivitySerializer; |
| import org.eclipse.bpel.model.extensions.BPELExtensionRegistry; |
| import org.eclipse.bpel.model.extensions.BPELExtensionSerializer; |
| import org.eclipse.bpel.model.extensions.ServiceReferenceSerializer; |
| import org.eclipse.bpel.model.messageproperties.Property; |
| import org.eclipse.bpel.model.partnerlinktype.PartnerLinkType; |
| import org.eclipse.bpel.model.partnerlinktype.Role; |
| import org.eclipse.bpel.model.proxy.IBPELServicesProxy; |
| import org.eclipse.bpel.model.reordering.IExtensibilityElementListHandler; |
| import org.eclipse.bpel.model.reordering.extensions.ExtensionFactory; |
| import org.eclipse.bpel.model.util.BPELConstants; |
| import org.eclipse.bpel.model.util.BPELServicesUtility; |
| import org.eclipse.bpel.model.util.BPELUtils; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.common.util.WrappedException; |
| import org.eclipse.emf.ecore.EAttribute; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.wst.wsdl.Definition; |
| import org.eclipse.wst.wsdl.Message; |
| import org.eclipse.wst.wsdl.Operation; |
| import org.eclipse.wst.wsdl.util.WSDLConstants; |
| import org.eclipse.wst.wsdl.util.WSDLResourceImpl; |
| import org.eclipse.xsd.XSDElementDeclaration; |
| import org.eclipse.xsd.XSDNamedComponent; |
| import org.eclipse.xsd.XSDTypeDefinition; |
| import org.eclipse.xsd.util.XSDConstants; |
| import org.eclipse.xsd.util.XSDResourceImpl; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.CDATASection; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.DocumentFragment; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.Text; |
| |
| /** |
| * BPELWriter is responsible for serializing the BPEL EMF model to an output stream. |
| */ |
| @SuppressWarnings("nls") |
| public class BPELWriter { |
| |
| /** |
| * Prevents the BPEL writer from searching and adding automatically import declarations. |
| * <p> |
| * This option was added because the BPEL writer performs some actions that are |
| * not natural with a pure EMF approach. Using this option in the EMF serialization |
| * allows to by-pass these actions for the automatic resolution of imports. |
| * </p> |
| */ |
| public static final String SKIP_AUTO_IMPORT = "bpel.skip.auto.import"; |
| |
| static final String EMPTY_STRING = ""; //$NON-NLS-1$ |
| |
| private Document document = null; |
| private BPELResource fBPELResource = null; |
| private WsdlImportsManager wsdlNamespacePrefixManager; |
| // private NamespacePrefixManager bpelNamespacePrefixManager; |
| private List<IExtensibilityElementListHandler> extensibilityElementListHandlers = null; |
| protected BPELPackage bpelPackage = null; |
| |
| private final BPELExtensionRegistry extensionRegistry = BPELExtensionRegistry |
| .getInstance(); |
| |
| /** |
| * WsdlImportsManager is responsible for ensuring that, for a given |
| * namespace and resource uri, an import exists in the bpel file. |
| */ |
| class WsdlImportsManager { |
| |
| Process fProcessContext; |
| |
| // Map of resource URIs to namespaces |
| private final Map<String, String> fResourceNamespaceMap; |
| |
| /** |
| * @param context |
| */ |
| WsdlImportsManager(Process process) { |
| |
| this.fProcessContext = process; |
| |
| this.fResourceNamespaceMap = new HashMap<String, String>(); |
| |
| // For each existing import in the process, add it to the namespace |
| // map. |
| for (Object next : this.fProcessContext.getImports()) { |
| Import imp = (org.eclipse.bpel.model.Import) next; |
| if (imp.getLocation() == null) { |
| System.err.println("Import location is unexpectedly null: " |
| + imp); |
| } else { |
| URI locationURI = URI.createURI(imp.getLocation()); |
| String importPath = locationURI.resolve( |
| getResource().getURI()).toString(); |
| |
| this.fResourceNamespaceMap.put(importPath, imp.getNamespace()); |
| } |
| } |
| } |
| |
| /** |
| * Ensure that there exists an import mapping the given namespace to the |
| * given resource. If the import doesn't exist in our map, add it to the |
| * map and create a new Import in the process. |
| * |
| * @param resource |
| * @param namespace |
| */ |
| |
| void ensureImported(Resource resource, String namespace) { |
| |
| // For service references. If the declaration comes from the |
| // bpel xsd, bail out. |
| if (BPELConstants.NAMESPACE.equals(namespace)) { |
| return; |
| } |
| |
| String key = resource.getURI().toString(); |
| |
| if (this.fResourceNamespaceMap.containsKey(key)) { |
| return; |
| } |
| // second check to ensure the calculated path is not empty |
| String locationURI = getRelativeLocation(resource.getURI()); |
| if (locationURI != null && locationURI.length() != 0) { |
| |
| // Create and add the import to the process |
| org.eclipse.bpel.model.Import _import = BPELFactory.eINSTANCE |
| .createImport(); |
| |
| _import.setNamespace(namespace); |
| _import.setLocation(locationURI); |
| |
| if (resource instanceof WSDLResourceImpl) { |
| _import.setImportType(WSDLConstants.WSDL_NAMESPACE_URI); |
| } else if (resource instanceof XSDResourceImpl) { |
| _import |
| .setImportType(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001); |
| } |
| |
| this.fProcessContext.getImports().add(_import); |
| |
| // Add it to our namespace map for easy reference |
| this.fResourceNamespaceMap.put(key, namespace); |
| } |
| } |
| |
| /** |
| * Helper method. Return the relative location of the given file uri, |
| * relative to the location of the BPEL file. |
| */ |
| String getRelativeLocation(URI importedFileUri) { |
| URI relativeURI = importedFileUri.deresolve(getResourceURI(), true, |
| true, false); |
| return relativeURI.toString(); |
| } |
| |
| URI getResourceURI() { |
| return getResource().getURI(); |
| } |
| } |
| |
| public BPELWriter() { |
| } |
| |
| public BPELWriter(BPELResource resource, Document document) { |
| this(); |
| this.fBPELResource = resource; |
| this.document = document; |
| // bpelNamespacePrefixManager = new NamespacePrefixManager(resource); |
| } |
| |
| /** |
| * Return the resource used in this writer. |
| * |
| * @return the resource used in this writer. |
| */ |
| |
| public BPELResource getResource() { |
| return this.fBPELResource; |
| } |
| |
| /** |
| * Convert the BPEL model to an XML DOM model and then write the DOM model |
| * to the output stream. |
| * |
| * @see org.eclipse.emf.ecore.resource.impl.ResourceImpl#doSave(OutputStream, |
| * Map) |
| */ |
| public void write(BPELResource resource, OutputStream out, Map<?, ?> args) |
| throws IOException { |
| |
| try { |
| // Create a DOM document. |
| |
| final DocumentBuilderFactory documentBuilderFactory = |
| // DocumentBuilderFactory.newInstance(); |
| // new org.apache.crimson.jaxp.DocumentBuilderFactoryImpl(); |
| new org.apache.xerces.jaxp.DocumentBuilderFactoryImpl(); |
| |
| documentBuilderFactory.setNamespaceAware(true); |
| documentBuilderFactory.setValidating(false); |
| DocumentBuilder builder = documentBuilderFactory |
| .newDocumentBuilder(); |
| this.document = builder.newDocument(); |
| |
| // Transform the EMF model to the DOM document. |
| |
| this.bpelPackage = BPELPackage.eINSTANCE; |
| |
| this.fBPELResource = resource; |
| |
| Process process = resource.getProcess(); |
| |
| // bpelNamespacePrefixManager = new NamespacePrefixManager( resource |
| // ); |
| this.wsdlNamespacePrefixManager = new WsdlImportsManager(process); |
| |
| // VZ: do not force auto imports |
| Boolean skipAutoImport = (Boolean) args.get( SKIP_AUTO_IMPORT ); |
| if( skipAutoImport == null || ! skipAutoImport ) |
| walkExternalReferences(); |
| // VZ |
| |
| this.document = resource2XML(resource); |
| |
| // Transform the DOM document to its serialized form. |
| |
| OutputFormat fmt = new OutputFormat(this.document); |
| fmt.setIndenting(true); |
| fmt.setIndent(4); |
| |
| XMLSerializer serializer = new XMLSerializer(out, fmt); |
| serializer.serialize(this.document); |
| |
| // The code below does not indent, due to bug in JDK 1.5. Read it |
| // here. |
| // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5064280 |
| |
| // |
| // TransformerFactory transformerFactory = |
| // TransformerFactory.newInstance(); |
| // Transformer transformer = transformerFactory.newTransformer(); |
| // |
| // |
| // transformer.setOutputProperty(OutputKeys.INDENT, "yes"); |
| // transformer.setOutputProperty(OutputKeys.METHOD, "xml"); |
| // |
| // // Unless a width is set, there will be only line breaks but no |
| // indentation. |
| // // The IBM JDK and the Sun JDK don't agree on the property name, |
| // // so we set them both. |
| // // |
| // transformer.setOutputProperty("{http://xml.apache.org/xalan}indent-amount", |
| // "2"); |
| // transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", |
| // "2"); |
| // // TODO Do we need to support different encodings? |
| // // if (encoding != null) |
| // // { |
| // // transformer.setOutputProperty(OutputKeys.ENCODING, encoding); |
| // // } |
| // |
| // transformer.transform(new DOMSource(document), new |
| // StreamResult(out)); |
| } catch (Exception ex) { |
| ex.printStackTrace(); |
| } |
| } |
| |
| /** |
| * Convert the BPEL model to an XML DOM model and then write the DOM model |
| * to the output stream. |
| * |
| * @param eObj |
| * @return |
| * |
| * @see org.eclipse.emf.ecore.resource.impl.ResourceImpl#doSave(OutputStream, |
| * Map) |
| */ |
| public String toXML(EObject eObj) { |
| |
| // Create a DOM document. |
| |
| final DocumentBuilderFactory documentBuilderFactory = |
| // DocumentBuilderFactory.newInstance(); |
| // new org.apache.crimson.jaxp.DocumentBuilderFactoryImpl(); |
| new org.apache.xerces.jaxp.DocumentBuilderFactoryImpl(); |
| |
| documentBuilderFactory.setNamespaceAware(true); |
| documentBuilderFactory.setValidating(false); |
| DocumentBuilder builder = null; |
| try { |
| builder = documentBuilderFactory.newDocumentBuilder(); |
| } catch (Exception ex) { |
| return EMPTY_STRING; |
| } |
| this.document = builder.newDocument(); |
| |
| // Transform the EMF model to the DOM document. |
| |
| this.bpelPackage = BPELPackage.eINSTANCE; |
| |
| // bpelNamespacePrefixManager = new NamespacePrefixManager( |
| // getResource() ); |
| if (eObj instanceof Process) { |
| this.wsdlNamespacePrefixManager = new WsdlImportsManager((Process) eObj); |
| } else { |
| this.wsdlNamespacePrefixManager = null; |
| } |
| |
| anyBPELObject2xml(eObj); |
| |
| // Transform the DOM document to its serialized form. |
| |
| OutputFormat fmt = new OutputFormat(this.document); |
| fmt.setIndenting(true); |
| fmt.setIndent(4); |
| fmt.setOmitDocumentType(true); |
| fmt.setOmitXMLDeclaration(true); |
| |
| StringWriter out = new StringWriter(); |
| XMLSerializer serializer = new XMLSerializer(out, fmt); |
| |
| try { |
| serializer.serialize(this.document); |
| } catch (Exception ex) { |
| // |
| } |
| |
| return out.toString(); |
| } |
| |
| protected Document anyBPELObject2xml(EObject eObj) { |
| |
| Element element = anyObject2xml(eObj); |
| this.document.appendChild(element); |
| serializePrefixes(eObj, element); |
| |
| return this.document; |
| } |
| |
| protected Element anyObject2xml(EObject eObj) { |
| |
| String methodName = eObj.eClass().getName(); |
| methodName = Character.toLowerCase(methodName.charAt(0)) |
| + methodName.substring(1) + "2XML"; |
| |
| Method serializeMethod = lookupMethod(getClass(), methodName, |
| EObject.class); |
| |
| if (serializeMethod == null) { |
| throw new IllegalArgumentException("No serialize method " |
| + methodName); |
| } |
| |
| Class<?> paramClazz = serializeMethod.getParameterTypes()[0]; |
| try { |
| return (Element) serializeMethod |
| .invoke(this, paramClazz.cast(eObj)); |
| } catch (Throwable t) { |
| t.printStackTrace(); |
| |
| } |
| throw new IllegalArgumentException("Cannot serialize object " + eObj); |
| } |
| |
| Method lookupMethod(Class<?> target, String methodName, Class<?>... args) { |
| if (target == null || target == Object.class) { |
| return null; |
| } |
| |
| for (Method m : target.getDeclaredMethods()) { |
| if (methodName.equals(m.getName()) == false |
| || m.getParameterTypes().length != args.length) { |
| continue; |
| } |
| Class<?> argTypes[] = m.getParameterTypes(); |
| for (int i = 0; i < args.length; i++) { |
| // This is reversed, on purpose. |
| if (args[i].isAssignableFrom(argTypes[i]) == false) { |
| continue; |
| } |
| } |
| return m; |
| } |
| return lookupMethod(target.getSuperclass(), methodName, args); |
| } |
| |
| protected Document resource2XML(BPELResource resource) { |
| Process process = resource.getProcess(); |
| Element procElement = process2XML(process); |
| this.document.appendChild(procElement); |
| serializePrefixes(process, procElement); |
| return this.document; |
| } |
| |
| protected Element process2XML(Process process) { |
| |
| Element processElement = createBPELElement("process"); |
| if (process.getName() != null) |
| processElement.setAttribute("name", process.getName()); |
| if (process.getTargetNamespace() != null) |
| processElement.setAttribute("targetNamespace", process |
| .getTargetNamespace()); |
| if (process.isSetSuppressJoinFailure()) |
| processElement.setAttribute("suppressJoinFailure", BPELUtils |
| .boolean2XML(process.getSuppressJoinFailure())); |
| if (process.getExitOnStandardFault() != null) |
| processElement.setAttribute("exitOnStandardFault", BPELUtils |
| .boolean2XML(process.getExitOnStandardFault())); |
| if (process.isSetVariableAccessSerializable()) |
| processElement.setAttribute("variableAccessSerializable", BPELUtils |
| .boolean2XML(process.getVariableAccessSerializable())); |
| if (process.isSetQueryLanguage()) |
| processElement.setAttribute("queryLanguage", process |
| .getQueryLanguage()); |
| if (process.isSetExpressionLanguage()) |
| processElement.setAttribute("expressionLanguage", process |
| .getExpressionLanguage()); |
| if (process.isSetAbstractProcessProfile()) |
| processElement.setAttribute("abstractProcessProfile", process |
| .getAbstractProcessProfile()); |
| |
| |
| for (Object next : process.getImports()) { |
| processElement |
| .appendChild(import2XML((org.eclipse.bpel.model.Import) next)); |
| } |
| |
| if (process.getPartnerLinks() != null |
| && !process.getPartnerLinks().getChildren().isEmpty()) |
| processElement.appendChild(partnerLinks2XML(process |
| .getPartnerLinks())); |
| |
| if (process.getVariables() != null |
| && !process.getVariables().getChildren().isEmpty()) |
| processElement.appendChild(variables2XML(process.getVariables())); |
| |
| if (process.getCorrelationSets() != null |
| && !process.getCorrelationSets().getChildren().isEmpty()) |
| processElement.appendChild(correlationSets2XML(process |
| .getCorrelationSets())); |
| |
| if (process.getExtensions() != null) |
| processElement.appendChild(extensions2XML(process.getExtensions())); |
| |
| if (process.getFaultHandlers() != null) |
| processElement.appendChild(faultHandlers2XML(process |
| .getFaultHandlers())); |
| |
| if (process.getEventHandlers() != null) |
| processElement.appendChild(eventHandler2XML(process |
| .getEventHandlers())); |
| |
| if (process.getMessageExchanges() != null |
| && !process.getMessageExchanges().getChildren().isEmpty()) |
| processElement.appendChild(messageExchanges2XML(process |
| .getMessageExchanges())); |
| |
| if (process.getActivity() != null) |
| processElement.appendChild(activity2XML(process.getActivity())); |
| |
| extensibleElement2XML(process, processElement); |
| |
| return processElement; |
| } |
| |
| protected void walkExternalReferences() { |
| Map<?, ?> crossReferences = EcoreUtil.ExternalCrossReferencer |
| .find(getResource()); |
| |
| for (Object name : crossReferences.keySet()) { |
| EObject externalObject = (EObject) name; |
| String namespace = getNamespace(externalObject); |
| if (XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001.equals(namespace)) { |
| addNewRootPrefix("xsd", namespace); |
| } else if (namespace != null && externalObject.eResource() != null) { |
| this.wsdlNamespacePrefixManager.ensureImported(externalObject |
| .eResource(), namespace); |
| } |
| } |
| } |
| |
| protected QName getQName(EObject object) { |
| QName qname = null; |
| |
| if (object.eIsProxy() && object instanceof IBPELServicesProxy) { |
| qname = ((IBPELServicesProxy) object).getQName(); |
| } else if (object instanceof PartnerLinkType) { |
| qname = BPELServicesUtility.getQName((PartnerLinkType) object); |
| } else if (object instanceof Property) { |
| qname = BPELServicesUtility.getQName((Property) object); |
| } |
| |
| return qname; |
| } |
| |
| protected String getNamespace(EObject object) { |
| String namespace = null; |
| if (object instanceof IBPELServicesProxy) { |
| return ((IBPELServicesProxy) object).getQName().getNamespaceURI(); |
| } else if (object instanceof PartnerLinkType |
| || object instanceof Property) { |
| Definition def = ((org.eclipse.wst.wsdl.ExtensibilityElement) object) |
| .getEnclosingDefinition(); |
| if (def != null) { |
| namespace = def.getTargetNamespace(); |
| } |
| } else if (object instanceof XSDNamedComponent) { |
| return ((XSDNamedComponent) object).getTargetNamespace(); |
| } else { |
| for (Iterator<?> featureIt = object.eClass().getEAllAttributes() |
| .iterator(); featureIt.hasNext() && namespace == null;) { |
| EAttribute attr = (EAttribute) featureIt.next(); |
| if (attr.getName().equals("qName")) { |
| QName qName = (QName) object.eGet(attr); |
| if (qName != null) |
| namespace = qName.getNamespaceURI(); |
| } |
| } |
| } |
| return namespace; |
| } |
| |
| protected String getOperationSignature(Operation op) { |
| String signature = ""; |
| if (op != null) { |
| signature = op.getName(); |
| } |
| return signature; |
| } |
| |
| protected Element import2XML(org.eclipse.bpel.model.Import imp) { |
| Element importElement = createBPELElement("import"); |
| if (imp.getNamespace() != null) { |
| importElement.setAttribute("namespace", imp.getNamespace()); |
| } |
| if (imp.getLocation() != null) { |
| importElement.setAttribute("location", imp.getLocation()); |
| } |
| if (imp.getImportType() != null) { |
| importElement.setAttribute("importType", imp.getImportType()); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(imp, importElement); |
| |
| return importElement; |
| } |
| |
| protected Element partnerLinks2XML(PartnerLinks partnerLinks) { |
| // If there are no partner links then skip creating Element |
| if (partnerLinks.getChildren().isEmpty()) |
| return null; |
| |
| Element partnerLinksElement = createBPELElement("partnerLinks"); |
| |
| for (Object next : partnerLinks.getChildren()) { |
| partnerLinksElement |
| .appendChild(partnerLink2XML((PartnerLink) next)); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(partnerLinks, partnerLinksElement); |
| extensibleElement2XML(partnerLinks, partnerLinksElement); |
| |
| return partnerLinksElement; |
| } |
| |
| protected Element partnerLink2XML(PartnerLink partnerLink) { |
| Element partnerLinkElement = createBPELElement("partnerLink"); |
| if (partnerLink.getName() != null) { |
| partnerLinkElement.setAttribute("name", partnerLink.getName()); |
| } |
| |
| if (partnerLink.isSetInitializePartnerRole()) |
| partnerLinkElement.setAttribute("initializePartnerRole", BPELUtils |
| .boolean2XML(partnerLink.getInitializePartnerRole())); |
| |
| PartnerLinkType plt = partnerLink.getPartnerLinkType(); |
| if (plt != null) { |
| String qnameStr = qNameToString(partnerLink, getQName(plt)); |
| partnerLinkElement.setAttribute("partnerLinkType", qnameStr); |
| Role myRole = partnerLink.getMyRole(); |
| if (myRole != null) { |
| partnerLinkElement.setAttribute("myRole", myRole.getName()); |
| } |
| Role partnerRole = partnerLink.getPartnerRole(); |
| if (partnerRole != null) { |
| partnerLinkElement.setAttribute("partnerRole", partnerRole |
| .getName()); |
| } |
| |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(partnerLink, partnerLinkElement); |
| extensibleElement2XML(partnerLink, partnerLinkElement); |
| |
| return partnerLinkElement; |
| } |
| |
| protected Element variables2XML(Variables variables) { |
| // If there are no variables then skip creating Element |
| if (variables.getChildren().isEmpty()) |
| return null; |
| |
| Element variablesElement = createBPELElement("variables"); |
| |
| for (Object next : variables.getChildren()) { |
| Variable variable = (Variable) next; |
| variablesElement.appendChild(variable2XML(variable)); |
| } |
| |
| extensibleElement2XML(variables, variablesElement); |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(variables, variablesElement); |
| extensibleElement2XML(variables, variablesElement); |
| |
| return variablesElement; |
| } |
| |
| protected Element variable2XML(Variable variable) { |
| Element variableElement = createBPELElement("variable"); |
| |
| if (variable.getName() != null) { |
| variableElement.setAttribute("name", variable.getName()); |
| } |
| |
| Message msg = variable.getMessageType(); |
| if (msg != null) { |
| variableElement.setAttribute("messageType", qNameToString(variable, |
| msg.getQName())); |
| } |
| |
| if (variable.getType() != null) { |
| XSDTypeDefinition type = variable.getType(); |
| QName qname = new QName(type.getTargetNamespace(), type.getName()); |
| variableElement |
| .setAttribute("type", qNameToString(variable, qname)); |
| } |
| |
| if (variable.getXSDElement() != null) { |
| XSDElementDeclaration element = variable.getXSDElement(); |
| QName qname = new QName(element.getTargetNamespace(), element |
| .getName()); |
| variableElement.setAttribute("element", qNameToString(variable, |
| qname)); |
| } |
| |
| // from-spec |
| From from = variable.getFrom(); |
| if (from != null) { |
| Element fromElement = createBPELElement("from"); |
| from2XML(from, fromElement); |
| variableElement.appendChild(fromElement); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(variable, variableElement); |
| extensibleElement2XML(variable, variableElement); |
| |
| return variableElement; |
| } |
| |
| protected Element fromPart2XML(FromPart fromPart) { |
| Element fromPartElement = createBPELElement("fromPart"); |
| |
| if (fromPart.getPart() != null) { |
| fromPartElement.setAttribute("part", fromPart.getPart().getName()); |
| } |
| |
| if (fromPart.getToVariable() != null) { |
| fromPartElement.setAttribute("toVariable", fromPart.getToVariable() |
| .getName()); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(fromPart, fromPartElement); |
| |
| return fromPartElement; |
| } |
| |
| protected Element toPart2XML(ToPart toPart) { |
| Element toPartElement = createBPELElement("toPart"); |
| |
| if (toPart.getPart() != null) { |
| toPartElement.setAttribute("part", toPart.getPart().getName()); |
| } |
| |
| if (toPart.getFromVariable() != null) { |
| toPartElement.setAttribute("fromVariable", toPart.getFromVariable() |
| .getName()); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(toPart, toPartElement); |
| |
| return toPartElement; |
| } |
| |
| protected Element extensions2XML(Extensions extensions) { |
| Element extensionsElement = createBPELElement("extensions"); |
| |
| Iterator<?> it = extensions.getChildren().iterator(); |
| while (it.hasNext()) { |
| Extension extension = (Extension) it.next(); |
| extensionsElement.appendChild(extension2XML(extension)); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(extensions, extensionsElement); |
| extensibleElement2XML(extensions, extensionsElement); |
| |
| return extensionsElement; |
| } |
| |
| protected Element extension2XML(Extension extension) { |
| Element extensionElement = createBPELElement("extension"); |
| if (extension.getNamespace() != null) { |
| extensionElement |
| .setAttribute("namespace", extension.getNamespace()); |
| } |
| if (extension.isSetMustUnderstand()) { |
| extensionElement.setAttribute("mustUnderstand", BPELUtils |
| .boolean2XML(extension.getMustUnderstand())); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(extension, extensionElement); |
| extensibleElement2XML(extension, extensionElement); |
| return extensionElement; |
| } |
| |
| protected Element correlationSets2XML(CorrelationSets correlationSets) { |
| // If there are no correlation sets then skip creating Element |
| if (correlationSets.getChildren().isEmpty()) |
| return null; |
| |
| Element correlationSetsElement = createBPELElement("correlationSets"); |
| |
| Iterator<?> it = correlationSets.getChildren().iterator(); |
| while (it.hasNext()) { |
| CorrelationSet correlationSet = (CorrelationSet) it.next(); |
| correlationSetsElement |
| .appendChild(correlationSet2XML(correlationSet)); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(correlationSets, correlationSetsElement); |
| extensibleElement2XML(correlationSets, correlationSetsElement); |
| |
| return correlationSetsElement; |
| } |
| |
| protected Element correlationSet2XML(CorrelationSet correlationSet) { |
| Element correlationSetElement = createBPELElement("correlationSet"); |
| if (correlationSet.getName() != null) { |
| correlationSetElement |
| .setAttribute("name", correlationSet.getName()); |
| } |
| String propertiesList = properties2XML(correlationSet); |
| if (propertiesList.length() > 0) { |
| correlationSetElement.setAttribute("properties", propertiesList); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(correlationSet, correlationSetElement); |
| extensibleElement2XML(correlationSet, correlationSetElement); |
| return correlationSetElement; |
| } |
| |
| protected String properties2XML(CorrelationSet correlationSet) { |
| StringBuffer propertiesList = new StringBuffer(); |
| Iterator<?> properties = correlationSet.getProperties().iterator(); |
| while (properties.hasNext()) { |
| Property property = (Property) properties.next(); |
| String qnameStr = qNameToString(correlationSet, getQName(property)); |
| propertiesList.append(qnameStr); |
| if (properties.hasNext()) |
| propertiesList.append(" "); |
| } |
| return propertiesList.toString(); |
| } |
| |
| protected Element messageExchanges2XML(MessageExchanges messageExchanges) { |
| // If there are no messageExchanges then skip creating Element |
| if (messageExchanges.getChildren().isEmpty()) |
| return null; |
| |
| Element messageExchangesElement = createBPELElement("messageExchanges"); |
| |
| for (Object next : messageExchanges.getChildren()) { |
| messageExchangesElement |
| .appendChild(messageExchange2XML((MessageExchange) next)); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(messageExchanges, messageExchangesElement); |
| extensibleElement2XML(messageExchanges, messageExchangesElement); |
| |
| return messageExchangesElement; |
| } |
| |
| protected Element messageExchange2XML(MessageExchange messageExchange) { |
| Element messageExchangeElement = createBPELElement("messageExchange"); |
| |
| if (messageExchange.getName() != null) |
| messageExchangeElement.setAttribute("name", messageExchange |
| .getName()); |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(messageExchange, messageExchangeElement); |
| extensibleElement2XML(messageExchange, messageExchangeElement); |
| |
| return messageExchangeElement; |
| } |
| |
| protected Element fromParts2XML(FromParts fromParts) { |
| Element fromPartsElement = createBPELElement("fromParts"); |
| |
| for (Object next : fromParts.getChildren()) { |
| FromPart fromPart = (FromPart) next; |
| fromPartsElement.appendChild(fromPart2XML(fromPart)); |
| } |
| |
| extensibleElement2XML(fromParts, fromPartsElement); |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(fromParts, fromPartsElement); |
| extensibleElement2XML(fromParts, fromPartsElement); |
| |
| return fromPartsElement; |
| } |
| |
| protected Element toParts2XML(ToParts toParts) { |
| Element toPartsElement = createBPELElement("toParts"); |
| |
| for (Object next : toParts.getChildren()) { |
| ToPart toPart = (ToPart) next; |
| toPartsElement.appendChild(toPart2XML(toPart)); |
| } |
| |
| extensibleElement2XML(toParts, toPartsElement); |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(toParts, toPartsElement); |
| extensibleElement2XML(toParts, toPartsElement); |
| |
| return toPartsElement; |
| } |
| |
| protected Element correlations2XML(Correlations correlations) { |
| Element correlationsElement = createBPELElement("correlations"); |
| |
| Iterator<?> it = correlations.getChildren().iterator(); |
| while (it.hasNext()) { |
| Correlation correlation = (Correlation) it.next(); |
| correlationsElement.appendChild(correlation2XML(correlation)); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(correlations, correlationsElement); |
| extensibleElement2XML(correlations, correlationsElement); |
| |
| return correlationsElement; |
| } |
| |
| protected Element correlation2XML(Correlation correlation) { |
| Element correlationElement = createBPELElement("correlation"); |
| |
| if (correlation.getSet() != null |
| && correlation.getSet().getName() != null) |
| correlationElement.setAttribute("set", correlation.getSet() |
| .getName()); |
| |
| if (correlation.isSetInitiate()) |
| correlationElement.setAttribute("initiate", correlation |
| .getInitiate()); |
| |
| if (correlation.isSetPattern()) |
| correlationElement.setAttribute("pattern", correlation.getPattern() |
| // Bugzilla 340654 |
| .getLiteral()); |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(correlation, correlationElement); |
| extensibleElement2XML(correlation, correlationElement); |
| |
| return correlationElement; |
| } |
| |
| protected Element faultHandlers2XML(FaultHandler faultHandler) { |
| Element faultHandlersElement = createBPELElement("faultHandlers"); |
| faultHandler2XML(faultHandlersElement, faultHandler); |
| // serialize local namespace prefixes to XML |
| serializePrefixes(faultHandler, faultHandlersElement); |
| extensibleElement2XML(faultHandler, faultHandlersElement); |
| |
| return faultHandlersElement; |
| } |
| |
| protected void faultHandler2XML(Element parentElement, |
| FaultHandler faultHandler) { |
| Iterator<?> catches = faultHandler.getCatch().iterator(); |
| while (catches.hasNext()) { |
| Catch _catch = (Catch) catches.next(); |
| parentElement.appendChild(catch2XML(_catch)); |
| } |
| if (faultHandler.getCatchAll() != null) { |
| parentElement.appendChild(catchAll2XML(faultHandler.getCatchAll())); |
| } |
| } |
| |
| protected Element compensationHandler2XML( |
| CompensationHandler compensationHandler) { |
| Element compensationHandlerElement = createBPELElement("compensationHandler"); |
| |
| if (compensationHandler.getActivity() != null) { |
| Element activityElement = activity2XML(compensationHandler |
| .getActivity()); |
| compensationHandlerElement.appendChild(activityElement); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(compensationHandler, compensationHandlerElement); |
| extensibleElement2XML(compensationHandler, compensationHandlerElement); |
| return compensationHandlerElement; |
| } |
| |
| protected Element terminationHandler2XML( |
| TerminationHandler terminationHandler) { |
| Element terminationHandlerElement = createBPELElement("terminationHandler"); |
| |
| if (terminationHandler.getActivity() != null) { |
| Element activityElement = activity2XML(terminationHandler |
| .getActivity()); |
| terminationHandlerElement.appendChild(activityElement); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(terminationHandler, terminationHandlerElement); |
| extensibleElement2XML(terminationHandler, terminationHandlerElement); |
| return terminationHandlerElement; |
| } |
| |
| protected Element eventHandler2XML(EventHandler eventHandler) { |
| Element eventHandlerElement = createBPELElement("eventHandlers"); |
| |
| // TODO: For backwards compatibility with 1.1 we should serialize |
| // OnMessages here. |
| for (Object name : eventHandler.getEvents()) { |
| OnEvent onEvent = (OnEvent) name; |
| eventHandlerElement.appendChild(onEvent2XML(onEvent)); |
| } |
| for (Object name : eventHandler.getAlarm()) { |
| OnAlarm onAlarm = (OnAlarm) name; |
| eventHandlerElement.appendChild(onAlarm2XML(onAlarm)); |
| } |
| // serialize local namespace prefixes to XML |
| serializePrefixes(eventHandler, eventHandlerElement); |
| extensibleElement2XML(eventHandler, eventHandlerElement); |
| return eventHandlerElement; |
| } |
| |
| public Element activity2XML(Activity activity) { |
| |
| Element activityElement = null; |
| |
| if (activity instanceof Empty) |
| activityElement = empty2XML((Empty) activity); |
| else if (activity instanceof Invoke) |
| activityElement = invoke2XML((Invoke) activity); |
| else if (activity instanceof Assign) |
| activityElement = assign2XML((Assign) activity); |
| else if (activity instanceof Reply) |
| activityElement = reply2XML((Reply) activity); |
| else if (activity instanceof Receive) |
| activityElement = receive2XML((Receive) activity); |
| else if (activity instanceof Wait) |
| activityElement = wait2XML((Wait) activity); |
| else if (activity instanceof Throw) |
| activityElement = throw2XML((Throw) activity); |
| else if (activity instanceof Exit) |
| activityElement = exit2XML((Exit) activity); |
| else if (activity instanceof Flow) |
| activityElement = flow2XML((Flow) activity); |
| else if (activity instanceof If) |
| activityElement = if2XML((If) activity); |
| else if (activity instanceof While) |
| activityElement = while2XML((While) activity); |
| else if (activity instanceof Sequence) |
| activityElement = sequence2XML((Sequence) activity); |
| else if (activity instanceof Pick) |
| activityElement = pick2XML((Pick) activity); |
| else if (activity instanceof Scope) |
| activityElement = scope2XML((Scope) activity); |
| else if (activity instanceof Compensate) |
| activityElement = compensate2XML((Compensate) activity); |
| else if (activity instanceof CompensateScope) |
| activityElement = compensateScope2XML((CompensateScope) activity); |
| else if (activity instanceof Rethrow) |
| activityElement = rethrow2XML((Rethrow) activity); |
| else if (activity instanceof OpaqueActivity) |
| activityElement = opaqueActivity2XML((OpaqueActivity) activity); |
| else if (activity instanceof ForEach) |
| activityElement = forEach2XML((ForEach) activity); |
| else if (activity instanceof RepeatUntil) |
| activityElement = repeatUntil2XML((RepeatUntil) activity); |
| else if (activity instanceof Validate) |
| activityElement = validate2XML((Validate) activity); |
| else if (activity instanceof ExtensionActivity) |
| activityElement = extensionActivity2XML((ExtensionActivity) activity); |
| |
| return activityElement; |
| } |
| |
| protected Element addCommonActivityItems(Element activityElement, |
| Activity activity) { |
| |
| addStandardAttributes(activityElement, activity); |
| addStandardElements(activityElement, activity); |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(activity, activityElement); |
| |
| extensibleElement2XML(activity, activityElement); |
| |
| return activityElement; |
| } |
| |
| protected void addStandardAttributes(Element activityElement, |
| Activity activity) { |
| if (activity.getName() != null) |
| activityElement.setAttribute("name", activity.getName()); |
| if (activity.isSetSuppressJoinFailure()) { |
| activityElement.setAttribute("suppressJoinFailure", BPELUtils |
| .boolean2XML(activity.getSuppressJoinFailure())); |
| } |
| |
| } |
| |
| protected void addStandardElements(Element activityElement, |
| Activity activity) { |
| // NOTE: Mind the order of these elements. |
| Node firstChild = activityElement.getFirstChild(); |
| Targets targets = activity.getTargets(); |
| if (targets != null) { |
| activityElement.insertBefore(targets2XML(targets), firstChild); |
| } |
| Sources sources = activity.getSources(); |
| if (sources != null) { |
| activityElement.insertBefore(sources2XML(sources), firstChild); |
| } |
| } |
| |
| protected Element catch2XML(Catch _catch) { |
| Element catchElement = createBPELElement("catch"); |
| if (_catch.getFaultName() != null) { |
| catchElement.setAttribute("faultName", qNameToString(_catch, _catch |
| .getFaultName())); |
| } |
| if (_catch.getFaultVariable() != null) { |
| catchElement.setAttribute("faultVariable", _catch |
| .getFaultVariable().getName()); |
| } |
| if (_catch.getFaultMessageType() != null) { |
| catchElement.setAttribute("faultMessageType", qNameToString(_catch, |
| _catch.getFaultMessageType().getQName())); |
| } |
| if (_catch.getFaultElement() != null) { |
| XSDElementDeclaration element = _catch.getFaultElement(); |
| QName qname = new QName(element.getTargetNamespace(), element |
| .getName()); |
| catchElement.setAttribute("faultElement", qNameToString(_catch, |
| qname)); |
| } |
| if (_catch.getActivity() != null) { |
| catchElement.appendChild(activity2XML(_catch.getActivity())); // might |
| // be a |
| // compensate |
| // activity |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(_catch, catchElement); |
| extensibleElement2XML(_catch, catchElement); |
| return catchElement; |
| } |
| |
| protected Element catchAll2XML(CatchAll catchAll) { |
| Element catchAllElement = createBPELElement("catchAll"); |
| |
| Activity activity = catchAll.getActivity(); |
| if (activity != null) |
| catchAllElement.appendChild(activity2XML(activity)); // might be |
| // a |
| // compensate |
| // activity |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(catchAll, catchAllElement); |
| extensibleElement2XML(catchAll, catchAllElement); |
| |
| return catchAllElement; |
| } |
| |
| protected Element empty2XML(Empty empty) { |
| Element activityElement = createBPELElement("empty"); |
| |
| addCommonActivityItems(activityElement, empty); |
| return activityElement; |
| } |
| |
| protected Element opaqueActivity2XML(OpaqueActivity activity) { |
| Element activityElement = createBPELElement("opaqueActivity"); |
| |
| //Set Namespace to Abstract Process |
| INamespaceMap<String, String> nsMap = BPELUtils.getNamespaceMap(this.fBPELResource.getProcess()); |
| |
| if (this.fBPELResource.getOptionUseNSPrefix()) { |
| nsMap.remove(""); |
| List<String> prefix = nsMap.getReverse(this.fBPELResource.getNamespaceURI()); |
| if (prefix.isEmpty()){ |
| nsMap.put(BPELConstants.PREFIX, BPELConstants.NAMESPACE_ABSTRACT_2007); |
| } else { |
| //TODO: Which prefix? |
| nsMap.put(prefix.get(0), BPELConstants.NAMESPACE_ABSTRACT_2007); |
| } |
| } else { |
| nsMap.put("", BPELConstants.NAMESPACE_ABSTRACT_2007); |
| } |
| |
| this.fBPELResource.setNamespaceURI(BPELConstants.NAMESPACE_ABSTRACT_2007); |
| |
| Process process = this.fBPELResource.getProcess(); |
| //Set Default Abstract Process Profile |
| //TODO: Let user decide whether to use a profile |
| if (!process.isSetAbstractProcessProfile()){ |
| process.setAbstractProcessProfile(BPELConstants.NAMESPACE_ABSTRACT_PROFILE_T); |
| } |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element forEach2XML(ForEach forEach) { |
| |
| Element activityElement = createBPELElement("forEach"); |
| |
| if (forEach.getParallel() != null) |
| activityElement.setAttribute("parallel", BPELUtils |
| .boolean2XML(forEach.getParallel())); |
| |
| if (forEach.getCounterName() != null) { |
| activityElement.setAttribute("counterName", forEach |
| .getCounterName().getName()); |
| } |
| |
| if (forEach.getStartCounterValue() != null) { |
| activityElement.appendChild(expression2XML(forEach |
| .getStartCounterValue(), "startCounterValue")); |
| } |
| |
| if (forEach.getFinalCounterValue() != null) { |
| activityElement.appendChild(expression2XML(forEach |
| .getFinalCounterValue(), "finalCounterValue")); |
| } |
| |
| CompletionCondition completionCondition = forEach |
| .getCompletionCondition(); |
| if (completionCondition != null) { |
| Element completionConditionElement = completionCondition2XML(completionCondition); |
| activityElement.appendChild(completionConditionElement); |
| } |
| |
| if (forEach.getActivity() != null) { |
| activityElement.appendChild(activity2XML(forEach.getActivity())); |
| } |
| |
| addCommonActivityItems(activityElement, forEach); |
| return activityElement; |
| } |
| |
| protected Element completionCondition2XML( |
| CompletionCondition completionCondition) { |
| Element completionConditionElement = createBPELElement("completionCondition"); |
| |
| if (completionCondition.getBranches() != null) { |
| Element branchesElement = branches2XML(completionCondition |
| .getBranches()); |
| completionConditionElement.appendChild(branchesElement); |
| } |
| |
| return completionConditionElement; |
| } |
| |
| protected Element branches2XML(Branches branches) { |
| Element branchesElement = expression2XML(branches, "branches"); |
| |
| if (branches.isSetCountCompletedBranchesOnly()) |
| branchesElement.setAttribute("successfulBranchesOnly", BPELUtils |
| .boolean2XML(branches.getCountCompletedBranchesOnly())); |
| |
| return branchesElement; |
| } |
| |
| protected Element rethrow2XML(Rethrow activity) { |
| Element activityElement = createBPELElement("rethrow"); |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element validate2XML(Validate activity) { |
| Element activityElement = createBPELElement("validate"); |
| |
| StringBuilder variablesList = new StringBuilder(); |
| Iterator<?> variables = activity.getVariables().iterator(); |
| while (variables.hasNext()) { |
| Variable variable = (Variable) variables.next(); |
| variablesList.append(variable.getName()); |
| if (variables.hasNext()) |
| variablesList.append(" "); |
| } |
| if (variablesList.length() > 0) { |
| activityElement.setAttribute("variables", variablesList.toString()); |
| } |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element extensionActivity2XML(ExtensionActivity activity) { |
| |
| Element activityElement = createBPELElement("extensionActivity"); |
| |
| String localName = activity.eClass().getName(); |
| String namespace = activity.eClass().getEPackage().getNsURI(); |
| QName qName = new QName(namespace, localName); |
| BPELActivitySerializer serializer = this.extensionRegistry |
| .getActivitySerializer(qName); |
| DocumentFragment fragment = null; |
| if (serializer != null) { |
| fragment = this.document.createDocumentFragment(); |
| serializer.marshall(qName, activity, fragment, getProcess(), this); |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=335458 |
| // Only append Element nodes generated by the serializer |
| // XML beautification is handled by the ElementPlacer class |
| Element child = getFirstChildElement(fragment); |
| if (child!=null) { |
| activityElement.appendChild(child); |
| } |
| } |
| |
| return activityElement; |
| } |
| |
| protected Element invoke2XML(Invoke activity) { |
| |
| Element activityElement = createBPELElement("invoke"); |
| |
| if (activity.getPartnerLink() != null) |
| activityElement.setAttribute("partnerLink", activity |
| .getPartnerLink().getName()); |
| if (activity.getPortType() != null) |
| activityElement.setAttribute("portType", qNameToString(activity, |
| activity.getPortType().getQName())); |
| if (activity.getOperation() != null) |
| activityElement.setAttribute("operation", |
| getOperationSignature(activity.getOperation())); |
| if (activity.getInputVariable() != null) |
| activityElement.setAttribute("inputVariable", activity |
| .getInputVariable().getName()); |
| if (activity.getOutputVariable() != null) |
| activityElement.setAttribute("outputVariable", activity |
| .getOutputVariable().getName()); |
| |
| if (activity.getCorrelations() != null) |
| activityElement.appendChild(correlations2XML(activity |
| .getCorrelations())); |
| |
| FaultHandler faultHandler = activity.getFaultHandler(); |
| if (faultHandler != null) { |
| faultHandler2XML(activityElement, faultHandler); |
| } |
| |
| if (activity.getCompensationHandler() != null) |
| activityElement.appendChild(compensationHandler2XML(activity |
| .getCompensationHandler())); |
| |
| if (activity.getFromParts() != null) |
| activityElement.appendChild(fromParts2XML(activity.getFromParts())); |
| |
| if (activity.getToParts() != null) |
| activityElement.appendChild(toParts2XML(activity.getToParts())); |
| |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element receive2XML(Receive activity) { |
| |
| Element activityElement = createBPELElement("receive"); |
| |
| if (activity.getPartnerLink() != null) |
| activityElement.setAttribute("partnerLink", activity |
| .getPartnerLink().getName()); |
| if (activity.getPortType() != null) |
| activityElement.setAttribute("portType", qNameToString(activity, |
| activity.getPortType().getQName())); |
| if (activity.getOperation() != null) |
| activityElement.setAttribute("operation", |
| getOperationSignature(activity.getOperation())); |
| if (activity.getVariable() != null) |
| activityElement.setAttribute("variable", activity.getVariable() |
| .getName()); |
| if (activity.isSetCreateInstance()) |
| activityElement.setAttribute("createInstance", BPELUtils |
| .boolean2XML(activity.getCreateInstance())); |
| if (activity.getMessageExchange() != null) |
| activityElement.setAttribute("messageExchange", activity |
| .getMessageExchange().getName()); |
| |
| if (activity.getCorrelations() != null) |
| activityElement.appendChild(correlations2XML(activity |
| .getCorrelations())); |
| |
| if (activity.getFromParts() != null) |
| activityElement.appendChild(fromParts2XML(activity.getFromParts())); |
| |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element reply2XML(Reply activity) { |
| |
| Element activityElement = createBPELElement("reply"); |
| if (activity.getPartnerLink() != null) |
| activityElement.setAttribute("partnerLink", activity |
| .getPartnerLink().getName()); |
| if (activity.getPortType() != null) |
| activityElement.setAttribute("portType", qNameToString(activity, |
| activity.getPortType().getQName())); |
| if (activity.getOperation() != null) |
| activityElement.setAttribute("operation", |
| getOperationSignature(activity.getOperation())); |
| if (activity.getVariable() != null) |
| activityElement.setAttribute("variable", activity.getVariable() |
| .getName()); |
| if (activity.getFaultName() != null) { |
| activityElement.setAttribute("faultName", qNameToString(activity, |
| activity.getFaultName())); |
| } |
| if (activity.getMessageExchange() != null) |
| activityElement.setAttribute("messageExchange", activity |
| .getMessageExchange().getName()); |
| |
| if (activity.getCorrelations() != null) |
| activityElement.appendChild(correlations2XML(activity |
| .getCorrelations())); |
| |
| if (activity.getToParts() != null) |
| activityElement.appendChild(toParts2XML(activity.getToParts())); |
| |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element assign2XML(Assign activity) { |
| |
| Element activityElement = createBPELElement("assign"); |
| |
| if (activity.getValidate() != null) |
| activityElement.setAttribute("validate", BPELUtils |
| .boolean2XML(activity.getValidate())); |
| |
| List<?> copies = activity.getCopy(); |
| if (!copies.isEmpty()) { |
| for (Object name : copies) { |
| Copy copy = (Copy) name; |
| activityElement.appendChild(copy2XML(copy)); |
| } |
| } |
| |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element copy2XML(Copy copy) { |
| Element copyElement = createBPELElement("copy"); |
| |
| if (copy.isSetKeepSrcElementName()) |
| copyElement.setAttribute("keepSrcElementName", BPELUtils |
| .boolean2XML(copy.getKeepSrcElementName())); |
| |
| if (copy.isSetIgnoreMissingFromData()) |
| copyElement.setAttribute("ignoreMissingFromData", BPELUtils |
| .boolean2XML(copy.getIgnoreMissingFromData())); |
| |
| From from = copy.getFrom(); |
| if (from != null) { |
| Element fromElement = createBPELElement("from"); |
| from2XML(from, fromElement); |
| copyElement.appendChild(fromElement); |
| } |
| To to = copy.getTo(); |
| if (to != null) { |
| Element toElement = createBPELElement("to"); |
| to2XML(to, toElement); |
| copyElement.appendChild(toElement); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(copy, copyElement); |
| extensibleElement2XML(copy, copyElement); |
| |
| return copyElement; |
| } |
| |
| protected void from2XML(From from, Element fromElement) { |
| |
| if (from.getVariable() != null) { |
| fromElement.setAttribute("variable", from.getVariable().getName()); |
| } |
| if (from.getPart() != null) { |
| fromElement.setAttribute("part", from.getPart().getName()); |
| } |
| if (from.getPartnerLink() != null) { |
| fromElement.setAttribute("partnerLink", from.getPartnerLink() |
| .getName()); |
| } |
| Property property = from.getProperty(); |
| if (property != null) { |
| String qnameStr = qNameToString(from, getQName(property)); |
| fromElement.setAttribute("property", qnameStr); |
| } |
| |
| if (from.getQuery() != null) { |
| Query query = from.getQuery(); |
| Element queryElement = query2XML(query); |
| fromElement.appendChild(queryElement); |
| } |
| |
| if (from.isSetEndpointReference()) { |
| fromElement.setAttribute("endpointReference", from |
| .getEndpointReference().toString()); |
| } |
| |
| if (from.isSetOpaque()) { |
| fromElement.setAttribute("opaque", BPELUtils.boolean2XML(from |
| .getOpaque())); |
| } |
| |
| if (from.isSetLiteral() && from.getLiteral() != null |
| && !from.getLiteral().equals("")) { |
| |
| Node node = null; |
| Element literal = createBPELElement("literal"); |
| |
| fromElement.appendChild(literal); |
| |
| if (Boolean.TRUE.equals(from.getUnsafeLiteral())) { |
| node = BPELUtils.convertStringToNode(from, from.getLiteral(), |
| getResource()); |
| } |
| |
| if (node != null) { |
| for (Node child = node.getFirstChild(); child != null; child = child |
| .getNextSibling()) { |
| DOMUtil.copyInto(child, literal); |
| } |
| } else { |
| CDATASection cdata = BPELUtils.createCDATASection(this.document, |
| from.getLiteral()); |
| fromElement.appendChild(cdata); |
| } |
| |
| } |
| |
| if (from.getServiceRef() != null) { |
| fromElement.appendChild(serviceRef2XML(from.getServiceRef())); |
| } |
| |
| if (from.getExpression() != null) { |
| Expression expression = from.getExpression(); |
| |
| if (expression.getExpressionLanguage() != null) { |
| fromElement.setAttribute("expressionLanguage", expression |
| .getExpressionLanguage()); |
| } |
| if (expression.getBody() != null) { |
| CDATASection cdata = BPELUtils.createCDATASection(this.document, |
| (String) expression.getBody()); |
| fromElement.appendChild(cdata); |
| } |
| } |
| |
| if (from.getType() != null) { |
| XSDTypeDefinition type = from.getType(); |
| QName qname = new QName(type.getTargetNamespace(), type.getName()); |
| fromElement.setAttribute("xsi:type", qNameToString(from, qname)); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(from, fromElement); |
| extensibleElement2XML(from, fromElement); |
| |
| } |
| |
| protected Element serviceRef2XML(ServiceRef serviceRef) { |
| Element serviceRefElement = createBPELElement("service-ref"); |
| String referenceScheme = serviceRef.getReferenceScheme(); |
| if (referenceScheme != null) { |
| serviceRefElement.setAttribute("reference-scheme", referenceScheme); |
| } |
| if (serviceRef.getValue() != null) { |
| Node valueNode = serviceRefValue2XML(serviceRef); |
| if (valueNode != null) { |
| serviceRefElement.appendChild(valueNode); |
| } |
| } |
| return serviceRefElement; |
| } |
| |
| protected Node serviceRefValue2XML(ServiceRef serviceRef) { |
| Object value = serviceRef.getValue(); |
| if (value instanceof ExtensibilityElement) { |
| ExtensibilityElement extensibilityElement = (ExtensibilityElement) value; |
| BPELExtensionSerializer serializer = null; |
| QName qname = extensibilityElement.getElementType(); |
| try { |
| serializer = (BPELExtensionSerializer) this.extensionRegistry |
| .querySerializer(BPELExtensibleElement.class, qname); |
| } catch (WSDLException e) { |
| } |
| |
| if (serializer != null) { |
| // Deserialize the DOM element and add the new Extensibility |
| // element to the parent |
| // BPELExtensibleElement |
| DocumentFragment fragment = this.document.createDocumentFragment(); |
| try { |
| serializer.marshall(BPELExtensibleElement.class, qname, |
| extensibilityElement, fragment, getProcess(), |
| this.extensionRegistry, this); |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=335458 |
| Element child = getFirstChildElement(fragment); |
| return child; |
| } catch (WSDLException e) { |
| throw new WrappedException(e); |
| } |
| } |
| } else if (serviceRef.getValue() != null) { |
| ServiceReferenceSerializer serializer = this.extensionRegistry |
| .getServiceReferenceSerializer(serviceRef |
| .getReferenceScheme()); |
| if (serializer != null) { |
| DocumentFragment fragment = this.document.createDocumentFragment(); |
| serializer.marshall(value, fragment, getProcess(), serviceRef |
| .eContainer(), this); |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=335458 |
| Element child = getFirstChildElement(fragment); |
| return child; |
| } else { |
| CDATASection cdata = BPELUtils.createCDATASection(this.document, |
| serviceRef.getValue().toString()); |
| return cdata; |
| } |
| } |
| return null; |
| } |
| |
| protected Element query2XML(Query query) { |
| Element queryElement = createBPELElement("query"); |
| if (query.getQueryLanguage() != null) { |
| queryElement |
| .setAttribute("queryLanguage", query.getQueryLanguage()); |
| } |
| if (query.getValue() != null) { |
| CDATASection cdata = BPELUtils.createCDATASection(this.document, query |
| .getValue()); |
| queryElement.appendChild(cdata); |
| } |
| return queryElement; |
| } |
| |
| protected void to2XML(To to, Element toElement) { |
| if (to.getVariable() != null) { |
| toElement.setAttribute("variable", to.getVariable().getName()); |
| } |
| if (to.getPart() != null) { |
| toElement.setAttribute("part", to.getPart().getName()); |
| } |
| if (to.getPartnerLink() != null) { |
| toElement |
| .setAttribute("partnerLink", to.getPartnerLink().getName()); |
| } |
| Property property = to.getProperty(); |
| if (property != null) { |
| String qnameStr = qNameToString(to, getQName(property)); |
| toElement.setAttribute("property", qnameStr); |
| } |
| |
| if (to.getQuery() != null) { |
| Query query = to.getQuery(); |
| Element queryElement = query2XML(query); |
| toElement.appendChild(queryElement); |
| } |
| if (to.getExpression() != null) { |
| Expression expression = to.getExpression(); |
| |
| if (expression.getExpressionLanguage() != null) { |
| toElement.setAttribute("expressionLanguage", expression |
| .getExpressionLanguage()); |
| } |
| if (expression.getBody() != null) { |
| CDATASection cdata = BPELUtils.createCDATASection(this.document, |
| (String) expression.getBody()); |
| toElement.appendChild(cdata); |
| } |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(to, toElement); |
| extensibleElement2XML(to, toElement); |
| } |
| |
| protected Element wait2XML(Wait activity) { |
| Element activityElement = createBPELElement("wait"); |
| |
| if (activity.getFor() != null) { |
| activityElement |
| .appendChild(expression2XML(activity.getFor(), "for")); |
| } |
| if (activity.getUntil() != null) { |
| activityElement.appendChild(expression2XML(activity.getUntil(), |
| "until")); |
| } |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element throw2XML(Throw activity) { |
| Element activityElement = createBPELElement("throw"); |
| |
| if (activity.getFaultVariable() != null |
| && activity.getFaultVariable().getName() != null) { |
| activityElement.setAttribute("faultVariable", activity |
| .getFaultVariable().getName()); |
| } |
| if (activity.getFaultName() != null) { |
| activityElement.setAttribute("faultName", qNameToString(activity, |
| activity.getFaultName())); |
| } |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element exit2XML(Exit activity) { |
| Element activityElement = createBPELElement("exit"); |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| void addActivities(Element activityElement, List<?> listOfActivities) { |
| for (Object next : listOfActivities) { |
| activityElement.appendChild(activity2XML((Activity) next)); |
| } |
| } |
| |
| protected Element flow2XML(Flow activity) { |
| |
| Element activityElement = createBPELElement("flow"); |
| |
| Links links = activity.getLinks(); |
| if (links != null) { |
| Element linksElement = links2XML(links); |
| activityElement.appendChild(linksElement); |
| } |
| |
| CompletionCondition completionCondition = activity |
| .getCompletionCondition(); |
| if (completionCondition != null) { |
| Element completionConditionElement = completionCondition2XML(completionCondition); |
| activityElement.appendChild(completionConditionElement); |
| } |
| |
| addActivities(activityElement, activity.getActivities()); |
| |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element documentation2XML(Documentation documentation) { |
| Element documentationElement = createBPELElement("documentation"); |
| |
| if (documentation.getSource() != null) { |
| documentationElement.setAttribute("source", documentation |
| .getSource()); |
| } |
| if (documentation.getLang() != null) { |
| documentationElement.setAttribute("xml:lang", documentation |
| .getLang()); |
| } |
| if (documentation.getValue() != null |
| && documentation.getValue().length() > 0) { |
| Text textNode = documentationElement.getOwnerDocument() |
| .createTextNode(documentation.getValue()); |
| documentationElement.appendChild(textNode); |
| } |
| |
| return documentationElement; |
| } |
| |
| protected Element links2XML(Links links) { |
| Element linksElement = createBPELElement("links"); |
| |
| for (Object next : links.getChildren()) { |
| linksElement.appendChild(link2XML((Link) next)); |
| } |
| // serialize local namespace prefixes to XML |
| serializePrefixes(links, linksElement); |
| extensibleElement2XML(links, linksElement); |
| |
| return linksElement; |
| } |
| |
| protected Element link2XML(Link link) { |
| Element linkElement = createBPELElement("link"); |
| if (link.getName() != null) |
| linkElement.setAttribute("name", link.getName()); |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(link, linkElement); |
| extensibleElement2XML(link, linkElement); |
| |
| return linkElement; |
| } |
| |
| protected Element if2XML(If activity) { |
| |
| Element ifElement = createBPELElement("if"); |
| |
| if (activity.getCondition() != null) { |
| ifElement.appendChild(expression2XML(activity.getCondition(), |
| "condition")); |
| } |
| |
| if (activity.getActivity() != null) { |
| ifElement.appendChild(activity2XML(activity.getActivity())); |
| } |
| |
| |
| List<?> elseIfs = activity.getElseIf(); |
| if (!elseIfs.isEmpty()) { |
| for (Object next : elseIfs) { |
| ElseIf elseIf = (ElseIf) next; |
| ifElement.appendChild(elseIf2XML(elseIf)); |
| } |
| } |
| Else _else = activity.getElse(); |
| if (_else != null) { |
| Element elseElement = else2XML(_else); |
| ifElement.appendChild(elseElement); |
| } |
| |
| addCommonActivityItems(ifElement, activity); |
| return ifElement; |
| } |
| |
| protected Element elseIf2XML(ElseIf elseIf) { |
| Element elseIfElement = createBPELElement("elseif"); |
| |
| if (elseIf.getCondition() != null) { |
| elseIfElement.appendChild(expression2XML(elseIf.getCondition(), |
| "condition")); |
| } |
| if (elseIf.getActivity() != null) { |
| elseIfElement.appendChild(activity2XML(elseIf.getActivity())); |
| } |
| // serialize local namespace prefixes to XML |
| serializePrefixes(elseIf, elseIfElement); |
| extensibleElement2XML(elseIf, elseIfElement); |
| |
| return elseIfElement; |
| } |
| |
| protected Element else2XML(Else _else) { |
| Element elseElement = createBPELElement("else"); |
| if (_else.getActivity() != null) { |
| Element activityElement = activity2XML(_else.getActivity()); |
| elseElement.appendChild(activityElement); |
| } |
| // serialize local namespace prefixes to XML |
| serializePrefixes(_else, elseElement); |
| extensibleElement2XML(_else, elseElement); |
| |
| return elseElement; |
| } |
| |
| protected Element while2XML(While activity) { |
| Element activityElement = createBPELElement("while"); |
| |
| if (activity.getCondition() != null) { |
| activityElement.appendChild(expression2XML(activity.getCondition(), |
| "condition")); |
| } |
| if (activity.getActivity() != null) { |
| activityElement.appendChild(activity2XML(activity.getActivity())); |
| } |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element repeatUntil2XML(RepeatUntil activity) { |
| |
| Element activityElement = createBPELElement("repeatUntil"); |
| |
| if (activity.getActivity() != null) { |
| activityElement.appendChild(activity2XML(activity.getActivity())); |
| } |
| if (activity.getCondition() != null) { |
| activityElement.appendChild(expression2XML(activity.getCondition(), |
| "condition")); |
| } |
| |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element expression2XML(Expression expression, String elementName) { |
| Element expressionElement = createBPELElement(elementName); |
| |
| if (expression.getExpressionLanguage() != null) { |
| expressionElement.setAttribute("expressionLanguage", expression |
| .getExpressionLanguage()); |
| } |
| if (expression.getOpaque() != null) { |
| expressionElement.setAttribute("opaque", BPELUtils |
| .boolean2XML(expression.getOpaque())); |
| } |
| if (expression.getBody() != null) { |
| Object body = expression.getBody(); |
| if (body instanceof ExtensibilityElement) { |
| ExtensibilityElement extensibilityElement = (ExtensibilityElement) body; |
| Element child = extensibilityElement2XML(extensibilityElement); |
| if (child != null) { |
| expressionElement.appendChild(child); |
| } |
| } else { |
| CDATASection cdata = BPELUtils.createCDATASection(this.document, |
| expression.getBody().toString()); |
| expressionElement.appendChild(cdata); |
| } |
| } |
| |
| return expressionElement; |
| } |
| |
| protected Element sequence2XML(Sequence activity) { |
| Element activityElement = createBPELElement("sequence"); |
| |
| addActivities(activityElement, activity.getActivities()); |
| addCommonActivityItems(activityElement, activity); |
| |
| return activityElement; |
| } |
| |
| protected Element sources2XML(Sources sources) { |
| Element sourcesElement = createBPELElement("sources"); |
| for (Object next : sources.getChildren()) { |
| sourcesElement.appendChild(source2XML((Source) next)); |
| } |
| extensibleElement2XML(sources, sourcesElement); |
| return sourcesElement; |
| } |
| |
| protected Element source2XML(Source source) { |
| |
| Element sourceElement = createBPELElement("source"); |
| sourceElement.setAttribute("linkName", source.getLink().getName()); |
| Condition transitionCondition = source.getTransitionCondition(); |
| if (transitionCondition != null) { |
| sourceElement.appendChild(expression2XML(transitionCondition, |
| "transitionCondition")); |
| } |
| extensibleElement2XML(source, sourceElement); |
| return sourceElement; |
| } |
| |
| protected Element targets2XML(Targets targets) { |
| Element targetsElement = createBPELElement("targets"); |
| |
| // Write out the join condition |
| Condition joinCondition = targets.getJoinCondition(); |
| if (joinCondition != null) { |
| targetsElement.appendChild(expression2XML(joinCondition, |
| "joinCondition")); |
| } |
| for (Object next : targets.getChildren()) { |
| targetsElement.appendChild(target2XML((Target) next)); |
| } |
| |
| extensibleElement2XML(targets, targetsElement); |
| return targetsElement; |
| } |
| |
| protected Element target2XML(Target target) { |
| Element targetElement = createBPELElement("target"); |
| targetElement.setAttribute("linkName", target.getLink().getName()); |
| extensibleElement2XML(target, targetElement); |
| return targetElement; |
| } |
| |
| protected Element onMessage2XML(OnMessage onMsg) { |
| Element onMessageElement = createBPELElement("onMessage"); |
| if (onMsg.getPartnerLink() != null |
| && onMsg.getPartnerLink().getName() != null) { |
| onMessageElement.setAttribute("partnerLink", onMsg.getPartnerLink() |
| .getName()); |
| } |
| if (onMsg.getPortType() != null |
| && onMsg.getPortType().getQName() != null) { |
| onMessageElement.setAttribute("portType", qNameToString(onMsg, |
| onMsg.getPortType().getQName())); |
| } |
| if (onMsg.getOperation() != null) { |
| onMessageElement.setAttribute("operation", |
| getOperationSignature(onMsg.getOperation())); |
| } |
| if (onMsg.getVariable() != null |
| && onMsg.getVariable().getName() != null) { |
| onMessageElement.setAttribute("variable", onMsg.getVariable() |
| .getName()); |
| } |
| if (onMsg.getMessageExchange() != null) |
| onMessageElement.setAttribute("messageExchange", onMsg |
| .getMessageExchange().getName()); |
| if (onMsg.getCorrelations() != null) { |
| onMessageElement.appendChild(correlations2XML(onMsg |
| .getCorrelations())); |
| } |
| if (onMsg.getActivity() != null) { |
| onMessageElement.appendChild(activity2XML(onMsg.getActivity())); |
| } |
| if (onMsg.getFromParts() != null) { |
| onMessageElement.appendChild(fromParts2XML(onMsg.getFromParts())); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(onMsg, onMessageElement); |
| |
| // TODO: Why do we have this? I don't think OnMessage is extensible. |
| extensibleElement2XML(onMsg, onMessageElement); |
| return onMessageElement; |
| } |
| |
| protected Element onEvent2XML(OnEvent onEvent) { |
| Element onEventElement = createBPELElement("onEvent"); |
| if (onEvent.getPartnerLink() != null |
| && onEvent.getPartnerLink().getName() != null) { |
| onEventElement.setAttribute("partnerLink", onEvent.getPartnerLink() |
| .getName()); |
| } |
| if (onEvent.getPortType() != null |
| && onEvent.getPortType().getQName() != null) { |
| onEventElement.setAttribute("portType", qNameToString(onEvent, |
| onEvent.getPortType().getQName())); |
| } |
| if (onEvent.getOperation() != null) { |
| onEventElement.setAttribute("operation", |
| getOperationSignature(onEvent.getOperation())); |
| } |
| if (onEvent.getVariable() != null |
| && onEvent.getVariable().getName() != null) { |
| onEventElement.setAttribute("variable", onEvent.getVariable() |
| .getName()); |
| } |
| if (onEvent.getMessageExchange() != null) |
| onEventElement.setAttribute("messageExchange", onEvent |
| .getMessageExchange().getName()); |
| if (onEvent.getMessageType() != null) { |
| onEventElement.setAttribute("messageType", qNameToString(onEvent, |
| onEvent.getMessageType().getQName())); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=336003 |
| // "element" attribute was missing from original model |
| if (onEvent.getXSDElement() != null) { |
| onEventElement.setAttribute("element", |
| onEvent.getXSDElement().getQName()); |
| } |
| if (onEvent.getCorrelationSets() != null) { |
| onEventElement.appendChild(correlationSets2XML(onEvent |
| .getCorrelationSets())); |
| } |
| if (onEvent.getCorrelations() != null) { |
| onEventElement.appendChild(correlations2XML(onEvent |
| .getCorrelations())); |
| } |
| |
| if (onEvent.getActivity() != null) { |
| onEventElement.appendChild(activity2XML(onEvent.getActivity())); |
| } |
| |
| if (onEvent.getFromParts() != null) { |
| onEventElement.appendChild(fromParts2XML(onEvent.getFromParts())); |
| } |
| |
| // serialize local namespace prefixes to XML |
| serializePrefixes(onEvent, onEventElement); |
| |
| // TODO: Why do we have this? I don't think OnEvent is extensible. |
| extensibleElement2XML(onEvent, onEventElement); |
| return onEventElement; |
| } |
| |
| protected Element onAlarm2XML(OnAlarm onAlarm) { |
| Element onAlarmElement = createBPELElement("onAlarm"); |
| if (onAlarm.getFor() != null) { |
| onAlarmElement.appendChild(expression2XML(onAlarm.getFor(), "for")); |
| } |
| if (onAlarm.getUntil() != null) { |
| onAlarmElement.appendChild(expression2XML(onAlarm.getUntil(), |
| "until")); |
| } |
| if (onAlarm.getRepeatEvery() != null) { |
| onAlarmElement.appendChild(expression2XML(onAlarm.getRepeatEvery(), |
| "repeatEvery")); |
| } |
| if (onAlarm.getActivity() != null) { |
| onAlarmElement.appendChild(activity2XML(onAlarm.getActivity())); |
| } |
| // serialize local namespace prefixes to XML |
| serializePrefixes(onAlarm, onAlarmElement); |
| |
| // TODO: Why do we have this? I don't think OnAlarm is extensible. |
| extensibleElement2XML(onAlarm, onAlarmElement); |
| return onAlarmElement; |
| } |
| |
| protected Element pick2XML(Pick activity) { |
| Element activityElement = createBPELElement("pick"); |
| |
| if (activity.isSetCreateInstance()) { |
| activityElement.setAttribute("createInstance", BPELUtils |
| .boolean2XML(activity.getCreateInstance())); |
| } |
| for (Object next : activity.getMessages()) { |
| activityElement.appendChild(onMessage2XML((OnMessage) next)); |
| } |
| for (Object next : activity.getAlarm()) { |
| activityElement.appendChild(onAlarm2XML((OnAlarm) next)); |
| } |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element scope2XML(Scope activity) { |
| |
| Element activityElement = createBPELElement("scope"); |
| |
| if (activity.isSetIsolated()) |
| activityElement.setAttribute("isolated", BPELUtils |
| .boolean2XML(activity.getIsolated())); |
| if (activity.isSetExitOnStandardFault()) |
| activityElement.setAttribute("exitOnStandardFault", BPELUtils |
| .boolean2XML(activity.getExitOnStandardFault())); |
| if (activity.getVariables() != null |
| && !activity.getVariables().getChildren().isEmpty()) |
| activityElement.appendChild(variables2XML(activity.getVariables())); |
| if (activity.getCorrelationSets() != null |
| && !activity.getCorrelationSets().getChildren().isEmpty()) |
| activityElement.appendChild(correlationSets2XML(activity |
| .getCorrelationSets())); |
| if (activity.getPartnerLinks() != null |
| && !activity.getPartnerLinks().getChildren().isEmpty()) |
| activityElement.appendChild(partnerLinks2XML(activity |
| .getPartnerLinks())); |
| if (activity.getFaultHandlers() != null) |
| activityElement.appendChild(faultHandlers2XML(activity |
| .getFaultHandlers())); |
| if (activity.getCompensationHandler() != null) |
| activityElement.appendChild(compensationHandler2XML(activity |
| .getCompensationHandler())); |
| if (activity.getTerminationHandler() != null) |
| activityElement.appendChild(terminationHandler2XML(activity |
| .getTerminationHandler())); |
| if (activity.getEventHandlers() != null) |
| activityElement.appendChild(eventHandler2XML(activity |
| .getEventHandlers())); |
| if (activity.getMessageExchanges() != null |
| && !activity.getMessageExchanges().getChildren().isEmpty()) |
| activityElement.appendChild(messageExchanges2XML(activity |
| .getMessageExchanges())); |
| if (activity.getActivity() != null) |
| activityElement.appendChild(activity2XML(activity.getActivity())); |
| |
| addCommonActivityItems(activityElement, activity); |
| |
| return activityElement; |
| } |
| |
| protected Element compensateScope2XML(CompensateScope activity) { |
| Element activityElement = createBPELElement("compensateScope"); |
| |
| Activity scopeOrInvoke = activity.getTarget(); |
| if (scopeOrInvoke != null) { |
| activityElement.setAttribute("scope", scopeOrInvoke.getName()); |
| } |
| |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected Element compensate2XML(Compensate activity) { |
| Element activityElement = createBPELElement("compensate"); |
| addCommonActivityItems(activityElement, activity); |
| return activityElement; |
| } |
| |
| protected QName getQName(org.eclipse.wst.wsdl.ExtensibilityElement element, |
| String localName) { |
| EObject container = null; |
| for (container = element.eContainer(); container != null |
| && !(container instanceof Definition);) { |
| container = container.eContainer(); |
| } |
| if (container == null) { |
| return null; |
| } |
| return new QName(((Definition) container).getTargetNamespace(), |
| localName); |
| } |
| |
| /** |
| * Convert a BPEL ExtensibileElement to XML |
| */ |
| protected void extensibleElement2XML(BPELExtensibleElement extensibleElement, |
| Element element) { |
| |
| if (extensibleElement.getDocumentation() != null) { |
| // We can't just do appendChild here. This is called *after* the |
| // concrete type |
| // has had a chance to append children, and documentation should |
| // precede all of |
| // these children |
| Node firstChild = element.getFirstChild(); |
| Element documentationElement = documentation2XML(extensibleElement |
| .getDocumentation()); |
| if (firstChild == null) { |
| element.appendChild(documentationElement); |
| } else { |
| element.insertBefore(documentationElement, firstChild); |
| } |
| } |
| |
| // Get the extensibility elements and if the platform is running try to |
| // order them. |
| // If the platform is not running just serialize the elements in the |
| // order they appear. |
| List<org.eclipse.wst.wsdl.ExtensibleElement> extensibilityElements; |
| if (Platform.isRunning()) { |
| if (this.extensibilityElementListHandlers == null) { |
| this.extensibilityElementListHandlers = ExtensionFactory.INSTANCE |
| .createHandlers(ExtensionFactory.ID_EXTENSION_REORDERING); |
| } |
| extensibilityElements = BPELUtils.reorderExtensibilityList( |
| this.extensibilityElementListHandlers, extensibleElement); |
| } else { |
| extensibilityElements = extensibleElement.getExtensibilityElements(); |
| } |
| |
| // Loop through the extensibility elements |
| for (Object name : extensibilityElements) { |
| ExtensibilityElement extensibilityElement = (ExtensibilityElement) name; |
| |
| // Lookup a serializer for the extensibility element |
| BPELExtensionSerializer serializer = null; |
| QName qname = extensibilityElement.getElementType(); |
| try { |
| serializer = (BPELExtensionSerializer) this.extensionRegistry |
| .querySerializer(BPELExtensibleElement.class, qname); |
| } catch (WSDLException e) { |
| // TODO: Exception handling |
| } |
| if (serializer != null) { |
| |
| // Create a temp document fragment for the serializer |
| DocumentFragment fragment = this.document.createDocumentFragment(); |
| |
| // Serialize the extensibility element into the parent DOM |
| // element |
| try { |
| serializer.marshall(BPELExtensibleElement.class, qname, |
| extensibilityElement, fragment, getProcess(), |
| this.extensionRegistry, this); |
| } catch (WSDLException e) { |
| throw new WrappedException(e); |
| } |
| |
| Node tempElement = fragment.getFirstChild(); |
| if (tempElement == null) { |
| return; |
| } |
| String nodeName = tempElement.getNodeName(); |
| nodeName = nodeName.substring(nodeName.lastIndexOf(':') + 1); |
| if (nodeName.equals("extensibilityAttributes")) { |
| |
| // Add the attributes to the parent DOM element |
| String elementName = tempElement.getNodeName(); |
| String prefix = elementName.lastIndexOf(':') != -1 ? elementName |
| .substring(0, elementName.indexOf(':')) |
| : null; |
| NamedNodeMap attributes = tempElement.getAttributes(); |
| for (int a = 0, n = attributes.getLength(); a < n; a++) { |
| Attr attr = (Attr) attributes.item(a); |
| String attrName = attr.getNodeName(); |
| if (attrName.indexOf(':') == -1 && prefix != null) |
| attrName = prefix + ':' + attrName; |
| if (attrName.startsWith("xmlns:")) { |
| String localName = attrName.substring("xmlns:" |
| .length()); |
| Map<String, String> nsMap = BPELUtils |
| .getNamespaceMap(extensibleElement); |
| if (!nsMap.containsKey(localName) |
| || !attr.getNodeValue().equals( |
| nsMap.get(localName))) { |
| nsMap.put(localName, attr.getNodeValue()); |
| } |
| } else { |
| element.setAttribute(attrName, attr.getNodeValue()); |
| } |
| } |
| } else { |
| // The extensibility element was serialized into a DOM |
| // element, simply |
| // add it to the parent DOM element |
| // always append the extension element to the |
| // begining of the children list |
| if (element.getFirstChild() == null) |
| element.appendChild(tempElement); |
| else |
| element.insertBefore(tempElement, element |
| .getFirstChild()); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Get process from the resource |
| * @return the Process |
| */ |
| private Process getProcess() { |
| return getResource().getProcess(); |
| } |
| |
| /** |
| * Convert a BPEL ExtensibilityElement to XML |
| */ |
| protected Element extensibilityElement2XML( |
| ExtensibilityElement extensibilityElement) { |
| |
| BPELExtensionSerializer serializer = null; |
| QName qname = extensibilityElement.getElementType(); |
| try { |
| serializer = (BPELExtensionSerializer) this.extensionRegistry |
| .querySerializer(BPELExtensibleElement.class, qname); |
| } catch (WSDLException e) { |
| return null; |
| } |
| |
| // Deserialize the DOM element and add the new Extensibility element to |
| // the parent |
| // BPELExtensibleElement |
| DocumentFragment fragment = this.document.createDocumentFragment(); |
| try { |
| serializer |
| .marshall(BPELExtensibleElement.class, qname, |
| extensibilityElement, fragment, getProcess(), |
| this.extensionRegistry, this); |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=335458 |
| Element child = getFirstChildElement(fragment); |
| return child; |
| } catch (WSDLException e) { |
| throw new WrappedException(e); |
| } |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=335458 |
| |
| protected Element createBPELElement(String tagName) { |
| |
| String namespaceURI = null; |
| |
| if (getResource() != null) { |
| namespaceURI = getResource().getNamespaceURI(); |
| } else { |
| namespaceURI = BPELConstants.NAMESPACE; |
| } |
| |
| if (namespaceURI != null) { |
| List<String> prefixes = BPELUtils.getNamespaceMap( |
| getProcess()).getReverse(namespaceURI); |
| if (!prefixes.isEmpty() && !prefixes.get(0).equals("")) { |
| return this.document.createElementNS(namespaceURI, prefixes.get(0) |
| + ":" + tagName); |
| } |
| } |
| |
| return this.document.createElement(tagName); |
| } |
| |
| /** |
| * |
| * @return the namespace prefix manager. |
| */ |
| |
| // public NamespacePrefixManager getNamespacePrefixManager() { |
| // return bpelNamespacePrefixManager; |
| // } |
| private void serializePrefixes(EObject eObject, Element context) { |
| INamespaceMap<String, String> nsMap = BPELUtils |
| .getNamespaceMap(eObject); |
| if (!nsMap.isEmpty()) { |
| for( Map.Entry<String,String> entry : nsMap.entrySet()) { |
| String prefix = entry.getKey(); |
| String namespace = entry.getValue(); |
| if (prefix.length() == 0) |
| context.setAttributeNS(XSDConstants.XMLNS_URI_2000, |
| "xmlns", namespace); |
| else |
| context.setAttributeNS(XSDConstants.XMLNS_URI_2000, |
| "xmlns:" + prefix, namespace); |
| } |
| } |
| } |
| |
| private String addNewRootPrefix(String basePrefix, String namespace) { |
| INamespaceMap<String, String> nsMap = BPELUtils |
| .getNamespaceMap(getProcess()); |
| |
| List<String> prefixes = nsMap.getReverse(namespace); |
| if (prefixes.isEmpty()) { |
| int i = 0; |
| String prefix = basePrefix; |
| while (nsMap.containsKey(prefix)) { |
| prefix = basePrefix + i; |
| i++; |
| } |
| nsMap.put(prefix, namespace); |
| return prefix; |
| } else { |
| return prefixes.get(0); |
| } |
| } |
| |
| private String qNameToString(EObject eObject, QName qname) { |
| EObject context = eObject; |
| List<String> prefixes = null; |
| String namespace = qname.getNamespaceURI(); |
| |
| if (namespace == null || namespace.length() == 0) { |
| return qname.getLocalPart(); |
| } |
| |
| // Transform BPEL namespaces to the latest version so that |
| // references to the old namespace are not serialized. |
| if (BPELConstants.isBPELNamespace(namespace)) { |
| namespace = BPELConstants.NAMESPACE; |
| } |
| while (context != null) { |
| INamespaceMap<String, String> prefixNSMap = BPELUtils |
| .getNamespaceMap(context); |
| prefixes = prefixNSMap.getReverse(namespace); |
| if (!prefixes.isEmpty()) { |
| String prefix = prefixes.get(0); |
| if (!prefix.equals("")) |
| return prefix + ":" + qname.getLocalPart(); |
| else |
| return qname.getLocalPart(); |
| } |
| context = context.eContainer(); |
| } |
| // if a prefix is not found for the namespaceURI, create a new |
| // prefix |
| return addNewRootPrefix("ns", namespace) + ":" + qname.getLocalPart(); |
| } |
| |
| |
| private Element getFirstChildElement(DocumentFragment fragment) { |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=335458 |
| // first child may be a TEXT Node (e.g. whitespace) |
| Node child = fragment.getFirstChild(); |
| while (child != null && !(child instanceof Element)) { |
| child = child.getNextSibling(); |
| } |
| |
| // We are out of the loop: either child is null, or it is an element |
| if( child != null ) |
| return (Element) child; |
| |
| throw new IllegalArgumentException("Document Fragment does not contain any Elements"); |
| } |
| } |