ServiceTemplateUtil.java

/*******************************************************************************
 * Copyright (c) 2006-2010 eBay Inc. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *******************************************************************************/
package org.ebayopensource.turmeric.eclipse.template.wsdl.util;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;

import javax.xml.namespace.QName;

import org.apache.commons.lang.StringUtils;
import org.ebayopensource.turmeric.common.config.LibraryType;
import org.ebayopensource.turmeric.eclipse.core.model.IParameterElement;
import org.ebayopensource.turmeric.eclipse.core.resources.constants.SOAProjectConstants.TemplateBinding;
import org.ebayopensource.turmeric.eclipse.core.resources.constants.SOATypeLibraryConstants;
import org.ebayopensource.turmeric.eclipse.exception.core.CommandFailedException;
import org.ebayopensource.turmeric.eclipse.repositorysystem.core.GlobalRepositorySystem;
import org.ebayopensource.turmeric.eclipse.repositorysystem.core.SOAGlobalRegistryAdapter;
import org.ebayopensource.turmeric.eclipse.template.wsdl.resources.SOAMessages;
import org.ebayopensource.turmeric.eclipse.typelibrary.ui.TypeLibraryUIActivator;
import org.ebayopensource.turmeric.eclipse.typelibrary.ui.TypeLibraryUtil;
import org.ebayopensource.turmeric.eclipse.typelibrary.ui.wst.WTPTypeLibUtil;
import org.ebayopensource.turmeric.eclipse.utils.lang.StringUtil;
import org.eclipse.wst.wsdl.Binding;
import org.eclipse.wst.wsdl.Definition;
import org.eclipse.wst.wsdl.Input;
import org.eclipse.wst.wsdl.Message;
import org.eclipse.wst.wsdl.MessageReference;
import org.eclipse.wst.wsdl.Operation;
import org.eclipse.wst.wsdl.Output;
import org.eclipse.wst.wsdl.Part;
import org.eclipse.wst.wsdl.PortType;
import org.eclipse.wst.wsdl.WSDLFactory;
import org.eclipse.wst.wsdl.internal.generator.BindingGenerator;
import org.eclipse.wst.wsdl.internal.generator.extension.ContentGeneratorExtensionFactoryRegistry;
import org.eclipse.wst.wsdl.ui.internal.commands.AddMessageCommand;
import org.eclipse.wst.wsdl.ui.internal.commands.AddPartCommand;
import org.eclipse.wst.wsdl.ui.internal.util.NameUtil;
import org.eclipse.wst.wsdl.ui.internal.util.XSDComponentHelper;
import org.eclipse.xsd.XSDComplexTypeDefinition;
import org.eclipse.xsd.XSDCompositor;
import org.eclipse.xsd.XSDDerivationMethod;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDFactory;
import org.eclipse.xsd.XSDImport;
import org.eclipse.xsd.XSDModelGroup;
import org.eclipse.xsd.XSDParticle;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDTypeDefinition;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * The Utility class to serve the Service template processors and other template
 * classes. This class has methods to create the WSDL, manipulate it i.e add
 * operation, elements etc. Basically this class manipulates the WSDL using the
 * WTP EMF model and expose the manipulating functionalities SOA require. It
 * also has getters for accessing the the WSDL properties like the port,
 * operations, elements etc. Has the binding generation responsibility also.
 * 
 * @author smathew
 * 
 */
public class ServiceTemplateUtil {

	/**
	 * Gets the default port in a definition object. The default is the first
	 * port type available in the WSDL. If the definition does not have any port
	 * types then it creates a new one, add it to the definition and returns it.
	 *
	 * @param definition the definition
	 * @return the default port
	 */
	public static PortType getDefaultPort(Definition definition) {
		PortType portType = null;
		if (definition.getPortTypes() != null) {
			Iterator<?> iterator = definition.getPortTypes().values().iterator();
			while (iterator.hasNext()) {
				Object objPortType = iterator.next();
				if (objPortType != null && objPortType instanceof PortType) {
					portType = (PortType) objPortType;
					break;
				}
			}
		}
		if (portType == null) {
			portType = WSDLFactory.eINSTANCE.createPortType();
			portType.setQName(new QName(definition.getTargetNamespace(),
					ServiceTemplateConstants.DEFAULT_PORT_NAME));
			portType.setEnclosingDefinition(definition);
			definition.addPortType(portType);
		}
		return portType;
	}

	/**
	 * Returns true if the operation with with given name exists in the given
	 * port type. This is a case sensitive API. Remember an operation with the
	 * same name can exist in the WSDL under a different port type and clients
	 * are supposed to use this API with different port types to achieve a full
	 * length uniqueness.
	 *
	 * @param portType the port type
	 * @param opName the op name
	 * @return true, if successful
	 */
	public static boolean operationExists(PortType portType, String opName) {
		for (Object operationObject : portType.getOperations()) {
			if (operationObject instanceof Operation) {
				if (StringUtils.equals(((Operation) operationObject).getName(),
						opName)) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * Adds an operation with the given name to the port type. Does not check
	 * for existing operations. In that case clients can use
	 *
	 * @param portType the port type
	 * @param operationName the operation name
	 * @return the operation
	 * @see ServiceTemplateUtil#operationExists(PortType, String) API before
	 * calling this API.
	 */
	public static Operation addOperation(PortType portType, String operationName) {
		Operation operation = WSDLFactory.eINSTANCE.createOperation();
		operation.setName(operationName);
		operation.setEnclosingDefinition(portType.getEnclosingDefinition());
		if (portType.getElement() != null && portType.getElement().getOwnerDocument() != null) {
			//adding the wsdl:documentation tag to the PortType->Operation
			final Document ownerDoc = portType.getElement().getOwnerDocument();
			final Element element = ownerDoc.createElement(
					ServiceTemplateConstants.TAG_DOCUMENTATION_ELEMENT);
			element.appendChild(ownerDoc.createTextNode(
					ServiceTemplateConstants.DEFAULT_DOCUMENT_TEXT));
			operation.setDocumentationElement(element);
		}
		
		portType.addOperation(operation);
		return operation;
	}

	/**
	 * Adds the specified input parameter to the operation, creates a message
	 * for it and return the part. Remember for setting the input parameter we
	 * need the message and part to be added as well.
	 *
	 * @param operation the operation
	 * @param inputParamName the input param name
	 * @return the part
	 * @throws CommandFailedException the command failed exception
	 */
	public static Part addInput(Operation operation, String inputParamName)
			throws CommandFailedException {
		MessageReference messageReference = WSDLFactory.eINSTANCE.createInput();
		messageReference.setEnclosingDefinition(operation
				.getEnclosingDefinition());
		operation.setInput((Input) messageReference);
		return createMessage(operation, inputParamName, messageReference);

	}

	/**
	 * Adds the specified output parameter to the operation, creates a message
	 * for it and return the part. Remember for setting the output parameter we
	 * need the message and part to be added as well.
	 *
	 * @param operation the operation
	 * @param outputParamName the output param name
	 * @return the part
	 * @throws CommandFailedException the command failed exception
	 */
	public static Part addOutput(Operation operation, String outputParamName)
			throws CommandFailedException {
		MessageReference messageReference = WSDLFactory.eINSTANCE
				.createOutput();
		messageReference.setEnclosingDefinition(operation
				.getEnclosingDefinition());
		operation.setOutput((Output) messageReference);
		return createMessage(operation, outputParamName, messageReference);
	}

	/**
	 * Creates the message with the given message name. The WSDL definition is
	 * automatically discovered from the operation passed. Finally the part is
	 * also created with this message and returned to the client.
	 *
	 * @param operation the operation
	 * @param messageName the message name
	 * @param messageReference the message reference
	 * @return the part
	 * @throws CommandFailedException the command failed exception
	 */
	public static Part createMessage(Operation operation, String messageName,
			MessageReference messageReference) throws CommandFailedException {
		Definition definition = operation.getEnclosingDefinition();
		AddMessageCommand command = new AddMessageCommand(definition,
				messageName, false);
		command.run();
		messageReference.setEMessage((Message) command.getWSDLElement());
		return createPart((Message) command.getWSDLElement());
	}

	/**
	 * Creates the part for the message, the name of the part is the default
	 * name and the name space and name are discovered from the message
	 * parameter. It used the WTP EMF based command internally.
	 *
	 * @param message the message
	 * @return the part
	 */
	public static Part createPart(Message message) {
		AddPartCommand command = new AddPartCommand(message,
				ServiceTemplateConstants.DEFAULT_PART_NAME, message.getQName()
						.getNamespaceURI(), message.getQName().getLocalPart(),
				false);
		command.run();
		return (Part) command.getWSDLElement();
	}

	/**
	 * Wrapper over the method.
	 *
	 * @param part the part
	 * @param operation the operation
	 * @param typeFolding the type folding
	 * @return the xSD complex type definition
	 * @throws CommandFailedException the command failed exception
	 * @see ServiceTemplateUtil#createXSDElementDefinition(String, Part, String,
	 * String).
	 * 
	 * The input parameter element name is computed from the part name using the
	 * WTP API and the operation parameter. The base service request type name
	 * and name space are parsed from the "service_config.properties" and passed
	 * to the API
	 */
	public static XSDComplexTypeDefinition createInputComplexType(Part part,
			Operation operation, boolean typeFolding)
			throws CommandFailedException {
		return createXSDElementDefinition(NameUtil.getPartName(operation
				.getEInput()), part, GlobalRepositorySystem.instanceOf()
				.getActiveRepositorySystem().getConfigurationRegistry()
				.getBaseServiceRequestType(), GlobalRepositorySystem
				.instanceOf().getActiveRepositorySystem()
				.getConfigurationRegistry().getBaseServiceRequestNameSpace(),
				typeFolding, operation.getEnclosingDefinition()
						.getTargetNamespace());

	}

	/**
	 * Wrapper over the method.
	 *
	 * @param part the part
	 * @param operation the operation
	 * @param typeFolding the type folding
	 * @return the xSD complex type definition
	 * @throws CommandFailedException the command failed exception
	 * @see ServiceTemplateUtil#createXSDElementDefinition(String, Part, String,
	 * String).
	 * 
	 * The output parameter element name is computed from the part name using
	 * the WTP API and the operation parameter. The base service response type
	 * name and name space are parsed from the "service_config.properties" and
	 * passed to the API
	 */
	public static XSDComplexTypeDefinition createOutputComplexType(Part part,
			Operation operation, boolean typeFolding)
			throws CommandFailedException {
		return createXSDElementDefinition(NameUtil.getPartName(operation
				.getEOutput()), part, GlobalRepositorySystem.instanceOf()
				.getActiveRepositorySystem().getConfigurationRegistry()
				.getBaseServiceResponseType(), GlobalRepositorySystem
				.instanceOf().getActiveRepositorySystem()
				.getConfigurationRegistry().getBaseServiceResponseNameSpace(),
				typeFolding, operation.getEnclosingDefinition()
						.getTargetNamespace());
	}

	/**
	 * Add the element declaration based on the parameter element passed. The
	 * default w3c data types will carry the prefix from corresponding to w3c
	 * name space and rest all will be computed and if the prefix does not exist
	 * then it is added before using it.
	 *
	 * @param parameterElement the parameter element
	 * @param complexTypeDefinition the complex type definition
	 * @param typeFolding the type folding
	 * @throws CommandFailedException the command failed exception
	 */
	public static void addElementDeclaration(
			IParameterElement parameterElement,
			XSDComplexTypeDefinition complexTypeDefinition, boolean typeFolding)
			throws CommandFailedException {
		String prefixedElementType = "";
		if (parameterElement.getDatatype() instanceof String) {
			prefixedElementType = TypeLibraryUIActivator.getPrefix(complexTypeDefinition
					.getSchema(), SOATypeLibraryConstants.W3C_NAMEPSACE)
					+ (String) parameterElement.getDatatype();
		} else {
			try {
				LibraryType libElementType = (LibraryType) parameterElement
						.getDatatype();
				String elementName = libElementType.getName();
				String elementNamespace = typeFolding ? complexTypeDefinition
						.getTargetNamespace() : TypeLibraryUtil
						.getNameSpace(libElementType);
				prefixedElementType = TypeLibraryUIActivator.getPrefix(
						complexTypeDefinition.getSchema(), elementNamespace)
						+ elementName;
			} catch (Exception e) {
				throw new CommandFailedException(StringUtil.formatString(
						SOAMessages.TYPE_NOT_FOUND, parameterElement
								.getDatatype()));
			}
		}
		XSDParticle xsdParticle = TypeLibraryUIActivator.createXSDElementDeclaration(
				parameterElement.getName(), prefixedElementType,
				parameterElement.getMinOccurs(), parameterElement
						.getMaxOccurs());
		XSDModelGroup xsdModelGroup = TypeLibraryUIActivator
				.getModelGroup(complexTypeDefinition);
		xsdModelGroup.getContents().add(xsdParticle);

	}

	/**
	 * Adds a binding to the definition model being used. Here we have both SOAP
	 * and HTTP bindings generation logic embedded. First we parse all the
	 * bindings to see if we have an existing binding. If we don't have one the
	 * we will add it. Note there is no hard coding for HTTP or SOAP here, but
	 * is there in the UI and we just consult the WTP model before adding it.
	 *
	 * @param definition the definition
	 * @param bindings the bindings
	 * @return the binding
	 */
	public static Binding addBinding(Definition definition,
			Set<TemplateBinding> bindings) {
		Binding binding = null;

		if (definition.getBindings() != null) {
			Iterator iterator = definition.getBindings().values().iterator();
			while (iterator.hasNext()) {
				Object objBinding = iterator.next();
				if (objBinding != null && objBinding instanceof Binding) {
					binding = (Binding) objBinding;
					BindingGenerator bindingGenerator = new BindingGenerator(
							definition, binding);
					for (TemplateBinding templBinding : bindings) {
						// This is bad we are identifying the type
						// of binding (ie if it is http or soap)
						// by the name
						if (StringUtils.containsIgnoreCase(binding.getQName()
								.getLocalPart(), templBinding.name())) {
							if (bindingGenerator.getContentGenerator() == null) {
								bindingGenerator.setOverwrite(true);
								bindingGenerator
										.setContentGenerator(ContentGeneratorExtensionFactoryRegistry
												.getInstance()
												.getGeneratorClassFromName(
														templBinding.name()));

							}
							bindingGenerator.generateBinding();

						}
					}

				}
			}
		}

		if (binding == null) {
			binding = WSDLFactory.eINSTANCE.createBinding();
			binding.setQName(new QName(definition.getTargetNamespace(),
					ServiceTemplateConstants.DEFAULT_BINDING_NAME));
			binding.setEnclosingDefinition(definition);
			definition.addBinding(binding);
			BindingGenerator bindingGenerator = new BindingGenerator(
					definition, binding);
			bindingGenerator.generateBinding();
		}
		return binding;
	}

	/**
	 * Creates an element definition with the given element name. The parent
	 * type of this definition would be the base element name parameter and the
	 * name space is the base element name space. THe definition is derived from
	 * the part and the anonymous type is also created based on the part. This
	 * API also makes sure that the parent type is imported before usage.
	 *
	 * @param elementName the element name
	 * @param part the part
	 * @param baseElementName the base element name
	 * @param baseElementNameSpace the base element name space
	 * @param typeFolding the type folding
	 * @param targetNameSpace the target name space
	 * @return the xSD complex type definition
	 */
	public static XSDComplexTypeDefinition createXSDElementDefinition(
			String elementName, Part part, String baseElementName,
			String baseElementNameSpace, boolean typeFolding,
			String targetNameSpace) {
		XSDElementDeclaration elementDef = XSDComponentHelper
				.createAnonymousXSDElementDefinition(elementName, part);

		XSDComplexTypeDefinition complexType = XSDFactory.eINSTANCE
				.createXSDComplexTypeDefinition();
		complexType.setName(StringUtils.capitalize(elementName));
		complexType.setTargetNamespace(part.getEnclosingDefinition()
				.getTargetNamespace());

		XSDParticle newXSDParticle = XSDFactory.eINSTANCE.createXSDParticle();
		XSDModelGroup newXSDModelGroup = XSDFactory.eINSTANCE
				.createXSDModelGroup();
		newXSDModelGroup.setCompositor(XSDCompositor.SEQUENCE_LITERAL);
		newXSDParticle.setContent(newXSDModelGroup);
		complexType.setContent(newXSDParticle);

		elementDef.setTypeDefinition(complexType);
		XSDComplexTypeDefinition complexTypeDefition = XSDComponentHelper
				.createXSDComplexTypeDefiniion(complexType.getName(), part);

		XSDComplexTypeDefinition restriction = XSDFactory.eINSTANCE
				.createXSDComplexTypeDefinition();

		if (!StringUtils.isEmpty(baseElementName)
				&& !StringUtils.isEmpty(baseElementNameSpace)) {
			if (!typeFolding)
				restriction.setName(TypeLibraryUIActivator.getPrefix(complexTypeDefition
						.getSchema(), baseElementNameSpace)
						+ baseElementName);
			else
				restriction.setName(TypeLibraryUIActivator.getPrefix(complexTypeDefition
						.getSchema(), targetNameSpace)
						+ baseElementName);
			complexTypeDefition
					.setDerivationMethod(XSDDerivationMethod.EXTENSION_LITERAL);
			complexTypeDefition.setBaseTypeDefinition(restriction);
		}
		TypeLibraryUIActivator.addDocumentation(complexTypeDefition, "Document goes here");
		return complexTypeDefition;
	}

	/**
	 * Computes the dependency of the parameter library type and in line the
	 * WSDL with the computed types. Duplicate types will be ignored. This is
	 * more a Wrapper over the method
	 *
	 * @param libraryType the library type
	 * @param definition the definition
	 * @param typeFolding the type folding
	 * @throws Exception the exception
	 * @see WTPTypeLibUtil#inlineType(LibraryType, Definition, boolean, boolean)
	 */
	public static void inlineTypesInWSDL(LibraryType libraryType,
			Definition definition, boolean typeFolding) throws Exception {
		ArrayList<LibraryType> librarylist = new ArrayList<LibraryType>();
		librarylist.add(libraryType);
		for (LibraryType loopLibraryType : SOAGlobalRegistryAdapter.getInstance()
				.getGlobalRegistry().getDependentParentTypeFiles(libraryType)) {
			librarylist.add(loopLibraryType);
		}
		for (LibraryType selectedType : librarylist) {
			WTPTypeLibUtil.inlineType(selectedType, definition, true,
					typeFolding);
		}
	}

	private static void addImportDirective(XSDTypeDefinition typeDefinition,
			String libElementNamespace) {
		if (!StringUtil.broadEquals(typeDefinition.getSchema()
				.getTargetNamespace(), libElementNamespace)
				&& !importExists(typeDefinition.getSchema(),
						libElementNamespace)) {
			XSDImport xsdSchemaDirective = XSDFactory.eINSTANCE
					.createXSDImport();
			xsdSchemaDirective.setNamespace(libElementNamespace);
			typeDefinition.getSchema().getContents().add(0, xsdSchemaDirective);
		}
	}

	private static boolean importExists(XSDSchema schema,
			String libElementNamespace) {
		for (Iterator i = schema.getContents().iterator(); i.hasNext();) {
			Object o = i.next();
			if (o instanceof XSDImport) {
				if (StringUtil.broadEquals(((XSDImport) o).getNamespace(),
						libElementNamespace)) {
					return true;
				}
			}
		}
		return false;
	}

}