SOAServiceUtil.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.resources.util;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Properties;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.ebayopensource.turmeric.eclipse.core.logging.SOALogger;
import org.ebayopensource.turmeric.eclipse.core.resources.constants.SOAProjectConstants;
import org.ebayopensource.turmeric.eclipse.core.resources.constants.SOAProjectConstants.ServiceLayer;
import org.ebayopensource.turmeric.eclipse.core.resources.constants.SOAProjectConstants.SupportedProjectType;
import org.ebayopensource.turmeric.eclipse.resources.model.ISOAProject;
import org.ebayopensource.turmeric.eclipse.resources.model.ISOAProjectResolver;
import org.ebayopensource.turmeric.eclipse.resources.model.SOAConsumerMetadata;
import org.ebayopensource.turmeric.eclipse.resources.model.SOAImplMetadata;
import org.ebayopensource.turmeric.eclipse.resources.model.SOAIntfMetadata;
import org.ebayopensource.turmeric.eclipse.resources.model.SOAIntfProject;
import org.ebayopensource.turmeric.eclipse.resources.model.SOAProjectEclipseMetadata;
import org.ebayopensource.turmeric.eclipse.resources.model.SOAProjectResolverFactory;
import org.ebayopensource.turmeric.eclipse.soatools.configtool.ConfigTool;
import org.ebayopensource.turmeric.eclipse.utils.lang.StringUtil;
import org.ebayopensource.turmeric.eclipse.utils.plugin.WorkspaceUtil;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;


/**
 * The Class SOAServiceUtil.
 *
 * @author smathew
 * 
 * Utility class for processing project properties The Project does not carry
 * information like the WSDL location. It will be calculated using the existing
 * project properties. The core calculation of the majority of functions inside
 * this class is based on the properties file. It handles all SOA interface,
 * implementation and consumer projects. Any new utility for these projects
 * should be added here.
 */
public class SOAServiceUtil {

	private static final SOALogger logger = SOALogger.getLogger();
	
	/**
	 * Compute admin name.
	 *
	 * @param serviceName the service name
	 * @param domainClassifier the domain classifier
	 * @param serviceVersion the service version
	 * @return the string
	 */
	public static String computeAdminName(String serviceName, String domainClassifier, 
			String serviceVersion) {
		if (StringUtils.isEmpty(serviceName))
			return SOAProjectConstants.EMPTY_STRING;
		StringBuffer result = new StringBuffer();
		if (StringUtils.isNotBlank(domainClassifier)) {
			//Marketplace organization
			result.append(StringUtils.capitalize(domainClassifier));
		}
		
		result.append(serviceName);
		result.append(SOAProjectConstants.MAJOR_VERSION_PREFIX);
		result.append(SOAServiceUtil.getServiceMajorVersion(serviceVersion));
		
		return result.toString();
	}
	
	/**
	 * Generate interface class name.
	 *
	 * @param adminName the admin name
	 * @param servicePackageName the service package name
	 * @return the string
	 */
	public static String generateInterfaceClassName(String adminName, 
			String servicePackageName) {
		return StringUtils.isBlank(servicePackageName) ? adminName
				: servicePackageName + SOAProjectConstants.CLASS_NAME_SEPARATOR + adminName;
	}
	
	/**
	 * Generate package name prefix.
	 *
	 * @param targetNamespace the target namespace
	 * @return the string
	 */
	public static String generatePackageNamePrefix(String targetNamespace) {
		if (StringUtils.isNotBlank(targetNamespace)) {
			return ConfigTool.getDefaultPackageNameFromNamespace(targetNamespace);
		}
		return "";
	}
	
	/**
	 * Generate service package name.
	 *
	 * @param serviceName the service name
	 * @param packageNamePrefix the package name prefix
	 * @return the string
	 */
	public static String generateServicePackageName(String serviceName, String packageNamePrefix) {
		if (StringUtils.isBlank(serviceName))
			return StringUtil.toString(packageNamePrefix);
		return StringUtil.toString(packageNamePrefix,
				SOAProjectConstants.CLASS_NAME_SEPARATOR, serviceName
						.toLowerCase(Locale.US));
	}
	
	/**
	 * Generate service impl class name.
	 *
	 * @param serviceName the service name
	 * @param adminName the admin name
	 * @param targetNamespace the target namespace
	 * @return the string
	 */
	public static String generateServiceImplClassName(String serviceName,String adminName, String targetNamespace) {
		return generateServiceImplPackageName(serviceName, adminName,
				generatePackageNamePrefix(targetNamespace));
	}

	/**
	 * Generate service impl package name.
	 *
	 * @param serviceName the service name
	 * @param adminName the admin name
	 * @param packageNamePrefix the package name prefix
	 * @return the string
	 */
	public static String generateServiceImplPackageName(String serviceName, String adminName, String packageNamePrefix) {
		if (StringUtils.isBlank(packageNamePrefix))
			return "";
		if (StringUtils.isBlank(serviceName))
			return StringUtil.toString(packageNamePrefix,
					SOAProjectConstants.CLASS_NAME_SEPARATOR,
					SOAProjectConstants.IMPL_PROJECT_SUFFIX.toLowerCase(),
					".Service", SOAProjectConstants.IMPL_PROJECT_SUFFIX);
		return StringUtil.toString(packageNamePrefix,
				SOAProjectConstants.CLASS_NAME_SEPARATOR, serviceName
				.toLowerCase(),
				SOAProjectConstants.CLASS_NAME_SEPARATOR,
				SOAProjectConstants.IMPL_PROJECT_SUFFIX.toLowerCase(),
				SOAProjectConstants.CLASS_NAME_SEPARATOR, adminName,
				SOAProjectConstants.IMPL_PROJECT_SUFFIX);
	}

	/**
	 * Gets the WSDL from the given interface project, It scans the project and
	 * look for the WSDL in the designated location if the project is created
	 * from WSDL. Remember Now SOA supports only services from WSDL. After the
	 * above mentioned checks it calls the method
	 *
	 * @param project the project
	 * @return the wsdl file
	 * @link {@link SOAServiceUtil}{@link #getWsdlFile(IProject, String)}
	 */
	public static IFile getWsdlFile(SOAIntfProject project) {
		if (SOALogger.DEBUG)
			logger.entering(project);
		IFile result = null;
		SOAIntfMetadata metadata = project.getMetadata();
		SOAProjectEclipseMetadata eclipseMetadata = project
				.getEclipseMetadata();
		if (metadata.getSourceType().equals(
				SOAProjectConstants.InterfaceSourceType.WSDL)) {
			if (SOALogger.DEBUG)
				logger.debug("The source type of this intf project is WSDL->",
						project.getProject());
			result = getWsdlFile(eclipseMetadata.getProject(), metadata
					.getServiceName());
		}
		if (SOALogger.DEBUG)
			logger.exiting(result);
		return result;
	}

	/**
	 * Wrapper over the linked method. Does not check if the service was created
	 * from WSDL or java. Client to check it. First it find out the project in
	 * the work space with the given name and will invoke the linked method.
	 *
	 * @param serviceName the service name
	 * @return the wsdl file
	 * @link {@link SOAServiceUtil}{@link #getWsdlFile(IProject, String)}
	 */
	public static IFile getWsdlFile(String serviceName) {
		if (SOALogger.DEBUG)
			logger.entering(serviceName);
		IProject project = WorkspaceUtil.getProject(serviceName);
		final IFile result = getWsdlFile(project, serviceName);
		if (SOALogger.DEBUG)
			logger.exiting(result);
		return result;
	}

	/**
	 * Gets the WSDL from the given eclipse project, It scans the project and
	 * look for the WSDL in the designated location. It just looks for the WSDL
	 * in the given eclipse project and does not have any SOA specific logic
	 * except for the location. If the project is null and is not accessible
	 * this will return null, so that way it is null safe but clients are
	 * supposed to handle the null graciously.
	 *
	 * @param project the project
	 * @param serviceName the service name
	 * @return the wsdl file
	 */
	public static IFile getWsdlFile(final IProject project,
			final String serviceName) {
		if (SOALogger.DEBUG)
			logger.entering(project, serviceName);
		IFile result = null;
		try {
			if (project == null || project.isAccessible() == false
					|| serviceName == null)
				return result;

			return result = project.getFile(SOAIntfProject.META_SRC_WSDL
					+ WorkspaceUtil.PATH_SEPERATOR + serviceName
					+ WorkspaceUtil.PATH_SEPERATOR + serviceName + ".wsdl");
		} finally {
			if (SOALogger.DEBUG)
				logger.exiting(result);
		}
	}

	/**
	 * Gets the sOA eclipse metadata.
	 *
	 * @param project the project
	 * @return the sOA eclipse metadata
	 */
	public static SOAProjectEclipseMetadata getSOAEclipseMetadata(
			IProject project) {
		return SOAProjectEclipseMetadata.create(project.getName(), project
				.getLocation().removeLastSegments(1));
	}

	/**
	 * Loads the SOA project from the given eclipse project, first it checks the
	 * type of project that is whether it is an interface, implementation or
	 * consumer and then load the rest of the project values from the
	 * corresponding configuration file(properties file). For implementation
	 * projects, the service configuration might not be loaded properly, because
	 * the interface project name is missing. In such a case, please load the
	 * service configuration yourself.
	 *
	 * @param project the project
	 * @param natureId the nature id
	 * @return the iSOA project
	 * @throws Exception the exception
	 */
	public static ISOAProject loadSOAProject(final IProject project, 
			String natureId)
			throws Exception {
		if (SOALogger.DEBUG)
			logger.entering(project);
		ISOAProject result = null;
		if (project == null || project.exists() == false
				|| project.isAccessible() == false)
			return result;
		project.refreshLocal(IResource.DEPTH_INFINITE, null);
		final SOAProjectEclipseMetadata eclipseMetadata = getSOAEclipseMetadata(project);
		if (SOALogger.DEBUG)
			logger.debug("Loading turmeric project->", project);
		final ISOAProjectResolver<?> resolver = SOAProjectResolverFactory.getSOAProjectResolver(
				natureId);
		if (resolver != null)
			result = resolver.loadProject(eclipseMetadata);
		else
			logger.warning("can not find project resolver for nature ID: ", natureId);
		
		if (SOALogger.DEBUG)
			logger.exiting(result);
		return result;
	}

	/**
	 * Loads SOAIntfMedata from service_intf_project.properties. Pure Wrapper
	 * over the linked method.
	 *
	 * @param metadata the metadata
	 * @return the sOA intf metadata
	 * @throws IOException Signals that an I/O exception has occurred.
	 * @throws CoreException the core exception
	 * @see {@link SOAServiceUtil}{@link #getSOAIntfMetadata(SOAProjectEclipseMetadata, SOAIntfMetadata)}
	 */
	public static SOAIntfMetadata getSOAIntfMetadata(
			SOAProjectEclipseMetadata metadata) throws IOException,
			CoreException {
		return getSOAIntfMetadata(metadata, null);
	}

	/**
	 * Loads the SOA interface project properties from the given meta data
	 * object. It can tolerate a null SOAIntfMetadata but meta data is not
	 * supposed to be null. Not null safe, Clients should handle the exceptions.
	 * It does not fail with an invalid properties file meaning an absence of a
	 * property will not cause this function to fail, It just makes the
	 * corresponding property empty.
	 *
	 * @param metadata the metadata
	 * @param intfMetadata the intf metadata
	 * @return the sOA intf metadata
	 * @throws IOException Signals that an I/O exception has occurred.
	 * @throws CoreException the core exception
	 */
	public static SOAIntfMetadata getSOAIntfMetadata(
			SOAProjectEclipseMetadata metadata, SOAIntfMetadata intfMetadata)
	throws IOException, CoreException {
		if (SOALogger.DEBUG)
			logger.entering(metadata, intfMetadata);

		if (intfMetadata == null) {
			intfMetadata = SOAIntfMetadata
			.create(SOAProjectConstants.InterfaceSourceType.JAVA);
		}

		final IFile file = SOAIntfUtil.getIntfProjectPropFile(metadata
				.getProject());
		if (file.isAccessible() == false) {
			logger
			.warning("The interface project's property file[", file
					.getLocation(),
			"] is not accessible, returning an empty instance of SOAIntfMetadata.");
			return SOAIntfMetadata
			.create(SOAProjectConstants.InterfaceSourceType.JAVA);
		}
		final Properties properties = new Properties();
		InputStream io = null;
		try {
			io = file.getContents();
			properties.load(io);
			if (SOAProjectConstants.PROPS_INTF_SOURCE_TYPE_WSDL
					.equals(StringUtils.trim(properties
							.getProperty(SOAProjectConstants.PROPS_INTF_SOURCE_TYPE)))) {
				intfMetadata
				.setSourceType(SOAProjectConstants.InterfaceSourceType.WSDL);
			}
			final String typeNamespace = StringUtils.trim(properties
					.getProperty(SOAProjectConstants.PROPS_KEY_TYPE_NAMESPACE));
			if (StringUtils.isNotBlank(typeNamespace)) {
				intfMetadata.setTypeNamespace(typeNamespace);
			}
			
			if(properties.containsKey(SOAProjectConstants.PROP_KEY_SERVICE_VERSION)) {
				intfMetadata.setServiceVersion(StringUtils.trim(properties.getProperty(
						SOAProjectConstants.PROP_KEY_SERVICE_VERSION)));
			}
			
			if(properties.containsKey(SOAProjectConstants.PROP_KEY_SERVICE_INTERFACE_CLASS_NAME)) {
				intfMetadata.setServiceInterface(StringUtils.trim(properties.getProperty(
						SOAProjectConstants.PROP_KEY_SERVICE_INTERFACE_CLASS_NAME)));
			}
			
			if(properties.containsKey(SOAProjectConstants.PROP_KEY_SERVICE_LAYER)) {
				intfMetadata.setServiceLayer(StringUtils.trim(properties.getProperty(
						SOAProjectConstants.PROP_KEY_SERVICE_LAYER)));
			}
			
			if(properties.containsKey(SOAProjectConstants.PROP_KEY_NON_XSD_FORMATS)) {
				intfMetadata.setServiceNonXSDProtocols(StringUtils.trim(properties.getProperty(
						SOAProjectConstants.PROP_KEY_NON_XSD_FORMATS)));
			}

			final String strTypeFolding = StringUtils.trim(properties
					.getProperty(SOAProjectConstants.PROPS_KEY_TYPE_FOLDING));

			intfMetadata.setTypeFolding(Boolean.valueOf(strTypeFolding));

			final String domainName = StringUtils.trim(properties
					.getProperty(SOAProjectConstants.PROPS_SERVICE_DOMAIN_NAME));
			if (StringUtils.isNotBlank(domainName)) {
				intfMetadata.setServiceDomainName(domainName);
			}
			final String nsPart = StringUtils.trim(properties
					.getProperty(SOAProjectConstants.PROPS_SERVICE_NAMESPACE_PART));

			if (StringUtils.isNotBlank(nsPart)) {
				intfMetadata.setServiceNamespacePart(nsPart);
			}
		} finally {
			IOUtils.closeQuietly(io);
		}
		if (SOALogger.DEBUG)
			logger.exiting(intfMetadata);
		return intfMetadata;
	}

	/**
	 * Loads meta data from service_impl_project.properties Pure Wrapper over
	 * the linked method.
	 *
	 * @param metadata the metadata
	 * @return the sOA impl metadata
	 * @throws IOException Signals that an I/O exception has occurred.
	 * @throws CoreException the core exception
	 * @see {@link SOAServiceUtil}{@link #getSOAImplMetadata(IProject))}
	 */
	public static SOAImplMetadata getSOAImplMetadata(
			SOAProjectEclipseMetadata metadata) throws IOException,
			CoreException {
		if (SOALogger.DEBUG)
			logger.entering(metadata);
		final SOAImplMetadata implMetadata = getSOAImplMetadata(metadata
				.getProject());
		if (SOALogger.DEBUG)
			logger.exiting(implMetadata);
		return implMetadata;
	}

	/**
	 * Loads the SOA implementation project properties from the given IProject
	 * object. It can tolerate a null SOAImplMetadata but meta data is not
	 * supposed to be null. Not null safe, Clients should handle the exceptions.
	 * It does not fail with an invalid properties file meaning an absence of a
	 * property will not cause this function to fail, It just makes the
	 * corresponding property empty.
	 *
	 * @param project the project
	 * @return the sOA impl metadata
	 * @throws IOException Signals that an I/O exception has occurred.
	 * @throws CoreException the core exception
	 */
	public static SOAImplMetadata getSOAImplMetadata(final IProject project)
			throws IOException, CoreException {
		if (SOALogger.DEBUG)
			logger.entering(project);
		final IFile file = project
				.getFile(SOAProjectConstants.PROPS_FILE_SERVICE_IMPL);
		if (file.isAccessible() == false) {
			logger
					.warning("The implementation project's property file[",
							file.getLocation(),
							"] is not accessible, returning an empty instance of SOAImplMetadata.");
			return SOAImplMetadata.create(project.getName(),
					SOAProjectConstants.DEFAULT_BASE_CONSUMER_SOURCE_DIRECTORY);
		}
		Properties properties = new Properties();
		InputStream io = null;
		SOAImplMetadata implMetadata = null;
		try {
			io = file.getContents();
			properties.load(io);
			final String baseConsumerDir = StringUtils.trim(properties
					.getProperty(SOAProjectConstants.PROPS_IMPL_BASE_CONSUMER_SRC_DIR));
			implMetadata = SOAImplMetadata.create(project.getName(),
					baseConsumerDir);
		} finally {
			IOUtils.closeQuietly(io);
		}
		if (SOALogger.DEBUG)
			logger.exiting(implMetadata);
		return implMetadata;
	}

	/**
	 * This function creates the SOA related meta data for the given project
	 * from service_consumer_project.properties. Pure Wrapper over the linked
	 * method.
	 *
	 * @param metadata the metadata
	 * @return the sOA consumer metadata
	 * @throws IOException Signals that an I/O exception has occurred.
	 * @throws CoreException Suresh changed this
	 * @see {@link SOAServiceUtil}{@link #getSOAConsumerMetadata(IProject))}
	 */
	public static SOAConsumerMetadata getSOAConsumerMetadata(
			SOAProjectEclipseMetadata metadata) throws IOException,
			CoreException {
		if (SOALogger.DEBUG)
			logger.entering(metadata);
		SOAConsumerMetadata consumerMetadata = getSOAConsumerMetadata(metadata
				.getProject());
		if (SOALogger.DEBUG)
			logger.exiting(consumerMetadata);
		return consumerMetadata;
	}

	/**
	 * Loads the SOA consumer project properties from the given IProject object.
	 * It can tolerate a null SOAConsumerMetadata but meta data is not supposed
	 * to be null. Not null safe, Clients should handle the exceptions. It does
	 * not fail with an invalid properties file meaning an absence of a property
	 * will not cause this function to fail, It just makes the corresponding
	 * property empty.
	 *
	 * @param project the project
	 * @return the sOA consumer metadata
	 * @throws IOException Signals that an I/O exception has occurred.
	 * @throws CoreException the core exception
	 */
	public static SOAConsumerMetadata getSOAConsumerMetadata(
			final IProject project) throws IOException, CoreException {
		if (SOALogger.DEBUG)
			logger.entering(project);
		final IFile file = project
				.getFile(SOAProjectConstants.PROPS_FILE_SERVICE_CONSUMER);
		Properties properties = new Properties();
		InputStream input = null;
		try {
			input = file.getContents();
			properties.load(input);
		} finally {
			IOUtils.closeQuietly(input);
		}

		String baseConsumerDir = StringUtils.trim(properties
				.getProperty(SOAProjectConstants.PROPS_IMPL_BASE_CONSUMER_SRC_DIR));
		
		SOAConsumerMetadata consumerMetadata = SOAConsumerMetadata.create(
				project.getName(), baseConsumerDir);
		final String envMapper = StringUtils.trim(properties.getProperty(
				SOAProjectConstants.PROPS_ENV_MAPPER));
		if (StringUtils.isNotBlank(envMapper)) {
			consumerMetadata.setEnvMapper(envMapper);
		}
		final String clientName = properties.getProperty(
				SOAProjectConstants.PROPS_KEY_CLIENT_NAME, project.getName());
		final String consumerId = properties.getProperty(
				SOAProjectConstants.PROPS_KEY_CONSUMER_ID, null);
		consumerMetadata.setClientName(clientName);
		consumerMetadata.setConsumerId(consumerId);
		consumerMetadata.setZeroConfig(Boolean.valueOf(StringUtils.trim(
				properties.getProperty(SOAProjectConstants.PROPS_SUPPORT_ZERO_CONFIG, 
					Boolean.FALSE.toString()))));
		
		if (SOALogger.DEBUG)
			logger.exiting(consumerMetadata);
		return consumerMetadata;
	}

	

	/**
	 * Returns true if the given project has one of the natures passed. Not null
	 * safe. If the project is not accessible, the API will fail and clients are
	 * supposed to handle it.
	 *
	 * @param project the project
	 * @param natureIDs the nature i ds
	 * @return true, if successful
	 * @throws CoreException the core exception
	 */
	public static boolean hasNatures(final IProject project,
			final String... natureIDs) throws CoreException {
		for (String natureId : natureIDs) {
			if (project.hasNature(natureId)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Checks if the given string is a valid service layer string, Now two
	 * checks are performed, empty and non numeric.
	 *
	 * @param layer the layer
	 * @return true, if is valid service layer
	 */
	public static boolean isValidServiceLayer(final String layer) {
		return StringUtils.isNotBlank(layer)
				&& StringUtils.isNumeric(layer) == false;
	}

	/**
	 * It first use the string based non SOA specific basic validation and it it
	 * passes then it will do the domain specific validation using the linked
	 * method for both the layers passed.
	 *
	 * @param layer the layer
	 * @param dependencyLayer the dependency layer
	 * @return true, if successful
	 * @see SOAServiceUtil#validateServiceLayer(ServiceLayer, ServiceLayer)
	 */
	public static boolean validateServiceLayer(final String layer,
			final String dependencyLayer) {
		if (isValidServiceLayer(layer) == false
				|| isValidServiceLayer(dependencyLayer) == false)
			return false;
		return validateServiceLayer(ServiceLayer.value(layer), ServiceLayer
				.value(dependencyLayer));
	}

	/**
	 * Does the SOA specific service layer validation specified in the SOA ERD.
	 * The API is null safe and returns false if any of the layer passed is
	 * null.
	 *
	 * @param layer the layer
	 * @param dependencyLayer the dependency layer
	 * @return true, if successful
	 */
	public static boolean validateServiceLayer(final ServiceLayer layer,
			final ServiceLayer dependencyLayer) {
		if (SOALogger.DEBUG)
			logger.entering(layer, dependencyLayer);
		boolean result = false;
		try {
			if (layer == null || dependencyLayer == null)
				return result;
			// This is eBay Marketplaces service layering policy for SOA
			// Framework
			// 1.8+ as per ERD
			// The relationship is greater than or equal (ordinal value) unless
			// its
			// the Business layer.
			if (ServiceLayer.BUSINESS.ordinal() == layer.ordinal()
					&& ServiceLayer.BUSINESS.ordinal() == dependencyLayer
							.ordinal())
				return result;
			return result = layer.ordinal() >= dependencyLayer.ordinal();
		} finally {
			if (SOALogger.DEBUG)
				logger.exiting(result);
		}
	}

	/**
	 * Gets the consumer folder for a given eclipse project. This API works for
	 * both implementation projects and consumer projects. The meta data object
	 * will have the directory name and it makes an eclipse API call on the
	 * project.
	 *
	 * @param project the project
	 * @param projectType the project type
	 * @return the base consumer folder
	 * @throws IOException Signals that an I/O exception has occurred.
	 * @throws CoreException the core exception
	 */
	public static IFolder getBaseConsumerFolder(final IProject project, 
			SupportedProjectType projectType)
			throws IOException, CoreException {
		if (SupportedProjectType.IMPL.equals(projectType)) {
			final SOAImplMetadata metadata = getSOAImplMetadata(project);
			if (metadata != null
					&& StringUtils.isNotBlank(metadata.getBaseConsumerSrcDir())) {
				return project.getFolder(metadata.getBaseConsumerSrcDir());
			}
		} else if (SupportedProjectType.CONSUMER.equals(projectType)) {
			final SOAConsumerMetadata metadata = getSOAConsumerMetadata(project);
			if (metadata != null
					&& StringUtils.isNotBlank(metadata.getBaseConsumerSrcDir())) {
				return project.getFolder(metadata.getBaseConsumerSrcDir());
			}
		}
		return project.getFolder(SOAProjectConstants.FOLDER_SRC);
	}
	
	/**
	 * Gets the invokeable service layer.
	 *
	 * @param layerName the layer name
	 * @return the invokeable service layer
	 */
	public static List<String> getInvokeableServiceLayer(String layerName){
		List<String> layers = new ArrayList<String>();
		ServiceLayer layer = ServiceLayer.value(layerName);
		switch (layer) {
		case COMMON:
			layers.add(ServiceLayer.COMMON.name());
			break;
		case INTERMEDIATE:
			layers.add(ServiceLayer.COMMON.name());
			layers.add(ServiceLayer.INTERMEDIATE.name());
			break;
		case BUSINESS:
			layers.add(ServiceLayer.COMMON.name());
			layers.add(ServiceLayer.INTERMEDIATE.name());
			break;
		}
		return layers;
	}
	
	/**
	 * Get the major version of the given service version.
	 * @param version
	 * @return
	 */
	public static String getServiceMajorVersion(String version) {
		if (StringUtils.isBlank(version))
			return "1";
		return StringUtils.substringBefore(version, ".");
	}

}