Attachment #69345 for bug #179329

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




            container="Axis2"
            platform="J2EE"/>
      <projectizer
            class="org.eclipse.tptp.wsdm.tooling.internal.projectizer.EclipseJ2EEAxis2Projectizer"
            name="Axis2 J2EE"
            servicePath="/services"
            servicePort="8080"/>

         point="org.eclipse.ui.startup">
      <startup class="org.eclipse.tptp.wsdm.tooling.internal.codegeneration.Activator"/>
   </extension>
   <extension
         point="org.eclipse.tptp.wsdm.editor.codeGeneration">
      <description
            container="Mini"
            platform="J2EE">
      </description>
      <projectizer
            class="org.eclipse.tptp.wsdm.tooling.internal.projectizer.EclipseJ2EEMiniProjectizer"
            name="J2EE Mini"
            servicePort="8080">
      </projectizer>
   </extension>
</plugin>






import java.io.File;
import java.net.URI;

import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.jst.common.project.facet.IJavaFacetInstallDataModelProperties;
import org.eclipse.jst.j2ee.project.facet.IJ2EEFacetConstants;
import org.eclipse.jst.j2ee.web.project.facet.IWebFacetInstallDataModelProperties;
import org.eclipse.tptp.wsdm.tooling.provisional.util.ProjectHelper;
import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties;
import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetProjectCreationDataModelProperties.FacetDataModelMap;

	private IProject _project;

	public WebProjectHelper(String name, String location, String binDir, String sourceDir) throws Exception {
		_project = getProject(location, name, null, false);
		
		IDataModel dataModel = DataModelFactory.createDataModel(IWebFacetInstallDataModelProperties.class);   
		dataModel.setProperty(IFacetProjectCreationDataModelProperties.FACET_PROJECT_NAME, name);     

		return _project;
	}

	public void setSuspendValidation(boolean shouldSuspend) {
		ValidatorManager.getManager().suspendValidation(getProject(), shouldSuspend);
	}
	




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.internal.projectizer;


import java.io.File;
import java.io.FileNotFoundException;
import java.net.URL;
import java.util.Map;

import org.apache.muse.tools.generator.projectizer.Axis2ProjectizerConstants;
import org.apache.muse.tools.generator.projectizer.J2EEAxis2Projectizer;
import org.apache.muse.tools.generator.util.ConfigurationData;
import org.apache.muse.tools.generator.util.ServicesDescriptorHelper;
import org.apache.muse.util.FileUtils;
import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.muse.ws.wsdl.WsdlUtils;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.EclipseConfigurationData;
import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.TargetedFileList;
import org.eclipse.tptp.wsdm.tooling.internal.codegeneration.Activator;
import org.eclipse.tptp.wsdm.tooling.internal.util.WebProjectHelper;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * Construct the projectizer for code generation
 */
public class EclipseAxis2Projectizer extends J2EEAxis2Projectizer {
	
	private static final String[] LIB_BUNDLE_IDS = { 
		"org.apache.muse.api", //$NON-NLS-1$
		"org.apache.muse.impl", //$NON-NLS-1$
		"org.apache.muse.core", //$NON-NLS-1$
		"org.apache.muse.tools", //$NON-NLS-1$
		"org.apache.muse.utils" //$NON-NLS-1$
		};
	
	private static final String[] MODULE_BUNDLE_IDS = { 
		"org.apache.muse.tools", //$NON-NLS-1$
		};
	
	private File[] _additionalJars;
	private Object[][] _instances;
	private IProgressMonitor _progressMonitor;
	private TargetedFileList[] _filesToCopy;

	private int _resourceCounter = 0;

	private String _projectName;

	private String _projectLocation;
	
	public void projectize(ConfigurationData configuration) throws Exception {
		
		ConfigurationData.checkConfiguration(this, configuration);
				
		try {
			
		loadParameters(configuration);

		startProgressMonitor(_progressMonitor, 10);

		WebProjectHelper helper = createProject();
		
		_targetDirectory = helper.getProjectDirectory();		
		
		recordProgress(_progressMonitor, 1);
		
		helper.setSuspendValidation(true);

		File webContentDir = copyTemplate(_targetDirectory);
		recordProgress(_progressMonitor, 1);
						
		File descriptorFile = new File(
				webContentDir, 
				Axis2ProjectizerConstants.DESCRIPTOR_FILE);
		
		File javaSourceDir = new File(
				_targetDirectory, 
				Axis2ProjectizerConstants.JAVA_SRC_DIR);
		
		createJavaSources(javaSourceDir, _filesMaps);
		recordProgress(_progressMonitor, 1);
		
		File wsdldir = new File(
				webContentDir, 
				Axis2ProjectizerConstants.WSDL_DIR);

		File routerEntriesDir = new File(webContentDir,Axis2ProjectizerConstants.ROUTER_ENTRIES_DIR);
		
		ServicesDescriptorHelper servicesHelper = new ServicesDescriptorHelper();
				
		createBuildFile(_targetDirectory, EclipseAxis2ProjectizerConstants.BUILD_FILE_RESOURCE, EclipseAxis2ProjectizerConstants.BUILD_FILE);
		recordProgress(_progressMonitor, 1);
		
		for(int i=0; i < _capabilitiesList.length; i++) {
			Map capabilities = _capabilitiesList[i];
			Document wsdl = _wsdls[i];
			createDescriptor(_descriptor, wsdl, descriptorFile, capabilities, Axis2ProjectizerConstants.WSDL_RELATIVE_PATH, i);						
			MetadataDescriptor rmd = _metadatas[i];
			createRMDFile(rmd, wsdl, wsdldir);
			createWSDLFile(wsdl, wsdldir);
			if(_instances == null) {
				createRouterEntries(routerEntriesDir, WsdlUtils.getServiceName(wsdl.getDocumentElement()), _capabilitiesList[i]);
			}
			updateServicesDescriptor(servicesHelper, wsdl, capabilities);
		}		
					
		if(_instances != null) {
			createRouterEntries(routerEntriesDir, _instances);
		}
		recordProgress(_progressMonitor, 4);
		
		File servicesFile = new File(webContentDir, Axis2ProjectizerConstants.SERVICES_FILE);
		createServicesDescriptor(servicesHelper, servicesFile);
		recordProgress(_progressMonitor, 1);
		
		helper.refreshProject();
		recordProgress(_progressMonitor, 1);
		
		helper.setSuspendValidation(false);
		} finally {
			finishProgressMonitor(_progressMonitor);
		}
	}
		
	private void finishProgressMonitor(IProgressMonitor monitor) {
		if(monitor != null) {
			monitor.done();
		}
	}

	private void recordProgress(IProgressMonitor monitor, int i) {
		if(monitor != null) {
			monitor.worked(1);
		}
	}

	private void startProgressMonitor(IProgressMonitor monitor, int i) {
		if(monitor != null) {
			monitor.beginTask("Running Projectizer", 9);
		}
	}

	protected void loadParameters(ConfigurationData data) {
		super.loadParameters(data);
		
		_additionalJars = (File[])data.getParameter(EclipseConfigurationData.ADDITIONAL_JARS);
		_instances = (Object[][])data.getParameter(EclipseConfigurationData.INSTANCES);	
		_progressMonitor = (IProgressMonitor)data.getParameter(EclipseConfigurationData.PROGRESS_MONITOR);
		_filesToCopy = (TargetedFileList[])data.getParameter(EclipseConfigurationData.AXIS2_FILES);
		_projectName = (String)data.getParameter(EclipseConfigurationData.PROJECT_NAME);
		_projectLocation = (String)data.getParameter(EclipseConfigurationData.PROJECT_LOCATION);		
	}

	private WebProjectHelper createProject() throws Exception {
		WebProjectHelper helper = new WebProjectHelper(_projectName, _projectLocation, EclipseAxis2ProjectizerConstants.JAVA_BIN_DIR, Axis2ProjectizerConstants.JAVA_SRC_DIR);
		
		return helper;
	}
	
	protected void createRouterEntries(File routerEntriesDir,Object[][] instances) throws Exception {
		routerEntriesDir.mkdirs();
		
		for (int i = 0; i < _instances.length; i++) {
			Object[] instancePair = _instances[i];

			//
			// This is really tacky, but it's the only real way to do this
			// since there are no pairs. The File use is to get the last element
			// of the path in a nice, non-hack way.
			//
			String path = (String) instancePair[0];
			String resourcePathName = new File(path).getName();

			Element instanceElement = (Element) instancePair[1];

			File serviceDir = new File(routerEntriesDir, resourcePathName);
			File routerEntryFile = new File(serviceDir, getResourceFileName());

			writeToFileCheck(instanceElement, routerEntryFile);
		}
	}
	
	protected String getResourceFileName() {
		return Axis2ProjectizerConstants.RESOURCE_FILE.replaceFirst(PLACE_HOLDER, String.valueOf(_resourceCounter++));
	}
	
	protected File copyTemplate(File destination) throws Exception {	
		URL url = Platform.getBundle(Activator.PLUGIN_ID).getEntry(EclipseAxis2ProjectizerConstants.WEBCONTENT_DIR_RESOURCE);
		url = FileLocator.toFileURL(url);
		
		File source = toFile(url);
		FileUtils.copyDirectory(source, destination);
		
		File webContentDir = new File(destination, source.getName());
		File webContentDestination = new File(webContentDir, "WEB-INF"); //$NON-NLS-1$
		
		for (int i=0; i < LIB_BUNDLE_IDS.length; i++) {		
			url = Platform.getBundle(LIB_BUNDLE_IDS[i]).getEntry(EclipseAxis2ProjectizerConstants.PROJECT_LIB_DIR_RESOURCE);
			url = FileLocator.toFileURL(url);
	
			File libSource = toFile(url);			
			FileUtils.copyDirectory(libSource, webContentDestination);
		}
		
		for (int i=0; i < MODULE_BUNDLE_IDS.length; i++) {		
			url = Platform.getBundle(MODULE_BUNDLE_IDS[i]).getEntry(EclipseAxis2ProjectizerConstants.PROJECT_MODULE_DIR_RESOURCE);
			url = FileLocator.toFileURL(url);
	
			File libSource = toFile(url);			
			FileUtils.copyDirectory(libSource, webContentDestination);
		}
		
		//
		//TODO: Hack to copy axis2-platform
		//this should be done in some cleaner way
		//
		
		url = Platform.getBundle(MODULE_BUNDLE_IDS[0]).getEntry("/lib/muse-platform-axis2-2.2.0.jar");
		url = FileLocator.toFileURL(url);

		File libSource = toFile(url);			
		FileUtils.copyFile(libSource, webContentDestination);
		
		File libDestination = new File(webContentDestination, "lib");
		
		if(_additionalJars != null) {
			for (int i=0; i < _additionalJars.length; i++) {
				if(!_additionalJars[i].exists()) {
					throw new FileNotFoundException(_additionalJars[i].getAbsolutePath());
				}
				
				FileUtils.copyFile(_additionalJars[i], libDestination);
			}
		}
		
		for (int i=0; i < _filesToCopy.length; i++) {
			String dest = _filesToCopy[i].getRelativePath();
			File destDir = new File(webContentDir, dest);
			String[] files = _filesToCopy[i].getFiles();
			
			for (int j=0; j < files.length; j++) {
				File file = new File(files[j]);
				if(!file.exists()) {
					throw new FileNotFoundException(file.getAbsolutePath());
				}
				
				FileUtils.copyFile(file, destDir);
			}
		}

		return webContentDir;	
	}
	private File toFile(URL url) throws Exception{

		return new File(url.getFile());
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.internal.projectizer;


public interface EclipseAxis2ProjectizerConstants {
	
	String RESOURCES_DIR = "/resources/axis2/"; //$NON-NLS-1$
	
	String BUILD_FILE_RESOURCE = RESOURCES_DIR + "build.xml"; //$NON-NLS-1$
	
	String BUILD_FILE = "build.xml"; //$NON-NLS-1$

	String LAUNCH_FILE_RESOURCE = RESOURCES_DIR + ".externalToolBuilders/jarBuilder.launch"; //$NON-NLS-1$

	String WEBCONTENT_DIR_RESOURCE = RESOURCES_DIR + "WebContent"; //$NON-NLS-1$

	String PROJECT_LIB_DIR_RESOURCE = "/lib"; //$NON-NLS-1$
	
	String PROJECT_MODULE_DIR_RESOURCE = "/modules"; //$NON-NLS-1$

	String JAVA_BIN_DIR = "bin"; //$NON-NLS-1$

}

Lines 1-7 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/internal/projectizer/EclipseJ2EEMiniProjectizer.java (+285 lines)
		1	/*******************************************************************************
		2	* Copyright (c) 2007 IBM Corporation and others.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Andrew Eberbach (aeberbac@us.ibm.com)
		10	* IBM Corporation - initial API and implementation
		11	*******************************************************************************/
1	package org.eclipse.tptp.wsdm.tooling.internal.projectizer;	12	package org.eclipse.tptp.wsdm.tooling.internal.projectizer;
2		13
		14	import java.io.File;
		15	import java.io.FileNotFoundException;
		16	import java.io.InputStream;
		17	import java.net.URL;
		18	import java.util.Map;
		19
3	import org.apache.muse.tools.generator.projectizer.J2EEMiniProjectizer;	20	import org.apache.muse.tools.generator.projectizer.J2EEMiniProjectizer;
		21	import org.apache.muse.tools.generator.util.ConfigurationData;
		22	import org.apache.muse.util.FileUtils;
		23	import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
		24	import org.apache.muse.ws.wsdl.WsdlUtils;
		25	import org.eclipse.core.runtime.FileLocator;
		26	import org.eclipse.core.runtime.IProgressMonitor;
		27	import org.eclipse.core.runtime.Platform;
		28	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.EclipseConfigurationData;
		29	import org.eclipse.tptp.wsdm.tooling.internal.util.ProgressMonitorHelper;
		30	import org.eclipse.tptp.wsdm.tooling.internal.util.ProjectHelper;
		31	import org.eclipse.tptp.wsdm.tooling.internal.util.WebProjectHelper;
		32	import org.w3c.dom.Document;
		33	import org.w3c.dom.Element;
4		34
5	public class EclipseJ2EEMiniProjectizer extends J2EEMiniProjectizer {	35	public class EclipseJ2EEMiniProjectizer extends J2EEMiniProjectizer {
		36	private static final String[] LIB_BUNDLE_IDS = {
		37	"org.apache.muse.api", //$NON-NLS-1$
		38	"org.apache.muse.impl", //$NON-NLS-1$
		39	"org.apache.muse.core", //$NON-NLS-1$
		40	"org.apache.muse.tools", //$NON-NLS-1$
		41	"org.apache.muse.utils" //$NON-NLS-1$
		42	};
		43
		44	private static final String CONTAINER_BUNDLE = "org.apache.muse.tools";//$NON-NLS-1$
		45	private static final String CONTAINER_RESOURCE = "/containers/muse-platform-mini-2.2.0.jar";//$NON-NLS-1$
		46
		47	private String _projectName;
		48	private String _projectLocation;
		49	private File[] _additionalJars;
		50	private Object[][] _instances;
		51	private ProgressMonitorHelper _progressMonitorHelper;
		52
		53	public void projectize(ConfigurationData configuration) throws Exception {
		54	ConfigurationData.checkConfiguration(this, configuration);
		55	loadParameters(configuration);
		56	ProgressMonitorHelper progressHelper = getProgressMonitor();
		57	progressHelper.startProgressMonitor(6);
		58
		59	try {
		60	WebProjectHelper helper = createProjectHelper();
		61
		62	helper.setSuspendValidation(true);
		63
		64	createJavaSources(helper, progressHelper);
		65	createArtifacts(helper, progressHelper);
		66	createLibraries(helper, progressHelper);
		67
		68	helper.refreshProject();
		69	helper.setSuspendValidation(false);
		70	} finally {
		71	progressHelper.finishProgressMonitor();
		72	}
		73	}
		74
		75	protected void createLibraries(WebProjectHelper helper, ProgressMonitorHelper progressHelper) throws Exception {
		76	copyLibrariesFromBundles(helper, LIB_BUNDLE_IDS);
		77	progressHelper.recordProgress();
		78
		79	copyAdditionalJars(helper);
		80	progressHelper.recordProgress();
		81
		82	copyContainer(helper);
		83	progressHelper.recordProgress();
		84	}
		85
		86	protected void copyContainer(WebProjectHelper helper) throws Exception {
		87	File webInfLibDir = new File(helper.getProjectDirectory(), EclipseJ2EEMiniProjectizerConstants.WEBINFLIB_DIR);
		88	URL url = Platform.getBundle(CONTAINER_BUNDLE).getEntry(CONTAINER_RESOURCE);
		89	url = FileLocator.toFileURL(url);
		90
		91	File libSource = ProjectHelper.toFile(url);
		92	FileUtils.copy(libSource, webInfLibDir);
		93	}
		94
		95	protected void copyAdditionalJars(WebProjectHelper helper) throws Exception {
		96	File webInfLibDir = new File(helper.getProjectDirectory(), EclipseJ2EEMiniProjectizerConstants.WEBINFLIB_DIR);
		97
		98	File[] additionalJars = getAdditionalJars();
		99
100	if(additionalJars != null) {
101	for (int i=0; i < additionalJars.length; i++) {
102	if(!additionalJars[i].exists()) {
103	throw new FileNotFoundException(additionalJars[i].getAbsolutePath());
104	}
105
106	FileUtils.copyFile(additionalJars[i], webInfLibDir);
107	}
108	}
109	}
110
111	protected void copyLibrariesFromBundles(WebProjectHelper helper, String[] libBundleIds) throws Exception {
112	URL url = null;
113	File webInfDir = new File(helper.getProjectDirectory(), EclipseJ2EEMiniProjectizerConstants.WEBINF_DIR);
114
115	for (int i=0; i < libBundleIds.length; i++) {
116	url = Platform.getBundle(libBundleIds[i]).getEntry(EclipseJ2EEMiniProjectizerConstants.PROJECT_LIB_DIR_RESOURCE);
117	url = FileLocator.toFileURL(url);
118
119	File libSource = ProjectHelper.toFile(url);
120	FileUtils.copyDirectory(libSource, webInfDir);
121	}
122	}
123
124	protected WebProjectHelper createProjectHelper() throws Exception {
125	return new WebProjectHelper(
126	getProjectName(),
127	getProjectLocation(),
128	EclipseJ2EEMiniProjectizerConstants.JAVA_BIN_DIR,
129	EclipseJ2EEMiniProjectizerConstants.JAVA_SRC_DIR);
130	}
131
132	protected void createJavaSources(WebProjectHelper helper, ProgressMonitorHelper progressHelper) throws Exception {
133	File javaSourceDir = new File(
134	helper.getProjectDirectory(),
135	EclipseJ2EEMiniProjectizerConstants.JAVA_SRC_DIR);
136
137	createJavaSources(javaSourceDir, getFilesMaps());
138	progressHelper.recordProgress();
139	}
140
141	protected void createArtifacts(WebProjectHelper helper, ProgressMonitorHelper progressHelper) throws Exception {
142	File descriptorFile = new File(
143	helper.getProjectDirectory(),
144	EclipseJ2EEMiniProjectizerConstants.DESCRIPTOR_FILE);
145
146	File wsdldir = new File(
147	helper.getProjectDirectory(),
148	EclipseJ2EEMiniProjectizerConstants.WSDL_DIR);
149
150	File routerEntriesDir = new File(
151	helper.getProjectDirectory(),
152	EclipseJ2EEMiniProjectizerConstants.ROUTER_ENTRIES_DIR);
153
154	for(int i=0; i < getNumCapabilityMaps(); i++) {
155	Map capabilities = getCapabilityMap(i);
156	MetadataDescriptor rmd = getMetadata(i);
157	Document wsdl = getWsdl(i);
158
159	createDescriptor(getDescriptor(),
160	wsdl,
161	descriptorFile,
162	capabilities,
163	EclipseJ2EEMiniProjectizerConstants.WSDL_RELATIVE_PATH,
164	i);
165
166	createRMDFile(rmd, wsdl, wsdldir);
167	createWSDLFile(wsdl, wsdldir);
168
169	if(getInstances() == null) {
170	createRouterEntries(routerEntriesDir, WsdlUtils.getServiceName(wsdl.getDocumentElement()), _capabilitiesList[i]);
171	}
172	}
173
174	progressHelper.recordProgress();
175
176	if(getInstances() != null) {
177	createRouterEntries(routerEntriesDir, getInstances());
178	}
179
180	createWebDescriptor(helper);
181	createBuildFile(helper.getProjectDirectory(),
182	EclipseJ2EEMiniProjectizerConstants.BUILD_FILE_RESOURCE,
183	EclipseJ2EEMiniProjectizerConstants.BUILD_FILE);
184
185	progressHelper.recordProgress();
186	}
187
188	protected void createBuildFile(File baseTargetDir, String buildFileResource, String buildFile) throws Exception {
189	InputStream buildTemplate = FileUtils.loadFromContext(this.getClass(),buildFileResource);
190	File build = new File(baseTargetDir, buildFile);
191	copyStreamCheck(buildTemplate, build);
192	}
193
194	protected void createWebDescriptor(WebProjectHelper helper) throws Exception {
195	File webInfDir = new File(helper.getProjectDirectory(),EclipseJ2EEMiniProjectizerConstants.WEBINF_DIR);
196	File descriptorFile = new File(webInfDir, EclipseJ2EEMiniProjectizerConstants.WEBXML_FILE);
197	if(!descriptorFile.delete()) {
198	throw new Exception();
199	}
200	createFileFromResource(webInfDir,
201	EclipseJ2EEMiniProjectizerConstants.WEBXML_RESOURCE,
202	EclipseJ2EEMiniProjectizerConstants.WEBXML_FILE);
203	}
204
205	protected Map getCapabilityMap(int index) {
206	return _capabilitiesList[index];
207	}
208
209	protected void createRouterEntries(File routerEntriesDir,Object[][] instances) throws Exception {
210	routerEntriesDir.mkdirs();
211
212	for (int i = 0; i < getInstances().length; i++) {
213	Object[] instancePair = getInstances()[i];
214
215	//
216	// This is really tacky, but it's the only real way to do this
217	// since there are no pairs. The File use is to get the last element
218	// of the path in a nice, non-hack way.
219	//
220	String path = (String) instancePair[0];
221	String resourcePathName = new File(path).getName();
222
223	Element instanceElement = (Element) instancePair[1];
224
225	File serviceDir = new File(routerEntriesDir, resourcePathName);
226	File routerEntryFile = new File(serviceDir, getResourceFileName(i));
227
228	writeToFileCheck(instanceElement, routerEntryFile);
229	}
230	}
231
232	/**
233	* Get the name of a resource-instance file with the appropriate counter. This is
234	* really just a string-replace of the PLACE_HOLDER value with the given counter
235	*
236	* @param counter The number to use in the string replace
237	* @return The string with PLACE_HOLDER replaced by the string value of counter
238	*/
239	protected String getResourceFileName(int counter) {
240	return EclipseJ2EEMiniProjectizerConstants.RESOURCE_FILE.replaceFirst(PLACE_HOLDER, String.valueOf(counter));
241	}
242
243	protected void loadParameters(ConfigurationData data) {
244	super.loadParameters(data);
245
246	_additionalJars = (File[]) data.getParameter(EclipseConfigurationData.ADDITIONAL_JARS);
247	_instances = (Object[][]) data.getParameter(EclipseConfigurationData.INSTANCES);
248	_progressMonitorHelper = new ProgressMonitorHelper((IProgressMonitor) data.getParameter(EclipseConfigurationData.PROGRESS_MONITOR));
249	_projectName = (String) data.getParameter(EclipseConfigurationData.PROJECT_NAME);
250	_projectLocation = (String) data.getParameter(EclipseConfigurationData.PROJECT_LOCATION);
251	}
252
253	protected File[] getAdditionalJars() {
254	return _additionalJars;
255	}
256
257	protected Map[] getFilesMaps() {
258	return _filesMaps;
259	}
260
261	protected String getProjectLocation() {
262	return _projectLocation;
263	}
264
265	protected String getProjectName() {
266	return _projectName;
267	}
268
269	protected ProgressMonitorHelper getProgressMonitor() {
270	return _progressMonitorHelper;
271	}
272
273	protected Object[][] getInstances() {
274	return _instances;
275	}
276
277	protected Document getDescriptor() {
278	return _descriptor;
279	}
280
281	protected int getNumCapabilityMaps() {
282	return _capabilitiesList.length;
283	}
284
285	protected Document getWsdl(int index) {
286	return _wsdls[index];
287	}
6		288
		289	protected MetadataDescriptor getMetadata(int index) {
		290	return _metadatas[index];
		291	}
7	}	292	}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.tptp.wsdm.tooling.internal.projectizer;

public interface EclipseJ2EEMiniProjectizerConstants {

	String RESOURCE_FILE = "resource-instance-XXX.xml";//$NON-NLS-1$
	String WSDL_RELATIVE_PATH = "/wsdl/";//$NON-NLS-1$
	
	String JAVA_SRC_DIR = "JavaSource/";//$NON-NLS-1$
	String WEBCONTENT_DIR = "WebContent/";//$NON-NLS-1$
	String WEBINF_DIR = WEBCONTENT_DIR + "WEB-INF/";//$NON-NLS-1$
	
	String JAVA_BIN_DIR = "/bin";//$NON-NLS-1$
	String JAVA_CLASSES_DIR = WEBINF_DIR + "classes/";//$NON-NLS-1$
	String DESCRIPTOR_FILE = JAVA_CLASSES_DIR + "muse.xml";//$NON-NLS-1$			
	String WSDL_DIR = JAVA_CLASSES_DIR + "wsdl/";//$NON-NLS-1$
	String ROUTER_ENTRIES_DIR = JAVA_CLASSES_DIR + "router-entries/";//$NON-NLS-1$
	
	String RESOURCES_DIR = "/resources/mini/";//$NON-NLS-1$
	String WEBXML_RESOURCE = RESOURCES_DIR + "web.xml";//$NON-NLS-1$
	String WEBXML_FILE = "web.xml";//$NON-NLS-1$
	String PROJECT_LIB_DIR_RESOURCE = "/lib/";//$NON-NLS-1$
	String WEBINFLIB_DIR = WEBINF_DIR + "lib/";//$NON-NLS-1$
	String BUILD_FILE_RESOURCE = RESOURCES_DIR + "build.xml"; //$NON-NLS-1$;
	String BUILD_FILE = "build.xml";
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.internal.projectizer;


import java.io.File;
import java.io.FileNotFoundException;
import java.net.URL;
import java.util.Map;

import org.apache.muse.tools.generator.projectizer.Axis2ProjectizerConstants;
import org.apache.muse.tools.generator.projectizer.J2EEAxis2Projectizer;
import org.apache.muse.tools.generator.util.ConfigurationData;
import org.apache.muse.tools.generator.util.ServicesDescriptorHelper;
import org.apache.muse.util.FileUtils;
import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.muse.ws.wsdl.WsdlUtils;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.EclipseConfigurationData;
import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.TargetedFileList;
import org.eclipse.tptp.wsdm.tooling.internal.codegeneration.Activator;
import org.eclipse.tptp.wsdm.tooling.internal.util.ProgressMonitorHelper;
import org.eclipse.tptp.wsdm.tooling.internal.util.ProjectHelper;
import org.eclipse.tptp.wsdm.tooling.internal.util.WebProjectHelper;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * Construct the projectizer for code generation
 */
public class EclipseJ2EEAxis2Projectizer extends J2EEAxis2Projectizer {
	
	
	private static final String CONTAINER_BUNDLE = "org.apache.muse.tools";//$NON-NLS-1$
	private static final String CONTAINER_RESOURCE = "/containers/muse-platform-axis2-2.2.0.jar";//$NON-NLS-1$
		
	
	private static final String[] LIB_BUNDLE_IDS = { 
		"org.apache.muse.api", //$NON-NLS-1$
		"org.apache.muse.impl", //$NON-NLS-1$
		"org.apache.muse.core", //$NON-NLS-1$
		"org.apache.muse.tools", //$NON-NLS-1$
		"org.apache.muse.utils" //$NON-NLS-1$
		};
	
	private static final String[] MODULE_BUNDLE_IDS = { 
		"org.apache.muse.tools", //$NON-NLS-1$
		};
	
	private File[] _additionalJars;
	private Object[][] _instances;
	private IProgressMonitor _progressMonitor;
	private TargetedFileList[] _filesToCopy;

	private int _resourceCounter = 0;

	private String _projectName;

	private String _projectLocation;
	
	public void projectize(ConfigurationData configuration) throws Exception {
		
		ConfigurationData.checkConfiguration(this, configuration);
		loadParameters(configuration);
		ProgressMonitorHelper progressHelper = new ProgressMonitorHelper(_progressMonitor);	
		try {
			
		progressHelper.startProgressMonitor(10);

		WebProjectHelper helper = createProject();
		
		_targetDirectory = helper.getProjectDirectory();		
		
		progressHelper.recordProgress();
		
		helper.setSuspendValidation(true);

		File webContentDir = copyTemplate(_targetDirectory);
		progressHelper.recordProgress();
						
		File descriptorFile = new File(
				webContentDir, 
				Axis2ProjectizerConstants.DESCRIPTOR_FILE);
		
		File javaSourceDir = new File(
				_targetDirectory, 
				Axis2ProjectizerConstants.JAVA_SRC_DIR);
		
		createJavaSources(javaSourceDir, _filesMaps);
		progressHelper.recordProgress();
		
		File wsdldir = new File(
				webContentDir, 
				Axis2ProjectizerConstants.WSDL_DIR);

		File routerEntriesDir = new File(webContentDir,Axis2ProjectizerConstants.ROUTER_ENTRIES_DIR);
		
		ServicesDescriptorHelper servicesHelper = new ServicesDescriptorHelper();
				
		createBuildFile(_targetDirectory, EclipseJ2EEAxis2ProjectizerConstants.BUILD_FILE_RESOURCE, EclipseJ2EEAxis2ProjectizerConstants.BUILD_FILE);
		progressHelper.recordProgress();
		
		for(int i=0; i < _capabilitiesList.length; i++) {
			Map capabilities = _capabilitiesList[i];
			Document wsdl = _wsdls[i];
			createDescriptor(_descriptor, wsdl, descriptorFile, capabilities, Axis2ProjectizerConstants.WSDL_RELATIVE_PATH, i);						
			MetadataDescriptor rmd = _metadatas[i];
			createRMDFile(rmd, wsdl, wsdldir);
			createWSDLFile(wsdl, wsdldir);
			if(_instances == null) {
				createRouterEntries(routerEntriesDir, WsdlUtils.getServiceName(wsdl.getDocumentElement()), _capabilitiesList[i]);
			}
			updateServicesDescriptor(servicesHelper, wsdl, capabilities);
		}		
					
		if(_instances != null) {
			createRouterEntries(routerEntriesDir, _instances);
		}
		progressHelper.recordProgress(4);
		
		File servicesFile = new File(webContentDir, Axis2ProjectizerConstants.SERVICES_FILE);
		createServicesDescriptor(servicesHelper, servicesFile);
		progressHelper.recordProgress();
		
		helper.refreshProject();
		progressHelper.recordProgress();
		
		helper.setSuspendValidation(false);
		} finally {
			progressHelper.finishProgressMonitor();
		}
	}	

	protected void loadParameters(ConfigurationData data) {
		super.loadParameters(data);
		
		_additionalJars = (File[])data.getParameter(EclipseConfigurationData.ADDITIONAL_JARS);
		_instances = (Object[][])data.getParameter(EclipseConfigurationData.INSTANCES);	
		_progressMonitor = (IProgressMonitor)data.getParameter(EclipseConfigurationData.PROGRESS_MONITOR);
		_filesToCopy = (TargetedFileList[])data.getParameter(EclipseConfigurationData.AXIS2_FILES);
		_projectName = (String)data.getParameter(EclipseConfigurationData.PROJECT_NAME);
		_projectLocation = (String)data.getParameter(EclipseConfigurationData.PROJECT_LOCATION);		
	}

	private WebProjectHelper createProject() throws Exception {
		WebProjectHelper helper = new WebProjectHelper(_projectName, _projectLocation, EclipseJ2EEAxis2ProjectizerConstants.JAVA_BIN_DIR, Axis2ProjectizerConstants.JAVA_SRC_DIR);
		
		return helper;
	}
	
	protected void createRouterEntries(File routerEntriesDir,Object[][] instances) throws Exception {
		routerEntriesDir.mkdirs();
		
		for (int i = 0; i < _instances.length; i++) {
			Object[] instancePair = _instances[i];

			//
			// This is really tacky, but it's the only real way to do this
			// since there are no pairs. The File use is to get the last element
			// of the path in a nice, non-hack way.
			//
			String path = (String) instancePair[0];
			String resourcePathName = new File(path).getName();

			Element instanceElement = (Element) instancePair[1];

			File serviceDir = new File(routerEntriesDir, resourcePathName);
			File routerEntryFile = new File(serviceDir, getResourceFileName());

			writeToFileCheck(instanceElement, routerEntryFile);
		}
	}
	
	protected String getResourceFileName() {
		return Axis2ProjectizerConstants.RESOURCE_FILE.replaceFirst(PLACE_HOLDER, String.valueOf(_resourceCounter++));
	}
	
	protected File copyTemplate(File destination) throws Exception {	
		URL url = Platform.getBundle(Activator.PLUGIN_ID).getEntry(EclipseJ2EEAxis2ProjectizerConstants.WEBCONTENT_DIR_RESOURCE);
		url = FileLocator.toFileURL(url);
		
		File source = ProjectHelper.toFile(url);
		FileUtils.copyDirectory(source, destination);
		
		File webContentDir = new File(destination, source.getName());
		File webContentDestination = new File(webContentDir, "WEB-INF"); //$NON-NLS-1$
		
		for (int i=0; i < LIB_BUNDLE_IDS.length; i++) {		
			url = Platform.getBundle(LIB_BUNDLE_IDS[i]).getEntry(EclipseJ2EEAxis2ProjectizerConstants.PROJECT_LIB_DIR_RESOURCE);
			url = FileLocator.toFileURL(url);
	
			File libSource = ProjectHelper.toFile(url);			
			FileUtils.copyDirectory(libSource, webContentDestination);
		}
		
		for (int i=0; i < MODULE_BUNDLE_IDS.length; i++) {		
			url = Platform.getBundle(MODULE_BUNDLE_IDS[i]).getEntry(EclipseJ2EEAxis2ProjectizerConstants.PROJECT_MODULE_DIR_RESOURCE);
			url = FileLocator.toFileURL(url);
	
			File libSource = ProjectHelper.toFile(url);			
			FileUtils.copyDirectory(libSource, webContentDestination);
		}
				
		File libDestination = new File(webContentDestination, "lib");
		
		url = Platform.getBundle(CONTAINER_BUNDLE).getEntry(CONTAINER_RESOURCE);
		url = FileLocator.toFileURL(url);
		
		File libSource = ProjectHelper.toFile(url);			
		FileUtils.copy(libSource, libDestination);		
		
		if(_additionalJars != null) {
			for (int i=0; i < _additionalJars.length; i++) {
				if(!_additionalJars[i].exists()) {
					throw new FileNotFoundException(_additionalJars[i].getAbsolutePath());
				}
				
				FileUtils.copyFile(_additionalJars[i], libDestination);
			}
		}
		
		for (int i=0; i < _filesToCopy.length; i++) {
			String dest = _filesToCopy[i].getRelativePath();
			File destDir = new File(webContentDir, dest);
			String[] files = _filesToCopy[i].getFiles();
			
			for (int j=0; j < files.length; j++) {
				File file = new File(files[j]);
				if(!file.exists()) {
					throw new FileNotFoundException(file.getAbsolutePath());
				}
				
				FileUtils.copyFile(file, destDir);
			}
		}

		return webContentDir;	
	}
}

Added Link Here

(-)resources/mini/build.xml (+10 lines)
1	<?xml version="1.0"?>
2	<project name="project" default="default">
3	<target name="default">
4	<jar destfile="${basedir}/WebContent/WEB-INF/lib/capability.jar">
5	<fileset dir="bin">
6	<include name="*/.class"/>
7	</fileset>
8	</jar>
9	</target>
10	</project>




<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
	<display-name>Apache Muse Servlet</display-name>
	<servlet>
		<display-name>Apache Muse Servlet</display-name>
		<servlet-name>ApacheMuseServlet</servlet-name>
		<servlet-class>org.apache.muse.core.platform.mini.MiniServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>ApacheMuseServlet</servlet-name>
		<url-pattern>/*</url-pattern>
	</servlet-mapping>
</web-app>




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.internal.projectizer;


public interface EclipseJ2EEAxis2ProjectizerConstants {
	
	String RESOURCES_DIR = "/resources/axis2/"; //$NON-NLS-1$
	
	String BUILD_FILE_RESOURCE = RESOURCES_DIR + "build.xml"; //$NON-NLS-1$
	
	String BUILD_FILE = "build.xml"; //$NON-NLS-1$

	String LAUNCH_FILE_RESOURCE = RESOURCES_DIR + ".externalToolBuilders/jarBuilder.launch"; //$NON-NLS-1$

	String WEBCONTENT_DIR_RESOURCE = RESOURCES_DIR + "WebContent"; //$NON-NLS-1$

	String PROJECT_LIB_DIR_RESOURCE = "/lib"; //$NON-NLS-1$
	
	String PROJECT_MODULE_DIR_RESOURCE = "/modules"; //$NON-NLS-1$

	String JAVA_BIN_DIR = "bin"; //$NON-NLS-1$

}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.ByteArrayOutputStream;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import javax.wsdl.WSDLException;
import javax.wsdl.factory.WSDLFactory;
import javax.wsdl.xml.WSDLReader;
import javax.wsdl.xml.WSDLWriter;
import javax.xml.namespace.QName;

import org.apache.muse.tools.generator.WsdlMerge;
import org.apache.muse.util.xml.XmlUtils;
import org.apache.muse.ws.addressing.soap.SoapFault;
import org.apache.muse.ws.notification.WsnConstants;
import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.muse.ws.resource.metadata.WsrmdConstants;
import org.apache.muse.ws.resource.metadata.impl.SimpleMetadataDescriptor;
import org.apache.muse.ws.wsdl.WsdlUtils;
import org.eclipse.emf.common.util.URI;
import org.eclipse.tptp.wsdm.tooling.editor.capability.util.internal.MetaDataUtils;
import org.eclipse.tptp.wsdm.tooling.editor.internal.CapabilityDefinition;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * This class provides the utility method for merging the MRT to get the smashed WSDL and RMD documents.
 *
 */

public class MrtMerge 
{
	private static WSDLReader _reader;
	private static WSDLWriter _writer;
	private static WSDLFactory _factory;
	
	/**
	 * Creates the smashed WSDL file for representing the resource type
	 * 
	 * @param mrtFile -
	 *            Manageable Resource Type file
	 * @throws Exception -
	 *             Throws exception while getting WSDL files and also while
	 *             merging them
	 */
	public static Document createMergedWSDL(ManageableResourceType mrt, String address)
			throws Exception
	{
		checkReadersWriters();

		List wsdlFiles = null;

		try
		{
			wsdlFiles = getWsdlFiles(mrt);
		}
		catch (Exception e)
		{
			throw new Exception(Messages.HOOKUP_WIZARD_ERROR_7, e);
		}

		String namespaceURI = mrt.getNamespace();

		Document[] wsdlFragments = (Document[])wsdlFiles.toArray(new Document[wsdlFiles.size()]);
		javax.wsdl.Definition def = WsdlMerge.merge(namespaceURI, wsdlFragments,
 				address);

		return _writer.getDocument(def);
	}

	private static void checkReadersWriters() throws InvocationTargetException
	{
		try
		{
			_factory = WSDLFactory.newInstance();
			_reader = _factory.newWSDLReader();
			_writer = _factory.newWSDLWriter();
		}
		catch (WSDLException e)
		{
			throw new InvocationTargetException(new Exception(
					Messages.HOOKUP_WIZARD_ERROR_3, e));
		}
	}

	/**
	 * Given an MRT file return a list of <code>Definition</code> objects that
	 * correspond to the WSDL files related to this MRT (that is, its
	 * Capabilities).
	 * 
	 * @param mrtFile
	 * @return
	 * @throws Exception
	 */
	private static List getWsdlFiles(ManageableResourceType mrt)
			throws Exception
	{
		//Get a list of all of the capabilities in this MRT 
		//This should just be a list of URIs
		List capabilityList = mrt.getImplements();		
		
		//Here is our list of clean WSDL documents
		//we are returning
		ArrayList wsdls = new ArrayList();	

		//Use an EclipseEnvironment to do the resolution of paths
		EclipseEnvironment eclipseEnv = new EclipseEnvironment();
		
		//Iterate over each capability and load it into a Definition
		for (Iterator i = capabilityList.iterator(); i.hasNext();) {
			String nextPath = i.next().toString();
			
			Document document = WsdlUtils.createWSDL(eclipseEnv, nextPath, true);
			
			//clean up imports
			//see the actual functions to understand how 
			//the removal is done
			Element cleanDocument = WsdlUtils.removeSchemaReferences(document.getDocumentElement());
			cleanDocument = WsdlUtils.removeWsdlReferences(cleanDocument);
			
			wsdls.add(cleanDocument.getOwnerDocument());
		}
		
		return wsdls;
	}
	
	/**
	 * Creates the merged RMD file for representing the manageable resource type
	 * 
	 * @param mrtFile -
	 *            Manageable Resource Type file
	 * @throws Exception -
	 *             Throws exception while getting capabilities defined in MRT and also while
	 *             merging their RMDs
	 */
	public static MetadataDescriptor createMergedRMD(ManageableResourceType mrt) throws Exception
	{
			List rmds = new ArrayList();
			Capability[] capabilities = MrtUtils.getCapabilities(mrt);
			List allTopicExpressions = new ArrayList();
			for(int i=0;i<capabilities.length;i++)
			{
				CapabilityDefinition capabilityDef = (CapabilityDefinition)capabilities[i].getWsdlDefinition();
				URI capabilityFileLocationURI = capabilityDef.getWSDLResourceProtocolURI();
				String metadataDescriptorLocation = capabilityDef.getMetadataDescriptorLocation();
				if(metadataDescriptorLocation == null || metadataDescriptorLocation.length() == 0)
					continue;
				URI rmdFileLocationURI = URI.createURI(capabilityFileLocationURI.trimSegments(1).toString()+ "/" + metadataDescriptorLocation);
				org.eclipse.tptp.wsdm.tooling.model.metadataDescriptor.DocumentRoot root = MetaDataUtils.getDocumentRoot(rmdFileLocationURI);
				ByteArrayOutputStream baos = MetaDataUtils.saveRMD(root, rmdFileLocationURI.toString(), null);
				String rmdXML = new String(baos.toByteArray());
				Element definitionElement = (Element) XmlUtils.createDocument(rmdXML).getFirstChild();
				Element metadataDescriptorElement = XmlUtils.getFirstElement(definitionElement);			
				MetadataDescriptor rmdDescriptor = new SimpleMetadataDescriptor(metadataDescriptorElement);				
				
				// Get all the topic expressions defined in different capabilities
				String[] topicExpressions = getTopicExpressions(rmdDescriptor);
				for(int j=0;j<topicExpressions.length;j++)
				{
					String prefix = topicExpressions[j].substring(0,topicExpressions[j].indexOf(':'));
					String namespace = (String)root.getXMLNSPrefixMap().get(prefix);
					String topicPath = topicExpressions[j].substring(topicExpressions[j].indexOf(':')+1);
					allTopicExpressions.add(new TopicExpression(namespace, topicPath));
				}				
				rmdDescriptor.removeProperty(WsnConstants.TOPIC_EXPRESSION_QNAME);
				
				rmds.add(rmdDescriptor);		
			}
			MetadataDescriptor[] descriptors = (MetadataDescriptor[]) rmds.toArray(new MetadataDescriptor[rmds.size()]);
			QName qname = new QName(mrt.getNamespace(), "PortType");
			// TODO Verify with Andrew that is it the way that MUSE creates the smashed wsdl by this name
			String name = mrt.getIdentifier()+".wsdl";
			MetadataDescriptor mergedRMD = WsdlMerge.merge(name, qname, descriptors);
			TopicExpression[] topicExpressions = (TopicExpression[]) allTopicExpressions.toArray(new TopicExpression[allTopicExpressions.size()]);
			// Merge all the topic expressions defined in different capabilities
			mergeTopicExpressions(mergedRMD, topicExpressions);
			return mergedRMD;		
	}
	
	private static String[] getTopicExpressions(MetadataDescriptor rmdDescriptor) throws SoapFault
	{
		if(rmdDescriptor.hasProperty(WsnConstants.TOPIC_EXPRESSION_QNAME))
		{
			Collection collection = rmdDescriptor.getInitialValues(WsnConstants.TOPIC_EXPRESSION_QNAME, String.class);
			return (String[])collection.toArray(new String[collection.size()]);
		}
		return new String[0];
	}
	
	private static void mergeTopicExpressions(MetadataDescriptor rmdDescriptor, TopicExpression[] topicExpressions) throws SoapFault
	{
		if(topicExpressions!=null && topicExpressions.length>0)
		{
			rmdDescriptor.addProperty(WsnConstants.TOPIC_EXPRESSION_QNAME, WsrmdConstants.READ_ONLY, WsrmdConstants.MUTABLE);
			List initValues = new ArrayList();
			Document doc = XmlUtils.createDocument();
			for(int i=0;i<topicExpressions.length;i++)
			{
				String namespace = topicExpressions[i].getTopicNamespace();
				String topicPath = topicExpressions[i].getTopicPath();
				String expression = "pfx:"+topicPath;
				Element propertyElement = XmlUtils.createElement(doc, WsnConstants.TOPIC_EXPRESSION_QNAME);
				propertyElement.setAttribute("xmlns:pfx", namespace);
				XmlUtils.setElementText(propertyElement, expression);
				initValues.add(propertyElement);
			}
			rmdDescriptor.setInitialValues(WsnConstants.TOPIC_EXPRESSION_QNAME, initValues);			
		}
	}
}

class TopicExpression
{
	private String _topicNamespace;
	private String _topicPath;
	
	TopicExpression(String topicNamespace, String topicPath)
	{
		_topicNamespace = topicNamespace;
		_topicPath = topicPath;
	}
	
	String getTopicNamespace()
	{
		return _topicNamespace;
	}
	
	String getTopicPath()
	{
		return _topicPath;
	}
}





/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;

import org.eclipse.swt.SWT;
import org.eclipse.swt.browser.Browser;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;
import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.osgi.framework.Bundle;

/**
 * This class is used to display the Axis-2 License. 
 */
public class Axis2LicenseDialog 
{
	private Shell _shell;
	
	private Browser _text;
	
	private Button _btnAgree;
	
	private Button _btnDecline;
	
	public static int AGREE = 0;
	
	public static int DECLINE = 1;
	
	private int _retInt = DECLINE;
		
	/**
	 * Constructor of the class. It initialises the UI for
	 * displaying the license
	 */
	public Axis2LicenseDialog()
	{
		initUI();
	}
	
	private void initUI()
	{
		_shell = new Shell(Display.getCurrent(), SWT.CLOSE | SWT.SYSTEM_MODAL | SWT.APPLICATION_MODAL | SWT.RESIZE);
		_shell.setLayout(new GridLayout(2, true));
		_shell.setText(Messages.AXIS2_LICENSE_LABEL);
		_shell.setSize(300, 300);
		
		_text = new Browser(_shell, SWT.BORDER | SWT.MULTI | SWT.WRAP);
		try 
		{
			_text.setText(readLicence());
		} 
		catch (Throwable e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}
		
		_btnAgree = new Button(_shell, SWT.PUSH);
		_btnAgree.setText(Messages.LICENSE_AGREE_TEXT);
		_btnAgree.addSelectionListener(new SelectionAdapter()
		{
			public void widgetSelected(SelectionEvent se)
			{
				_retInt = AGREE;
				_shell.dispose();
			}
		}
		);
		
		_btnDecline = new Button(_shell, SWT.PUSH);
		_btnDecline.setText(Messages.LICENSE_DECLINE_TEXT);
		_btnDecline.addSelectionListener(new SelectionAdapter()
		{
			public void widgetSelected(SelectionEvent se)
			{
				_retInt = DECLINE;
				_shell.dispose();
			}
		}
		);
		
		GridData gd = new GridData(GridData.FILL_BOTH);
		gd.horizontalSpan = 2;
		_text.setLayoutData(gd);
		
		gd = new GridData();
		gd.horizontalAlignment = SWT.RIGHT;
		_btnAgree.setLayoutData(gd);
		
		gd = new GridData();
		gd.horizontalAlignment = SWT.LEFT;
		_btnDecline.setLayoutData(gd);
	}
	
	/**
	 * Method  to show the Dialog that displays the Liscense
	 */
	public int showWindow()
	{
		_shell.open();
		while(!_shell.isDisposed())
		{
			if(!Display.getCurrent().readAndDispatch())
				Display.getCurrent().sleep();
		}
		return _retInt;
	}
	
	private String readLicence() throws Throwable
	{
		Bundle bundle = Activator.INSTANCE.getPlugin().getBundle();
		URL licenceURL = bundle.getEntry("licence/Licence.txt");
		BufferedReader in = new BufferedReader(new InputStreamReader(licenceURL.openStream()));
		StringBuffer buffer = new StringBuffer();
		String line = null;
		while ((line = in.readLine()) != null)
			buffer.append(line);
		return buffer.toString();
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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
 * $Id: CodeGenerationData.java,v 1.2 2007/05/07 09:15:10 dnsmith Exp $
 * 
 * Contributors:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import org.apache.muse.tools.generator.analyzer.Analyzer;
import org.apache.muse.tools.generator.projectizer.Projectizer;
import org.apache.muse.tools.generator.synthesizer.Synthesizer;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;

class CodeGenerationData {				
	private Analyzer _analyzer;
	private Synthesizer _synthesizer;
	private Projectizer _projectizer;
	
	private int _servicePort;
	private String _servicePath;
	private String _container;
	private String _platform;
	
	public CodeGenerationData(IConfigurationElement[] elements) {
		for (int i = 0; i < elements.length; i++)
		{
			String name = elements[i].getName();
						
			if(name.equals("description")) {
				extractDescription(elements[i]);
			} else if (name.equals("projectizer")) {
				extractProjectizer(elements[i]);
			} else if (name.equals("synthesizer")) {
				extractSynthesizer(elements[i]);
			} else if (name.equals("analyzer")) {
				extractAnalyzer(elements[i]);
			}
		}
	}
	
	private void extractDescription(IConfigurationElement configurationElement) {
		_container = configurationElement.getAttribute("container");
		_platform = configurationElement.getAttribute("platform");
	}
	
	private void extractProjectizer(IConfigurationElement configurationElement) {
		String port = configurationElement.getAttribute("servicePort");
		if(port != null && port.length() != 0) {
			_servicePort = Integer.parseInt(port);
		}
		_servicePath = configurationElement.getAttribute("servicePath");
		_projectizer = (Projectizer) createExecutable(configurationElement);
	}
	
	private void extractSynthesizer(IConfigurationElement configurationElement) {
		_synthesizer = (Synthesizer) createExecutable(configurationElement);			
	}
	
	private void extractAnalyzer(IConfigurationElement configurationElement) {
		_analyzer = (Analyzer) createExecutable(configurationElement);
	}	
	
	private Object createExecutable(IConfigurationElement configurationElement) {
		try {
			return configurationElement.createExecutableExtension("class");
		} catch (CoreException e) {
			throw new RuntimeException(configurationElement.getAttribute("class"));
		}
	}
	
	public Analyzer getAnalyzer() {
		return _analyzer;
	}

	public Synthesizer getSynthesizer() {
		return _synthesizer;
	}

	public Projectizer getProjectizer() {
		return _projectizer;
	}

	public int getServicePort() {
		return _servicePort;
	}

	public String getServicePath() {
		return _servicePath;
	}

	public String getContainer() {
		return _container;
	}

	public String getPlatform() {
		return _platform;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import org.eclipse.core.resources.IFile;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPart;

/**
 * Access point code from the code generation option in popup
 */
public class Generation implements IObjectActionDelegate
{

	private IWorkbenchPart _targetPart;

	private StructuredSelection _selection;

	/**
	 * (non-Javadoc)
	 * @see org.eclipse.ui.IObjectActionDelegate#run(org.eclipse.jface.action.IAction)
	 */ 
	public void run(IAction action)
	{
		IFile mrtFile = (IFile) _selection.getFirstElement();
		MrtUtils.searchAndSaveMRTEditor(mrtFile);
		MRTCodeGenerationDelegate codeGenerationDelegate = new MRTCodeGenerationDelegate(
				mrtFile);

		NewProjectWizard npw = new NewProjectWizard(codeGenerationDelegate);
		WizardDialog wd = new WizardDialog(_targetPart.getSite().getShell(),
				npw);
		wd.open();
	}

	/**
	 * (non-Javadoc)
	 * @see org.eclipse.ui.IObjectActionDelegate#setActivePart(org.eclipse.jface.action.IAction, org.eclipse.ui.IWorkbenchPart)
	 */ 
	public void setActivePart(IAction action, IWorkbenchPart targetPart)
	{
		_targetPart = targetPart;
	}

	/**
	 * (non-Javadoc)
	 * @see org.eclipse.ui.IObjectActionDelegate#selectionChanged
	(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
	 */
	public void selectionChanged(IAction action, ISelection selection)
	{
		if (selection instanceof StructuredSelection)
		{
			_selection = (StructuredSelection) selection;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.osgi.util.TextProcessor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.DirectoryDialog;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;
import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.preferences.internal.Axis2ServerLocationPreferencePage;
import org.eclipse.tptp.wsdm.tooling.validation.util.internal.ValidationUtils;

/**
 * This is Wizard Page to show the Axis2 server location details
 *
 */
public class Axis2ServerLocationPage extends WizardPage
{
	
	protected Text _serverNameField;
	private Button _browseButton;
	private Button _preferenceUpdate;
	private TargetedFileList[] _filesToCopy;
	
	private String userDefinedLocation ="";
	
	/**
	 * Instantiates the class.
	 */
	public Axis2ServerLocationPage() 
	{
		super("wizardPage");
		setTitle(Messages.HOOKUP_WIZARD_TXT1);
		setDescription(Messages.HOOKUP_WIZARD_TXT2);
	}

	/**
	 *  Creates wizard controls.
	 */
	public void createControl(Composite parent) 
	{
		Composite page = new Composite(parent, SWT.NULL);
		GridLayout layout = new GridLayout(1, false);
		page.setLayout(layout);
		createPageControls(page);
		//dialogChanged();
		setControl(page);
	}

	private void createPageControls(Composite page) 
	{
		Composite column = new Composite(page, SWT.NULL);
		GridLayout layout = new GridLayout(2, false);
		column.setLayout(layout);
		createServerLocationColumn(column);
	}

	private void createServerLocationColumn(Composite parent) 
	{
		GridData data = new GridData(GridData.FILL_HORIZONTAL);
		data.horizontalSpan = 2;
        // new server location label
        Label serverLabel = new Label(parent, SWT.NONE);
        serverLabel.setText(Messages.CODE_GEN_AXIS2_LOCATION);
        serverLabel.setFont(parent.getFont());
        serverLabel.setLayoutData(data);

		// server location entry field
        data = new GridData(GridData.FILL_HORIZONTAL);
        data.widthHint = 350;
        data.horizontalSpan = 1;
        _serverNameField = new Text(parent, SWT.BORDER);
        _serverNameField.setLayoutData(data);
        _serverNameField.setFont(parent.getFont());
        _serverNameField.addModifyListener(new ModifyListener()
		{
			public void modifyText(ModifyEvent e)
			{
				boolean pageCompleted = true;
				userDefinedLocation = _serverNameField.getText();
				String errorMsg = validateLocation(); 
				if(errorMsg == null)
				{
					setErrorMessage(errorMsg);
					pageCompleted = true;
				}
				else
				{
					setErrorMessage(errorMsg);
					pageCompleted = false;
				}
				makePageComplete(pageCompleted);
			}
		});
        
    //    _serverNameField.setText(getPreferenceServerLocation());

        // browse button
		_browseButton = new Button(parent, SWT.PUSH);
		_browseButton.setText(Messages.HOOKUP_WIZARD_TXT5);
		_browseButton.addSelectionListener(new SelectionAdapter() 
		{
			public void widgetSelected(SelectionEvent event) 
			{
				handleLocationBrowseButtonPressed();
			}
		});
		
		// server location entry field
        data = new GridData(GridData.FILL_HORIZONTAL);
        //data.widthHint = 350;
        data.horizontalSpan = 2;
        _preferenceUpdate = new Button(parent, SWT.CHECK);
        _preferenceUpdate.setText(Messages.CODE_GEN_UPDATE_PREF);
        _preferenceUpdate.setLayoutData(data);
        _preferenceUpdate.setFont(parent.getFont());		
	}
	
	protected String getPreferenceServerLocation() 
	{
		IPreferenceStore store = Activator.getPlugin().getPreferenceStore();
		String location = store.getString(Axis2ServerLocationPreferencePage.SERVER_LOCATION_PREFERENCE_KEY).trim();
		if(location != null && !location.equals(""))
			return location;
		return "";
	}

	private void handleLocationBrowseButtonPressed() 
	{

		String selectedDirectory = null;

		DirectoryDialog dialog = new DirectoryDialog(_serverNameField.getShell());
		dialog.setMessage(Messages.CODE_GEN_DIR_LOCATION);
		//dialog.setFilterPath(dirName);
		selectedDirectory = dialog.open();
		
		if (selectedDirectory != null)
			updateLocationField(selectedDirectory);

	}
	
	private void updateLocationField(String selectedPath) 
	{
		_serverNameField.setText(TextProcessor.process(selectedPath));
	}

	/**
	 * Returns the server location.
	 * @return
	 */
	public String getServerLocation() 
	{
		return _serverNameField.getText();
	}

	/**
	 * Checks to see if Update Preferences checkbox is selected
	 * @return
	 */
	public boolean isUpdatePreference()
	{
		return _preferenceUpdate.getSelection();
	}
	
	private String validateLocation()
	{
		String serverHome = _serverNameField.getText();
		
		ISoapServerDependency axisValidators[] = ValidationUtils.getAllAxisValidators();
		for(int i = 0 ; i < axisValidators.length ; i++){
			
			ISoapServerDependency axis2Dependency = (Axis2ServerDependency)axisValidators[i];
			String errorMessage = axis2Dependency.validateSoapServerHome(serverHome);
			if(errorMessage!=null)
				return errorMessage;
			_filesToCopy = axis2Dependency.getFilesToCopy();
			if(_filesToCopy == null)
				_filesToCopy = new TargetedFileList[0];
		}
		return null;		
	}
	
	/**
	 * Returns the Axis2 files to copied to generated code
	 * @return
	 */
	public TargetedFileList[] getAxis2FilesToCopy()
	{
		return _filesToCopy;
	}

	/**
	 * Method to Set the Wizard page to complete state
	 * @param validPage 
	 */
	public synchronized void makePageComplete(boolean completePage)
	{
		if(completePage){
			setPageComplete(true);
		}
		else
			setPageComplete(false);		
	}
	
	protected String getUserDefinedLocation()
	{
		return userDefinedLocation;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.File;
import java.io.InputStream;
import java.net.URI;
import java.net.URL;
import java.net.URLConnection;

import org.apache.muse.core.AbstractEnvironment;
import org.apache.muse.util.xml.XmlUtils;
import org.apache.muse.ws.addressing.EndpointReference;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.osgi.framework.Bundle;
import org.w3c.dom.Document;

public class EclipseEnvironment extends AbstractEnvironment
{

	public EndpointReference getDeploymentEPR()
	{
		// TODO Auto-generated method stub
		return null;
	}

	public File getRealDirectory()
	{
		// TODO Auto-generated method stub
		return null;
	}

	public Document getDocument(String path)
	{
		try
		{
			if(isHttpScheme(path))
			{
				URLConnection conn = new URL(path).openConnection();
				InputStream stream = conn.getInputStream();
				return XmlUtils.createDocument(stream);
			}			
		}
		catch(Exception e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}
		
		
		try
		{
			if (!isBuiltin(path))
			{
				IFile wsdlFile = EclipseUtils.getIFile(ResourcesPlugin
						.getWorkspace().getRoot(), path);
				return XmlUtils.createDocument(wsdlFile.getLocation().toFile()
						.getAbsoluteFile());
			}
			else
			{
				String substr = path.substring(path.indexOf("platform:/plugin/")+"platform:/plugin/".length());
				String contributorPlugin = substr.substring(0,substr.indexOf('/'));
				String relativePath = substr.substring(substr.indexOf('/')+1);
				
				Bundle bundle = Platform.getBundle(contributorPlugin);
				return XmlUtils.createDocument(FileLocator.openStream(bundle,
						new Path(relativePath), false));
			}
		}
		catch (Exception e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}
		return null;
	}

	/**
	 * Utility method to see if the path is referring to something in the
	 * plugins or in the workspace.
	 * 
	 * @param path
	 *            A path to examine
	 * @return true if the path starts with <code>"platform:/plugin"</code>
	 */
	private boolean isBuiltin(String path)
	{
		return path.startsWith("platform:/plugin");
	}
	
	private boolean isHttpScheme(String path)
	{
		try{
			URI uri = URI.create(path);		
			String scheme = uri.getScheme();
			if(scheme != null && uri.getScheme().equals("http"))
				return true;
		}catch(Exception e){
			// nuthing to do, just return false
		}
		return false;
	}

	public String createRelativePath(String original, String relative)
	{

		// If the relative path starts with "platform:/" then it
		// is an absolute path, so just return it instead.
		if (relative.startsWith("platform:/"))
		{
			return relative;
		}

		return super.createRelativePath(original, relative);
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.File;
import java.io.FileFilter;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.osgi.util.NLS;
import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;

/**
 * This class verifies the Axis2 Soap Library dependency. 
 */

public class Axis2ServerDependency extends SoapServerDependency implements ISoapServerDependency
{
	private List _filesToCopy = new LinkedList();
	
	/**
	 * @see ISoapServerDependency#validateSoapServerHome(String)
	 */
	public String validateSoapServerHome(String serverHome)
	{
		if(serverHome == null || serverHome.length() == 0)
			return Messages.CODE_GEN_AXIS2_PROJECT_DIR;
		
		File serverHomeDir = new File(serverHome);
		if(!serverHomeDir.exists()){
			return NLS.bind(Messages.CODE_GEN_AXIS2_LOCATION_ERROR_, serverHome);
		}
		
		TargetedFileList _jarFilesToCopy = new TargetedFileList("WEB-INF/lib/");
		TargetedFileList _marFilesToCopy = new TargetedFileList("WEB-INF/modules/");
		TargetedFileList _restFilesToCopy = new TargetedFileList("WEB-INF/");
		
		String[] relativeFilePaths = (String[]) _requiredFiles.toArray(new String[_requiredFiles.size()]);
		for(int i=0;i<relativeFilePaths.length;i++)
		{
			String parentDirectory = getParentDirectory(relativeFilePaths[i]);
			if(parentDirectory == null)
				parentDirectory = serverHome;
			else
				parentDirectory = serverHome+File.separatorChar+parentDirectory;
			
			String fileExtension = getFileExtension(relativeFilePaths[i]);
			if(fileExtension == null)
				fileExtension = "*";
			FileFilter filter = new CustomFileFilter(fileExtension);
			
			File parentDirectoryFile = new File(parentDirectory);
			if(!parentDirectoryFile.exists())
				return NLS.bind(Messages.CODE_GEN_AXIS2_LOCATION_ERROR_, parentDirectory);
			
			File[] allFiles = parentDirectoryFile.listFiles(filter);
			String fileName = getFileName(relativeFilePaths[i]);
			File matchedFile = getMatchedPatternFile(allFiles, fileName);
			if(matchedFile == null)
				return NLS.bind(Messages.CODE_GEN_ERROR_INVALID_AXIS_FILE, serverHome+File.separatorChar+relativeFilePaths[i]);
						
			String absolutePath = matchedFile.getAbsolutePath();
			if(absolutePath.endsWith("jar"))
				_jarFilesToCopy.add(absolutePath);
			else if(absolutePath.endsWith("mar"))
				_marFilesToCopy.add(absolutePath);
			else
				_restFilesToCopy.add(absolutePath);
		}
		
		_filesToCopy.add(_jarFilesToCopy);
		_filesToCopy.add(_marFilesToCopy);
		_filesToCopy.add(_restFilesToCopy);
		
		return null;
	}
	
	private String getParentDirectory(String relativePath)
	{
		if(relativePath.indexOf('/')==-1)
			return null;
		return relativePath.substring(0,relativePath.lastIndexOf('/'));		
	}
	
	private String getFileExtension(String relativePath)
	{
		if(relativePath.indexOf('.')==-1)
			return null;
		return relativePath.substring(relativePath.lastIndexOf('.')+1);
	}
	
	private String getFileName(String relativePath)
	{
		if(relativePath.indexOf('/')==-1)
		{
			if(relativePath.indexOf('.')==-1)
				return relativePath;
			else
				return relativePath.substring(0,relativePath.lastIndexOf('.'));
		}
		else
		{
			String fileNameWithExtn = relativePath.substring(relativePath.lastIndexOf('/')+1);
			if(fileNameWithExtn.indexOf('.')==-1)
				return fileNameWithExtn;
			else
				return fileNameWithExtn.substring(0,fileNameWithExtn.lastIndexOf('.'));
		}
	}
	
	private File getMatchedPatternFile(File[] allFiles, String pattern)
	{
		String strippedPattern = pattern.indexOf("-*")==-1?pattern:pattern.substring(0,pattern.lastIndexOf("-*"));
		for(int i=0;i<allFiles.length;i++)
		{
			if(allFiles[i].getName().startsWith(strippedPattern))
				return allFiles[i];
		}
		return null;
	}

	/**
	 * @see ISoapServerDependency#getFilesToCopy()
	 */
	public TargetedFileList[] getFilesToCopy()
	{
		return (TargetedFileList[])_filesToCopy.toArray(new TargetedFileList[_filesToCopy.size()]);
	}	
}

class CustomFileFilter implements FileFilter
{
	String fileExtension;
	
	CustomFileFilter(String extension)
	{
		fileExtension = extension;
	}
	
	public boolean accept(File pathname) 
	{
		if(!pathname.isFile())
			return false;
		if(fileExtension.equals("*"))
			return true;
		return pathname.getName().endsWith(fileExtension);		
 	}	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.wsdl.Definition;

import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.InitParamType;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.ReferenceParametersType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.WsdlType;
import org.apache.ws.muse.descriptor.impl.CapabilityTypeImpl;
import org.apache.ws.muse.descriptor.impl.ResourceTypeTypeImpl;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.EMap;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.nls.messages.dde.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmConstants;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;

/**
 * This class analyzes the given manageable resource type and provide a resource
 * type for muse descriptor.
 */

public class BasicMrtInspector implements MrtInspector
{
	private DocumentRoot _root;

	private ResourceTypeType _resourceType;

	private ManageableResourceType _mrt;
	/**
	 * Constructor of the class
	 * @param mrt
	 * @param root
	 */
	public BasicMrtInspector(ManageableResourceType mrt,DocumentRoot root)
	{
		_root = root;
		_mrt = mrt;
	}

	/**
	 *  Get the initial instance for this manageable resource type
	 *  @return InitialInstancesType - Array of the initial instances
	 */
	public InitialInstancesType[] getInitialInstances()
	{
		InitialInstancesType instance = DescriptorFactory.eINSTANCE
				.createInitialInstancesType();
		ResourceTypeType rtClone = MRTCodeGenerationDelegate
				.cloneResourceType(_resourceType);
		instance.setResourceType(rtClone);
		ReferenceParametersType refParam = DescriptorFactory.eINSTANCE
				.createReferenceParametersType();

		instance.setReferenceParameters(refParam);
		return new InitialInstancesType[] { instance };
	}

	/**
	 *  Create a new descriptor resource type for the given manageable resource
	 *  type
	 *  @param mrtCapabilities
	 *  @return {@link ResourceTypeType}
	 */
	public ResourceTypeType inspect(Capability[] mrtCapabilities)
	{
		Mrt2DescriptorResourceType mrt2dd = new Mrt2DescriptorResourceType(
				_root, _mrt, mrtCapabilities);
		_resourceType = mrt2dd.getResourceTypeType();
		return _resourceType;
	}

	public void setMrtParentDirectory(String mrtParentDir)
	{
	}

	public void persistArtifacts()
	{
	}

	public ManageableResourceType getExtraGeneratedMrt() 
	{
		return null;
	}

	public String getExtraGeneratedMrtPersistanceLocation() 
	{
		return null;
	}

	public void inspectMetadata(ManageableResourceType mrt,
			MetadataDescriptor rmd) 
	{
	}

}

class Mrt2DescriptorResourceType
{
	private ManageableResourceType _mrt;

	private DocumentRoot _root;

	private Capability[] _mrtCapabilities;

	Mrt2DescriptorResourceType(DocumentRoot root, ManageableResourceType mrt)
	{
		this(root, mrt, null);
	}

	Mrt2DescriptorResourceType(DocumentRoot root, ManageableResourceType mrt,
			Capability[] mrtCapabilities)
	{
		_mrt = mrt;
		_root = root;
		if (mrtCapabilities == null)
			try
			{
				_mrtCapabilities = MrtUtils.getCapabilities(mrt);
			}
			catch (Exception e)
			{
			}
		else
			_mrtCapabilities = mrtCapabilities;
	}

	ResourceTypeType getResourceTypeType()
	{
		ResourceTypeTypeImpl rtd = (ResourceTypeTypeImpl) DescriptorFactory.eINSTANCE
				.createResourceTypeType();
		rtd.setUseRouterPersistence(true);
		rtd.setContextPath("/" + _mrt.getIdentifier()); //$NON-NLS-1$
		rtd
				.setJavaIdFactoryClass(WsdmConstants.MUSE_RESOURCE_ID_FACTORY_CLASS); //$NON-NLS-1$
		rtd
				.setJavaResourceClass(WsdmConstants.MUSE_RESOURCE_CLASS); //$NON-NLS-1$
		rtd.getCapability().addAll(getCapabilitiesFromMRT());
		WsdlType wsdlType = DescriptorFactory.eINSTANCE.createWsdlType();

		String mrtFileLocation = getMrtFileWorkspaceLocation();
		if (mrtFileLocation == null)
			;
		// TODO Log error not resolved location of given mrt
		else
		{
			String mrtFilePathWithoutExtn = mrtFileLocation.substring(0,
					mrtFileLocation.lastIndexOf('.'));
			wsdlType.setWsdlFile(mrtFilePathWithoutExtn + ".wsdl");
		}

		String namespace = _mrt.getNamespace();
		String prefix = getOrCreatePrefix(_root, namespace);
		String localPart = Messages.DU_PORT_TYPE_LOCAL_PART; // Only
		// "PortType"
		// should come
		// with the
		// //$NON-NLS-1$
		// prefix.
		wsdlType.setWsdlPortType(prefix + ":" + localPart);

		rtd.setWsdl(wsdlType);
		
		// Fix for Bug 174792 Set "validate-wsrp-schema" to "false" for the dd file generated at the codegen from MRT
		// http://bugs.eclipse.org/bugs/show_bug.cgi?id=174792
		InitParamType noValidateParam = DescriptorFactory.eINSTANCE.createInitParamType();
		noValidateParam.setParamName("validate-wsrp-schema");
		noValidateParam.setParamValue("false");		
		rtd.getInitParam().add(noValidateParam);
		
		return rtd;
	}

	private static String getOrCreatePrefix(DocumentRoot root, String namespace)
	{
		String prefix = getPrefix(root, namespace);
		if (prefix != null)
			return prefix;
		String newPrefix = generateNewPrefix(root);
		root.getXMLNSPrefixMap().put(newPrefix, namespace);
		return newPrefix;
	}

	private static String generateNewPrefix(DocumentRoot root)
	{
		int count = 0;
		while (isPrefixExists(root, "pfx" + count)) //$NON-NLS-1$
			count++;
		return "pfx" + count; //$NON-NLS-1$
	}

	private static boolean isPrefixExists(DocumentRoot root, String prefix)
	{
		EMap map = root.getXMLNSPrefixMap();
		Iterator keyIt = map.keySet().iterator();
		while (keyIt.hasNext())
		{
			String pfx = (String) keyIt.next();
			if (pfx.equals(prefix))
				return true;
		}
		return false;
	}

	private static String getPrefix(DocumentRoot root, String namespace)
	{
		if (root == null)
			return null;
		if (namespace == null)
			return null;
		EMap map = root.getXMLNSPrefixMap();
		Iterator keyIt = map.keySet().iterator();
		Iterator valuesIt = map.values().iterator();
		while (valuesIt.hasNext())
		{
			String ns = (String) valuesIt.next();
			String prefix = (String) keyIt.next();
			if (ns.equals(namespace))
				return prefix;
		}
		return null;
	}

	private List getCapabilitiesFromMRT()
	{
		if (_mrt == null)
			return null;
		List capDataList = new ArrayList();
		for (int i = 0; i < _mrtCapabilities.length; i++)
		{
			Capability capability = _mrtCapabilities[i];
			String capNS = ""; //$NON-NLS-1$
			Definition def = capability.getWsdlDefinition().getDefinition();
			if (def != null)
			{
				capNS = capability.getWsdlDefinition().getNamespace(
						"capabilityURI");
				if (capNS == null)
					capNS = capability.getNamespace();

			}
			CapabilityTypeImpl ctype = (CapabilityTypeImpl) DescriptorFactory.eINSTANCE
					.createCapabilityType();
			ctype.setCapabilityUri(capNS);
			String className = getJavaCapabilityClass(capNS);
			ctype.setJavaCapabilityClass(className);
			boolean isValid = validateCapability(capDataList, ctype);
			if (isValid)
				capDataList.add(ctype);
		}
		return capDataList;
	}

	private boolean validateCapability(List capDataList,
			CapabilityTypeImpl ctype)
	{
		if (capDataList == null || capDataList.size() == 0)
		{
			capDataList = new ArrayList();
			return true;
		}
		for (int i = 0; i < capDataList.size(); i++)
		{
			CapabilityTypeImpl tmp = (CapabilityTypeImpl) capDataList.get(i);
			if (tmp.getCapabilityUri().trim().equals(
					ctype.getCapabilityUri().trim()))
				return false;
		}
		return true;
	}

	private String getMrtFileWorkspaceLocation()
	{
		try
		{
			IFile mrtFile = EclipseUtils.getIFile(_mrt.eResource().getURI()
					.toString());
			return mrtFile.getFullPath().toString();
		}
		catch (CoreException e)
		{
			WsdmToolingLog.logError(e.getLocalizedMessage(), e);
		}
		return null;
	}

	private String getJavaCapabilityClass(String uri)
	{
		String ns = "org.eclipse.tptp.wsdm.model";
		IExtensionPoint iep = Platform.getExtensionRegistry()
				.getExtensionPoint(ns, "mrCapability");
		if (iep != null)
		{
			IExtension[] extensions = iep.getExtensions();
			for (int i = 0; i < extensions.length; i++)
			{
				IConfigurationElement[] ice = extensions[i]
						.getConfigurationElements();
				for (int j = 0; j < ice.length; j++)
				{
					String capURI = ice[j].getAttribute("uri");
					if (uri.equals(capURI))
					{
						String className = ice[j]
								.getAttribute("implementingClass");
						return (className == null) ? "" : className;
					}
				}
			}
		}
		return "";
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;

/**
 * This class collects the relative paths of required Axis-2 files specified in extension point.
 * So if you are extending "axisValidator" extension point, you have to extend this class and implement
 * the interface ISoapServerDependency.
 */

public abstract class SoapServerDependency implements ISoapServerDependency 
{

	protected List _requiredFiles = new ArrayList();
	
	public void setInitializationData(IConfigurationElement config,
			String propertyName, Object data) throws CoreException 
	{
		if(config.getName()!=null && config.getName().equals("axisValidator"))
		{
			IConfigurationElement requiredFileConfig = config.getChildren()[0];
			IConfigurationElement[] relativePathConfig = requiredFileConfig.getChildren();
			for(int i=0;i<relativePathConfig.length;i++)
			{
				if(relativePathConfig[i].getName()!=null && relativePathConfig[i].getName().equals("relativeFilePath"))
				{
					String value = relativePathConfig[i].getValue();
					if(value!=null && !value.equals("null"))
						_requiredFiles.add(value);					
				}
			}
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import javax.xml.namespace.QName;

import org.apache.muse.util.xml.XmlUtils;
import org.apache.muse.ws.addressing.soap.SoapFault;
import org.apache.muse.ws.resource.sg.WssgConstants;
import org.apache.ws.muse.descriptor.CapabilityType;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.InitParamType;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.ReferenceParametersType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.WsdlType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.tptp.wsdm.tooling.editor.ui.internal.NewNameGenerator;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceTypeFactory;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.MembershipContentRuleType;
import org.eclipse.tptp.wsdm.tooling.util.internal.CustomMrtResourceFactoryImpl;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmConstants;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
/**
 * This class analyzes the given manageable resource type and provide an extra
 * resource type for muse descriptor (ServiceGroupEntry), if manageable
 * resource type contains the ServiceGroupCapability and ServiceGroupRegistration capability.
 */

public class ServiceGroupInspector implements MrtInspector
{

	private String _mrtParentDirName;

	private DocumentRoot _root;
	
	private ResourceTypeType _serviceGroupEntryResorceType;
	
	private ManageableResourceType _serviceGroupEntrymrt;
	
	private HashMap _prefixNamespaceMap;
	
	/**
	 * Constructor for the ServiceGroupIspector class.
	 * @param mrt
	 * @param root
	 */
	
	public ServiceGroupInspector(ManageableResourceType mrt,DocumentRoot root)
	{
		_root = root;
	}

	/**
	 * Analyzes the given manageable resource type for ServiceGroupCapability and
	 * ServiceGroupRegistrationCapability and if the capabilities available then returns the muse
	 * resource type for ServiceGroupEntry  else returns the null.
	 */
	public ResourceTypeType inspect(Capability[] mrtCapabilities) 
	{
		
		if(hasServiceGroupCapabilities(mrtCapabilities))
			return createServiceGroupEntryResourceType();
		return null;
	}
	
	private boolean hasServiceGroupCapabilities(Capability[] mrtCapabilities)
	{
		boolean hasServiceGroupCapability = false;
		
		boolean hasServiceGroupRegistration = false;
		
		for(int i =0;i<mrtCapabilities.length;i++)
		{
			if(mrtCapabilities[i].getNamespace().equals(WsdmConstants.SERVICE_GROUP_NS))
					hasServiceGroupCapability = true;
			if(mrtCapabilities[i].getNamespace().equals(WsdmConstants.SERVICE_GROUP_REG_NS))
					hasServiceGroupRegistration = true;
		}
		return hasServiceGroupCapability && hasServiceGroupRegistration;
	}

	/**
	 * Returns the initial instances
	 * @return InitialInstancesType[]
	 */
	public InitialInstancesType[] getInitialInstances() {

		InitialInstancesType instance = DescriptorFactory.eINSTANCE
				.createInitialInstancesType();
		ResourceTypeType rtClone = MRTCodeGenerationDelegate
				.cloneResourceType(_serviceGroupEntryResorceType);
		instance.setResourceType(rtClone);
		ReferenceParametersType refParam = DescriptorFactory.eINSTANCE
				.createReferenceParametersType();
		instance.setReferenceParameters(refParam);
		return new InitialInstancesType[] { instance };
	
	}
	/**
	 * Sets the parent directory 
	 * @param mrtParentDir
	 */
	public void setMrtParentDirectory(String mrtParentDir) {
		_mrtParentDirName = mrtParentDir;
		
	}
	
	private ResourceTypeType createServiceGroupEntryResourceType()
	{
		createServiceGroupEntryMrt();
		_serviceGroupEntryResorceType = createServiceGroupEntryMuseResourceType();
		return _serviceGroupEntryResorceType;
	}
	
	private void createServiceGroupEntryMrt()
	{
		 org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.DocumentRoot documentRoot = ManageableResourceTypeFactory.eINSTANCE.createDocumentRoot();
		 _serviceGroupEntrymrt = ManageableResourceTypeFactory.eINSTANCE.createManageableResourceType();
		 documentRoot.setManageableResource(_serviceGroupEntrymrt);
		_serviceGroupEntrymrt.setIdentifier("ServiceGroupEntry");
		_serviceGroupEntrymrt.setNamespace("http://docs.oasis-open.org/wsrf/sgw-2");
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.MEX_CAPABILITY_LOCATION);
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.GET_CAPABILITY_LOCATION);
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.SET_CAPABILITY_LOCATION);
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.QUERY_CAPABILITY_LOCATION);
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.IMMIDIATE_RESOURCE_TERMINATION_CAPABILITY_LOCATION);
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.SCHEDULED_RESOURCE_TERMINATION_CAPABILITY_LOCATION);
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.SERVICE_GROUP_ENTRY_CAPABILITY_LOCATION);
	}
	
	private ResourceTypeType createServiceGroupEntryMuseResourceType()
	{
		ResourceTypeType resourceType = DescriptorFactory.eINSTANCE.createResourceTypeType();
		resourceType.setContextPath("/ServiceGroupEntry");
		resourceType.setJavaIdFactoryClass("org.apache.muse.core.routing.CounterResourceIdFactory");
		resourceType.setJavaResourceClass("org.apache.muse.ws.resource.impl.SimpleWsResource");

		WsdlType wsdlType = DescriptorFactory.eINSTANCE.createWsdlType();
		wsdlType.setWsdlFile(_mrtParentDirName + "/" + "ServiceGroupEntry.wsdl");
		_root.getXMLNSPrefixMap().put("wsrf-sge","http://docs.oasis-open.org/wsrf/sgw-2");
		wsdlType.setWsdlPortType("wsrf-sge:PortType");
		resourceType.setWsdl(wsdlType);

		CapabilityType metadataExchange = DescriptorFactory.eINSTANCE.createCapabilityType();
		metadataExchange.setCapabilityUri(WsdmConstants.MEX_NS);
		metadataExchange.setJavaCapabilityClass("");
		
		CapabilityType getCapability = DescriptorFactory.eINSTANCE.createCapabilityType();
		getCapability.setCapabilityUri(WsdmConstants.GET_NS);
		getCapability.setJavaCapabilityClass("");
		
		CapabilityType setCapability = DescriptorFactory.eINSTANCE.createCapabilityType();
		setCapability.setCapabilityUri(WsdmConstants.SET_NS);
		setCapability.setJavaCapabilityClass("");
		
		CapabilityType queryCapability = DescriptorFactory.eINSTANCE.createCapabilityType();
		queryCapability.setCapabilityUri(WsdmConstants.QUERY_NS);
		queryCapability.setJavaCapabilityClass("");

		CapabilityType immediateDestruction = DescriptorFactory.eINSTANCE.createCapabilityType();
		immediateDestruction.setCapabilityUri(WsdmConstants.IMMIDIATE_TERM_NS);
		immediateDestruction.setJavaCapabilityClass("");

		CapabilityType scheduledDestruction = DescriptorFactory.eINSTANCE.createCapabilityType();
		scheduledDestruction.setCapabilityUri(WsdmConstants.SCHEDULDED_TERM_NS);
		scheduledDestruction.setJavaCapabilityClass("");
	
		CapabilityType serviceGroupEntry = DescriptorFactory.eINSTANCE.createCapabilityType();
		serviceGroupEntry.setCapabilityUri(WsdmConstants.SERVICE_GROUP_ENTRY_NS);
		serviceGroupEntry.setJavaCapabilityClass("");
		
		InitParamType noValidateParam = DescriptorFactory.eINSTANCE	.createInitParamType();
		noValidateParam.setParamName("validate-wsrp-schema");
		noValidateParam.setParamValue("false");

		resourceType.getCapability().add(metadataExchange);
		resourceType.getCapability().add(getCapability);
		resourceType.getCapability().add(setCapability);
		resourceType.getCapability().add(queryCapability);
		resourceType.getCapability().add(immediateDestruction);
		resourceType.getCapability().add(scheduledDestruction);
		resourceType.getCapability().add(serviceGroupEntry);
		resourceType.getInitParam().add(noValidateParam);

		return resourceType;
	}
	
	private String getNamespace(String contentElement)
	{
		return contentElement.substring(1,contentElement.lastIndexOf('}'));
	}
	
	private void preparePrfixNamespaceMap(String contentElement)
	{
		if(!_prefixNamespaceMap.containsKey(contentElement))
		{
			NewNameGenerator nameGenerator = new NewNameGenerator("pfx");
			String prefix = nameGenerator.getNextName();
			
			while (nameAlreadyExists(prefix)) 
			{
				prefix = nameGenerator.getNextName();
			}
			_prefixNamespaceMap.put(contentElement, prefix);
		}
	}
	
	private boolean nameAlreadyExists(String prefix)
	{
		if(_prefixNamespaceMap.containsValue(prefix))
			return true;
		return false;
	}
	
	private String getLocalName(String namespace)
	{
		return namespace.substring(namespace.lastIndexOf('}')+1);
	}
	
	/**
	 * This method will returns the extra generated ManageableResourceType object equivalent to ServiceGroupEntry.
	 */
	public ManageableResourceType getExtraGeneratedMrt() {
	
		return _serviceGroupEntrymrt;
	}
	
	/**
	 * This method should return the persistance location for extra generated ManageableResourceType object equivalent to ServiceGroupEntry.
	 */
	public String getExtraGeneratedMrtPersistanceLocation() 
	{
		return _mrtParentDirName + "/"+ "ServiceGroupEntry.mrt";
	}
	/**
	 * This method will persist the extra artifacts generated at the code generation time(ServiceGroupEntry). 
	 */
	public void persistArtifacts()
	{
		try{
			ResourceSet rs = new ResourceSetImpl();
			rs.getResourceFactoryRegistry().getExtensionToFactoryMap()
			.put(Resource.Factory.Registry.DEFAULT_EXTENSION, new CustomMrtResourceFactoryImpl());
			String serviceGroupMrt = _mrtParentDirName + "/"+ "ServiceGroupEntry.mrt";
			URI uri = URI.createPlatformResourceURI(serviceGroupMrt);
			byte[] rawNewMRT = MrtUtils.serializeMRT(_serviceGroupEntrymrt, rs, uri, true);
			InputStream stream = new ByteArrayInputStream(rawNewMRT);			
			IFile subManagerMrtFile = EclipseUtils.getIFile(serviceGroupMrt);
			if (subManagerMrtFile.exists())
			{
				subManagerMrtFile.setContents(stream, true, true,
				new NullProgressMonitor());
			}
			else
			{
				subManagerMrtFile.create(stream, true,
				new NullProgressMonitor());
			}
			stream.close();			
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
	}
	
	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	public void inspectMetadata(ManageableResourceType mrt,
			org.apache.muse.ws.resource.metadata.MetadataDescriptor rmd) 
	{
		
		_prefixNamespaceMap  = new HashMap();
		Capability[] mrtCapabilities = new Capability[0];
		try 
		{
			mrtCapabilities = MrtUtils.getCapabilities(mrt);
		} 
		catch (Exception e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}
		
		if(hasServiceGroupCapabilities(mrtCapabilities))
		{
			List membershipContentRule = mrt.getMembershipContentRule();
			List initialValues = new ArrayList();
			for(int i=0;i<membershipContentRule.size();i++)
			{
				MembershipContentRuleType rule = (MembershipContentRuleType) membershipContentRule.get(i);
				Element value = createMembershipContentRuleElement(rule);
				
				initialValues.add(value);
			}
			if(!initialValues.isEmpty());
				try 
				{
					rmd.setInitialValues(new QName(WssgConstants.NAMESPACE_URI,"MembershipContentRule"), initialValues);
				} 
				catch (SoapFault e) 
				{
					WsdmToolingLog.logError(e.getMessage(), e);
				}
		}
	}
	
	private Element createMembershipContentRuleElement(MembershipContentRuleType rule)
	{
		Document document = XmlUtils.createDocument();
		Element membershipContentRuleElement = XmlUtils.createElement(document, new QName(WssgConstants.NAMESPACE_URI,"MembershipContentRule"));
		List contentElements = rule.getContentElements();
		String contentElementAttribute="";
		
		for(int i =0 ;i<contentElements.size();i++)
		{
			String contentElement = (String)contentElements.get(i);
			String tns = getNamespace(contentElement);
			String localName = getLocalName(contentElement);
			preparePrfixNamespaceMap(tns);
			
			if(contentElementAttribute.length() !=0)
				contentElementAttribute =  contentElementAttribute + " " + (String)_prefixNamespaceMap.get(tns)+":"+ localName;
			else
				contentElementAttribute =(String)_prefixNamespaceMap.get(tns)+":"+ localName;
			String  xmlns = "xmlns:" + _prefixNamespaceMap.get(tns);
			 membershipContentRuleElement.setAttribute(xmlns,tns );
			
		}
		membershipContentRuleElement.setAttribute("ContentElements",contentElementAttribute );
		
		return membershipContentRuleElement;
		
		
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.File;
import java.lang.reflect.InvocationTargetException;

import org.apache.muse.tools.generator.analyzer.Analyzer;
import org.apache.muse.tools.generator.analyzer.SimpleAnalyzer;
import org.apache.muse.tools.generator.projectizer.Projectizer;
import org.apache.muse.tools.generator.synthesizer.ServerSynthesizer;
import org.apache.muse.tools.generator.synthesizer.Synthesizer;
import org.apache.muse.tools.generator.util.ConfigurationData;
import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.ILog;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.swt.graphics.Image;
import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;
import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.preferences.internal.Axis2ServerLocationPreferencePage;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.eclipse.ui.INewWizard;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;
import org.w3c.dom.Document;

/**
 * This wizard accepts projectizer parameters, runtime environment and other
 * general parameters from the user so as to invoke Wsdl2Java
 */
public class NewProjectWizard extends Wizard implements INewWizard {

	private static ILog LOG = null;

	// We can't use internal classes, hence using view ID directly
	private static String TASK_VIEW_ID = "org.eclipse.ui.views.TaskList";

	private static String PLUGIN_ID = "org.eclipse.tptp.wsdm.tooling.editor.mrt";

	private GenerationOptionsPage _generationOptionsPage;

	private Axis2ServerLocationPage _axis2ServerLocationPage;

	private String _projectName;

	private boolean _overwrite;

	private boolean _shouldPersistArtifacts;

	private Projectizer _projectizer;

	private Synthesizer _synthesizer;

	private Analyzer _analyzer;

	private String _baseAddress;

	private CodeGenerationDelegate _codeGenerationDelegate;

	private Document[] _mergedWsdlDocuments;

	private MetadataDescriptor[] _mergedRMDs;

	private DescriptorHelper _helper;

	private String _serverLocation;

	private boolean _isAxis2Project;
	private boolean updatePreference;

	private String _projectLocation;

	private TargetedFileList[] _requiredAxis2Files;

	private boolean _licenseAccepted = false;

	/**
	 * Class that creates the Code Generation Wizard to create new Project
	 * 
	 * @param codeGenerationDelegate
	 */
	public NewProjectWizard(CodeGenerationDelegate codeGenerationDelegate) {
		setWindowTitle(Messages.HOOKUP_WIZARD_TXT7);
		setNeedsProgressMonitor(true);

		_codeGenerationDelegate = codeGenerationDelegate;
	}

	public void addPages() {
		_generationOptionsPage = new GenerationOptionsPage();
		addPage(_generationOptionsPage);

		_axis2ServerLocationPage = new Axis2ServerLocationPage();
		addPage(_axis2ServerLocationPage);

		// TODO AME why is this hardcoded here? why is it getting reloaded?
		Image imgTP = EclipseUtils.loadImage(PlatformUI.getWorkbench().getDisplay(),
				"icons/wizban/newEndpointProject_wiz.gif");
		ImageDescriptor imgDescrTP = ExtendedImageRegistry.INSTANCE.getImageDescriptor(imgTP);
		setDefaultPageImageDescriptor(imgDescrTP);
	}

	private void popupAxis2LicenseDialog() {
		IPreferenceStore store = Activator.getPlugin().getPreferenceStore();
		String preferencesLocation = store.getString(Axis2ServerLocationPreferencePage.SERVER_LOCATION_PREFERENCE_KEY);
		if (!_serverLocation.equals(preferencesLocation)) {
			int result = new Axis2LicenseDialog().showWindow();
			_licenseAccepted = (result == Axis2LicenseDialog.AGREE);
		} else
			_licenseAccepted = true;

	}

	private void performFinish(IProgressMonitor monitor) throws InvocationTargetException {
		try {
			monitor.beginTask(Messages.CODE_GEN_START, 7);

			if (_isAxis2Project) {
				try {
					// Step 1: Validate the server path
					monitor.subTask(Messages.CODE_GEN_VALIDATE_SLOCATION);
					// Step 2 : Update the Preferences, if needed
					if (updatePreference) {
						IPreferenceStore store = Activator.getPlugin().getPreferenceStore();
						store.setValue(Axis2ServerLocationPreferencePage.SERVER_LOCATION_PREFERENCE_KEY,
								_serverLocation);
						// Update the Lib and module location
					}
					_requiredAxis2Files = _axis2ServerLocationPage.getAxis2FilesToCopy();
				} catch (Exception e) {
					throw new RuntimeException(e);
				}
			}
			try {
				monitor.subTask(Messages.CODE_GEN_STEP1);
				_helper = _codeGenerationDelegate.run(new SubProgressMonitor(monitor, 1));

				monitor.worked(1);
			} catch (Exception e) {
				throw new RuntimeException(e);
				// TODO AME Why is this not defined?
				// throw new InvocationTargetException(new
				// Exception(Messages.HOOKUP_WIZARD_ERROR4, e));
			}

			try {
				monitor.subTask(Messages.CODE_GEN_STEP2);
				_mergedWsdlDocuments = _helper.getWsdlDocuments(_baseAddress);
				_mergedRMDs = _helper.getMergedRMDs();
				monitor.worked(1);
			} catch (Exception e) {
				e.printStackTrace();
				throw new RuntimeException(e);
			}

			try {
				monitor.subTask(Messages.CODE_GEN_STEP3);
				runProjectizer(monitor);
				monitor.worked(1);
			} catch (Exception e) {
				throw new InvocationTargetException(new Exception(Messages.CODE_GEN_FAILED_ERROR_, e));
			}

			if (_shouldPersistArtifacts) {
				monitor.subTask(Messages.CODE_GEN_STEP4);
				_codeGenerationDelegate.persistArtifacts();
				monitor.worked(1);
			}
		} finally {
			monitor.done();
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.wizard.Wizard#performFinish()
	 */
	public boolean performFinish() {
		_projectizer = _generationOptionsPage.getProjectizer();
		_synthesizer = _generationOptionsPage.getSynthesizer();
		_analyzer = _generationOptionsPage.getAnalyzer();
		_overwrite = _generationOptionsPage.canOverwrite();
		_shouldPersistArtifacts = _generationOptionsPage.shouldPersistArtifacts();
		_projectName = _generationOptionsPage.getProjectName();
		_baseAddress = _generationOptionsPage.getBaseAddress();
		_isAxis2Project = _generationOptionsPage.isAxis2Project();
		_projectName = _generationOptionsPage.getProjectName();
		_projectLocation = _generationOptionsPage.getProjectLocation();

		if (_isAxis2Project) {
			_serverLocation = _axis2ServerLocationPage.getServerLocation();
			updatePreference = _axis2ServerLocationPage.isUpdatePreference();
			popupAxis2LicenseDialog();
		}

		IRunnableWithProgress runnable = new IRunnableWithProgress() {
			public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
				if (!_isAxis2Project || _licenseAccepted)
					performFinish(monitor);
			}
		};
		
		_generationOptionsPage.saveCombo();

		try {
			getContainer().run(true, false, runnable);
			openTasksView();
			
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			handle(Messages.CODE_GEN_FAILED_ERROR_, e);
		}

		return false;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.IWorkbenchWizard#init(org.eclipse.ui.IWorkbench,
	 *      org.eclipse.jface.viewers.IStructuredSelection)
	 */
	public void init(IWorkbench workbench, IStructuredSelection selection) {
		// do nothing
	}

	private void runProjectizer(IProgressMonitor monitor) throws Exception {
		ConfigurationData data = new ConfigurationData();

		data.addParameter(EclipseConfigurationData.AXIS2_FILES, _requiredAxis2Files);

		data.addParameter(ConfigurationData.DESCRIPTOR_DOCUMENT, _helper.getDescriptorDocument());
		data.addParameter(EclipseConfigurationData.ADDITIONAL_JARS, _helper.getJarFiles());
		data.addParameter(EclipseConfigurationData.INSTANCES, _helper.getInstances());
		data.addParameter(EclipseConfigurationData.PROJECT_NAME, _projectName);
		data.addParameter(ConfigurationData.OVERWRITE, Boolean.valueOf(_overwrite));
		data.addParameter(EclipseConfigurationData.PROJECT_LOCATION, _projectLocation);
		data.addParameter(ConfigurationData.WSDL_DOCUMENT_LIST, _mergedWsdlDocuments);
		data.addParameter(ConfigurationData.METADATA_DESCRIPTOR_LIST, _mergedRMDs);
		data.addParameter(ConfigurationData.GENERATE_CUSTOM_HEADERS, Boolean.FALSE);

		// check if the analyzer is null, if it is then default to the
		// SimpleAnalyzer
		if (_analyzer == null) {
			_analyzer = new SimpleAnalyzer();
		}

		// check if the synthesizer is null, if it is then default to the
		// ServerSynthesizer
		if (_synthesizer == null) {
			_synthesizer = new ServerSynthesizer();
		}

		// Below, we make a new SubProgressMonitor for
		// each codegeneration component since we can't reuse the progress
		// monitor

		data.addParameter(EclipseConfigurationData.PROGRESS_MONITOR, new SubProgressMonitor(monitor, 1));

		monitor.subTask(Messages.CODE_GEN_SUBTASK1);
		data = _analyzer.analyze(data);
		monitor.worked(1);

		data.addParameter(EclipseConfigurationData.PROGRESS_MONITOR, new SubProgressMonitor(monitor, 1));

		monitor.subTask(Messages.CODE_GEN_SUBTASK2);
		data = _synthesizer.synthesize(data);
		monitor.worked(1);

		data.addParameter(EclipseConfigurationData.PROGRESS_MONITOR, new SubProgressMonitor(monitor, 1));

		monitor.subTask(Messages.CODE_GEN_SUBTASK3);
		_projectizer.projectize(data);
		monitor.worked(1);
	}

	private void handle(String message, Exception e) {
		_generationOptionsPage.setErrorMessage(message);
		_axis2ServerLocationPage.setErrorMessage(message);

		WsdmToolingLog.log(IStatus.ERROR, IStatus.OK, message, e);
	}

	private void openTasksView() {
		IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
		ViewPart view = (ViewPart) page.findView(TASK_VIEW_ID);

		// If the page isn't showing then show it
		if (view == null) {
			try {
				page.showView(TASK_VIEW_ID);
			} catch (PartInitException e) {
				WsdmToolingLog.logError(e.getMessage(), e);
			}
		}else{
			page.activate(view);
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;

/**
 * This interface is created for some cases where we expect some extra resource
 * type to be added to the muse descriptor based on the capability that
 * manageable resource type holds. For example if someone includes the
 * Notification producer capability in his manageable resource type, then muse
 * runtime requires the Subscription Manager as one of the resource type
 * described in muse descriptor file.
 */
public interface MrtInspector
{
	public static String WSDL_NAMESPACE = "http://schemas.xmlsoap.org/wsdl/";

	/**
	 * Analyzes the given manageable resource type capabilities and then returns the muse
	 * resource type for some extra generated artifact else returns the null.
	 */
	ResourceTypeType inspect(Capability[] mrtCapabilities);

	/**
	 * This method should set the parent directory for extra generated artifact. 
	 */
	void setMrtParentDirectory(String mrtParentDir);

	/**
	 * Returns initial instances for extra generated artifact. 
	 */
	InitialInstancesType[] getInitialInstances();
	
	/**
	 * This method will persist the extra artifacts generated at codegen time.
	 */
	void persistArtifacts();
	
	/**
	 * This method will returns the extra ManageableResourceType object generated at codegen time.
	 */
	ManageableResourceType getExtraGeneratedMrt();
	
	/**
	 * This method should return the persistance location for extra generated ManageableResourceType object.
	 */
	String getExtraGeneratedMrtPersistanceLocation();
	
	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	void inspectMetadata(ManageableResourceType mrt, MetadataDescriptor rmd);	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

public class EclipseConfigurationData
{
	public static final String ADDITIONAL_JARS = "jars";
	public static final String INSTANCES = "instances";
	public static final String PROGRESS_MONITOR = "progress_monitor";
	public static final String AXIS2_FILES = "axis2_files";
	public static final String PROJECT_LOCATION = "location";
	public static final String PROJECT_NAME = "project_name";
}




/*******************************************************************************
 * Copyright (c) 2006, 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.wsdl.Operation;
import javax.xml.namespace.QName;

import org.apache.muse.util.xml.XmlUtils;
import org.apache.muse.ws.addressing.WsaConstants;
import org.apache.muse.ws.addressing.soap.SoapFault;
import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.ws.muse.descriptor.CapabilityType;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.InitParamType;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.ReferenceParametersType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.WsdlType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.impl.EStructuralFeatureImpl;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.util.FeatureMap;
import org.eclipse.emf.ecore.util.BasicExtendedMetaData.EStructuralFeatureExtendedMetaData;
import org.eclipse.emf.ecore.xml.type.AnyType;
import org.eclipse.tptp.wsdm.tooling.editor.mrt.relationship.internal.RelationshipUtils;
import org.eclipse.tptp.wsdm.tooling.model.addressing.AttributedURIType;
import org.eclipse.tptp.wsdm.tooling.model.addressing.EndpointReferenceType;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceTypeFactory;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.Relationship;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.RelationshipParticipantType;
import org.eclipse.tptp.wsdm.tooling.util.internal.CustomMrtResourceFactoryImpl;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdlUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmConstants;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;

public class RelationshipInspector implements MrtInspector
{

	private String _mrtParentDirName;

	private DocumentRoot _root;

	private ResourceTypeType _relationshipResourceType;
	
	private ManageableResourceType _relationshipResourceMRT;
	
	/**
	 * Constructor of the class
	 * @param root
	 */
	public RelationshipInspector(DocumentRoot root)
	{
		_root = root;
	}

	public ManageableResourceType getExtraGeneratedMrt()
	{
		return _relationshipResourceMRT;
	}

	public String getExtraGeneratedMrtPersistanceLocation() 
	{
		return _mrtParentDirName+"/RelationshipResource.mrt";
	}

	public InitialInstancesType[] getInitialInstances() 
	{
		InitialInstancesType instance = DescriptorFactory.eINSTANCE
			.createInitialInstancesType();
		ResourceTypeType rtClone = MRTCodeGenerationDelegate
			.cloneResourceType(_relationshipResourceType);
		instance.setResourceType(rtClone);
		ReferenceParametersType refParam = DescriptorFactory.eINSTANCE
			.createReferenceParametersType();
		instance.setReferenceParameters(refParam);
		return new InitialInstancesType[] { instance };
	}

	public ResourceTypeType inspect(Capability[] mrtCapabilities) 
	{
		for (int i = 0; i < mrtCapabilities.length; i++)
		{
			if (hasRelationshipCapability(mrtCapabilities[i]))
				return createRelationshipResourceType();							
		}
		return null;
	}
	
	private ResourceTypeType createRelationshipResourceType()
	{
		createRelationshipResourceMrt();
		_relationshipResourceType = createRelationshipResourceMuseType();
		return _relationshipResourceType;
	}
	
	private void createRelationshipResourceMrt()
	{
		org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.DocumentRoot documentRoot = ManageableResourceTypeFactory.eINSTANCE.createDocumentRoot();
		_relationshipResourceMRT = ManageableResourceTypeFactory.eINSTANCE
				.createManageableResourceType();
		documentRoot.setManageableResource(_relationshipResourceMRT);
		_relationshipResourceMRT.setIdentifier("RelationshipResource");
		_relationshipResourceMRT
				.setNamespace("http://docs.oasis-open.org/wsdm/muws2-2.xsd/RelationshipResource");
		_relationshipResourceMRT
				.getImplements()
				.add(WsdmConstants.MEX_CAPABILITY_LOCATION);
		_relationshipResourceMRT
				.getImplements()
				.add(WsdmConstants.GET_CAPABILITY_LOCATION);
		_relationshipResourceMRT
				.getImplements()
				.add(WsdmConstants.SET_CAPABILITY_LOCATION);
		_relationshipResourceMRT
				.getImplements()
				.add(WsdmConstants.QUERY_CAPABILITY_LOCATION);
		_relationshipResourceMRT
				.getImplements()
				.add(WsdmConstants.RELATIONSHIP_RESOURCE_CAPABILITY_LOCATION);
	}
	
	private ResourceTypeType createRelationshipResourceMuseType()
	{
		ResourceTypeType resourceType = DescriptorFactory.eINSTANCE
				.createResourceTypeType();
		resourceType.setContextPath("/RelationshipResource");
		resourceType
				.setJavaIdFactoryClass(WsdmConstants.MUSE_RESOURCE_ID_FACTORY_CLASS);
		resourceType
				.setJavaResourceClass(WsdmConstants.MUSE_RESOURCE_CLASS);

		WsdlType wsdlType = DescriptorFactory.eINSTANCE.createWsdlType();
		wsdlType.setWsdlFile(_mrtParentDirName + "/"
				+ "RelationshipResource.wsdl");
		_root.getXMLNSPrefixMap().put("rel",
				"http://docs.oasis-open.org/wsdm/muws2-2.xsd/RelationshipResource");
		wsdlType.setWsdlPortType("rel:PortType");
		resourceType.setWsdl(wsdlType);

		CapabilityType metadataExchange = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		metadataExchange
				.setCapabilityUri("http://schemas.xmlsoap.org/ws/2004/09/mex");
		metadataExchange.setJavaCapabilityClass("");

		CapabilityType getCapability = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		getCapability
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Get");
		getCapability.setJavaCapabilityClass("");

		CapabilityType setCapability = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		setCapability
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Set");
		setCapability.setJavaCapabilityClass("");

		CapabilityType queryCapability = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		queryCapability
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Query");
		queryCapability.setJavaCapabilityClass("");

		CapabilityType relationshipResource = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		relationshipResource
				.setCapabilityUri("http://docs.oasis-open.org/wsdm/muws/capabilities/RelationshipResource");
		relationshipResource
				.setJavaCapabilityClass("");

		InitParamType noValidateParam = DescriptorFactory.eINSTANCE
				.createInitParamType();
		noValidateParam.setParamName("validate-wsrp-schema");
		noValidateParam.setParamValue("false");

		resourceType.getCapability().add(metadataExchange);
		resourceType.getCapability().add(getCapability);
		resourceType.getCapability().add(setCapability);
		resourceType.getCapability().add(queryCapability);
		resourceType.getCapability().add(relationshipResource);
		
		resourceType.getInitParam().add(noValidateParam);

		return resourceType;
	}
	
	private boolean hasRelationshipCapability(Capability capability)
	{
		boolean hasRelationshipNS = "http://docs.oasis-open.org/wsdm/muws2-2.xsd".equals(capability.getNamespace());
		String capabilityURI = capability.getWsdlDefinition().getNamespace("capabilityURI");
		boolean hasRelationshipURI = "http://docs.oasis-open.org/wsdm/muws/capabilities/Relationships".equals(capabilityURI);
		boolean hasRelationshipName = capability.getName().equals("Relationships");
		Operation[] operations = capability.getWsdlDefinition().getOperations();
		if (operations == null || operations.length < 1)
			return false;
		boolean hasQueryRelationshipsOp = WsdlUtils.getOperationName(operations[0])
				.equals("QueryRelationshipsByType");
		return hasRelationshipNS && hasRelationshipURI && hasRelationshipName && hasQueryRelationshipsOp;
	}

	public void persistArtifacts() 
	{
		ResourceSet rs = new ResourceSetImpl();
		rs.getResourceFactoryRegistry().getExtensionToFactoryMap()
			.put(Resource.Factory.Registry.DEFAULT_EXTENSION, new CustomMrtResourceFactoryImpl());
		byte[] rawNewMRT = MrtUtils.serializeMRT(_relationshipResourceMRT, rs, URI
				.createURI("dummy.xml"), true);
		InputStream stream = new ByteArrayInputStream(rawNewMRT);

		try
		{
			String relationshipResourceMrt = _mrtParentDirName + "/"
					+ "RelationshipResource.mrt";
			IFile relationshipResourceMrtFile = EclipseUtils.getIFile(relationshipResourceMrt);
			if (relationshipResourceMrtFile.exists())
			{
				relationshipResourceMrtFile.setContents(stream, true, true,
						new NullProgressMonitor());
			}
			else
			{
				relationshipResourceMrtFile.create(stream, true,
						new NullProgressMonitor());
			}
			try
			{
				stream.close();
			}
			catch (IOException e)
			{
				WsdmToolingLog.logError(e.getMessage(), e);
			}
		}
		catch (CoreException e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}		
	}

	public void setMrtParentDirectory(String mrtParentDir) 
	{
		_mrtParentDirName = mrtParentDir;
	}
	
	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	public void inspectMetadata(ManageableResourceType mrt, MetadataDescriptor rmd)
	{
		boolean hasRelationshipCapability = false;
		Capability[] mrtCapabilities = new Capability[0];
		try 
		{
			mrtCapabilities = MrtUtils.getCapabilities(mrt);
		} 
		catch (Exception e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}
		for (int i = 0; i < mrtCapabilities.length; i++)
		{
			if (hasRelationshipCapability(mrtCapabilities[i]))
			{
				hasRelationshipCapability = true;
				break;
			}
		}
		if(hasRelationshipCapability)
		{
			List relationships = mrt.getRelationshipDefinitions();
			List initialValues = new ArrayList();
			for(int i=0;i<relationships.size();i++)
			{
				Relationship relationship = (Relationship) relationships.get(i);
				Element value = createRelationshipElement(relationship);
				initialValues.add(value);
			}
			if(!initialValues.isEmpty());
				try 
				{
					rmd.setInitialValues(new QName(WsdmConstants.MUWS_P2_NS,"Relationship"), initialValues);
				} 
				catch (SoapFault e) 
				{
					WsdmToolingLog.logError(e.getMessage(), e);
				}
		}
	}
	
	private Element createRelationshipElement(Relationship relationship)
	{
		Document document = XmlUtils.createDocument();
		Element relationshipElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P2_NS,"Relationship"));
		
		Element nameElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P2_NS,"Name"));
		Text name = document.createTextNode(relationship.getName());
		nameElement.appendChild(name);		
		relationshipElement.appendChild(nameElement);
		
		Element typeElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P2_NS,"Type"));
		QName typeQName = RelationshipUtils.getRelationshipType(relationship);
		Element element = XmlUtils.createElement(document, typeQName);
		typeElement.appendChild(element);		
		relationshipElement.appendChild(typeElement);
		
		List participants = relationship.getParticipant();
		for(int i=0;i<participants.size();i++)
		{
			RelationshipParticipantType participant = (RelationshipParticipantType) participants.get(i);
			Element participantElement = createParticipantElement(participant, document);
			relationshipElement.appendChild(participantElement);
		}
		return relationshipElement;
	}
	
	private Element createParticipantElement(RelationshipParticipantType participant, Document document)
	{
		Element participantElement = XmlUtils.createElement(document,new QName(WsdmConstants.MUWS_P2_NS,"Participant"));
		
		// Create epr element 
		Element manageabilityEprElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P1_NS,"ManageabilityEndpointReference"));
		EndpointReferenceType epr = (EndpointReferenceType) participant.getManageabilityEndpointReference().get(0);
		AttributedURIType uri = epr.getAddress();
		Element addressElement = XmlUtils.createElement(document, new QName("http://www.w3.org/2005/08/addressing", "Address"));
		Text address = document.createTextNode(uri.getValue());
		addressElement.appendChild(address);
		manageabilityEprElement.appendChild(addressElement);
		participantElement.appendChild(manageabilityEprElement);
		
		// Create reference parameter element
		Element referenceParameterElement = XmlUtils.createElement(document, WsaConstants.PARAMETERS_QNAME);
		manageabilityEprElement.appendChild(referenceParameterElement);		
		org.eclipse.tptp.wsdm.tooling.model.addressing.ReferenceParametersType refParams = epr.getReferenceParameters();
		FeatureMap fm = refParams.getAny();
		Iterator it = fm.iterator();
		while (it.hasNext())
		{
			Object obj = it.next();
			if(obj instanceof EStructuralFeatureImpl.ContainmentUpdatingFeatureMapEntry)
			{
				EStructuralFeatureImpl.ContainmentUpdatingFeatureMapEntry containmentEntry = (EStructuralFeatureImpl.ContainmentUpdatingFeatureMapEntry)obj;
				EStructuralFeatureExtendedMetaData metadata = ((EStructuralFeatureImpl)containmentEntry.getEStructuralFeature()).getExtendedMetaData();
				String namespace = metadata.getNamespace();
				String name = metadata.getName();
				String value = "";
				Object containmentEntryValue = containmentEntry.getValue();
				if(containmentEntryValue instanceof AnyType)
				{
					AnyType anyType = (AnyType) containmentEntryValue;
					value = (String) anyType.getMixed().valueListIterator().next();
				}
				Element paramElement = XmlUtils.createElement(document, new QName(namespace, name));
				XmlUtils.setElementText(paramElement, value);
				referenceParameterElement.appendChild(paramElement);
			}			
		}
		
		// Create resource id element
		Element resourceIdElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P1_NS,"ResourceId"));
		Text resourceId = document.createTextNode(participant.getResourceId());
		resourceIdElement.appendChild(resourceId);
		participantElement.appendChild(resourceIdElement);
		
		// Create role element
		Element roleElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P2_NS,"Role"));
		Text role = document.createTextNode(participant.getRole());
		roleElement.appendChild(role);
		participantElement.appendChild(roleElement);
		
		return participantElement;
	}
	
	

}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import org.eclipse.core.runtime.IExecutableExtension;

/**
 * Interface to represent Soap Library dependency used in Tooling codegeneration. 
 */

public interface ISoapServerDependency extends IExecutableExtension
{
	/**
	 * Returns null if the given Server Home has all the required soap jar files.
	 */
	String validateSoapServerHome(String serverHome);
	
	/**
	 * Returns the absolute path of all the required soap jar files. 
	 */
	TargetedFileList[] getFilesToCopy();
	
	/**
	 * Returns the absolute path of the lib folder. 
	 */
//	String getServerLibLocation(String serverName);
	
	/**
	 * Returns the absolute path of the modules folder. 
	 */
//	String getServerModulesLocation(String serverName);

	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;

/**
 * This class acts as a way to capture doing WSDL resolution (which could
 * include WSDL manipulation like merging) so that it can be done later on, or
 * on another thread since this would be time-consuming.
 */
public interface CodeGenerationDelegate
{

	/**
	 * Do any work related to code generation. This kind of work is passed to
	 * this delegate so that it can be run in a separate thread. This can take a
	 * (optional) progress monitor which can be used to report progress done in
	 * this task. The method returns a DescriptorHelper which aggregates all of
	 * the work that was done.
	 * 
	 * @param progressMonitor
	 *            A progress monitor to show the progress done during this task.
	 * 
	 * @throws Exception
	 */
	DescriptorHelper run(SubProgressMonitor progressMonitor) throws Exception;
	
	/**
	 * Persist the extra artifacts generated during codegeneration such as SubscriptionManager.mrt etc.
	 */
	void persistArtifacts();
	
	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	void inspectMetadata(ManageableResourceType mrt, MetadataDescriptor metadata);
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.MuseType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.RootType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.tptp.wsdm.tooling.editor.dde.util.internal.DdeUtil;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;

/**
 * This class analyzes the given ManageableResourceType object and check whether it needs
 * any other extra ManageableResourceType object such as SubscriptionManager based on the capabilities 
 * available in given ManagableResourceType.   
 */

public class MrtPreProcessor 
{
	private ManageableResourceType _mrt;
	private DocumentRoot _ddRoot;
	private IFile _mrtFile;
	private List _generatedResourceTypes = new LinkedList();
	private List _initialInstancesList = new LinkedList();
	private List _contributedInspectors = new LinkedList();
	private Map _mrtObjectMap = new HashMap();
	private List _allInspectors = new LinkedList();
	
	/**
	 * Creates instance of this class.
	 * 
	 * @param mrt
	 * 			Given MRT to analyze.
	 * 
	 * @param ddRoot
	 * 			Given Descriptor file document root, can be null.
	 */
	public MrtPreProcessor(ManageableResourceType mrt, DocumentRoot ddRoot)
	{
		_mrt = mrt;
		if(ddRoot == null)
			ddRoot = DdeUtil.createInitialDDModel();
		_ddRoot = ddRoot;
		String mrtLocation = _mrt.eResource().getURI().toString();
		try 
		{
			_mrtFile = EclipseUtils.getIFile(mrtLocation);
		} 
		catch (CoreException e) 
		{
			e.printStackTrace();
		}
	}
	
	/**
	 * Creates instance of this class.
	 * 
	 * @param mrt
	 * 			Given MRT to analyze.
	 */
	public MrtPreProcessor(ManageableResourceType mrt)
	{
		this(mrt,null);
	}
	
	/**
	 * Returns the modified Descriptor document root. 
	 */
	public DocumentRoot getDDDocumentRoot()
	{
		return _ddRoot;
	}
	
	/**
	 * Analyzes the given MRT file for extra required artifacts. 
	 */
	public void preProcess()
	{
		if(_ddRoot!=null)
		{
			RootType root = _ddRoot.getRoot();
			MuseType muse = root.getMuse();		
			ResourceTypeType[] resourceTypes = process();
			for (int i = 0; i < resourceTypes.length; i++)
				muse.getResourceType().add(resourceTypes[i]);
			
			// Create initial instances
			
			InitialInstancesType[] instances = getInitialInstances();
			for (int i = 0; i < instances.length; i++)
				root.getInitialInstances().add(instances[i]);
		}
	}
	
	private boolean hasResourceTypeInDD(ResourceTypeType givenResourceType)
	{
		if(_ddRoot!=null)
		{
			if(_ddRoot.getRoot()!=null)
			{
				if(_ddRoot.getRoot().getMuse()!=null)
				{
					MuseType muse = _ddRoot.getRoot().getMuse();
					List resourceTypes = muse.getResourceType();
					if(resourceTypes!=null)
					{
						for(int i=0;i<resourceTypes.size();i++)
						{
							ResourceTypeType resourceType = (ResourceTypeType)resourceTypes.get(i);
							boolean equalContextPath = givenResourceType.getContextPath().equals(resourceType.getContextPath());
							boolean equalWsdlFile = givenResourceType.getWsdl().getWsdlFile().equals(resourceType.getWsdl().getWsdlFile());
							boolean equalWsdlPortType = givenResourceType.getWsdl().getWsdlPortType().equals(resourceType.getWsdl().getWsdlPortType());
							if(equalContextPath && equalWsdlFile && equalWsdlPortType)
								return true;
						}
					}
				}
			}
		}
		return false;
	}
	
	/**
	 * This method processes the given manageable resource type to check whether
	 * we need any extra resource type in muse descriptor file such as
	 * Subscription manager etc. It will returns all the proper ResourceTypeType
	 * objects. So it will return atleast one ResourceTypeType object that
	 * represents the given manageable resource type.
	 */
	private ResourceTypeType[] process()
	{
		Capability[] mrtCapabilities = new Capability[0];
		try
		{
			mrtCapabilities = MrtUtils.getCapabilities(_mrt);
		}
		catch (Exception e)
		{
		}
		// Analyze the given manageable resource type for Subscription manager
		// etc.
		// If needed add the extra resource type for Subscription manager
		List inspectors = getAllMrtInspectors();
		for (int i = 0; i < inspectors.size(); i++)
		{
			MrtInspector inspector = (MrtInspector) inspectors.get(i);
			inspector.setMrtParentDirectory(_mrtFile.getParent().getFullPath()
					.toString());
			ResourceTypeType resourceType = inspector.inspect(mrtCapabilities);
			if (resourceType != null)
			{
				if(!hasResourceTypeInDD(resourceType))
				{
					_generatedResourceTypes.add(resourceType);
					InitialInstancesType[] instances = inspector
							.getInitialInstances();
					for (int j = 0; j < instances.length; j++)
						_initialInstancesList.add(instances[j]);
					if(inspector.getExtraGeneratedMrt()!=null)
						_mrtObjectMap.put(inspector.getExtraGeneratedMrtPersistanceLocation(), inspector.getExtraGeneratedMrt());
					_contributedInspectors.add(inspector);
				}
			}
			_allInspectors.add(inspector);
		}
		return (ResourceTypeType[]) _generatedResourceTypes
				.toArray(new ResourceTypeType[_generatedResourceTypes.size()]);
	}

	private List getAllMrtInspectors()
	{
		List inspectors = new ArrayList();
		inspectors.add(new BasicMrtInspector(_mrt, _ddRoot));
		// We don't analyze MRT for SubscriptionManager
		// As it is already handled in MUSE-2.1
		//inspectors.add(new SubscriptionManagerInspector(_ddRoot));
		inspectors.add(new ServiceGroupInspector(_mrt, _ddRoot));
		inspectors.add(new RelationshipInspector(_ddRoot));
		return inspectors;
	}
	
	/**
	 * Returns the initial instances
	 * @return IntialInstancesType[]
	 */
	private InitialInstancesType[] getInitialInstances()
	{
		return (InitialInstancesType[]) _initialInstancesList
				.toArray(new InitialInstancesType[_initialInstancesList.size()]);
	}

	/**
	 * Returns the map.
	 * Key will be the persisted location of MRT and 
	 * value will be the ManageableREsourceType object. 
	 */
	public Map getMrtObjectMap() 
	{
		return _mrtObjectMap;
	}
	
	/**
	 * This method will persist the extra artifacts generated at codegen time.
	 */
	public void persistArtifacts()
	{
		for(int i=0;i<_contributedInspectors.size();i++)
		{
			MrtInspector inspector = (MrtInspector)_contributedInspectors.get(i);
			inspector.persistArtifacts();
		}		
	}
	
	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	public void inspectMetadata(ManageableResourceType mrt, MetadataDescriptor rmd)
	{
		for(Iterator iter = _allInspectors.iterator();iter.hasNext();)
		{
			MrtInspector inspector = (MrtInspector) iter.next();
			inspector.inspectMetadata(mrt, rmd);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.WsdlType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.tptp.wsdm.tooling.editor.dde.util.internal.DdeUtil;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MyDescriptorResourceFactoryImpl;

/**
 * This class acts as a way during the Code Generation of MRT to capture doing WSDL 
 * resolution so that it can be done later on, or on
 * another thread since this would be time-consuming.
 */
public class MRTCodeGenerationDelegate implements CodeGenerationDelegate
{
	private ManageableResourceType _mrt;
	private MrtPreProcessor _mrtPreProcessor;
	private String _ddFilePath;
	private IFile _mrtFile;
	private DocumentRoot _ddRoot;
	
	/**
	 * Constructor of the class
	 * @param mrtFile
	 */
	public MRTCodeGenerationDelegate(IFile mrtFile)
	{
		_mrtFile = mrtFile;
		URI mrtURI = URI.createPlatformResourceURI(mrtFile.getFullPath()
				.toString());
		_mrt = MrtUtils.loadMRT(mrtURI);
		_mrtPreProcessor = new MrtPreProcessor(_mrt);
	}

	/**
	 * Creates the DD file. 
	 * The method returns a DescriptorHelper which
	 * aggregates all of the work that was done.
	 * 
	 * @param progressMonitor 	A progress monitor to 
	 * 							show the progress done during this 
	 * 							task. 
	 * @throws Exception
	 */
	public DescriptorHelper run(SubProgressMonitor progressMonitor)
			throws Exception
	{
		byte[] serializedDD = createDD();
		Map mrtObjectMap = _mrtPreProcessor.getMrtObjectMap();
		return new DescriptorHelper(this, new ByteArrayInputStream(serializedDD), mrtObjectMap, false);
	}
	
	private byte[] createDD()
	{
		_mrtPreProcessor.preProcess();
		_ddRoot = _mrtPreProcessor.getDDDocumentRoot();
		ResourceSet resourceSet = new ResourceSetImpl();
		resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap()
		.put(Resource.Factory.Registry.DEFAULT_EXTENSION,
				new MyDescriptorResourceFactoryImpl());
		URI uri = URI.createURI("dummy.xml");
		Resource resource = resourceSet.createResource(uri);
		resource.getContents().add(_ddRoot);
		Map map = new HashMap();
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		try 
		{
			resource.save(baos, map);
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		}
		return baos.toByteArray();
	}
	
	private String createDDFilePath()
	{
		IPath ddIPath = _mrtFile.getFullPath().removeFileExtension()
				.addFileExtension("dd");
		return ddIPath.toString();
	}

	/**
	 * Create and return a new instance of given ResourceTypeType. Only
	 * ContextPath, JavaIdFactoryClass, JavaResourceClass and WsdlType fields
	 * have been copied.
	 */
	public static ResourceTypeType cloneResourceType(ResourceTypeType rt)
	{
		ResourceTypeType clone = DescriptorFactory.eINSTANCE
				.createResourceTypeType();
		clone.setContextPath(rt.getContextPath());
		clone.setJavaIdFactoryClass(rt.getJavaIdFactoryClass());
		clone.setJavaResourceClass(rt.getJavaResourceClass());
		WsdlType wClone = DescriptorFactory.eINSTANCE.createWsdlType();
		wClone.setWsdlFile(rt.getWsdl().getWsdlFile());
		wClone.setWsdlPortType(rt.getWsdl().getWsdlPortType());
		clone.setWsdl(wClone);
		return clone;
	}

	/**
	 * This method will persist the extra artifacts generated at codegen time.
	 */
	public void persistArtifacts() 
	{
		_mrtPreProcessor.persistArtifacts();
		persistDDFile();		
	}
	
	private void persistDDFile()
	{
		_ddFilePath = createDDFilePath();
		DdeUtil.serializeDescriptorRoot(_ddRoot, URI.createPlatformResourceURI(_ddFilePath));
	}

	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	public void inspectMetadata(ManageableResourceType mrt,
			MetadataDescriptor metadata) 
	{
		_mrtPreProcessor.inspectMetadata(mrt, metadata);		
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.wsdl.Operation;

import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.ws.muse.descriptor.CapabilityType;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.InitParamType;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.ReferenceParametersType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.WsdlType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceTypeFactory;
import org.eclipse.tptp.wsdm.tooling.util.internal.CustomMrtResourceFactoryImpl;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdlUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmConstants;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;

/**
 * This class analyzes the given manageable resource type and provide an extra
 * resource type for muse descriptor (SubscriptionManager), if manageable
 * resource type contains the NotificationProducer capability.
 */
public class SubscriptionManagerInspector implements MrtInspector
{

	private String _mrtParentDirName;

	private DocumentRoot _root;

	private ResourceTypeType _subManagerResourceType;
	
	private ManageableResourceType _subManagerMRT;
	/**
	 * Constructor of the class
	 * @param root
	 */
	public SubscriptionManagerInspector(DocumentRoot root)
	{
		_root = root;
	}

	/**
	 * Analyzes the given manageable resource type for NotificationProducer
	 * capability, and if the capability available then returns the muse
	 * resource type for SubscriptionManager else returns the null.
	 */
	public ResourceTypeType inspect(Capability[] mrtCapabilities)
	{
		for (int i = 0; i < mrtCapabilities.length; i++)
		{
			if (isNotificationProducerCapability(mrtCapabilities[i]))
				return createSubscriptionManagerResourceType();
		}
		return null;
	}

	private ResourceTypeType createSubscriptionManagerResourceType()
	{
		createSubManagerMrt();
		_subManagerResourceType = createSubManagerMuseResourceType();
		return _subManagerResourceType;
	}

	private void createSubManagerMrt()
	{
		org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.DocumentRoot documentRoot = ManageableResourceTypeFactory.eINSTANCE.createDocumentRoot();
		_subManagerMRT = ManageableResourceTypeFactory.eINSTANCE
				.createManageableResourceType();
		documentRoot.setManageableResource(_subManagerMRT);
		_subManagerMRT.setIdentifier("SubscriptionManager");
		_subManagerMRT
				.setNamespace("http://docs.oasis-open.org/wsn/b-2/SubscriptionManager");
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.IDENTITY_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.MANAGEABLITY_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.MEX_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.GET_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.SET_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.QUERY_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.IMMIDIATE_RESOURCE_TERMINATION_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.SCHEDULED_RESOURCE_TERMINATION_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.SUBSCRIPTION_MANAGER_CAPABILITY_LOCATION);		
	}

	private ResourceTypeType createSubManagerMuseResourceType()
	{
		ResourceTypeType resourceType = DescriptorFactory.eINSTANCE
				.createResourceTypeType();
		resourceType.setContextPath("/SubscriptionManager");
		resourceType
				.setJavaIdFactoryClass(WsdmConstants.MUSE_RESOURCE_ID_FACTORY_CLASS);
		resourceType
				.setJavaResourceClass(WsdmConstants.MUSE_RESOURCE_CLASS);

		WsdlType wsdlType = DescriptorFactory.eINSTANCE.createWsdlType();
		wsdlType.setWsdlFile(_mrtParentDirName + "/"
				+ "SubscriptionManager.wsdl");
		_root.getXMLNSPrefixMap().put("wsn",
				"http://docs.oasis-open.org/wsn/b-2/SubscriptionManager");
		wsdlType.setWsdlPortType("wsn:PortType");
		resourceType.setWsdl(wsdlType);

		CapabilityType identity = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		identity
				.setCapabilityUri("http://docs.oasis-open.org/wsdm/muws/capabilities/Identity");
		identity.setJavaCapabilityClass("");

		CapabilityType manageabilityCharacteristics = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		manageabilityCharacteristics
				.setCapabilityUri("http://docs.oasis-open.org/wsdm/muws/capabilities/ManageabilityCharacteristics");
		manageabilityCharacteristics.setJavaCapabilityClass("");

		CapabilityType metadataExchange = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		metadataExchange
				.setCapabilityUri("http://schemas.xmlsoap.org/ws/2004/09/mex");
		metadataExchange.setJavaCapabilityClass("");

		CapabilityType getCapability = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		getCapability
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Get");
		getCapability.setJavaCapabilityClass("");

		CapabilityType setCapability = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		setCapability
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Set");
		setCapability.setJavaCapabilityClass("");

		CapabilityType queryCapability = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		queryCapability
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Query");
		queryCapability.setJavaCapabilityClass("");

		CapabilityType immediateDestruction = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		immediateDestruction
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rlw-2/ImmediateResourceTermination");
		immediateDestruction
				.setJavaCapabilityClass("org.apache.muse.ws.resource.lifetime.impl.SimpleImmediateTermination");

		CapabilityType scheduledDestruction = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		scheduledDestruction
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rlw-2/ScheduledResourceTermination");
		scheduledDestruction
				.setJavaCapabilityClass("org.apache.muse.ws.resource.lifetime.impl.SimpleScheduledTermination");

		CapabilityType subscriptionManager = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		subscriptionManager
				.setCapabilityUri("http://docs.oasis-open.org/wsn/bw-2/SubscriptionManager");
		subscriptionManager
				.setJavaCapabilityClass("org.apache.muse.ws.notification.impl.SimpleSubscriptionManager");

		InitParamType noValidateParam = DescriptorFactory.eINSTANCE
				.createInitParamType();
		noValidateParam.setParamName("validate-wsrp-schema");
		noValidateParam.setParamValue("false");

		resourceType.getCapability().add(identity);
		resourceType.getCapability().add(manageabilityCharacteristics);
		resourceType.getCapability().add(metadataExchange);
		resourceType.getCapability().add(getCapability);
		resourceType.getCapability().add(setCapability);
		resourceType.getCapability().add(queryCapability);
		resourceType.getCapability().add(immediateDestruction);
		resourceType.getCapability().add(scheduledDestruction);
		resourceType.getCapability().add(subscriptionManager);

		resourceType.getInitParam().add(noValidateParam);

		return resourceType;
	}

	private boolean isNotificationProducerCapability(Capability capability)
	{
		boolean isNpNS = capability.getNamespace().equals(
				"http://docs.oasis-open.org/wsn/bw-2");
		boolean isNpName = capability.getName().equals("NotificationProducer");
		Operation[] operations = capability.getWsdlDefinition().getOperations();
		if (operations == null || operations.length < 2)
			return false;
		boolean isSubscribeOp = WsdlUtils.getOperationName(operations[0])
				.equals("Subscribe");
		boolean isGetCurrentMessageOp = WsdlUtils.getOperationName(
				operations[1]).equals("GetCurrentMessage");
		return isNpNS && isNpName && isSubscribeOp && isGetCurrentMessageOp;
	}

	/**
	 * Sets the parent directory 
	 * @param mrtParentDir
	 */
	public void setMrtParentDirectory(String mrtParentDir)
	{
		_mrtParentDirName = mrtParentDir;
	}
	/**
	 * Returns the initial instances
	 * @return InitialInstancesType[]
	 */
	public InitialInstancesType[] getInitialInstances()
	{
		InitialInstancesType instance = DescriptorFactory.eINSTANCE
				.createInitialInstancesType();
		ResourceTypeType rtClone = MRTCodeGenerationDelegate
				.cloneResourceType(_subManagerResourceType);
		instance.setResourceType(rtClone);
		ReferenceParametersType refParam = DescriptorFactory.eINSTANCE
				.createReferenceParametersType();
		instance.setReferenceParameters(refParam);
		return new InitialInstancesType[] { instance };
	}

	/**
	 * This method will persist the extra artifacts generated at codegen time (SubscriptionManager.mrt file).
	 */
	public void persistArtifacts()
	{
		ResourceSet rs = new ResourceSetImpl();
		rs.getResourceFactoryRegistry().getExtensionToFactoryMap()
			.put(Resource.Factory.Registry.DEFAULT_EXTENSION, new CustomMrtResourceFactoryImpl());
		byte[] rawNewMRT = MrtUtils.serializeMRT(_subManagerMRT, rs, URI
				.createURI("dummy.xml"), true);
		InputStream stream = new ByteArrayInputStream(rawNewMRT);

		try
		{
			String subManagerMrt = _mrtParentDirName + "/"
					+ "SubscriptionManager.mrt";
			IFile subManagerMrtFile = EclipseUtils.getIFile(subManagerMrt);
			if (subManagerMrtFile.exists())
			{
				subManagerMrtFile.setContents(stream, true, true,
						new NullProgressMonitor());
			}
			else
			{
				subManagerMrtFile.create(stream, true,
						new NullProgressMonitor());
			}
			try
			{
				stream.close();
			}
			catch (IOException e)
			{
				WsdmToolingLog.logError(e.getMessage(), e);
			}
		}
		catch (CoreException e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}
	}

	/**
	 * This method will returns the extra generated ManageableResourceType object equivalent to SubscriptionManager.
	 */
	public ManageableResourceType getExtraGeneratedMrt() 
	{
		return _subManagerMRT;
	}

	/**
	 * This method should return the persistance location for extra generated ManageableResourceType object equivalent to SubscriptionManager.
	 */
	public String getExtraGeneratedMrtPersistanceLocation() 
	{
		return _mrtParentDirName+"/SubscriptionManager.mrt";
	}

	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	public void inspectMetadata(ManageableResourceType mrt,
			MetadataDescriptor rmd)
	{
	}

	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import javax.xml.namespace.QName;

import org.apache.muse.core.descriptor.DescriptorConstants;
import org.apache.muse.util.xml.XmlUtils;
import org.apache.muse.ws.addressing.WsaConstants;
import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.util.URI;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

/**
 * A class that takes some of the pain out of working with the deployment
 * descriptor. Note, there's no EMF in this approach, just plain old XML.
 */
public class DescriptorHelper
{

	/**
	 * File Extension of MRT files
	 */
	private static final String MRT_EXTN = ".mrt";

	/**
	 * Element name constants
	 */
	public static final QName ADDITIONAL_JARS_QNAME = new QName(
			DescriptorConstants.NAMESPACE_URI, "additional-jars");
	public static final QName JAR_PATH_QNAME = new QName(
			DescriptorConstants.NAMESPACE_URI, "jar-path");
	public static final QName INITIAL_INSTANCES_QNAME = new QName(
			DescriptorConstants.NAMESPACE_URI, "initial-instances");
	public static final QName REFERENCE_PARAMETERS_QNAME = new QName(
			DescriptorConstants.NAMESPACE_URI, "referenceParameters");

	/**
	 * Constant for empty files
	 */
	private static final File[] EMPTY_FILES = new File[0];

	/**
	 * Constant for empty instances.
	 */
	private static final Object[][] EMPTY_INSTANCES = new Object[0][0];

	/**
	 * Constant for the xmlns prefix on namespace binding declarations
	 */
	private static final Object XMLNS_PREFIX = "xmlns";

	/**
	 * The descriptor document we pull out of the <code>Root</code> element
	 */
	private Document _descriptorDocument;

	/**
	 * A list of jar files that we pull out of the
	 * <code>Root/additional-jars</code> element
	 */
	private File[] _jarFiles;

	/**
	 * A list of instances which is really just a n by 2 list of arrays. The
	 * sub-arrays have the instance-path (<code>String</code>) as the first
	 * element and the reference parameters (<code>Element</code>) as the
	 * second element. This is tacky, but otherwise I'd be making a pretty
	 * useless "Pair" class.
	 */
	private Object[][] _instances;
	
	private IFile ddIFile;
	
	/**
	 * Descriptor file stores the MRT file reference in Wsdl-File element.
	 * When we do the codegeneration we generate some extra MRTs such as SubscriptionManager,
	 * so we pass the map of these MRTs to this class.
	 * Key will be the persisted location of MRT and value will be the ManageableREsourceType object.
	 */
	private Map _mrtObjectMap = new HashMap();
	
	private CodeGenerationDelegate _codeGenerationDelegate = null;

	/**
	 * A do-something constructor. Take a file, if that file is null, then load
	 * up a default template. Otherwise load up the file and pull out the
	 * instances, descriptor and additional jars. For the null file case, there
	 * will be no instances of additional-jars, hence the constants defined
	 * above.
	 * 
	 * @param file - The file to analyze, can be null.
	 * @throws Exception - If anything goes wrong.
	 */
	public DescriptorHelper(CodeGenerationDelegate codeGenerationDelegate, IFile descriptorFile) throws Exception
	{
		this(codeGenerationDelegate, new File(descriptorFile.getLocation().toString()));
		ddIFile = descriptorFile;		
	}

	/**
	 * A do-something constructor. Take a file, if that file is null, then load
	 * up a default template. Otherwise load up the file and pull out the
	 * instances, descriptor and additional jars. For the null file case, there
	 * will be no instances of additional-jars, hence the constants defined
	 * above.
	 * 
	 * @param file - The file to analyze, can be null.
	 * @throws Exception - If anything goes wrong.
	 */
	public DescriptorHelper(CodeGenerationDelegate codeGenerationDelegate, File file) throws Exception
	{
		this(codeGenerationDelegate, new FileInputStream(file), null);
	}
	
	/**
	 * A do-something constructor. Take a inputstream, if that inputstream is null, then load
	 * up a default template. Otherwise load up the inputstream and pull out the
	 * instances, descriptor and additional jars. For the null inputstream case, there
	 * will be no instances of additional-jars, hence the constants defined
	 * above.
	 * 
	 * @param inputstream - The inputstream to analyze, can be null.
	 * @param mrtObjectMap - The map of MRTLocation-MRTObject pair, can be null.
	 * @throws Exception - If anything goes wrong.
	 */
	public DescriptorHelper(CodeGenerationDelegate codeGenerationDelegate, InputStream inputStream, Map mrtObjectMap, boolean extractExtraInfo) throws Exception
	{
		if(mrtObjectMap!=null)
			_mrtObjectMap = mrtObjectMap;
		_codeGenerationDelegate = codeGenerationDelegate;
		
		Document rootDocument = XmlUtils.createDocument(inputStream);

		_descriptorDocument = extractDescriptorDocument(rootDocument);
		
		if(extractExtraInfo) {
			_instances = extractInstances(rootDocument);
			_jarFiles = extractJarFiles(rootDocument);
		} else {
			_instances = null;
			_jarFiles = null;
		}
		// Add Muse tools.jar
		if(_jarFiles == null)
			_jarFiles = new File[0];
		String toolsJarLocation = getMuseToolsJarLocation();
		if(toolsJarLocation == null)
			return;
		List jars = Arrays.asList(_jarFiles);
		List allJars = new ArrayList();
		allJars.addAll(jars);		
		allJars.add(new File(toolsJarLocation));
		_jarFiles = (File[])allJars.toArray(new File[allJars.size()]);		
	}
	
	public DescriptorHelper(CodeGenerationDelegate codeGenerationDelegate, InputStream inputStream, Map mrtObjectMap) throws Exception {
		this(codeGenerationDelegate, inputStream, mrtObjectMap, true);
	}

	/**
	 * Extract the instances from the initial-instances element.
	 * 
	 * TODO this needs to be updated when the initial instances element actually
	 * works.
	 * 
	 * @param rootDocument
	 * @return
	 */
	private Object[][] extractInstances(Document rootDocument)
	{
		Element[] initialInstancesElements = XmlUtils.findInSubTree(
				rootDocument.getDocumentElement(), INITIAL_INSTANCES_QNAME);
		if (initialInstancesElements.length == 0)
		{
			return EMPTY_INSTANCES;
		}

		// sorry about this, maybe someday java will have a Pair type
		Object[][] instances = new Object[initialInstancesElements.length][2];

		for (int i = 0; i < initialInstancesElements.length; i++)
		{
			Element contextElement = XmlUtils.findFirstInSubTree(
					initialInstancesElements[i],
					DescriptorConstants.CONTEXT_PATH_QNAME);
			instances[i][0] = XmlUtils.extractText(contextElement);
			Element instancesElement = XmlUtils.findFirstInSubTree(
					initialInstancesElements[i], REFERENCE_PARAMETERS_QNAME);
			
			Element referenceParametersElement = XmlUtils.createElement(WsaConstants.PARAMETERS_QNAME);
			
			Element[] referenceParameters = XmlUtils.getAllElements(instancesElement);
			Document owner = referenceParametersElement.getOwnerDocument();
			for(int j=0; j < referenceParameters.length; j++) {
				referenceParametersElement.appendChild(owner.importNode(referenceParameters[j], true));
			}
			instances[i][1] = referenceParametersElement;	
		}

		return instances;
	}

	/**
	 * Extract the jars from the additional jars element. Just read through each
	 * element, take the text content (which should be an absolute path) and put
	 * it into a <code>File</code> object. Returns a list of these
	 * <code>File</code>s.
	 * 
	 * @param rootDocument
	 *            The <code>Root</code> element-containing
	 *            <code>Document</code>
	 * 
	 * @return A list of <code>File</code>s for each path found under
	 *         additional-jars
	 */
	private File[] extractJarFiles(Document rootDocument)
	{
		Element additionalJarsElement = XmlUtils.findFirstInSubTree(
				rootDocument.getDocumentElement(), ADDITIONAL_JARS_QNAME);
		if (additionalJarsElement == null)
		{
			return EMPTY_FILES;
		}

		Element[] jarPaths = XmlUtils.findInSubTree(additionalJarsElement,
				JAR_PATH_QNAME);
		if (jarPaths.length == 0)
		{
			return EMPTY_FILES;
		}

		File[] files = new File[jarPaths.length];

		for (int i = 0; i < jarPaths.length; i++)
		{
			files[i] = new File(XmlUtils.extractText(jarPaths[i]));
		}		
		return files;
	}
	
	private String getMuseToolsJarLocation()
	{
		URL url = FileLocator.find(org.apache.muse.tools.Activator.getDefault().getBundle(), new Path("runtime/tools.jar"), null);
		try 
		{
			url = FileLocator.resolve(url);			
			return url.getFile();
		}
		catch (IOException ioe)
		{
			WsdmToolingLog.logError(ioe.getMessage(), ioe);
		}
		return null;
	}

	/**
	 * Get the Muse descriptor out of the document. Just looks for the
	 * <code>DescriptorConstants.MUSE_QNAME</code> QName.
	 * 
	 * @param rootDocument
	 *            The <code>Root</code> element-containing
	 *            <code>Document</code>
	 * @return The new <code>Document</code> that has as its document element
	 *         the muse descriptor
	 */
	private Document extractDescriptorDocument(Document rootDocument)
	{
		Element museElement = XmlUtils.findFirstInSubTree(rootDocument
				.getDocumentElement(), DescriptorConstants.MUSE_QNAME);
		Document descriptorDocument = XmlUtils.createDocument();
		descriptorDocument.appendChild(descriptorDocument.importNode(
				museElement, true));

		copyNamespacePrefixes(rootDocument.getDocumentElement(),
				descriptorDocument.getDocumentElement());
		
		museElement = XmlUtils.getElement(descriptorDocument,DescriptorConstants.MUSE_QNAME);
		adjustCustomSerializers(museElement);

		return descriptorDocument;
	}

	/**
	 * Given a source <code>Element</code> and a destination
	 * <code>Element</code> copy all of the namespace prefixese from the
	 * source to the destination. This is really horrid because of DOM's API
	 * being what it is and we treat the declarations as attributes. Yes, we do
	 * check to make sure we don't do double prefix declarations.
	 * 
	 * TODO this should go into a namespace utility class, I've had to write
	 * this in about 3 places now.
	 * 
	 * @param source
	 *            The source <code>Element</code>
	 * @param destination
	 *            The destination <code>Element</code>
	 */
	private void copyNamespacePrefixes(Element source, Element destination)
	{
		NamedNodeMap attributes = source.getAttributes();
		int size = attributes.getLength();
		for (int i = 0; i < size; i++)
		{
			Node nextAttribute = attributes.item(i);
			String prefix = nextAttribute.getPrefix();

			if (prefix == null || !prefix.equals(XMLNS_PREFIX))
			{
				continue;
			}

			if (destination.hasAttribute(nextAttribute.getNodeName()))
			{
				continue;
			}

			destination.setAttribute(nextAttribute.getNodeName(), nextAttribute
					.getNodeValue());
		}
	}
	
	/**
	 * Descriptor editor stores the xsd-serializer-type for custom-serializer as
	 * 
	 * <custom-serializer>
	 * 		<xsd-serializer-type>{http://www.eclipse.org/TP}StateType</xsd-serializer-type>
	 * <custom-serializer>
	 * 
	 * We have to convert the QName to prefix:localpart format so we adjust this part as
	 * 
	 * <custom-serializer>
	 * 		<xsd-serializer-type xmlns:pfx="http://www.eclipse.org/TP">pfx:StateType</xsd-serializer-type>
	 * <custom-serializer>
	 *   
	 */
	private void adjustCustomSerializers(Element museElement)
	{
		Element[] serializerElements = XmlUtils.getElements(museElement, DescriptorConstants.CUSTOM_SERIALIZER_QNAME);
		for(int i=0;i<serializerElements.length;i++)
		{
			// TODO Replace the QName with MUSE constant in MUSE 2.2
			Element xsdSerializerElement = XmlUtils.getElement(serializerElements[i], new QName(DescriptorConstants.NAMESPACE_URI,"xsd-serializable-type"));
			String qNameAsString = XmlUtils.extractText(xsdSerializerElement);
			if(qNameAsString!=null && !qNameAsString.equals(""))
			{
				try
				{
					QName qname = QName.valueOf(qNameAsString);
					String namespace = qname.getNamespaceURI();
					String localPart = qname.getLocalPart();
					if(namespace.equals(""))
						break;
					xsdSerializerElement.setAttribute("pfx", namespace);
					XmlUtils.setElementText(xsdSerializerElement, "pfx:"+localPart);									
				}
				catch(IllegalArgumentException e)
				{
					WsdmToolingLog.logError(e.getMessage(), e);
				}				
			}			
		}
	}
	
	/**
	 * Returns the Descriptor document
	 * @return Document
	 */
	public Document getDescriptorDocument()
	{
		return _descriptorDocument;
	}
	/**
	 * Returns the Jar files
	 * @return File[]
	 */
	public File[] getJarFiles()
	{
		return _jarFiles;
	}

	/**
	 * Returns the instances
	 * @return Object[][]
	 */
	public Object[][] getInstances()
	{
		return _instances;
	}

	/**
	 * Go through the parsed Muse descriptor associated with this object and
	 * find all of the MRT files referenced therein. For each MRT file use
	 * <code>WsdlMerge</code> to merge the MRT's WSDL into a consolidate WSDL.
	 * Return the Muse Descriptor document-order list of the WSDL files.
	 * The passed map will contain the MRT file location as key and MRT object as value.
	 * So first search the map for MRT if not found then load the MRT from location.
	 * 
	 * @return A list of merged WSDL files as gathered from the deployment
	 *         descriptor
	 * 
	 * @see org.eclipse.tptp.wsdm.tooling.wizard.mrt.internal.WsdlResolverDelegate#getWsdlDocuments()
	 */
	public Document[] getWsdlDocuments(String baseAddress)
	{
		Element[] resourceTypes = XmlUtils.findInSubTree(_descriptorDocument
				.getDocumentElement(), DescriptorConstants.RESOURCE_TYPE_QNAME);
		int mrtCount = resourceTypes.length;
		Document[] mergedWSDLs = new Document[mrtCount];

		for (int i = 0; i < mrtCount; i++)
		{
			Element wsdlFileElement = XmlUtils.findFirstInSubTree(
					resourceTypes[i], DescriptorConstants.WSDL_FILE_QNAME);

			String wsdlPath = XmlUtils.extractText(wsdlFileElement);
			String mrtPath = getMRTPathFromWSDLPath(wsdlPath);
			ManageableResourceType mrt = null;
			String serviceAddress = null;
			if(_mrtObjectMap!=null && _mrtObjectMap.containsKey(mrtPath))
			{
				mrt = (ManageableResourceType) _mrtObjectMap.get(mrtPath);
				serviceAddress = baseAddress+"/"+mrt.getIdentifier();
			}
			else
			{
				IWorkspace workspace = ResourcesPlugin.getWorkspace();
				IWorkspaceRoot root = workspace.getRoot();
				IPath mrtFilePath = root.findMember(mrtPath).getFullPath();
				URI uri = URI.createFileURI(mrtFilePath.toString());
				mrt = MrtUtils.loadMRT(uri);
				serviceAddress = makeServiceAddress(baseAddress, mrtFilePath);
			}
			if(mrt!=null)
			{
				try
				{
					mergedWSDLs[i] = MrtMerge.createMergedWSDL(mrt, serviceAddress);
				}
				catch (Exception e)
				{
					e.printStackTrace();
					// TODO AME add externalized message
					throw new RuntimeException(e);
				}
			}
			else
			{
				// TODO AME add externalized message
				throw new RuntimeException();
			}
		}
		return mergedWSDLs;
	}

	/**
	 * Given a base address add the service name. This is done by getting the
	 * name of the MRT file and stripping off the file extension.
	 * 
	 * @param baseAddress
	 *            Base address
	 * @param file
	 *            MRT file to use
	 * @return the combined address
	 */
	private String makeServiceAddress(String baseAddress, IPath file)
	{
		String fileName = file.toFile().getName();
		fileName = fileName.substring(0, fileName.lastIndexOf("."));
		return baseAddress + "/" + fileName;
	}

	private String getMRTPathFromWSDLPath(String fileName)
	{
		return fileName.substring(0, fileName.lastIndexOf(".")) + MRT_EXTN;
	}
	
	/**
	 * Adds the additional jar files to Descriptor file.
	 *  
	 * @param serverLocation
	 * 			Parent directory of Axis2-lib folder.
	 * 
	 * @param axis2files
	 * 			Axis2 jar files path.
	 */
	public void addAdditionalJars(String serverLocation, String[] axis2files)
	{
		List additionalJarFiles = new LinkedList();
		if(_jarFiles!=null)
			additionalJarFiles.addAll(Arrays.asList(_jarFiles));
		for(int i = 0 ; i < axis2files.length ; i++ )
			additionalJarFiles.add(new File(serverLocation + File.separator + axis2files[i]));
		_jarFiles = (File[]) additionalJarFiles.toArray(new File[additionalJarFiles.size()]);
	}

	/**
	 * Go through the parsed Muse descriptor associated with this object and
	 * find all of the MRT files referenced therein. For each MRT file create
	 * a merged RMD document.
	 * 
	 * @return A list of merged RMD documents as gathered from the deployment
	 *         descriptor
	 * 
	 */
	public MetadataDescriptor[] getMergedRMDs() 
	{
		Element[] resourceTypes = XmlUtils.findInSubTree(_descriptorDocument
				.getDocumentElement(), DescriptorConstants.RESOURCE_TYPE_QNAME);
		int mrtCount = resourceTypes.length;
		MetadataDescriptor[] mergedRMDs = new MetadataDescriptor[mrtCount];

		for (int i = 0; i < mrtCount; i++)
		{
			Element wsdlFileElement = XmlUtils.findFirstInSubTree(
					resourceTypes[i], DescriptorConstants.WSDL_FILE_QNAME);

			String wsdlPath = XmlUtils.extractText(wsdlFileElement);
			String mrtPath = getMRTPathFromWSDLPath(wsdlPath);
			ManageableResourceType mrt = null;
			String serviceAddress = null;
			if(_mrtObjectMap!=null && _mrtObjectMap.containsKey(mrtPath))
			{
				mrt = (ManageableResourceType) _mrtObjectMap.get(mrtPath);				
			}
			else
			{
				IWorkspace workspace = ResourcesPlugin.getWorkspace();
				IWorkspaceRoot root = workspace.getRoot();
				IPath mrtFilePath = root.findMember(mrtPath).getFullPath();
				URI uri = URI.createFileURI(mrtFilePath.toString());
				mrt = MrtUtils.loadMRT(uri);				
			}
			if(mrt!=null)
			{
				try
				{
					mergedRMDs[i] = MrtMerge.createMergedRMD(mrt);
					_codeGenerationDelegate.inspectMetadata(mrt, mergedRMDs[i]);
				}
				catch (Exception e)
				{
					throw new RuntimeException(e);
				}
			}
			else
			{
				throw new RuntimeException();
			}
		}		
		return mergedRMDs;		
	} 	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.util.ArrayList;

public class TargetedFileList {
	private String _relativePath;	// path relative to webcontent folder
	private ArrayList _absoluteFilePaths;
	
	public TargetedFileList(String relativePath){
		_relativePath = relativePath;
		_absoluteFilePaths = new ArrayList();
	}
	
	public void add(String absolutePath){
		if(absolutePath!=null && !absolutePath.trim().equals("")){
			_absoluteFilePaths.add(absolutePath);
		}
	}
	
	public String[] getFiles(){
		if(_absoluteFilePaths==null) return new String[]{};
		return (String[]) _absoluteFilePaths.toArray(new String[]{});
	}
	
	public String getRelativePath(){
		return _relativePath;
	}
	
	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.prefs.Preferences;

import org.apache.muse.tools.generator.analyzer.Analyzer;
import org.apache.muse.tools.generator.projectizer.Projectizer;
import org.apache.muse.tools.generator.synthesizer.Synthesizer;
import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.dialogs.DialogPage;
import org.eclipse.jface.util.Util;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.osgi.util.TextProcessor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.DirectoryDialog;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Text;
import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;
import org.eclipse.tptp.wsdm.tooling.editor.mrt.relationship.dialog.internal.MemoryComboBox;
import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.util.internal.Validation;

/**
 * This wizard enables the use to specify the projectizer options and also the
 * runtime environment and general options
 */
public class GenerationOptionsPage extends WizardPage
{
	private static final String PROJECT_MEMORY_COMBO_ID = "project_memory_combo";
	
	private static final String EXT_PT = "codeGeneration";
	
	private Button _overwriteButton;

	private Combo _projectNameField;

	private String _userPath = Util.ZERO_LENGTH_STRING;// IDEResourceInfoUtils.EMPTY_STRING;

	private Button _useDefaultsButton;

	private Label _locationLabel;

	private Text _locationPathField;

	private Button _browseButton;

	private IProject _existingProject;
	
	private Combo _projectizerCombo;

	private Button _persistExtraArtifactsButton;
			
	private Map _platformContainerMap = new HashMap();

	private Combo _containerCombo;

	private Label _containerLabel;

	public GenerationOptionsPage() {
		super("wizardPage");
		setTitle(Messages.HOOKUP_WIZARD_TXT1);
		setDescription(Messages.HOOKUP_WIZARD_TXT2);
		
		loadExtensionData();
	}
	
	private void loadExtensionData() {
		IExtensionRegistry er = Platform.getExtensionRegistry();
		IExtensionPoint ep = er.getExtensionPoint(Activator.PLUGIN_ID, EXT_PT);
		IExtension[] extensions = ep.getExtensions();

		for (int i = 0; i < extensions.length; i++) {	
			IConfigurationElement[] elements = extensions[i].getConfigurationElements();			
			CodeGenerationData codeGenData = new CodeGenerationData(elements);				
			updatePlatformContainerMap(codeGenData);	
		}
	}

	private void updatePlatformContainerMap(CodeGenerationData codeGenData) {
		Map containerCodeGenDataMap = (Map) _platformContainerMap.get(codeGenData.getPlatform());
		if(containerCodeGenDataMap == null) {					
			//
			// handles the case of proxy which doesn't have a container
			//
			if(codeGenData.getContainer() == null) {			
				containerCodeGenDataMap = new SingleValueMap();
			} else {
				containerCodeGenDataMap = new HashMap();
			}
			
			_platformContainerMap.put(codeGenData.getPlatform(), containerCodeGenDataMap);
		}

		//
		// if the platform was null then it means we're using a
		// singlevaluemap which doesn't look at the key ever
		//
		containerCodeGenDataMap.put(codeGenData.getContainer(), codeGenData);
	}

	public void createControl(Composite parent) {
		setControl(doLayout(parent));
		dialogChanged();
	}

	private Composite doLayout(Composite parent) {
		Composite container = new Composite(parent, SWT.NULL);
		container.setLayout(new GridLayout(2, false));	
		
		GridData data = new GridData();
		data.horizontalAlignment = SWT.FILL;
		data.grabExcessHorizontalSpace = true;
		container.setLayoutData(data);
								
		createProjectInput(container);
		
		Composite composite = createProjectTypeGroup(container);
		
		data = new GridData();
		data.grabExcessHorizontalSpace = true;
		data.horizontalAlignment = SWT.FILL;
		data.horizontalSpan = 2;
		composite.setLayoutData(data);
				
		composite = createProjectOptionsGroup(container);
		
		data = new GridData();
		data.grabExcessHorizontalSpace = true;
		data.horizontalAlignment = SWT.FILL;
		data.horizontalSpan = 2;
		composite.setLayoutData(data);
		return container;
	}

	private void createProjectInput(Composite parent) {
		Label projectNameLabel = new Label(parent, SWT.NONE);
		projectNameLabel.setText(Messages.HOOKUP_WIZARD_TXT4);

		GridData data = new GridData();		
		data.horizontalAlignment = SWT.FILL;
		data.grabExcessHorizontalSpace = false;	
		projectNameLabel.setLayoutData(data);
		
		_projectNameField = MemoryComboBox.createMemoryComboBox(parent, Preferences.userNodeForPackage(GenerationOptionsPage.class), PROJECT_MEMORY_COMBO_ID);				
		
		data = new GridData();		
		data.horizontalAlignment = SWT.FILL;
		data.grabExcessHorizontalSpace = true;
		_projectNameField.setLayoutData(data);	
		
		_projectNameField.addListener(SWT.Modify, nameModifyListener);
	}
	
	private Group createProjectTypeGroup(Composite parent) {
		Group page = new Group(parent, SWT.SHADOW_IN);
		page.setText("Code Generation Options");
		page.setLayout(new GridLayout(2, false));

		Label platformLabel = new Label(page, SWT.NONE);
		platformLabel.setText("Platform:");//TODO AME
		_projectizerCombo = makePlatformCombo(page);
		
		_containerLabel = new Label(page, SWT.NONE);
		_containerLabel.setText("Container:");//TODO AME
		_containerLabel.setEnabled(false);
		
		_containerCombo = makeContainerCombo(page);		
		
		return page;
	}

	private Group createProjectOptionsGroup(Composite parent) {
		Group  group = new Group(parent, SWT.SHADOW_IN);
		group.setText("Project Options");
		group.setLayout(new GridLayout(3, false));
		
		_useDefaultsButton = createDefaultsButton(group);
		
		GridData buttonData = new GridData();
		buttonData.horizontalSpan = 3;
		_useDefaultsButton.setLayoutData(buttonData);

		createUserEntryArea(group, true);				
		createCheckboxes(group);	
	
		return group;		
	}

	private Button createDefaultsButton(Composite parent) {
		Button button = new Button(parent, SWT.CHECK | SWT.RIGHT);
		button.setText(Messages.CODE_GEN_DEFAULT_LOCATION);// IDEWorkbenchMessages.ProjectLocationSelectionDialog_useDefaultLabel);
		button.setSelection(true);
		
		button.addSelectionListener(new SelectionAdapter()
		{
			public void widgetSelected(SelectionEvent e)
			{
				boolean useDefaults = _useDefaultsButton.getSelection();

				if (!useDefaults)
				{
					_userPath = _locationPathField.getText();
					_locationPathField.setText(TextProcessor
							.process(getDefaultPathDisplayString()));
				}
				else
				{
					_locationPathField
							.setText(TextProcessor.process(_userPath));
				}
				setUserAreaEnabled(!useDefaults);
			}
		});
		
		return button;
	}

	private void createCheckboxes(Composite parent) {
		GridData data = null;
	
		_overwriteButton = makeButton(parent, Messages.HOOKUP_WIZARD_TXT3, SWT.CHECK);		
		
		data = new GridData();
		data.horizontalSpan = 2;
		_overwriteButton.setLayoutData(data);
		
		_persistExtraArtifactsButton = makeButton(parent, Messages.HOOKUP_WIZARD_PERSIST, SWT.CHECK);
		
		data = new GridData();
		data.horizontalSpan = 2;
		_persistExtraArtifactsButton.setLayoutData(data);
	}

	private Combo makeContainerCombo(Group page) {
		Combo combo = new Combo(page, SWT.BORDER | SWT.READ_ONLY);
		combo.setEnabled(false);	
		
		return combo;
	}

	private Combo makePlatformCombo(Group page)
	{
		Combo combo = new Combo(page, SWT.BORDER | SWT.READ_ONLY);
		for(Iterator i=_platformContainerMap.keySet().iterator(); i.hasNext();) {
			combo.add(i.next().toString());
		}
		combo.select(0);		
		combo.addListener(SWT.Modify, comboChangeListener);
		
		return combo;
	}

	private void setUserAreaEnabled(boolean enabled)
	{
		_locationLabel.setEnabled(enabled);
		_locationPathField.setEnabled(enabled);
		_browseButton.setEnabled(enabled);
	}

	private void createUserEntryArea(Composite composite, boolean defaultEnabled)
	{
		GridData data = null;
		
		// location label
		_locationLabel = new Label(composite, SWT.NONE);
		_locationLabel.setText(Messages.HOOKUP_WIZARD_TXT6);

		// project location entry field
		_locationPathField = new Text(composite, SWT.BORDER);
		data = new GridData(GridData.FILL_HORIZONTAL);
		_locationPathField.setLayoutData(data);

		// browse button
		_browseButton = new Button(composite, SWT.PUSH);
		_browseButton.setText(Messages.HOOKUP_WIZARD_TXT5);
		_browseButton.addSelectionListener(new SelectionAdapter()
		{
			public void widgetSelected(SelectionEvent event)
			{
				handleLocationBrowseButtonPressed();
			}
		});

		if (defaultEnabled)
		{
			_locationPathField.setText(TextProcessor
					.process(getDefaultPathDisplayString()));
		}
		else
		{
			if (_existingProject == null)
			{
				_locationPathField.setText(Util.ZERO_LENGTH_STRING);// IDEResourceInfoUtils.EMPTY_STRING);
			}
			else
			{
				_locationPathField.setText(TextProcessor
						.process(_existingProject.getLocation().toString()));
			}
		}

		_locationPathField.addModifyListener(new ModifyListener()
		{
			public void modifyText(ModifyEvent e)
			{
				setErrorMessage(checkValidLocation());
			}
		});
		
		setUserAreaEnabled(false);
	}

	public boolean isDefault()
	{
		return _useDefaultsButton.getSelection();
	}

	public String getProjectLocation()
	{
		if(isDefault()) {
			return null;
		}
		
		String projectLocation = _locationPathField.getText();		
		return projectLocation.length() == 0?null:projectLocation;
	}

	public String checkValidLocation()
	{

		if (isDefault())
		{
			return null;
		}

		String newPath = getProjectLocation();
		if (newPath == null)
		{
			return Messages.CODE_GEN_LOCATION_ERROR_;
		}

		if (_existingProject == null)
		{
			IPath projectPath = new Path(newPath);
			if (Platform.getLocation().isPrefixOf(projectPath))
			{
				return Messages.NEW_PROJECT_CREATION_PAGE_DEFAULT_LOCATION_ERROR_;
			}

		}
		else
		{
			
			IStatus locationStatus = _existingProject.getWorkspace()
					.validateProjectLocationURI(_existingProject, URIUtil.toURI(newPath));

			if (!locationStatus.isOK())
			{
				return locationStatus.getMessage();
			}

			java.net.URI projectPath = _existingProject.getLocationURI();
			if (projectPath != null && URIUtil.equals(projectPath, URIUtil.toURI(newPath)))
			{
				return Messages.CODE_GEN_LOCATION_ERROR_;
			}
		}

		return null;
	}

	private String getDefaultPathDisplayString()
	{

		java.net.URI defaultURI = null;
		if (_existingProject != null)
		{
			defaultURI = _existingProject.getLocationURI();
		}

		// Handle files specially. Assume a file if there is no project to query
		if (defaultURI == null || defaultURI.getScheme().equals("file"))
		{
			return Platform.getLocation().append(_projectNameField.getText())
					.toString();
		}
		return defaultURI.toString();

	}

	private String getPathFromLocationField()
	{
		java.net.URI fieldURI;
		try
		{
			fieldURI = new java.net.URI(_locationPathField.getText());
		}
		catch (java.net.URISyntaxException e)
		{
			return _locationPathField.getText();
		}
		return fieldURI.getPath();
	}

	private void updateLocationField(String selectedPath)
	{
		_locationPathField.setText(TextProcessor.process(selectedPath));
	}

	private void handleLocationBrowseButtonPressed()
	{

		String selectedDirectory = null;
		String dirName = getPathFromLocationField();

		DirectoryDialog dialog = new DirectoryDialog(_locationPathField
				.getShell());
		dialog.setMessage(Messages.CODE_GEN_DIR_LOCATION);// IDEWorkbenchMessages.ProjectLocationSelectionDialog_directoryLabel);
		dialog.setFilterPath(dirName);
		selectedDirectory = dialog.open();

		if (selectedDirectory != null)
			updateLocationField(selectedDirectory);
	}

	private Listener nameModifyListener = new Listener()
	{
		public void handleEvent(Event e)
		{
			setLocationForSelection();
			dialogChanged();
		}
	};

	private Listener comboChangeListener = new Listener() {
		public void handleEvent(Event e) {
			String platform = _projectizerCombo.getText();
			
			Map containerCodeGenDataMap = (Map) _platformContainerMap.get(platform);
			_containerCombo.removeAll();
			
			boolean hasContainers = containerCodeGenDataMap.size() != 0;
			
			if(hasContainers) {
				for(Iterator i=containerCodeGenDataMap.keySet().iterator(); i.hasNext();) {
					_containerCombo.add(i.next().toString());
				}
				_containerCombo.select(0);
			}
			
			_containerCombo.setEnabled(hasContainers);
			_containerLabel.setEnabled(hasContainers);

		   	dialogChanged();
		}
	};
	
	void setLocationForSelection()
	{
//		 _locationArea.updateProjectName(getProjectNameFieldValue());
	}

	protected void dialogChanged()
	{
		if(true) return;
		String prjName = getProjectName();

		if (prjName.length() == 0)
		{
			updateStatus(Messages.HOOKUP_WIZARD_ERROR_1);
			return;
		}

		IWorkspace workspace = ResourcesPlugin.getWorkspace();
		IWorkspaceRoot root = workspace.getRoot();

		IProject project = root.getProject(prjName);

		if (project != null && project.exists())
		{
			updateStatus(Messages.PROJECT_EXISTS_WARN_, DialogPage.WARNING);
			return;
		}

		if (!Validation.isQName(prjName))
		{
			updateStatus(Messages.HOOKUP_WIZARD_ERROR_2);
			return;
		}
		
		canFlipToNextPage();
		
		updateStatus(null, DialogPage.NONE);
	}

	private void updateStatus(String message)
	{
		updateStatus(message, DialogPage.ERROR);
	}

	private void updateStatus(String message, int type)
	{
		setMessage(message, type);
		setPageComplete(type != DialogPage.ERROR);
	}

	private Button makeButton(Composite parent, String title, int style)
	{
		Button b = new Button(parent, style);
		b.setText(title);
		return b;
	}

	public boolean shouldPersistArtifacts()
	{
		return _persistExtraArtifactsButton.isEnabled();
	}

	/**
	 * Return the value of the output project
	 * @return String
	 */
	public String getProjectName()
	{
		return _projectNameField.getText();
	}

	/**
	 * Returns if Overwrite button is enabled
	 * @return boolean
	 */
	public boolean canOverwrite()
	{
		return _overwriteButton.getSelection();
	}
	
	public CodeGenerationData getSelectedData() {
		String platform = _projectizerCombo.getText();
		Map containerCodeGenDataMap = (Map) _platformContainerMap.get(platform);
		String container = _containerCombo.getText();
		return (CodeGenerationData) containerCodeGenDataMap.get(container);
	}

	/**
	 * Return the projectizer
	 * @return {@link Projectizer}
	 */
	public Projectizer getProjectizer()
	{
		return getSelectedData().getProjectizer();
	}

	/**
	 * Return the synthesizer
	 * @return {@link Synthesizer}
	 */
	public Synthesizer getSynthesizer()
	{
		return getSelectedData().getSynthesizer();
	}

	/**
	 * Return the analyzer
	 * @return {@link Analyzer}
	 */
	public Analyzer getAnalyzer()
	{
		return getSelectedData().getAnalyzer();
	}

	/**
	 * Returns the base address
	 * 
	 * @return String
	 */
	public String getBaseAddress()
	{
		String baseAddress = "http://localhost";

		int port = getSelectedData().getServicePort();
		if (port != 0)
		{
			baseAddress += ":" + port;
		}

		baseAddress += "/" + getProjectName();

		String servicePath = getSelectedData().getServicePath();

		if (servicePath != null)
		{
			baseAddress += servicePath;
		}
		
		return baseAddress;
	}
	
	/**
	 * Checks to see if the Next Page can be enabled or not.
	 */
	public boolean canFlipToNextPage(){
		return true;
//		Axis2ServerLocationPage nextPage = (Axis2ServerLocationPage)this.getNextPage();
//		if(isPageComplete() && isAxis2Project())
//		{			
//			nextPage.makePageComplete(false);
//			String userLocation = nextPage.getUserDefinedLocation();
//			if(userLocation != null && userLocation.trim().length() > 0)
//			{
//				nextPage._serverNameField.setText(userLocation);
//			}else
//			{
//				nextPage._serverNameField.setText(nextPage.getPreferenceServerLocation());
//			}
//
//			return true;
//		}
//		
//		nextPage.makePageComplete(true);
//		
//		return false;
	}

	/**
	 * Returns whether the new Project to be created is a Axis2 project
	 * @return
	 */
	public boolean isAxis2Project(){
		String container = getSelectedData().getContainer();
		return container != null && container.equals("Axis2");
	}	
	
	public void saveCombo() {
		MemoryComboBox.save(_projectNameField, PROJECT_MEMORY_COMBO_ID, Preferences.userNodeForPackage(GenerationOptionsPage.class));
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;

import java.util.AbstractMap;
import java.util.HashSet;
import java.util.Set;

public class SingleValueMap extends AbstractMap {
	Object _value;
	Set _entrySet = new HashSet();
			
	public Object get(Object key) {
		return _value;
	}
	
	public Object put(Object key, Object value) {
		Object oldValue = _value;
		_value = value;		
		return oldValue;
	}
	
	public Set entrySet() {
		return _entrySet;
	}
}

Lines 24-30 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
24	Bundle-Vendor: %providerName	24	Bundle-Vendor: %providerName
25	Bundle-RequiredExecutionEnvironment: J2SE-1.4	25	Bundle-RequiredExecutionEnvironment: J2SE-1.4
26	Export-Package: org.eclipse.tptp.wsdm.tooling.codegen.dd.internal;x-friends:="org.eclipse.tptp.wsdm.editor.test",	26	Export-Package: org.eclipse.tptp.wsdm.tooling.codegen.dd.internal;x-friends:="org.eclipse.tptp.wsdm.editor.test",
27	org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional,	27	org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;x-internal:=true,
28	org.eclipse.tptp.wsdm.tooling.dialog.provisional;x-friends:="org.eclipse.tptp.wsdm.editor.test",	28	org.eclipse.tptp.wsdm.tooling.dialog.provisional;x-friends:="org.eclipse.tptp.wsdm.editor.test",
29	org.eclipse.tptp.wsdm.tooling.editor.capability.command.operation.internal;x-friends:="org.eclipse.tptp.wsdm.editor.test",	29	org.eclipse.tptp.wsdm.tooling.editor.capability.command.operation.internal;x-friends:="org.eclipse.tptp.wsdm.editor.test",
30	org.eclipse.tptp.wsdm.tooling.editor.capability.command.overview.internal;x-friends:="org.eclipse.tptp.wsdm.editor.test",	30	org.eclipse.tptp.wsdm.tooling.editor.capability.command.overview.internal;x-friends:="org.eclipse.tptp.wsdm.editor.test",

Lines 72-78 Link Here

(-)plugin.xml (-2 / +2 lines)
72	name="Axis2 Validator"	72	name="Axis2 Validator"
73	point="org.eclipse.tptp.wsdm.editor.axisValidator">	73	point="org.eclipse.tptp.wsdm.editor.axisValidator">
74	<axisValidator	74	<axisValidator
75	validator="org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.Axis2ServerDependency">	75	validator="org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.Axis2ServerDependency">
76	<requiredFiles>	76	<requiredFiles>
77	<relativeFilePath>lib/annogen-*.jar</relativeFilePath>	77	<relativeFilePath>lib/annogen-*.jar</relativeFilePath>
78	<relativeFilePath>lib/axiom-api-*.jar</relativeFilePath>	78	<relativeFilePath>lib/axiom-api-*.jar</relativeFilePath>
Lines 192-198 Link Here
192	enablesFor="1"	192	enablesFor="1"
193	label="%Generate_Java_Code_Action"	193	label="%Generate_Java_Code_Action"
194	icon="icons/obj16/mrt_obj.gif"	194	icon="icons/obj16/mrt_obj.gif"
195	class="org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.Generation"	195	class="org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.Generation"
196	id="org.eclipse.tptp.wsdm.tooling.codegen.mrt.action"/>	196	id="org.eclipse.tptp.wsdm.tooling.codegen.mrt.action"/>
197	</objectContribution>	197	</objectContribution>
198		198

Lines 32-38 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/nls/messages/mrt/internal/messages.properties (-1 / +1 lines)
32	SYSTEM_CAPS_ERROR_2 = IWAT0646E Access Denied	32	SYSTEM_CAPS_ERROR_2 = IWAT0646E Access Denied
33	HOOKUP_WIZARD_TXT1 = Deployment target and generation options	33	HOOKUP_WIZARD_TXT1 = Deployment target and generation options
34	HOOKUP_WIZARD_TXT2 = This wizard creates code for touchpoint	34	HOOKUP_WIZARD_TXT2 = This wizard creates code for touchpoint
35	HOOKUP_WIZARD_TXT3 = Overwrite files if necessary	35	HOOKUP_WIZARD_TXT3 = Overwrite files
36	HOOKUP_WIZARD_PERSIST = Persist generated artifacts	36	HOOKUP_WIZARD_PERSIST = Persist generated artifacts
37	HOOKUP_WIZARD_TXT4 = Output project	37	HOOKUP_WIZARD_TXT4 = Output project
38	HOOKUP_WIZARD_TXT5 = Browse...	38	HOOKUP_WIZARD_TXT5 = Browse...

Lines 18-24 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/codegen/dd/internal/Generation.java (-1 / +1 lines)
18	import org.eclipse.jface.viewers.ISelection;	18	import org.eclipse.jface.viewers.ISelection;
19	import org.eclipse.jface.viewers.StructuredSelection;	19	import org.eclipse.jface.viewers.StructuredSelection;
20	import org.eclipse.jface.wizard.WizardDialog;	20	import org.eclipse.jface.wizard.WizardDialog;
21	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.NewProjectWizard;	21	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.NewProjectWizard;
22	import org.eclipse.ui.IObjectActionDelegate;	22	import org.eclipse.ui.IObjectActionDelegate;
23	import org.eclipse.ui.IWorkbenchPart;	23	import org.eclipse.ui.IWorkbenchPart;
24		24

Lines 31-39 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/codegen/dd/internal/DDCodeGenerationDelegate.java (-3 / +3 lines)
31	import org.eclipse.emf.ecore.resource.Resource;	31	import org.eclipse.emf.ecore.resource.Resource;
32	import org.eclipse.emf.ecore.resource.ResourceSet;	32	import org.eclipse.emf.ecore.resource.ResourceSet;
33	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;	33	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
34	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.CodeGenerationDelegate;	34	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.CodeGenerationDelegate;
35	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.DescriptorHelper;	35	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.DescriptorHelper;
36	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.MrtPreProcessor;	36	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.MrtPreProcessor;
37	import org.eclipse.tptp.wsdm.tooling.editor.dde.util.internal.DdeUtil;	37	import org.eclipse.tptp.wsdm.tooling.editor.dde.util.internal.DdeUtil;
38	import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;	38	import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
39	import org.eclipse.tptp.wsdm.tooling.util.internal.MyDescriptorResourceFactoryImpl;	39	import org.eclipse.tptp.wsdm.tooling.util.internal.MyDescriptorResourceFactoryImpl;

Lines 20-26 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/validation/util/internal/ValidationUtils.java (-1 / +1 lines)
20	import org.eclipse.core.runtime.IExtensionPoint;	20	import org.eclipse.core.runtime.IExtensionPoint;
21	import org.eclipse.core.runtime.IExtensionRegistry;	21	import org.eclipse.core.runtime.IExtensionRegistry;
22	import org.eclipse.core.runtime.Platform;	22	import org.eclipse.core.runtime.Platform;
23	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.ISoapServerDependency;	23	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.ISoapServerDependency;
24	import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;	24	import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;
25	import org.eclipse.tptp.wsdm.tooling.nls.messages.validation.internal.Messages;	25	import org.eclipse.tptp.wsdm.tooling.nls.messages.validation.internal.Messages;
26	import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;	26	import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;

Lines 27-33 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/preferences/internal/Axis2ServerLocationPreferencePage.java (-1 / +1 lines)
27	import org.eclipse.swt.widgets.DirectoryDialog;	27	import org.eclipse.swt.widgets.DirectoryDialog;
28	import org.eclipse.swt.widgets.Label;	28	import org.eclipse.swt.widgets.Label;
29	import org.eclipse.swt.widgets.Text;	29	import org.eclipse.swt.widgets.Text;
30	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.Axis2LicenseDialog;	30	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.Axis2LicenseDialog;
31	import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;	31	import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;
32	import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;	32	import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;
33	import org.eclipse.ui.IWorkbench;	33	import org.eclipse.ui.IWorkbench;

Lines 68-74 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/editor/dde/util/internal/DdeUtil.java (-1 / +1 lines)
68	import org.eclipse.swt.widgets.Table;	68	import org.eclipse.swt.widgets.Table;
69	import org.eclipse.swt.widgets.TableItem;	69	import org.eclipse.swt.widgets.TableItem;
70	import org.eclipse.swt.widgets.Text;	70	import org.eclipse.swt.widgets.Text;
71	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.Generation;	71	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.Generation;
72	import org.eclipse.tptp.wsdm.tooling.editor.dde.internal.DescriptorEditor;	72	import org.eclipse.tptp.wsdm.tooling.editor.dde.internal.DescriptorEditor;
73	import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;	73	import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;
74	import org.eclipse.tptp.wsdm.tooling.editor.internal.CapabilityDefinition;	74	import org.eclipse.tptp.wsdm.tooling.editor.internal.CapabilityDefinition;

Lines 32-38 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/editor/capability/command/operation/internal/ImportWSDLOperationCommand.java (-1 / +1 lines)
32	import org.eclipse.core.runtime.IProgressMonitor;	32	import org.eclipse.core.runtime.IProgressMonitor;
33	import org.eclipse.core.runtime.NullProgressMonitor;	33	import org.eclipse.core.runtime.NullProgressMonitor;
34	import org.eclipse.emf.common.util.URI;	34	import org.eclipse.emf.common.util.URI;
35	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.EclipseEnvironment;	35	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.EclipseEnvironment;
36	import org.eclipse.tptp.wsdm.tooling.editor.internal.CapabilityDefinition;	36	import org.eclipse.tptp.wsdm.tooling.editor.internal.CapabilityDefinition;
37	import org.eclipse.tptp.wsdm.tooling.nls.messages.capability.imports.internal.Messages;	37	import org.eclipse.tptp.wsdm.tooling.nls.messages.capability.imports.internal.Messages;
38	import org.eclipse.tptp.wsdm.tooling.util.internal.WsdlUtils;	38	import org.eclipse.tptp.wsdm.tooling.util.internal.WsdlUtils;




         <meta.schema plugin="org.eclipse.tptp.wsdm.editor" id="axisValidator" name="axisValidator"/>
      </appInfo>
      <documentation>
         This extension point will be used for validation of Axis2 required files(Jar files and Module files). This extension point is meant for internal use only and tool extenders are not expected to use this extension point in 4.4.
      </documentation>
   </annotation>


         <attribute name="validator" type="string" use="required">
            <annotation>
               <documentation>
                  Specify the class that validates the Axis Server Location. Specified class should extend &quot;org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.SoapServerDependency&quot; class and should implement the interface &quot;org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.ISoapServerDependency&quot;.
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn="org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.SoapServerDependency:org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.ISoapServerDependency"/>
               </appInfo>
            </annotation>
         </attribute>

         name=&quot;Axis2 Validator&quot;
         point=&quot;org.eclipse.tptp.wsdm.editor.axisValidator&quot;&gt;
      &lt;axisValidator
            validator=&quot;org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.Axis2ServerDependency&quot;&gt;
         &lt;requiredFiles&gt;
               &lt;relativeFilePath&gt;lib/annogen-*.jar&lt;/relativeFilePath&gt;
               &lt;relativeFilePath&gt;lib/axiom-api-*.jar&lt;/relativeFilePath&gt;

         <meta.section type="apiInfo"/>
      </appInfo>
      <documentation>
         Provided validator class must implement the &quot;org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.ISoapServerDependency&quot; interface. This extension point is meant for internal use only and tool extenders are not expected to use this extension point in 4.4.
      </documentation>
   </annotation>


         <meta.section type="implementation"/>
      </appInfo>
      <documentation>
         Provided validator class can extend the &quot;org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.SoapServerDependency&quot; class to get the required files specified in extension point. This extension point is meant for internal use only and tool extenders are not expected to use this extension point in 4.4.
      </documentation>
   </annotation>


Lines 25-32 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/editor/mrt/internal/GenerateDDTemplateAction.java (-2 / +2 lines)
25	import org.eclipse.jface.action.IAction;	25	import org.eclipse.jface.action.IAction;
26	import org.eclipse.jface.viewers.ISelection;	26	import org.eclipse.jface.viewers.ISelection;
27	import org.eclipse.jface.viewers.StructuredSelection;	27	import org.eclipse.jface.viewers.StructuredSelection;
28	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.BasicMrtInspector;	28	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.BasicMrtInspector;
29	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.MrtInspector;	29	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.MrtInspector;
30	import org.eclipse.tptp.wsdm.tooling.editor.dde.util.internal.DdeUtil;	30	import org.eclipse.tptp.wsdm.tooling.editor.dde.util.internal.DdeUtil;
31	import org.eclipse.tptp.wsdm.tooling.editor.ui.internal.namegenerator.INewNameGenerator;	31	import org.eclipse.tptp.wsdm.tooling.editor.ui.internal.namegenerator.INewNameGenerator;
32	import org.eclipse.tptp.wsdm.tooling.editor.ui.internal.namegenerator.NewIFileNameGenerator;	32	import org.eclipse.tptp.wsdm.tooling.editor.ui.internal.namegenerator.NewIFileNameGenerator;

Lines 53-60 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/editor/mrt/internal/MrtPrototypeForm.java (-2 / +2 lines)
53	import org.eclipse.swt.widgets.Listener;	53	import org.eclipse.swt.widgets.Listener;
54	import org.eclipse.swt.widgets.Shell;	54	import org.eclipse.swt.widgets.Shell;
55	import org.eclipse.swt.widgets.Text;	55	import org.eclipse.swt.widgets.Text;
56	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.MRTCodeGenerationDelegate;	56	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.MRTCodeGenerationDelegate;
57	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.NewProjectWizard;	57	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.NewProjectWizard;
58	import org.eclipse.tptp.wsdm.tooling.editor.capability.internal.CapabilityEditor;	58	import org.eclipse.tptp.wsdm.tooling.editor.capability.internal.CapabilityEditor;
59	import org.eclipse.tptp.wsdm.tooling.editor.capability.internal.CapabilityStorage;	59	import org.eclipse.tptp.wsdm.tooling.editor.capability.internal.CapabilityStorage;
60	import org.eclipse.tptp.wsdm.tooling.editor.capability.internal.CapabilityStorageEditorInput;	60	import org.eclipse.tptp.wsdm.tooling.editor.capability.internal.CapabilityStorageEditorInput;

Lines 39-45 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/util/internal/WsdlUtils.java (-1 / +1 lines)
39	import org.eclipse.core.resources.IFile;	39	import org.eclipse.core.resources.IFile;
40	import org.eclipse.core.runtime.CoreException;	40	import org.eclipse.core.runtime.CoreException;
41	import org.eclipse.emf.common.util.URI;	41	import org.eclipse.emf.common.util.URI;
42	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.EclipseEnvironment;	42	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.EclipseEnvironment;
43	import org.eclipse.tptp.wsdm.tooling.editor.internal.CapabilityDefinition;	43	import org.eclipse.tptp.wsdm.tooling.editor.internal.CapabilityDefinition;
44	import org.eclipse.tptp.wsdm.tooling.nls.messages.capability.internal.Messages;	44	import org.eclipse.tptp.wsdm.tooling.nls.messages.capability.internal.Messages;
45	import org.eclipse.xsd.XSDComplexTypeDefinition;	45	import org.eclipse.xsd.XSDComplexTypeDefinition;

Lines 18-24 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/util/internal/IFile2Capability.java (-1 / +1 lines)
18		18
19	import org.eclipse.core.resources.IFile;	19	import org.eclipse.core.resources.IFile;
20	import org.eclipse.emf.common.util.URI;	20	import org.eclipse.emf.common.util.URI;
21	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.EclipseEnvironment;	21	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.EclipseEnvironment;
22	import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;	22	import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
23	import org.w3c.dom.Document;	23	import org.w3c.dom.Document;
24	import org.w3c.dom.Element;	24	import org.w3c.dom.Element;




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.io.ByteArrayOutputStream;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import javax.wsdl.WSDLException;
import javax.wsdl.factory.WSDLFactory;
import javax.wsdl.xml.WSDLReader;
import javax.wsdl.xml.WSDLWriter;
import javax.xml.namespace.QName;

import org.apache.muse.tools.generator.WsdlMerge;
import org.apache.muse.util.xml.XmlUtils;
import org.apache.muse.ws.addressing.soap.SoapFault;
import org.apache.muse.ws.notification.WsnConstants;
import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.muse.ws.resource.metadata.WsrmdConstants;
import org.apache.muse.ws.resource.metadata.impl.SimpleMetadataDescriptor;
import org.apache.muse.ws.wsdl.WsdlUtils;
import org.eclipse.emf.common.util.URI;
import org.eclipse.tptp.wsdm.tooling.editor.capability.util.internal.MetaDataUtils;
import org.eclipse.tptp.wsdm.tooling.editor.internal.CapabilityDefinition;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * This class provides the utility method for merging the MRT to get the smashed WSDL and RMD documents.
 *
 */

public class MrtMerge 
{
	private static WSDLReader _reader;
	private static WSDLWriter _writer;
	private static WSDLFactory _factory;
	
	/**
	 * Creates the smashed WSDL file for representing the resource type
	 * 
	 * @param mrtFile -
	 *            Manageable Resource Type file
	 * @throws Exception -
	 *             Throws exception while getting WSDL files and also while
	 *             merging them
	 */
	public static Document createMergedWSDL(ManageableResourceType mrt, String address)
			throws Exception
	{
		checkReadersWriters();

		List wsdlFiles = null;

		try
		{
			wsdlFiles = getWsdlFiles(mrt);
		}
		catch (Exception e)
		{
			throw new Exception(Messages.HOOKUP_WIZARD_ERROR_7, e);
		}

		String namespaceURI = mrt.getNamespace();

		Document[] wsdlFragments = (Document[])wsdlFiles.toArray(new Document[wsdlFiles.size()]);
		javax.wsdl.Definition def = WsdlMerge.merge(namespaceURI, wsdlFragments,
 				address);

		return _writer.getDocument(def);
	}

	private static void checkReadersWriters() throws InvocationTargetException
	{
		try
		{
			_factory = WSDLFactory.newInstance();
			_reader = _factory.newWSDLReader();
			_writer = _factory.newWSDLWriter();
		}
		catch (WSDLException e)
		{
			throw new InvocationTargetException(new Exception(
					Messages.HOOKUP_WIZARD_ERROR_3, e));
		}
	}

	/**
	 * Given an MRT file return a list of <code>Definition</code> objects that
	 * correspond to the WSDL files related to this MRT (that is, its
	 * Capabilities).
	 * 
	 * @param mrtFile
	 * @return
	 * @throws Exception
	 */
	private static List getWsdlFiles(ManageableResourceType mrt)
			throws Exception
	{
		//Get a list of all of the capabilities in this MRT 
		//This should just be a list of URIs
		List capabilityList = mrt.getImplements();		
		
		//Here is our list of clean WSDL documents
		//we are returning
		ArrayList wsdls = new ArrayList();	

		//Use an EclipseEnvironment to do the resolution of paths
		EclipseEnvironment eclipseEnv = new EclipseEnvironment();
		
		//Iterate over each capability and load it into a Definition
		for (Iterator i = capabilityList.iterator(); i.hasNext();) {
			String nextPath = i.next().toString();
			
			Document document = WsdlUtils.createWSDL(eclipseEnv, nextPath, true);
			
			//clean up imports
			//see the actual functions to understand how 
			//the removal is done
			Element cleanDocument = WsdlUtils.removeSchemaReferences(document.getDocumentElement());
			cleanDocument = WsdlUtils.removeWsdlReferences(cleanDocument);
			
			wsdls.add(cleanDocument.getOwnerDocument());
		}
		
		return wsdls;
	}
	
	/**
	 * Creates the merged RMD file for representing the manageable resource type
	 * 
	 * @param mrtFile -
	 *            Manageable Resource Type file
	 * @throws Exception -
	 *             Throws exception while getting capabilities defined in MRT and also while
	 *             merging their RMDs
	 */
	public static MetadataDescriptor createMergedRMD(ManageableResourceType mrt) throws Exception
	{
			List rmds = new ArrayList();
			Capability[] capabilities = MrtUtils.getCapabilities(mrt);
			List allTopicExpressions = new ArrayList();
			for(int i=0;i<capabilities.length;i++)
			{
				CapabilityDefinition capabilityDef = (CapabilityDefinition)capabilities[i].getWsdlDefinition();
				URI capabilityFileLocationURI = capabilityDef.getWSDLResourceProtocolURI();
				String metadataDescriptorLocation = capabilityDef.getMetadataDescriptorLocation();
				if(metadataDescriptorLocation == null || metadataDescriptorLocation.length() == 0)
					continue;
				URI rmdFileLocationURI = URI.createURI(capabilityFileLocationURI.trimSegments(1).toString()+ "/" + metadataDescriptorLocation);
				org.eclipse.tptp.wsdm.tooling.model.metadataDescriptor.DocumentRoot root = MetaDataUtils.getDocumentRoot(rmdFileLocationURI);
				ByteArrayOutputStream baos = MetaDataUtils.saveRMD(root, rmdFileLocationURI.toString(), null);
				String rmdXML = new String(baos.toByteArray());
				Element definitionElement = (Element) XmlUtils.createDocument(rmdXML).getFirstChild();
				Element metadataDescriptorElement = XmlUtils.getFirstElement(definitionElement);			
				MetadataDescriptor rmdDescriptor = new SimpleMetadataDescriptor(metadataDescriptorElement);				
				
				// Get all the topic expressions defined in different capabilities
				String[] topicExpressions = getTopicExpressions(rmdDescriptor);
				for(int j=0;j<topicExpressions.length;j++)
				{
					String prefix = topicExpressions[j].substring(0,topicExpressions[j].indexOf(':'));
					String namespace = (String)root.getXMLNSPrefixMap().get(prefix);
					String topicPath = topicExpressions[j].substring(topicExpressions[j].indexOf(':')+1);
					allTopicExpressions.add(new TopicExpression(namespace, topicPath));
				}				
				rmdDescriptor.removeProperty(WsnConstants.TOPIC_EXPRESSION_QNAME);
				
				rmds.add(rmdDescriptor);		
			}
			MetadataDescriptor[] descriptors = (MetadataDescriptor[]) rmds.toArray(new MetadataDescriptor[rmds.size()]);
			QName qname = new QName(mrt.getNamespace(), "PortType");
			// TODO Verify with Andrew that is it the way that MUSE creates the smashed wsdl by this name
			String name = mrt.getIdentifier()+".wsdl";
			MetadataDescriptor mergedRMD = WsdlMerge.merge(name, qname, descriptors);
			TopicExpression[] topicExpressions = (TopicExpression[]) allTopicExpressions.toArray(new TopicExpression[allTopicExpressions.size()]);
			// Merge all the topic expressions defined in different capabilities
			mergeTopicExpressions(mergedRMD, topicExpressions);
			return mergedRMD;		
	}
	
	private static String[] getTopicExpressions(MetadataDescriptor rmdDescriptor) throws SoapFault
	{
		if(rmdDescriptor.hasProperty(WsnConstants.TOPIC_EXPRESSION_QNAME))
		{
			Collection collection = rmdDescriptor.getInitialValues(WsnConstants.TOPIC_EXPRESSION_QNAME, String.class);
			return (String[])collection.toArray(new String[collection.size()]);
		}
		return new String[0];
	}
	
	private static void mergeTopicExpressions(MetadataDescriptor rmdDescriptor, TopicExpression[] topicExpressions) throws SoapFault
	{
		if(topicExpressions!=null && topicExpressions.length>0)
		{
			rmdDescriptor.addProperty(WsnConstants.TOPIC_EXPRESSION_QNAME, WsrmdConstants.READ_ONLY, WsrmdConstants.MUTABLE);
			List initValues = new ArrayList();
			Document doc = XmlUtils.createDocument();
			for(int i=0;i<topicExpressions.length;i++)
			{
				String namespace = topicExpressions[i].getTopicNamespace();
				String topicPath = topicExpressions[i].getTopicPath();
				String expression = "pfx:"+topicPath;
				Element propertyElement = XmlUtils.createElement(doc, WsnConstants.TOPIC_EXPRESSION_QNAME);
				propertyElement.setAttribute("xmlns:pfx", namespace);
				XmlUtils.setElementText(propertyElement, expression);
				initValues.add(propertyElement);
			}
			rmdDescriptor.setInitialValues(WsnConstants.TOPIC_EXPRESSION_QNAME, initValues);			
		}
	}
}

class TopicExpression
{
	private String _topicNamespace;
	private String _topicPath;
	
	TopicExpression(String topicNamespace, String topicPath)
	{
		_topicNamespace = topicNamespace;
		_topicPath = topicPath;
	}
	
	String getTopicNamespace()
	{
		return _topicNamespace;
	}
	
	String getTopicPath()
	{
		return _topicPath;
	}
}





/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;

import org.eclipse.swt.SWT;
import org.eclipse.swt.browser.Browser;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;
import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.osgi.framework.Bundle;

/**
 * This class is used to display the Axis-2 License. 
 */
public class Axis2LicenseDialog 
{
	private Shell _shell;
	
	private Browser _text;
	
	private Button _btnAgree;
	
	private Button _btnDecline;
	
	public static int AGREE = 0;
	
	public static int DECLINE = 1;
	
	private int _retInt = DECLINE;
		
	/**
	 * Constructor of the class. It initialises the UI for
	 * displaying the license
	 */
	public Axis2LicenseDialog()
	{
		initUI();
	}
	
	private void initUI()
	{
		_shell = new Shell(Display.getCurrent(), SWT.CLOSE | SWT.SYSTEM_MODAL | SWT.APPLICATION_MODAL | SWT.RESIZE);
		_shell.setLayout(new GridLayout(2, true));
		_shell.setText(Messages.AXIS2_LICENSE_LABEL);
		_shell.setSize(300, 300);
		
		_text = new Browser(_shell, SWT.BORDER | SWT.MULTI | SWT.WRAP);
		try 
		{
			_text.setText(readLicence());
		} 
		catch (Throwable e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}
		
		_btnAgree = new Button(_shell, SWT.PUSH);
		_btnAgree.setText(Messages.LICENSE_AGREE_TEXT);
		_btnAgree.addSelectionListener(new SelectionAdapter()
		{
			public void widgetSelected(SelectionEvent se)
			{
				_retInt = AGREE;
				_shell.dispose();
			}
		}
		);
		
		_btnDecline = new Button(_shell, SWT.PUSH);
		_btnDecline.setText(Messages.LICENSE_DECLINE_TEXT);
		_btnDecline.addSelectionListener(new SelectionAdapter()
		{
			public void widgetSelected(SelectionEvent se)
			{
				_retInt = DECLINE;
				_shell.dispose();
			}
		}
		);
		
		GridData gd = new GridData(GridData.FILL_BOTH);
		gd.horizontalSpan = 2;
		_text.setLayoutData(gd);
		
		gd = new GridData();
		gd.horizontalAlignment = SWT.RIGHT;
		_btnAgree.setLayoutData(gd);
		
		gd = new GridData();
		gd.horizontalAlignment = SWT.LEFT;
		_btnDecline.setLayoutData(gd);
	}
	
	/**
	 * Method  to show the Dialog that displays the Liscense
	 */
	public int showWindow()
	{
		_shell.open();
		while(!_shell.isDisposed())
		{
			if(!Display.getCurrent().readAndDispatch())
				Display.getCurrent().sleep();
		}
		return _retInt;
	}
	
	private String readLicence() throws Throwable
	{
		Bundle bundle = Activator.INSTANCE.getPlugin().getBundle();
		URL licenceURL = bundle.getEntry("licence/Licence.txt");
		BufferedReader in = new BufferedReader(new InputStreamReader(licenceURL.openStream()));
		StringBuffer buffer = new StringBuffer();
		String line = null;
		while ((line = in.readLine()) != null)
			buffer.append(line);
		return buffer.toString();
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.wsdl.Operation;

import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.ws.muse.descriptor.CapabilityType;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.InitParamType;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.ReferenceParametersType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.WsdlType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceTypeFactory;
import org.eclipse.tptp.wsdm.tooling.util.internal.CustomMrtResourceFactoryImpl;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdlUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmConstants;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;

/**
 * This class analyzes the given manageable resource type and provide an extra
 * resource type for muse descriptor (SubscriptionManager), if manageable
 * resource type contains the NotificationProducer capability.
 */
public class SubscriptionManagerInspector implements MrtInspector
{

	private String _mrtParentDirName;

	private DocumentRoot _root;

	private ResourceTypeType _subManagerResourceType;
	
	private ManageableResourceType _subManagerMRT;
	/**
	 * Constructor of the class
	 * @param root
	 */
	public SubscriptionManagerInspector(DocumentRoot root)
	{
		_root = root;
	}

	/**
	 * Analyzes the given manageable resource type for NotificationProducer
	 * capability, and if the capability available then returns the muse
	 * resource type for SubscriptionManager else returns the null.
	 */
	public ResourceTypeType inspect(Capability[] mrtCapabilities)
	{
		for (int i = 0; i < mrtCapabilities.length; i++)
		{
			if (isNotificationProducerCapability(mrtCapabilities[i]))
				return createSubscriptionManagerResourceType();
		}
		return null;
	}

	private ResourceTypeType createSubscriptionManagerResourceType()
	{
		createSubManagerMrt();
		_subManagerResourceType = createSubManagerMuseResourceType();
		return _subManagerResourceType;
	}

	private void createSubManagerMrt()
	{
		org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.DocumentRoot documentRoot = ManageableResourceTypeFactory.eINSTANCE.createDocumentRoot();
		_subManagerMRT = ManageableResourceTypeFactory.eINSTANCE
				.createManageableResourceType();
		documentRoot.setManageableResource(_subManagerMRT);
		_subManagerMRT.setIdentifier("SubscriptionManager");
		_subManagerMRT
				.setNamespace("http://docs.oasis-open.org/wsn/b-2/SubscriptionManager");
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.IDENTITY_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.MANAGEABLITY_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.MEX_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.GET_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.SET_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.QUERY_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.IMMIDIATE_RESOURCE_TERMINATION_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.SCHEDULED_RESOURCE_TERMINATION_CAPABILITY_LOCATION);
		_subManagerMRT
				.getImplements()
				.add(WsdmConstants.SUBSCRIPTION_MANAGER_CAPABILITY_LOCATION);		
	}

	private ResourceTypeType createSubManagerMuseResourceType()
	{
		ResourceTypeType resourceType = DescriptorFactory.eINSTANCE
				.createResourceTypeType();
		resourceType.setContextPath("/SubscriptionManager");
		resourceType
				.setJavaIdFactoryClass(WsdmConstants.MUSE_RESOURCE_ID_FACTORY_CLASS);
		resourceType
				.setJavaResourceClass(WsdmConstants.MUSE_RESOURCE_CLASS);

		WsdlType wsdlType = DescriptorFactory.eINSTANCE.createWsdlType();
		wsdlType.setWsdlFile(_mrtParentDirName + "/"
				+ "SubscriptionManager.wsdl");
		_root.getXMLNSPrefixMap().put("wsn",
				"http://docs.oasis-open.org/wsn/b-2/SubscriptionManager");
		wsdlType.setWsdlPortType("wsn:PortType");
		resourceType.setWsdl(wsdlType);

		CapabilityType identity = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		identity
				.setCapabilityUri("http://docs.oasis-open.org/wsdm/muws/capabilities/Identity");
		identity.setJavaCapabilityClass("");

		CapabilityType manageabilityCharacteristics = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		manageabilityCharacteristics
				.setCapabilityUri("http://docs.oasis-open.org/wsdm/muws/capabilities/ManageabilityCharacteristics");
		manageabilityCharacteristics.setJavaCapabilityClass("");

		CapabilityType metadataExchange = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		metadataExchange
				.setCapabilityUri("http://schemas.xmlsoap.org/ws/2004/09/mex");
		metadataExchange.setJavaCapabilityClass("");

		CapabilityType getCapability = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		getCapability
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Get");
		getCapability.setJavaCapabilityClass("");

		CapabilityType setCapability = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		setCapability
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Set");
		setCapability.setJavaCapabilityClass("");

		CapabilityType queryCapability = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		queryCapability
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Query");
		queryCapability.setJavaCapabilityClass("");

		CapabilityType immediateDestruction = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		immediateDestruction
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rlw-2/ImmediateResourceTermination");
		immediateDestruction
				.setJavaCapabilityClass("org.apache.muse.ws.resource.lifetime.impl.SimpleImmediateTermination");

		CapabilityType scheduledDestruction = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		scheduledDestruction
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rlw-2/ScheduledResourceTermination");
		scheduledDestruction
				.setJavaCapabilityClass("org.apache.muse.ws.resource.lifetime.impl.SimpleScheduledTermination");

		CapabilityType subscriptionManager = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		subscriptionManager
				.setCapabilityUri("http://docs.oasis-open.org/wsn/bw-2/SubscriptionManager");
		subscriptionManager
				.setJavaCapabilityClass("org.apache.muse.ws.notification.impl.SimpleSubscriptionManager");

		InitParamType noValidateParam = DescriptorFactory.eINSTANCE
				.createInitParamType();
		noValidateParam.setParamName("validate-wsrp-schema");
		noValidateParam.setParamValue("false");

		resourceType.getCapability().add(identity);
		resourceType.getCapability().add(manageabilityCharacteristics);
		resourceType.getCapability().add(metadataExchange);
		resourceType.getCapability().add(getCapability);
		resourceType.getCapability().add(setCapability);
		resourceType.getCapability().add(queryCapability);
		resourceType.getCapability().add(immediateDestruction);
		resourceType.getCapability().add(scheduledDestruction);
		resourceType.getCapability().add(subscriptionManager);

		resourceType.getInitParam().add(noValidateParam);

		return resourceType;
	}

	private boolean isNotificationProducerCapability(Capability capability)
	{
		boolean isNpNS = capability.getNamespace().equals(
				"http://docs.oasis-open.org/wsn/bw-2");
		boolean isNpName = capability.getName().equals("NotificationProducer");
		Operation[] operations = capability.getWsdlDefinition().getOperations();
		if (operations == null || operations.length < 2)
			return false;
		boolean isSubscribeOp = WsdlUtils.getOperationName(operations[0])
				.equals("Subscribe");
		boolean isGetCurrentMessageOp = WsdlUtils.getOperationName(
				operations[1]).equals("GetCurrentMessage");
		return isNpNS && isNpName && isSubscribeOp && isGetCurrentMessageOp;
	}

	/**
	 * Sets the parent directory 
	 * @param mrtParentDir
	 */
	public void setMrtParentDirectory(String mrtParentDir)
	{
		_mrtParentDirName = mrtParentDir;
	}
	/**
	 * Returns the initial instances
	 * @return InitialInstancesType[]
	 */
	public InitialInstancesType[] getInitialInstances()
	{
		InitialInstancesType instance = DescriptorFactory.eINSTANCE
				.createInitialInstancesType();
		ResourceTypeType rtClone = MRTCodeGenerationDelegate
				.cloneResourceType(_subManagerResourceType);
		instance.setResourceType(rtClone);
		ReferenceParametersType refParam = DescriptorFactory.eINSTANCE
				.createReferenceParametersType();
		instance.setReferenceParameters(refParam);
		return new InitialInstancesType[] { instance };
	}

	/**
	 * This method will persist the extra artifacts generated at codegen time (SubscriptionManager.mrt file).
	 */
	public void persistArtifacts()
	{
		ResourceSet rs = new ResourceSetImpl();
		rs.getResourceFactoryRegistry().getExtensionToFactoryMap()
			.put(Resource.Factory.Registry.DEFAULT_EXTENSION, new CustomMrtResourceFactoryImpl());
		byte[] rawNewMRT = MrtUtils.serializeMRT(_subManagerMRT, rs, URI
				.createURI("dummy.xml"), true);
		InputStream stream = new ByteArrayInputStream(rawNewMRT);

		try
		{
			String subManagerMrt = _mrtParentDirName + "/"
					+ "SubscriptionManager.mrt";
			IFile subManagerMrtFile = EclipseUtils.getIFile(subManagerMrt);
			if (subManagerMrtFile.exists())
			{
				subManagerMrtFile.setContents(stream, true, true,
						new NullProgressMonitor());
			}
			else
			{
				subManagerMrtFile.create(stream, true,
						new NullProgressMonitor());
			}
			try
			{
				stream.close();
			}
			catch (IOException e)
			{
				WsdmToolingLog.logError(e.getMessage(), e);
			}
		}
		catch (CoreException e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}
	}

	/**
	 * This method will returns the extra generated ManageableResourceType object equivalent to SubscriptionManager.
	 */
	public ManageableResourceType getExtraGeneratedMrt() 
	{
		return _subManagerMRT;
	}

	/**
	 * This method should return the persistance location for extra generated ManageableResourceType object equivalent to SubscriptionManager.
	 */
	public String getExtraGeneratedMrtPersistanceLocation() 
	{
		return _mrtParentDirName+"/SubscriptionManager.mrt";
	}

	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	public void inspectMetadata(ManageableResourceType mrt,
			MetadataDescriptor rmd)
	{
	}

	
}




/*******************************************************************************
 * Copyright (c) 2006, 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.wsdl.Operation;
import javax.xml.namespace.QName;

import org.apache.muse.util.xml.XmlUtils;
import org.apache.muse.ws.addressing.WsaConstants;
import org.apache.muse.ws.addressing.soap.SoapFault;
import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.ws.muse.descriptor.CapabilityType;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.InitParamType;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.ReferenceParametersType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.WsdlType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.impl.EStructuralFeatureImpl;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.util.FeatureMap;
import org.eclipse.emf.ecore.util.BasicExtendedMetaData.EStructuralFeatureExtendedMetaData;
import org.eclipse.emf.ecore.xml.type.AnyType;
import org.eclipse.tptp.wsdm.tooling.editor.mrt.relationship.internal.RelationshipUtils;
import org.eclipse.tptp.wsdm.tooling.model.addressing.AttributedURIType;
import org.eclipse.tptp.wsdm.tooling.model.addressing.EndpointReferenceType;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceTypeFactory;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.Relationship;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.RelationshipParticipantType;
import org.eclipse.tptp.wsdm.tooling.util.internal.CustomMrtResourceFactoryImpl;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdlUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmConstants;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;

public class RelationshipInspector implements MrtInspector
{

	private String _mrtParentDirName;

	private DocumentRoot _root;

	private ResourceTypeType _relationshipResourceType;
	
	private ManageableResourceType _relationshipResourceMRT;
	
	/**
	 * Constructor of the class
	 * @param root
	 */
	public RelationshipInspector(DocumentRoot root)
	{
		_root = root;
	}

	public ManageableResourceType getExtraGeneratedMrt()
	{
		return _relationshipResourceMRT;
	}

	public String getExtraGeneratedMrtPersistanceLocation() 
	{
		return _mrtParentDirName+"/RelationshipResource.mrt";
	}

	public InitialInstancesType[] getInitialInstances() 
	{
		InitialInstancesType instance = DescriptorFactory.eINSTANCE
			.createInitialInstancesType();
		ResourceTypeType rtClone = MRTCodeGenerationDelegate
			.cloneResourceType(_relationshipResourceType);
		instance.setResourceType(rtClone);
		ReferenceParametersType refParam = DescriptorFactory.eINSTANCE
			.createReferenceParametersType();
		instance.setReferenceParameters(refParam);
		return new InitialInstancesType[] { instance };
	}

	public ResourceTypeType inspect(Capability[] mrtCapabilities) 
	{
		for (int i = 0; i < mrtCapabilities.length; i++)
		{
			if (hasRelationshipCapability(mrtCapabilities[i]))
				return createRelationshipResourceType();							
		}
		return null;
	}
	
	private ResourceTypeType createRelationshipResourceType()
	{
		createRelationshipResourceMrt();
		_relationshipResourceType = createRelationshipResourceMuseType();
		return _relationshipResourceType;
	}
	
	private void createRelationshipResourceMrt()
	{
		org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.DocumentRoot documentRoot = ManageableResourceTypeFactory.eINSTANCE.createDocumentRoot();
		_relationshipResourceMRT = ManageableResourceTypeFactory.eINSTANCE
				.createManageableResourceType();
		documentRoot.setManageableResource(_relationshipResourceMRT);
		_relationshipResourceMRT.setIdentifier("RelationshipResource");
		_relationshipResourceMRT
				.setNamespace("http://docs.oasis-open.org/wsdm/muws2-2.xsd/RelationshipResource");
		_relationshipResourceMRT
				.getImplements()
				.add(WsdmConstants.MEX_CAPABILITY_LOCATION);
		_relationshipResourceMRT
				.getImplements()
				.add(WsdmConstants.GET_CAPABILITY_LOCATION);
		_relationshipResourceMRT
				.getImplements()
				.add(WsdmConstants.SET_CAPABILITY_LOCATION);
		_relationshipResourceMRT
				.getImplements()
				.add(WsdmConstants.QUERY_CAPABILITY_LOCATION);
		_relationshipResourceMRT
				.getImplements()
				.add(WsdmConstants.RELATIONSHIP_RESOURCE_CAPABILITY_LOCATION);
	}
	
	private ResourceTypeType createRelationshipResourceMuseType()
	{
		ResourceTypeType resourceType = DescriptorFactory.eINSTANCE
				.createResourceTypeType();
		resourceType.setContextPath("/RelationshipResource");
		resourceType
				.setJavaIdFactoryClass(WsdmConstants.MUSE_RESOURCE_ID_FACTORY_CLASS);
		resourceType
				.setJavaResourceClass(WsdmConstants.MUSE_RESOURCE_CLASS);

		WsdlType wsdlType = DescriptorFactory.eINSTANCE.createWsdlType();
		wsdlType.setWsdlFile(_mrtParentDirName + "/"
				+ "RelationshipResource.wsdl");
		_root.getXMLNSPrefixMap().put("rel",
				"http://docs.oasis-open.org/wsdm/muws2-2.xsd/RelationshipResource");
		wsdlType.setWsdlPortType("rel:PortType");
		resourceType.setWsdl(wsdlType);

		CapabilityType metadataExchange = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		metadataExchange
				.setCapabilityUri("http://schemas.xmlsoap.org/ws/2004/09/mex");
		metadataExchange.setJavaCapabilityClass("");

		CapabilityType getCapability = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		getCapability
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Get");
		getCapability.setJavaCapabilityClass("");

		CapabilityType setCapability = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		setCapability
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Set");
		setCapability.setJavaCapabilityClass("");

		CapabilityType queryCapability = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		queryCapability
				.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Query");
		queryCapability.setJavaCapabilityClass("");

		CapabilityType relationshipResource = DescriptorFactory.eINSTANCE
				.createCapabilityType();
		relationshipResource
				.setCapabilityUri("http://docs.oasis-open.org/wsdm/muws/capabilities/RelationshipResource");
		relationshipResource
				.setJavaCapabilityClass("");

		InitParamType noValidateParam = DescriptorFactory.eINSTANCE
				.createInitParamType();
		noValidateParam.setParamName("validate-wsrp-schema");
		noValidateParam.setParamValue("false");

		resourceType.getCapability().add(metadataExchange);
		resourceType.getCapability().add(getCapability);
		resourceType.getCapability().add(setCapability);
		resourceType.getCapability().add(queryCapability);
		resourceType.getCapability().add(relationshipResource);
		
		resourceType.getInitParam().add(noValidateParam);

		return resourceType;
	}
	
	private boolean hasRelationshipCapability(Capability capability)
	{
		boolean hasRelationshipNS = "http://docs.oasis-open.org/wsdm/muws2-2.xsd".equals(capability.getNamespace());
		String capabilityURI = capability.getWsdlDefinition().getNamespace("capabilityURI");
		boolean hasRelationshipURI = "http://docs.oasis-open.org/wsdm/muws/capabilities/Relationships".equals(capabilityURI);
		boolean hasRelationshipName = capability.getName().equals("Relationships");
		Operation[] operations = capability.getWsdlDefinition().getOperations();
		if (operations == null || operations.length < 1)
			return false;
		boolean hasQueryRelationshipsOp = WsdlUtils.getOperationName(operations[0])
				.equals("QueryRelationshipsByType");
		return hasRelationshipNS && hasRelationshipURI && hasRelationshipName && hasQueryRelationshipsOp;
	}

	public void persistArtifacts() 
	{
		ResourceSet rs = new ResourceSetImpl();
		rs.getResourceFactoryRegistry().getExtensionToFactoryMap()
			.put(Resource.Factory.Registry.DEFAULT_EXTENSION, new CustomMrtResourceFactoryImpl());
		byte[] rawNewMRT = MrtUtils.serializeMRT(_relationshipResourceMRT, rs, URI
				.createURI("dummy.xml"), true);
		InputStream stream = new ByteArrayInputStream(rawNewMRT);

		try
		{
			String relationshipResourceMrt = _mrtParentDirName + "/"
					+ "RelationshipResource.mrt";
			IFile relationshipResourceMrtFile = EclipseUtils.getIFile(relationshipResourceMrt);
			if (relationshipResourceMrtFile.exists())
			{
				relationshipResourceMrtFile.setContents(stream, true, true,
						new NullProgressMonitor());
			}
			else
			{
				relationshipResourceMrtFile.create(stream, true,
						new NullProgressMonitor());
			}
			try
			{
				stream.close();
			}
			catch (IOException e)
			{
				WsdmToolingLog.logError(e.getMessage(), e);
			}
		}
		catch (CoreException e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}		
	}

	public void setMrtParentDirectory(String mrtParentDir) 
	{
		_mrtParentDirName = mrtParentDir;
	}
	
	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	public void inspectMetadata(ManageableResourceType mrt, MetadataDescriptor rmd)
	{
		boolean hasRelationshipCapability = false;
		Capability[] mrtCapabilities = new Capability[0];
		try 
		{
			mrtCapabilities = MrtUtils.getCapabilities(mrt);
		} 
		catch (Exception e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}
		for (int i = 0; i < mrtCapabilities.length; i++)
		{
			if (hasRelationshipCapability(mrtCapabilities[i]))
			{
				hasRelationshipCapability = true;
				break;
			}
		}
		if(hasRelationshipCapability)
		{
			List relationships = mrt.getRelationshipDefinitions();
			List initialValues = new ArrayList();
			for(int i=0;i<relationships.size();i++)
			{
				Relationship relationship = (Relationship) relationships.get(i);
				Element value = createRelationshipElement(relationship);
				initialValues.add(value);
			}
			if(!initialValues.isEmpty());
				try 
				{
					rmd.setInitialValues(new QName(WsdmConstants.MUWS_P2_NS,"Relationship"), initialValues);
				} 
				catch (SoapFault e) 
				{
					WsdmToolingLog.logError(e.getMessage(), e);
				}
		}
	}
	
	private Element createRelationshipElement(Relationship relationship)
	{
		Document document = XmlUtils.createDocument();
		Element relationshipElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P2_NS,"Relationship"));
		
		Element nameElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P2_NS,"Name"));
		Text name = document.createTextNode(relationship.getName());
		nameElement.appendChild(name);		
		relationshipElement.appendChild(nameElement);
		
		Element typeElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P2_NS,"Type"));
		QName typeQName = RelationshipUtils.getRelationshipType(relationship);
		Element element = XmlUtils.createElement(document, typeQName);
		typeElement.appendChild(element);		
		relationshipElement.appendChild(typeElement);
		
		List participants = relationship.getParticipant();
		for(int i=0;i<participants.size();i++)
		{
			RelationshipParticipantType participant = (RelationshipParticipantType) participants.get(i);
			Element participantElement = createParticipantElement(participant, document);
			relationshipElement.appendChild(participantElement);
		}
		return relationshipElement;
	}
	
	private Element createParticipantElement(RelationshipParticipantType participant, Document document)
	{
		Element participantElement = XmlUtils.createElement(document,new QName(WsdmConstants.MUWS_P2_NS,"Participant"));
		
		// Create epr element 
		Element manageabilityEprElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P1_NS,"ManageabilityEndpointReference"));
		EndpointReferenceType epr = (EndpointReferenceType) participant.getManageabilityEndpointReference().get(0);
		AttributedURIType uri = epr.getAddress();
		Element addressElement = XmlUtils.createElement(document, new QName("http://www.w3.org/2005/08/addressing", "Address"));
		Text address = document.createTextNode(uri.getValue());
		addressElement.appendChild(address);
		manageabilityEprElement.appendChild(addressElement);
		participantElement.appendChild(manageabilityEprElement);
		
		// Create reference parameter element
		Element referenceParameterElement = XmlUtils.createElement(document, WsaConstants.PARAMETERS_QNAME);
		manageabilityEprElement.appendChild(referenceParameterElement);		
		org.eclipse.tptp.wsdm.tooling.model.addressing.ReferenceParametersType refParams = epr.getReferenceParameters();
		FeatureMap fm = refParams.getAny();
		Iterator it = fm.iterator();
		while (it.hasNext())
		{
			Object obj = it.next();
			if(obj instanceof EStructuralFeatureImpl.ContainmentUpdatingFeatureMapEntry)
			{
				EStructuralFeatureImpl.ContainmentUpdatingFeatureMapEntry containmentEntry = (EStructuralFeatureImpl.ContainmentUpdatingFeatureMapEntry)obj;
				EStructuralFeatureExtendedMetaData metadata = ((EStructuralFeatureImpl)containmentEntry.getEStructuralFeature()).getExtendedMetaData();
				String namespace = metadata.getNamespace();
				String name = metadata.getName();
				String value = "";
				Object containmentEntryValue = containmentEntry.getValue();
				if(containmentEntryValue instanceof AnyType)
				{
					AnyType anyType = (AnyType) containmentEntryValue;
					value = (String) anyType.getMixed().valueListIterator().next();
				}
				Element paramElement = XmlUtils.createElement(document, new QName(namespace, name));
				XmlUtils.setElementText(paramElement, value);
				referenceParameterElement.appendChild(paramElement);
			}			
		}
		
		// Create resource id element
		Element resourceIdElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P1_NS,"ResourceId"));
		Text resourceId = document.createTextNode(participant.getResourceId());
		resourceIdElement.appendChild(resourceId);
		participantElement.appendChild(resourceIdElement);
		
		// Create role element
		Element roleElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P2_NS,"Role"));
		Text role = document.createTextNode(participant.getRole());
		roleElement.appendChild(role);
		participantElement.appendChild(roleElement);
		
		return participantElement;
	}
	
	

}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;

/**
 * This class collects the relative paths of required Axis-2 files specified in extension point.
 * So if you are extending "axisValidator" extension point, you have to extend this class and implement
 * the interface ISoapServerDependency.
 */

public abstract class SoapServerDependency implements ISoapServerDependency 
{

	protected List _requiredFiles = new ArrayList();
	
	public void setInitializationData(IConfigurationElement config,
			String propertyName, Object data) throws CoreException 
	{
		if(config.getName()!=null && config.getName().equals("axisValidator"))
		{
			IConfigurationElement requiredFileConfig = config.getChildren()[0];
			IConfigurationElement[] relativePathConfig = requiredFileConfig.getChildren();
			for(int i=0;i<relativePathConfig.length;i++)
			{
				if(relativePathConfig[i].getName()!=null && relativePathConfig[i].getName().equals("relativeFilePath"))
				{
					String value = relativePathConfig[i].getValue();
					if(value!=null && !value.equals("null"))
						_requiredFiles.add(value);					
				}
			}
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.util.AbstractMap;
import java.util.HashSet;
import java.util.Set;

public class SingleValueMap extends AbstractMap {
	Object _value;
	Set _entrySet = new HashSet();
			
	public Object get(Object key) {
		return _value;
	}
	
	public Object put(Object key, Object value) {
		Object oldValue = _value;
		_value = value;		
		return oldValue;
	}
	
	public Set entrySet() {
		return _entrySet;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.wsdl.Definition;

import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.InitParamType;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.ReferenceParametersType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.WsdlType;
import org.apache.ws.muse.descriptor.impl.CapabilityTypeImpl;
import org.apache.ws.muse.descriptor.impl.ResourceTypeTypeImpl;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.EMap;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.nls.messages.dde.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmConstants;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;

/**
 * This class analyzes the given manageable resource type and provide a resource
 * type for muse descriptor.
 */

public class BasicMrtInspector implements MrtInspector
{
	private DocumentRoot _root;

	private ResourceTypeType _resourceType;

	private ManageableResourceType _mrt;
	/**
	 * Constructor of the class
	 * @param mrt
	 * @param root
	 */
	public BasicMrtInspector(ManageableResourceType mrt,DocumentRoot root)
	{
		_root = root;
		_mrt = mrt;
	}

	/**
	 *  Get the initial instance for this manageable resource type
	 *  @return InitialInstancesType - Array of the initial instances
	 */
	public InitialInstancesType[] getInitialInstances()
	{
		InitialInstancesType instance = DescriptorFactory.eINSTANCE
				.createInitialInstancesType();
		ResourceTypeType rtClone = MRTCodeGenerationDelegate
				.cloneResourceType(_resourceType);
		instance.setResourceType(rtClone);
		ReferenceParametersType refParam = DescriptorFactory.eINSTANCE
				.createReferenceParametersType();

		instance.setReferenceParameters(refParam);
		return new InitialInstancesType[] { instance };
	}

	/**
	 *  Create a new descriptor resource type for the given manageable resource
	 *  type
	 *  @param mrtCapabilities
	 *  @return {@link ResourceTypeType}
	 */
	public ResourceTypeType inspect(Capability[] mrtCapabilities)
	{
		Mrt2DescriptorResourceType mrt2dd = new Mrt2DescriptorResourceType(
				_root, _mrt, mrtCapabilities);
		_resourceType = mrt2dd.getResourceTypeType();
		return _resourceType;
	}

	public void setMrtParentDirectory(String mrtParentDir)
	{
	}

	public void persistArtifacts()
	{
	}

	public ManageableResourceType getExtraGeneratedMrt() 
	{
		return null;
	}

	public String getExtraGeneratedMrtPersistanceLocation() 
	{
		return null;
	}

	public void inspectMetadata(ManageableResourceType mrt,
			MetadataDescriptor rmd) 
	{
	}

}

class Mrt2DescriptorResourceType
{
	private ManageableResourceType _mrt;

	private DocumentRoot _root;

	private Capability[] _mrtCapabilities;

	Mrt2DescriptorResourceType(DocumentRoot root, ManageableResourceType mrt)
	{
		this(root, mrt, null);
	}

	Mrt2DescriptorResourceType(DocumentRoot root, ManageableResourceType mrt,
			Capability[] mrtCapabilities)
	{
		_mrt = mrt;
		_root = root;
		if (mrtCapabilities == null)
			try
			{
				_mrtCapabilities = MrtUtils.getCapabilities(mrt);
			}
			catch (Exception e)
			{
			}
		else
			_mrtCapabilities = mrtCapabilities;
	}

	ResourceTypeType getResourceTypeType()
	{
		ResourceTypeTypeImpl rtd = (ResourceTypeTypeImpl) DescriptorFactory.eINSTANCE
				.createResourceTypeType();
		rtd.setUseRouterPersistence(true);
		rtd.setContextPath("/" + _mrt.getIdentifier()); //$NON-NLS-1$
		rtd
				.setJavaIdFactoryClass(WsdmConstants.MUSE_RESOURCE_ID_FACTORY_CLASS); //$NON-NLS-1$
		rtd
				.setJavaResourceClass(WsdmConstants.MUSE_RESOURCE_CLASS); //$NON-NLS-1$
		rtd.getCapability().addAll(getCapabilitiesFromMRT());
		WsdlType wsdlType = DescriptorFactory.eINSTANCE.createWsdlType();

		String mrtFileLocation = getMrtFileWorkspaceLocation();
		if (mrtFileLocation == null)
			;
		// TODO Log error not resolved location of given mrt
		else
		{
			String mrtFilePathWithoutExtn = mrtFileLocation.substring(0,
					mrtFileLocation.lastIndexOf('.'));
			wsdlType.setWsdlFile(mrtFilePathWithoutExtn + ".wsdl");
		}

		String namespace = _mrt.getNamespace();
		String prefix = getOrCreatePrefix(_root, namespace);
		String localPart = Messages.DU_PORT_TYPE_LOCAL_PART; // Only
		// "PortType"
		// should come
		// with the
		// //$NON-NLS-1$
		// prefix.
		wsdlType.setWsdlPortType(prefix + ":" + localPart);

		rtd.setWsdl(wsdlType);
		
		// Fix for Bug 174792 Set "validate-wsrp-schema" to "false" for the dd file generated at the codegen from MRT
		// http://bugs.eclipse.org/bugs/show_bug.cgi?id=174792
		InitParamType noValidateParam = DescriptorFactory.eINSTANCE.createInitParamType();
		noValidateParam.setParamName("validate-wsrp-schema");
		noValidateParam.setParamValue("false");		
		rtd.getInitParam().add(noValidateParam);
		
		return rtd;
	}

	private static String getOrCreatePrefix(DocumentRoot root, String namespace)
	{
		String prefix = getPrefix(root, namespace);
		if (prefix != null)
			return prefix;
		String newPrefix = generateNewPrefix(root);
		root.getXMLNSPrefixMap().put(newPrefix, namespace);
		return newPrefix;
	}

	private static String generateNewPrefix(DocumentRoot root)
	{
		int count = 0;
		while (isPrefixExists(root, "pfx" + count)) //$NON-NLS-1$
			count++;
		return "pfx" + count; //$NON-NLS-1$
	}

	private static boolean isPrefixExists(DocumentRoot root, String prefix)
	{
		EMap map = root.getXMLNSPrefixMap();
		Iterator keyIt = map.keySet().iterator();
		while (keyIt.hasNext())
		{
			String pfx = (String) keyIt.next();
			if (pfx.equals(prefix))
				return true;
		}
		return false;
	}

	private static String getPrefix(DocumentRoot root, String namespace)
	{
		if (root == null)
			return null;
		if (namespace == null)
			return null;
		EMap map = root.getXMLNSPrefixMap();
		Iterator keyIt = map.keySet().iterator();
		Iterator valuesIt = map.values().iterator();
		while (valuesIt.hasNext())
		{
			String ns = (String) valuesIt.next();
			String prefix = (String) keyIt.next();
			if (ns.equals(namespace))
				return prefix;
		}
		return null;
	}

	private List getCapabilitiesFromMRT()
	{
		if (_mrt == null)
			return null;
		List capDataList = new ArrayList();
		for (int i = 0; i < _mrtCapabilities.length; i++)
		{
			Capability capability = _mrtCapabilities[i];
			String capNS = ""; //$NON-NLS-1$
			Definition def = capability.getWsdlDefinition().getDefinition();
			if (def != null)
			{
				capNS = capability.getWsdlDefinition().getNamespace(
						"capabilityURI");
				if (capNS == null)
					capNS = capability.getNamespace();

			}
			CapabilityTypeImpl ctype = (CapabilityTypeImpl) DescriptorFactory.eINSTANCE
					.createCapabilityType();
			ctype.setCapabilityUri(capNS);
			String className = getJavaCapabilityClass(capNS);
			ctype.setJavaCapabilityClass(className);
			boolean isValid = validateCapability(capDataList, ctype);
			if (isValid)
				capDataList.add(ctype);
		}
		return capDataList;
	}

	private boolean validateCapability(List capDataList,
			CapabilityTypeImpl ctype)
	{
		if (capDataList == null || capDataList.size() == 0)
		{
			capDataList = new ArrayList();
			return true;
		}
		for (int i = 0; i < capDataList.size(); i++)
		{
			CapabilityTypeImpl tmp = (CapabilityTypeImpl) capDataList.get(i);
			if (tmp.getCapabilityUri().trim().equals(
					ctype.getCapabilityUri().trim()))
				return false;
		}
		return true;
	}

	private String getMrtFileWorkspaceLocation()
	{
		try
		{
			IFile mrtFile = EclipseUtils.getIFile(_mrt.eResource().getURI()
					.toString());
			return mrtFile.getFullPath().toString();
		}
		catch (CoreException e)
		{
			WsdmToolingLog.logError(e.getLocalizedMessage(), e);
		}
		return null;
	}

	private String getJavaCapabilityClass(String uri)
	{
		String ns = "org.eclipse.tptp.wsdm.model";
		IExtensionPoint iep = Platform.getExtensionRegistry()
				.getExtensionPoint(ns, "mrCapability");
		if (iep != null)
		{
			IExtension[] extensions = iep.getExtensions();
			for (int i = 0; i < extensions.length; i++)
			{
				IConfigurationElement[] ice = extensions[i]
						.getConfigurationElements();
				for (int j = 0; j < ice.length; j++)
				{
					String capURI = ice[j].getAttribute("uri");
					if (uri.equals(capURI))
					{
						String className = ice[j]
								.getAttribute("implementingClass");
						return (className == null) ? "" : className;
					}
				}
			}
		}
		return "";
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.util.ArrayList;

public class TargetedFileList {
	private String _relativePath;	// path relative to webcontent folder
	private ArrayList _absoluteFilePaths;
	
	public TargetedFileList(String relativePath){
		_relativePath = relativePath;
		_absoluteFilePaths = new ArrayList();
	}
	
	public void add(String absolutePath){
		if(absolutePath!=null && !absolutePath.trim().equals("")){
			_absoluteFilePaths.add(absolutePath);
		}
	}
	
	public String[] getFiles(){
		if(_absoluteFilePaths==null) return new String[]{};
		return (String[]) _absoluteFilePaths.toArray(new String[]{});
	}
	
	public String getRelativePath(){
		return _relativePath;
	}
	
	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import javax.xml.namespace.QName;

import org.apache.muse.util.xml.XmlUtils;
import org.apache.muse.ws.addressing.soap.SoapFault;
import org.apache.muse.ws.resource.sg.WssgConstants;
import org.apache.ws.muse.descriptor.CapabilityType;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.InitParamType;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.ReferenceParametersType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.WsdlType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.tptp.wsdm.tooling.editor.ui.internal.NewNameGenerator;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceTypeFactory;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.MembershipContentRuleType;
import org.eclipse.tptp.wsdm.tooling.util.internal.CustomMrtResourceFactoryImpl;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmConstants;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
/**
 * This class analyzes the given manageable resource type and provide an extra
 * resource type for muse descriptor (ServiceGroupEntry), if manageable
 * resource type contains the ServiceGroupCapability and ServiceGroupRegistration capability.
 */

public class ServiceGroupInspector implements MrtInspector
{

	private String _mrtParentDirName;

	private DocumentRoot _root;
	
	private ResourceTypeType _serviceGroupEntryResorceType;
	
	private ManageableResourceType _serviceGroupEntrymrt;
	
	private HashMap _prefixNamespaceMap;
	
	/**
	 * Constructor for the ServiceGroupIspector class.
	 * @param mrt
	 * @param root
	 */
	
	public ServiceGroupInspector(ManageableResourceType mrt,DocumentRoot root)
	{
		_root = root;
	}

	/**
	 * Analyzes the given manageable resource type for ServiceGroupCapability and
	 * ServiceGroupRegistrationCapability and if the capabilities available then returns the muse
	 * resource type for ServiceGroupEntry  else returns the null.
	 */
	public ResourceTypeType inspect(Capability[] mrtCapabilities) 
	{
		
		if(hasServiceGroupCapabilities(mrtCapabilities))
			return createServiceGroupEntryResourceType();
		return null;
	}
	
	private boolean hasServiceGroupCapabilities(Capability[] mrtCapabilities)
	{
		boolean hasServiceGroupCapability = false;
		
		boolean hasServiceGroupRegistration = false;
		
		for(int i =0;i<mrtCapabilities.length;i++)
		{
			if(mrtCapabilities[i].getNamespace().equals(WsdmConstants.SERVICE_GROUP_NS))
					hasServiceGroupCapability = true;
			if(mrtCapabilities[i].getNamespace().equals(WsdmConstants.SERVICE_GROUP_REG_NS))
					hasServiceGroupRegistration = true;
		}
		return hasServiceGroupCapability && hasServiceGroupRegistration;
	}

	/**
	 * Returns the initial instances
	 * @return InitialInstancesType[]
	 */
	public InitialInstancesType[] getInitialInstances() {

		InitialInstancesType instance = DescriptorFactory.eINSTANCE
				.createInitialInstancesType();
		ResourceTypeType rtClone = MRTCodeGenerationDelegate
				.cloneResourceType(_serviceGroupEntryResorceType);
		instance.setResourceType(rtClone);
		ReferenceParametersType refParam = DescriptorFactory.eINSTANCE
				.createReferenceParametersType();
		instance.setReferenceParameters(refParam);
		return new InitialInstancesType[] { instance };
	
	}
	/**
	 * Sets the parent directory 
	 * @param mrtParentDir
	 */
	public void setMrtParentDirectory(String mrtParentDir) {
		_mrtParentDirName = mrtParentDir;
		
	}
	
	private ResourceTypeType createServiceGroupEntryResourceType()
	{
		createServiceGroupEntryMrt();
		_serviceGroupEntryResorceType = createServiceGroupEntryMuseResourceType();
		return _serviceGroupEntryResorceType;
	}
	
	private void createServiceGroupEntryMrt()
	{
		 org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.DocumentRoot documentRoot = ManageableResourceTypeFactory.eINSTANCE.createDocumentRoot();
		 _serviceGroupEntrymrt = ManageableResourceTypeFactory.eINSTANCE.createManageableResourceType();
		 documentRoot.setManageableResource(_serviceGroupEntrymrt);
		_serviceGroupEntrymrt.setIdentifier("ServiceGroupEntry");
		_serviceGroupEntrymrt.setNamespace("http://docs.oasis-open.org/wsrf/sgw-2");
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.MEX_CAPABILITY_LOCATION);
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.GET_CAPABILITY_LOCATION);
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.SET_CAPABILITY_LOCATION);
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.QUERY_CAPABILITY_LOCATION);
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.IMMIDIATE_RESOURCE_TERMINATION_CAPABILITY_LOCATION);
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.SCHEDULED_RESOURCE_TERMINATION_CAPABILITY_LOCATION);
		_serviceGroupEntrymrt.getImplements().add(WsdmConstants.SERVICE_GROUP_ENTRY_CAPABILITY_LOCATION);
	}
	
	private ResourceTypeType createServiceGroupEntryMuseResourceType()
	{
		ResourceTypeType resourceType = DescriptorFactory.eINSTANCE.createResourceTypeType();
		resourceType.setContextPath("/ServiceGroupEntry");
		resourceType.setJavaIdFactoryClass("org.apache.muse.core.routing.CounterResourceIdFactory");
		resourceType.setJavaResourceClass("org.apache.muse.ws.resource.impl.SimpleWsResource");

		WsdlType wsdlType = DescriptorFactory.eINSTANCE.createWsdlType();
		wsdlType.setWsdlFile(_mrtParentDirName + "/" + "ServiceGroupEntry.wsdl");
		_root.getXMLNSPrefixMap().put("wsrf-sge","http://docs.oasis-open.org/wsrf/sgw-2");
		wsdlType.setWsdlPortType("wsrf-sge:PortType");
		resourceType.setWsdl(wsdlType);

		CapabilityType metadataExchange = DescriptorFactory.eINSTANCE.createCapabilityType();
		metadataExchange.setCapabilityUri(WsdmConstants.MEX_NS);
		metadataExchange.setJavaCapabilityClass("");
		
		CapabilityType getCapability = DescriptorFactory.eINSTANCE.createCapabilityType();
		getCapability.setCapabilityUri(WsdmConstants.GET_NS);
		getCapability.setJavaCapabilityClass("");
		
		CapabilityType setCapability = DescriptorFactory.eINSTANCE.createCapabilityType();
		setCapability.setCapabilityUri(WsdmConstants.SET_NS);
		setCapability.setJavaCapabilityClass("");
		
		CapabilityType queryCapability = DescriptorFactory.eINSTANCE.createCapabilityType();
		queryCapability.setCapabilityUri(WsdmConstants.QUERY_NS);
		queryCapability.setJavaCapabilityClass("");

		CapabilityType immediateDestruction = DescriptorFactory.eINSTANCE.createCapabilityType();
		immediateDestruction.setCapabilityUri(WsdmConstants.IMMIDIATE_TERM_NS);
		immediateDestruction.setJavaCapabilityClass("");

		CapabilityType scheduledDestruction = DescriptorFactory.eINSTANCE.createCapabilityType();
		scheduledDestruction.setCapabilityUri(WsdmConstants.SCHEDULDED_TERM_NS);
		scheduledDestruction.setJavaCapabilityClass("");
	
		CapabilityType serviceGroupEntry = DescriptorFactory.eINSTANCE.createCapabilityType();
		serviceGroupEntry.setCapabilityUri(WsdmConstants.SERVICE_GROUP_ENTRY_NS);
		serviceGroupEntry.setJavaCapabilityClass("");
		
		InitParamType noValidateParam = DescriptorFactory.eINSTANCE	.createInitParamType();
		noValidateParam.setParamName("validate-wsrp-schema");
		noValidateParam.setParamValue("false");

		resourceType.getCapability().add(metadataExchange);
		resourceType.getCapability().add(getCapability);
		resourceType.getCapability().add(setCapability);
		resourceType.getCapability().add(queryCapability);
		resourceType.getCapability().add(immediateDestruction);
		resourceType.getCapability().add(scheduledDestruction);
		resourceType.getCapability().add(serviceGroupEntry);
		resourceType.getInitParam().add(noValidateParam);

		return resourceType;
	}
	
	private String getNamespace(String contentElement)
	{
		return contentElement.substring(1,contentElement.lastIndexOf('}'));
	}
	
	private void preparePrfixNamespaceMap(String contentElement)
	{
		if(!_prefixNamespaceMap.containsKey(contentElement))
		{
			NewNameGenerator nameGenerator = new NewNameGenerator("pfx");
			String prefix = nameGenerator.getNextName();
			
			while (nameAlreadyExists(prefix)) 
			{
				prefix = nameGenerator.getNextName();
			}
			_prefixNamespaceMap.put(contentElement, prefix);
		}
	}
	
	private boolean nameAlreadyExists(String prefix)
	{
		if(_prefixNamespaceMap.containsValue(prefix))
			return true;
		return false;
	}
	
	private String getLocalName(String namespace)
	{
		return namespace.substring(namespace.lastIndexOf('}')+1);
	}
	
	/**
	 * This method will returns the extra generated ManageableResourceType object equivalent to ServiceGroupEntry.
	 */
	public ManageableResourceType getExtraGeneratedMrt() {
	
		return _serviceGroupEntrymrt;
	}
	
	/**
	 * This method should return the persistance location for extra generated ManageableResourceType object equivalent to ServiceGroupEntry.
	 */
	public String getExtraGeneratedMrtPersistanceLocation() 
	{
		return _mrtParentDirName + "/"+ "ServiceGroupEntry.mrt";
	}
	/**
	 * This method will persist the extra artifacts generated at the code generation time(ServiceGroupEntry). 
	 */
	public void persistArtifacts()
	{
		try{
			ResourceSet rs = new ResourceSetImpl();
			rs.getResourceFactoryRegistry().getExtensionToFactoryMap()
			.put(Resource.Factory.Registry.DEFAULT_EXTENSION, new CustomMrtResourceFactoryImpl());
			String serviceGroupMrt = _mrtParentDirName + "/"+ "ServiceGroupEntry.mrt";
			URI uri = URI.createPlatformResourceURI(serviceGroupMrt);
			byte[] rawNewMRT = MrtUtils.serializeMRT(_serviceGroupEntrymrt, rs, uri, true);
			InputStream stream = new ByteArrayInputStream(rawNewMRT);			
			IFile subManagerMrtFile = EclipseUtils.getIFile(serviceGroupMrt);
			if (subManagerMrtFile.exists())
			{
				subManagerMrtFile.setContents(stream, true, true,
				new NullProgressMonitor());
			}
			else
			{
				subManagerMrtFile.create(stream, true,
				new NullProgressMonitor());
			}
			stream.close();			
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
	}
	
	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	public void inspectMetadata(ManageableResourceType mrt,
			org.apache.muse.ws.resource.metadata.MetadataDescriptor rmd) 
	{
		
		_prefixNamespaceMap  = new HashMap();
		Capability[] mrtCapabilities = new Capability[0];
		try 
		{
			mrtCapabilities = MrtUtils.getCapabilities(mrt);
		} 
		catch (Exception e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}
		
		if(hasServiceGroupCapabilities(mrtCapabilities))
		{
			List membershipContentRule = mrt.getMembershipContentRule();
			List initialValues = new ArrayList();
			for(int i=0;i<membershipContentRule.size();i++)
			{
				MembershipContentRuleType rule = (MembershipContentRuleType) membershipContentRule.get(i);
				Element value = createMembershipContentRuleElement(rule);
				
				initialValues.add(value);
			}
			if(!initialValues.isEmpty());
				try 
				{
					rmd.setInitialValues(new QName(WssgConstants.NAMESPACE_URI,"MembershipContentRule"), initialValues);
				} 
				catch (SoapFault e) 
				{
					WsdmToolingLog.logError(e.getMessage(), e);
				}
		}
	}
	
	private Element createMembershipContentRuleElement(MembershipContentRuleType rule)
	{
		Document document = XmlUtils.createDocument();
		Element membershipContentRuleElement = XmlUtils.createElement(document, new QName(WssgConstants.NAMESPACE_URI,"MembershipContentRule"));
		List contentElements = rule.getContentElements();
		String contentElementAttribute="";
		
		for(int i =0 ;i<contentElements.size();i++)
		{
			String contentElement = (String)contentElements.get(i);
			String tns = getNamespace(contentElement);
			String localName = getLocalName(contentElement);
			preparePrfixNamespaceMap(tns);
			
			if(contentElementAttribute.length() !=0)
				contentElementAttribute =  contentElementAttribute + " " + (String)_prefixNamespaceMap.get(tns)+":"+ localName;
			else
				contentElementAttribute =(String)_prefixNamespaceMap.get(tns)+":"+ localName;
			String  xmlns = "xmlns:" + _prefixNamespaceMap.get(tns);
			 membershipContentRuleElement.setAttribute(xmlns,tns );
			
		}
		membershipContentRuleElement.setAttribute("ContentElements",contentElementAttribute );
		
		return membershipContentRuleElement;
		
		
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import org.eclipse.core.resources.IFile;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPart;

/**
 * Access point code from the code generation option in popup
 */
public class Generation implements IObjectActionDelegate
{

	private IWorkbenchPart _targetPart;

	private StructuredSelection _selection;

	/**
	 * (non-Javadoc)
	 * @see org.eclipse.ui.IObjectActionDelegate#run(org.eclipse.jface.action.IAction)
	 */ 
	public void run(IAction action)
	{
		IFile mrtFile = (IFile) _selection.getFirstElement();
		MrtUtils.searchAndSaveMRTEditor(mrtFile);
		MRTCodeGenerationDelegate codeGenerationDelegate = new MRTCodeGenerationDelegate(
				mrtFile);

		NewProjectWizard npw = new NewProjectWizard(codeGenerationDelegate);
		WizardDialog wd = new WizardDialog(_targetPart.getSite().getShell(),
				npw);
		wd.open();
	}

	/**
	 * (non-Javadoc)
	 * @see org.eclipse.ui.IObjectActionDelegate#setActivePart(org.eclipse.jface.action.IAction, org.eclipse.ui.IWorkbenchPart)
	 */ 
	public void setActivePart(IAction action, IWorkbenchPart targetPart)
	{
		_targetPart = targetPart;
	}

	/**
	 * (non-Javadoc)
	 * @see org.eclipse.ui.IObjectActionDelegate#selectionChanged
	(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
	 */
	public void selectionChanged(IAction action, ISelection selection)
	{
		if (selection instanceof StructuredSelection)
		{
			_selection = (StructuredSelection) selection;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.MuseType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.RootType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.tptp.wsdm.tooling.editor.dde.util.internal.DdeUtil;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;

/**
 * This class analyzes the given ManageableResourceType object and check whether it needs
 * any other extra ManageableResourceType object such as SubscriptionManager based on the capabilities 
 * available in given ManagableResourceType.   
 */

public class MrtPreProcessor 
{
	private ManageableResourceType _mrt;
	private DocumentRoot _ddRoot;
	private IFile _mrtFile;
	private List _generatedResourceTypes = new LinkedList();
	private List _initialInstancesList = new LinkedList();
	private List _contributedInspectors = new LinkedList();
	private Map _mrtObjectMap = new HashMap();
	private List _allInspectors = new LinkedList();
	
	/**
	 * Creates instance of this class.
	 * 
	 * @param mrt
	 * 			Given MRT to analyze.
	 * 
	 * @param ddRoot
	 * 			Given Descriptor file document root, can be null.
	 */
	public MrtPreProcessor(ManageableResourceType mrt, DocumentRoot ddRoot)
	{
		_mrt = mrt;
		if(ddRoot == null)
			ddRoot = DdeUtil.createInitialDDModel();
		_ddRoot = ddRoot;
		String mrtLocation = _mrt.eResource().getURI().toString();
		try 
		{
			_mrtFile = EclipseUtils.getIFile(mrtLocation);
		} 
		catch (CoreException e) 
		{
			e.printStackTrace();
		}
	}
	
	/**
	 * Creates instance of this class.
	 * 
	 * @param mrt
	 * 			Given MRT to analyze.
	 */
	public MrtPreProcessor(ManageableResourceType mrt)
	{
		this(mrt,null);
	}
	
	/**
	 * Returns the modified Descriptor document root. 
	 */
	public DocumentRoot getDDDocumentRoot()
	{
		return _ddRoot;
	}
	
	/**
	 * Analyzes the given MRT file for extra required artifacts. 
	 */
	public void preProcess()
	{
		if(_ddRoot!=null)
		{
			RootType root = _ddRoot.getRoot();
			MuseType muse = root.getMuse();		
			ResourceTypeType[] resourceTypes = process();
			for (int i = 0; i < resourceTypes.length; i++)
				muse.getResourceType().add(resourceTypes[i]);
			
			// Create initial instances
			
			InitialInstancesType[] instances = getInitialInstances();
			for (int i = 0; i < instances.length; i++)
				root.getInitialInstances().add(instances[i]);
		}
	}
	
	private boolean hasResourceTypeInDD(ResourceTypeType givenResourceType)
	{
		if(_ddRoot!=null)
		{
			if(_ddRoot.getRoot()!=null)
			{
				if(_ddRoot.getRoot().getMuse()!=null)
				{
					MuseType muse = _ddRoot.getRoot().getMuse();
					List resourceTypes = muse.getResourceType();
					if(resourceTypes!=null)
					{
						for(int i=0;i<resourceTypes.size();i++)
						{
							ResourceTypeType resourceType = (ResourceTypeType)resourceTypes.get(i);
							boolean equalContextPath = givenResourceType.getContextPath().equals(resourceType.getContextPath());
							boolean equalWsdlFile = givenResourceType.getWsdl().getWsdlFile().equals(resourceType.getWsdl().getWsdlFile());
							boolean equalWsdlPortType = givenResourceType.getWsdl().getWsdlPortType().equals(resourceType.getWsdl().getWsdlPortType());
							if(equalContextPath && equalWsdlFile && equalWsdlPortType)
								return true;
						}
					}
				}
			}
		}
		return false;
	}
	
	/**
	 * This method processes the given manageable resource type to check whether
	 * we need any extra resource type in muse descriptor file such as
	 * Subscription manager etc. It will returns all the proper ResourceTypeType
	 * objects. So it will return atleast one ResourceTypeType object that
	 * represents the given manageable resource type.
	 */
	private ResourceTypeType[] process()
	{
		Capability[] mrtCapabilities = new Capability[0];
		try
		{
			mrtCapabilities = MrtUtils.getCapabilities(_mrt);
		}
		catch (Exception e)
		{
		}
		// Analyze the given manageable resource type for Subscription manager
		// etc.
		// If needed add the extra resource type for Subscription manager
		List inspectors = getAllMrtInspectors();
		for (int i = 0; i < inspectors.size(); i++)
		{
			MrtInspector inspector = (MrtInspector) inspectors.get(i);
			inspector.setMrtParentDirectory(_mrtFile.getParent().getFullPath()
					.toString());
			ResourceTypeType resourceType = inspector.inspect(mrtCapabilities);
			if (resourceType != null)
			{
				if(!hasResourceTypeInDD(resourceType))
				{
					_generatedResourceTypes.add(resourceType);
					InitialInstancesType[] instances = inspector
							.getInitialInstances();
					for (int j = 0; j < instances.length; j++)
						_initialInstancesList.add(instances[j]);
					if(inspector.getExtraGeneratedMrt()!=null)
						_mrtObjectMap.put(inspector.getExtraGeneratedMrtPersistanceLocation(), inspector.getExtraGeneratedMrt());
					_contributedInspectors.add(inspector);
				}
			}
			_allInspectors.add(inspector);
		}
		return (ResourceTypeType[]) _generatedResourceTypes
				.toArray(new ResourceTypeType[_generatedResourceTypes.size()]);
	}

	private List getAllMrtInspectors()
	{
		List inspectors = new ArrayList();
		inspectors.add(new BasicMrtInspector(_mrt, _ddRoot));
		// We don't analyze MRT for SubscriptionManager
		// As it is already handled in MUSE-2.1
		//inspectors.add(new SubscriptionManagerInspector(_ddRoot));
		inspectors.add(new ServiceGroupInspector(_mrt, _ddRoot));
		inspectors.add(new RelationshipInspector(_ddRoot));
		return inspectors;
	}
	
	/**
	 * Returns the initial instances
	 * @return IntialInstancesType[]
	 */
	private InitialInstancesType[] getInitialInstances()
	{
		return (InitialInstancesType[]) _initialInstancesList
				.toArray(new InitialInstancesType[_initialInstancesList.size()]);
	}

	/**
	 * Returns the map.
	 * Key will be the persisted location of MRT and 
	 * value will be the ManageableREsourceType object. 
	 */
	public Map getMrtObjectMap() 
	{
		return _mrtObjectMap;
	}
	
	/**
	 * This method will persist the extra artifacts generated at codegen time.
	 */
	public void persistArtifacts()
	{
		for(int i=0;i<_contributedInspectors.size();i++)
		{
			MrtInspector inspector = (MrtInspector)_contributedInspectors.get(i);
			inspector.persistArtifacts();
		}		
	}
	
	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	public void inspectMetadata(ManageableResourceType mrt, MetadataDescriptor rmd)
	{
		for(Iterator iter = _allInspectors.iterator();iter.hasNext();)
		{
			MrtInspector inspector = (MrtInspector) iter.next();
			inspector.inspectMetadata(mrt, rmd);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.ws.muse.descriptor.InitialInstancesType;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;

/**
 * This interface is created for some cases where we expect some extra resource
 * type to be added to the muse descriptor based on the capability that
 * manageable resource type holds. For example if someone includes the
 * Notification producer capability in his manageable resource type, then muse
 * runtime requires the Subscription Manager as one of the resource type
 * described in muse descriptor file.
 */
public interface MrtInspector
{
	public static String WSDL_NAMESPACE = "http://schemas.xmlsoap.org/wsdl/";

	/**
	 * Analyzes the given manageable resource type capabilities and then returns the muse
	 * resource type for some extra generated artifact else returns the null.
	 */
	ResourceTypeType inspect(Capability[] mrtCapabilities);

	/**
	 * This method should set the parent directory for extra generated artifact. 
	 */
	void setMrtParentDirectory(String mrtParentDir);

	/**
	 * Returns initial instances for extra generated artifact. 
	 */
	InitialInstancesType[] getInitialInstances();
	
	/**
	 * This method will persist the extra artifacts generated at codegen time.
	 */
	void persistArtifacts();
	
	/**
	 * This method will returns the extra ManageableResourceType object generated at codegen time.
	 */
	ManageableResourceType getExtraGeneratedMrt();
	
	/**
	 * This method should return the persistance location for extra generated ManageableResourceType object.
	 */
	String getExtraGeneratedMrtPersistanceLocation();
	
	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	void inspectMetadata(ManageableResourceType mrt, MetadataDescriptor rmd);	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.prefs.Preferences;

import org.apache.muse.tools.generator.analyzer.Analyzer;
import org.apache.muse.tools.generator.projectizer.Projectizer;
import org.apache.muse.tools.generator.synthesizer.Synthesizer;
import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.dialogs.DialogPage;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.Util;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.osgi.util.TextProcessor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.DirectoryDialog;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Text;
import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;
import org.eclipse.tptp.wsdm.tooling.editor.mrt.relationship.dialog.internal.MemoryComboBox;
import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.preferences.internal.Axis2ServerLocationPreferencePage;
import org.eclipse.tptp.wsdm.tooling.util.internal.Validation;
import org.eclipse.tptp.wsdm.tooling.validation.util.internal.ValidationUtils;

/**
 * This wizard enables the use to specify the projectizer options and also the
 * runtime environment and general options
 */
public class GenerationOptionsPage extends WizardPage
{
	private static final String PROJECT_MEMORY_COMBO_ID = "project_memory_combo";
	
	private static final String EXT_PT = "codeGeneration";
	
	private Button _overwriteButton;

	private Combo _projectNameField;

	private String _userPath = Util.ZERO_LENGTH_STRING;// IDEResourceInfoUtils.EMPTY_STRING;

	private Button _useDefaultsButton;

	private Label _locationLabel;

	private Text _locationPathField;

	private Button _browseButton;

	private IProject _existingProject;
	
	private Combo _projectizerCombo;

	private Button _persistExtraArtifactsButton;
			
	private Map _platformContainerMap = new HashMap();

	private Combo _containerCombo;

	private Label _containerLabel;

	private Listener _containerComboListener = new Listener() {

		public void handleEvent(Event event) {
			dialogChanged();
		}
		
	};

	public GenerationOptionsPage() {
		super("wizardPage");
		setTitle(Messages.HOOKUP_WIZARD_TXT1);
		setDescription(Messages.HOOKUP_WIZARD_TXT2);
		
		loadExtensionData();
		setPageComplete(false);
	}
	
	private void loadExtensionData() {
		IExtensionRegistry er = Platform.getExtensionRegistry();
		IExtensionPoint ep = er.getExtensionPoint(Activator.PLUGIN_ID, EXT_PT);
		IExtension[] extensions = ep.getExtensions();

		for (int i = 0; i < extensions.length; i++) {	
			IConfigurationElement[] elements = extensions[i].getConfigurationElements();			
			CodeGenerationData codeGenData = new CodeGenerationData(elements);
			updatePlatformContainerMap(codeGenData);	
		}
	}

	private void updatePlatformContainerMap(CodeGenerationData codeGenData) {
		Map containerCodeGenDataMap = (Map) _platformContainerMap.get(codeGenData.getPlatform());
		if(containerCodeGenDataMap == null) {					
			//
			// handles the case of proxy which doesn't have a container
			//
			if(codeGenData.getContainer() == null) {			
				containerCodeGenDataMap = new SingleValueMap();
			} else {
				containerCodeGenDataMap = new HashMap();
			}
			
			_platformContainerMap.put(codeGenData.getPlatform(), containerCodeGenDataMap);
		}

		//
		// if the platform was null then it means we're using a
		// singlevaluemap which doesn't look at the key ever
		//
		containerCodeGenDataMap.put(codeGenData.getContainer(), codeGenData);
	}

	public void createControl(Composite parent) {
		setControl(doLayout(parent));
	}

	private Composite doLayout(Composite parent) {
		Composite container = new Composite(parent, SWT.NULL);
		container.setLayout(new GridLayout(2, false));	
		
		GridData data = new GridData();
		data.horizontalAlignment = SWT.FILL;
		data.grabExcessHorizontalSpace = true;
		container.setLayoutData(data);
								
		createProjectInput(container);
		
		Composite composite = createProjectTypeGroup(container);
		
		data = new GridData();
		data.grabExcessHorizontalSpace = true;
		data.horizontalAlignment = SWT.FILL;
		data.horizontalSpan = 2;
		composite.setLayoutData(data);
				
		composite = createProjectOptionsGroup(container);
		
		data = new GridData();
		data.grabExcessHorizontalSpace = true;
		data.horizontalAlignment = SWT.FILL;
		data.horizontalSpan = 2;
		composite.setLayoutData(data);
		return container;
	}

	private void createProjectInput(Composite parent) {
		Label projectNameLabel = new Label(parent, SWT.NONE);
		projectNameLabel.setText(Messages.HOOKUP_WIZARD_TXT4);

		GridData data = new GridData();		
		data.horizontalAlignment = SWT.FILL;
		data.grabExcessHorizontalSpace = false;	
		projectNameLabel.setLayoutData(data);
		
		_projectNameField = MemoryComboBox.createMemoryComboBox(parent, Preferences.userNodeForPackage(GenerationOptionsPage.class), PROJECT_MEMORY_COMBO_ID);				
		
		data = new GridData();		
		data.horizontalAlignment = SWT.FILL;
		data.grabExcessHorizontalSpace = true;
		_projectNameField.setLayoutData(data);	
		
		_projectNameField.addListener(SWT.Modify, nameModifyListener);
	}
	
	private Group createProjectTypeGroup(Composite parent) {
		Group page = new Group(parent, SWT.SHADOW_IN);
		page.setText("Code Generation Options");
		page.setLayout(new GridLayout(2, false));

		Label platformLabel = new Label(page, SWT.NONE);
		platformLabel.setText("Platform:");//TODO AME
		_projectizerCombo = makePlatformCombo(page);
		
		_containerLabel = new Label(page, SWT.NONE);
		_containerLabel.setText("Container:");//TODO AME
		_containerLabel.setEnabled(false);
		
		_containerCombo = makeContainerCombo(page);		
		
		return page;
	}

	private Group createProjectOptionsGroup(Composite parent) {
		Group  group = new Group(parent, SWT.SHADOW_IN);
		group.setText("Project Options");
		group.setLayout(new GridLayout(3, false));
		
		_useDefaultsButton = createDefaultsButton(group);
		
		GridData buttonData = new GridData();
		buttonData.horizontalSpan = 3;
		_useDefaultsButton.setLayoutData(buttonData);

		createUserEntryArea(group, true);				
		createCheckboxes(group);	
	
		return group;		
	}

	private Button createDefaultsButton(Composite parent) {
		Button button = new Button(parent, SWT.CHECK | SWT.RIGHT);
		button.setText(Messages.CODE_GEN_DEFAULT_LOCATION);// IDEWorkbenchMessages.ProjectLocationSelectionDialog_useDefaultLabel);
		button.setSelection(true);
		
		button.addSelectionListener(new SelectionAdapter()
		{
			public void widgetSelected(SelectionEvent e)
			{
				boolean useDefaults = _useDefaultsButton.getSelection();

				if (!useDefaults)
				{
					_userPath = _locationPathField.getText();
					_locationPathField.setText(TextProcessor
							.process(getDefaultPathDisplayString()));
				}
				else
				{
					_locationPathField
							.setText(TextProcessor.process(_userPath));
				}
				setUserAreaEnabled(!useDefaults);
			}
		});
		
		return button;
	}

	private void createCheckboxes(Composite parent) {
		GridData data = null;
	
		_overwriteButton = makeButton(parent, Messages.HOOKUP_WIZARD_TXT3, SWT.CHECK);		
		
		data = new GridData();
		data.horizontalSpan = 2;
		_overwriteButton.setLayoutData(data);
		
		_persistExtraArtifactsButton = makeButton(parent, Messages.HOOKUP_WIZARD_PERSIST, SWT.CHECK);
		
		data = new GridData();
		data.horizontalSpan = 2;
		_persistExtraArtifactsButton.setLayoutData(data);
	}

	private Combo makeContainerCombo(Group page) {
		Combo combo = new Combo(page, SWT.BORDER | SWT.READ_ONLY);
		combo.setEnabled(false);	
		
		combo.addListener(SWT.Modify, _containerComboListener);
		return combo;
	}

	private Combo makePlatformCombo(Group page)
	{
		Combo combo = new Combo(page, SWT.BORDER | SWT.READ_ONLY);
		for(Iterator i=_platformContainerMap.keySet().iterator(); i.hasNext();) {
			combo.add(i.next().toString());
		}
		combo.select(0);		
		combo.addListener(SWT.Modify, comboChangeListener);
		
		return combo;
	}

	private void setUserAreaEnabled(boolean enabled)
	{
		_locationLabel.setEnabled(enabled);
		_locationPathField.setEnabled(enabled);
		_browseButton.setEnabled(enabled);
	}

	private void createUserEntryArea(Composite composite, boolean defaultEnabled)
	{
		GridData data = null;
		
		// location label
		_locationLabel = new Label(composite, SWT.NONE);
		_locationLabel.setText(Messages.HOOKUP_WIZARD_TXT6);

		// project location entry field
		_locationPathField = new Text(composite, SWT.BORDER);
		data = new GridData(GridData.FILL_HORIZONTAL);
		_locationPathField.setLayoutData(data);

		// browse button
		_browseButton = new Button(composite, SWT.PUSH);
		_browseButton.setText(Messages.HOOKUP_WIZARD_TXT5);
		_browseButton.addSelectionListener(new SelectionAdapter()
		{
			public void widgetSelected(SelectionEvent event)
			{
				handleLocationBrowseButtonPressed();
			}
		});

		if (defaultEnabled)
		{
			_locationPathField.setText(TextProcessor
					.process(getDefaultPathDisplayString()));
		}
		else
		{
			if (_existingProject == null)
			{
				_locationPathField.setText(Util.ZERO_LENGTH_STRING);// IDEResourceInfoUtils.EMPTY_STRING);
			}
			else
			{
				_locationPathField.setText(TextProcessor
						.process(_existingProject.getLocation().toString()));
			}
		}

		_locationPathField.addModifyListener(new ModifyListener()
		{
			public void modifyText(ModifyEvent e)
			{
				setErrorMessage(checkValidLocation());
			}
		});
		
		setUserAreaEnabled(false);
	}

	public boolean isDefault()
	{
		return _useDefaultsButton.getSelection();
	}

	public String getProjectLocation()
	{
		if(isDefault()) {
			return null;
		}
		
		String projectLocation = _locationPathField.getText();		
		return projectLocation.length() == 0?null:projectLocation;
	}

	public String checkValidLocation()
	{

		if (isDefault())
		{
			return null;
		}

		String newPath = getProjectLocation();
		if (newPath == null)
		{
			return Messages.CODE_GEN_LOCATION_ERROR_;
		}

		if (_existingProject == null)
		{
			IPath projectPath = new Path(newPath);
			if (Platform.getLocation().isPrefixOf(projectPath))
			{
				return Messages.NEW_PROJECT_CREATION_PAGE_DEFAULT_LOCATION_ERROR_;
			}

		}
		else
		{
			
			IStatus locationStatus = _existingProject.getWorkspace()
					.validateProjectLocationURI(_existingProject, URIUtil.toURI(newPath));

			if (!locationStatus.isOK())
			{
				return locationStatus.getMessage();
			}

			java.net.URI projectPath = _existingProject.getLocationURI();
			if (projectPath != null && URIUtil.equals(projectPath, URIUtil.toURI(newPath)))
			{
				return Messages.CODE_GEN_LOCATION_ERROR_;
			}
		}

		return null;
	}

	private String getDefaultPathDisplayString()
	{

		java.net.URI defaultURI = null;
		if (_existingProject != null)
		{
			defaultURI = _existingProject.getLocationURI();
		}

		// Handle files specially. Assume a file if there is no project to query
		if (defaultURI == null || defaultURI.getScheme().equals("file"))
		{
			return Platform.getLocation().append(_projectNameField.getText())
					.toString();
		}
		return defaultURI.toString();

	}

	private String getPathFromLocationField()
	{
		java.net.URI fieldURI;
		try
		{
			fieldURI = new java.net.URI(_locationPathField.getText());
		}
		catch (java.net.URISyntaxException e)
		{
			return _locationPathField.getText();
		}
		return fieldURI.getPath();
	}

	private void updateLocationField(String selectedPath)
	{
		_locationPathField.setText(TextProcessor.process(selectedPath));
	}

	private void handleLocationBrowseButtonPressed()
	{

		String selectedDirectory = null;
		String dirName = getPathFromLocationField();

		DirectoryDialog dialog = new DirectoryDialog(_locationPathField
				.getShell());
		dialog.setMessage(Messages.CODE_GEN_DIR_LOCATION);// IDEWorkbenchMessages.ProjectLocationSelectionDialog_directoryLabel);
		dialog.setFilterPath(dirName);
		selectedDirectory = dialog.open();

		if (selectedDirectory != null)
			updateLocationField(selectedDirectory);
	}

	private Listener nameModifyListener = new Listener()
	{
		public void handleEvent(Event e)
		{
			dialogChanged();
		}
	};

	private Listener comboChangeListener = new Listener() {
		public void handleEvent(Event e) {
			String platform = _projectizerCombo.getText();
			
			Map containerCodeGenDataMap = (Map) _platformContainerMap.get(platform);
			_containerCombo.removeListener(SWT.Modify, _containerComboListener);
			_containerCombo.removeAll();
			
			boolean hasContainers = containerCodeGenDataMap.size() != 0;
			
			if(hasContainers) {
				for(Iterator i=containerCodeGenDataMap.keySet().iterator(); i.hasNext();) {
					_containerCombo.add(i.next().toString());
				}
				_containerCombo.select(0);
			}
			
			_containerCombo.addListener(SWT.Modify, _containerComboListener);
			_containerCombo.setEnabled(hasContainers);
			_containerLabel.setEnabled(hasContainers);

		   	dialogChanged();
		}
	};

	private TargetedFileList[] _filesToCopy;
	
	protected void dialogChanged()
	{
		String prjName = getProjectName();

		if (prjName.length() == 0)
		{
			updateStatus(Messages.HOOKUP_WIZARD_ERROR_1);
			return;
		}

		IWorkspace workspace = ResourcesPlugin.getWorkspace();
		IWorkspaceRoot root = workspace.getRoot();

		IProject project = root.getProject(prjName);

		if (project != null && project.exists())
		{
			updateStatus(Messages.PROJECT_EXISTS_WARN_, DialogPage.WARNING);
			return;
		}

		if (!Validation.isQName(prjName))
		{
			updateStatus(Messages.HOOKUP_WIZARD_ERROR_2);
			return;
		}
		
		updateStatus(null, DialogPage.NONE);
	}

	private void updateStatus(String message)
	{
		updateStatus(message, DialogPage.ERROR);
	}

	private void updateStatus(String message, int type)
	{
		setMessage(message, type);
		setPageComplete(type != DialogPage.ERROR);
	}

	private Button makeButton(Composite parent, String title, int style)
	{
		Button b = new Button(parent, style);
		b.setText(title);
		return b;
	}

	public boolean shouldPersistArtifacts()
	{
		return _persistExtraArtifactsButton.getSelection();
	}

	/**
	 * Return the value of the output project
	 * @return String
	 */
	public String getProjectName()
	{
		return _projectNameField.getText();
	}

	/**
	 * Returns if Overwrite button is enabled
	 * @return boolean
	 */
	public boolean canOverwrite()
	{
		return _overwriteButton.getSelection();
	}
	
	public CodeGenerationData getSelectedData() {
		String platform = _projectizerCombo.getText();
		Map containerCodeGenDataMap = (Map) _platformContainerMap.get(platform);
		String container = _containerCombo.getText();
		return (CodeGenerationData) containerCodeGenDataMap.get(container);
	}

	/**
	 * Return the projectizer
	 * @return {@link Projectizer}
	 */
	public Projectizer getProjectizer()
	{
		return getSelectedData().getProjectizer();
	}

	/**
	 * Return the synthesizer
	 * @return {@link Synthesizer}
	 */
	public Synthesizer getSynthesizer()
	{
		return getSelectedData().getSynthesizer();
	}

	/**
	 * Return the analyzer
	 * @return {@link Analyzer}
	 */
	public Analyzer getAnalyzer()
	{
		return getSelectedData().getAnalyzer();
	}

	/**
	 * Returns the base address
	 * 
	 * @return String
	 */
	public String getBaseAddress()
	{
		String baseAddress = "http://localhost";

		int port = getSelectedData().getServicePort();
		if (port != 0)
		{
			baseAddress += ":" + port;
		}

		baseAddress += "/" + getProjectName();

		String servicePath = getSelectedData().getServicePath();

		if (servicePath != null)
		{
			baseAddress += servicePath;
		}
		
		return baseAddress;
	}

	public boolean canFlipToNextPage() {
		return isPageComplete() && isAxis2Project();
	}
	public boolean isAxis2Project(){
		String container = getSelectedData().getContainer();
		return container != null && container.equals("Axis2");
	}	
	
	public void saveCombo() {
		MemoryComboBox.save(_projectNameField, PROJECT_MEMORY_COMBO_ID, Preferences.userNodeForPackage(GenerationOptionsPage.class));
	}
	
	private String validateLocation()
	{
		String serverHome = getPreferenceServerLocation();
		
		ISoapServerDependency axisValidators[] = ValidationUtils.getAllAxisValidators();
		for(int i = 0 ; i < axisValidators.length ; i++){
			
			ISoapServerDependency axis2Dependency = (Axis2ServerDependency)axisValidators[i];
			String errorMessage = axis2Dependency.validateSoapServerHome(serverHome);
			if(errorMessage!=null)
				return errorMessage;
			_filesToCopy = axis2Dependency.getFilesToCopy();
			if(_filesToCopy == null)
				_filesToCopy = new TargetedFileList[0];
		}
		return null;		
	}
	
	/**
	 * Returns the Axis2 files to copied to generated code
	 * @return
	 */
	public TargetedFileList[] getAxis2FilesToCopy()
	{
		validateLocation();
		return _filesToCopy;
	}
	
	protected String getPreferenceServerLocation() 
	{
		IPreferenceStore store = Activator.getPlugin().getPreferenceStore();
		String location = store.getString(Axis2ServerLocationPreferencePage.SERVER_LOCATION_PREFERENCE_KEY).trim();
		if(location != null && !location.equals(""))
			return location;
		return "";
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.io.File;
import java.io.FileFilter;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.osgi.util.NLS;
import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;

/**
 * This class verifies the Axis2 Soap Library dependency. 
 */

public class Axis2ServerDependency extends SoapServerDependency implements ISoapServerDependency
{
	private List _filesToCopy = new LinkedList();
	
	/**
	 * @see ISoapServerDependency#validateSoapServerHome(String)
	 */
	public String validateSoapServerHome(String serverHome)
	{
		if(serverHome == null || serverHome.length() == 0)
			return Messages.CODE_GEN_AXIS2_PROJECT_DIR;
		
		File serverHomeDir = new File(serverHome);
		if(!serverHomeDir.exists()){
			return NLS.bind(Messages.CODE_GEN_AXIS2_LOCATION_ERROR_, serverHome);
		}
		
		TargetedFileList _jarFilesToCopy = new TargetedFileList("WEB-INF/lib/");
		TargetedFileList _marFilesToCopy = new TargetedFileList("WEB-INF/modules/");
		TargetedFileList _restFilesToCopy = new TargetedFileList("WEB-INF/");
		
		String[] relativeFilePaths = (String[]) _requiredFiles.toArray(new String[_requiredFiles.size()]);
		for(int i=0;i<relativeFilePaths.length;i++)
		{
			String parentDirectory = getParentDirectory(relativeFilePaths[i]);
			if(parentDirectory == null)
				parentDirectory = serverHome;
			else
				parentDirectory = serverHome+File.separatorChar+parentDirectory;
			
			String fileExtension = getFileExtension(relativeFilePaths[i]);
			if(fileExtension == null)
				fileExtension = "*";
			FileFilter filter = new CustomFileFilter(fileExtension);
			
			File parentDirectoryFile = new File(parentDirectory);
			if(!parentDirectoryFile.exists())
				return NLS.bind(Messages.CODE_GEN_AXIS2_LOCATION_ERROR_, parentDirectory);
			
			File[] allFiles = parentDirectoryFile.listFiles(filter);
			String fileName = getFileName(relativeFilePaths[i]);
			File matchedFile = getMatchedPatternFile(allFiles, fileName);
			if(matchedFile == null)
				return NLS.bind(Messages.CODE_GEN_ERROR_INVALID_AXIS_FILE, serverHome+File.separatorChar+relativeFilePaths[i]);
						
			String absolutePath = matchedFile.getAbsolutePath();
			if(absolutePath.endsWith("jar"))
				_jarFilesToCopy.add(absolutePath);
			else if(absolutePath.endsWith("mar"))
				_marFilesToCopy.add(absolutePath);
			else
				_restFilesToCopy.add(absolutePath);
		}
		
		_filesToCopy.add(_jarFilesToCopy);
		_filesToCopy.add(_marFilesToCopy);
		_filesToCopy.add(_restFilesToCopy);
		
		return null;
	}
	
	private String getParentDirectory(String relativePath)
	{
		if(relativePath.indexOf('/')==-1)
			return null;
		return relativePath.substring(0,relativePath.lastIndexOf('/'));		
	}
	
	private String getFileExtension(String relativePath)
	{
		if(relativePath.indexOf('.')==-1)
			return null;
		return relativePath.substring(relativePath.lastIndexOf('.')+1);
	}
	
	private String getFileName(String relativePath)
	{
		if(relativePath.indexOf('/')==-1)
		{
			if(relativePath.indexOf('.')==-1)
				return relativePath;
			else
				return relativePath.substring(0,relativePath.lastIndexOf('.'));
		}
		else
		{
			String fileNameWithExtn = relativePath.substring(relativePath.lastIndexOf('/')+1);
			if(fileNameWithExtn.indexOf('.')==-1)
				return fileNameWithExtn;
			else
				return fileNameWithExtn.substring(0,fileNameWithExtn.lastIndexOf('.'));
		}
	}
	
	private File getMatchedPatternFile(File[] allFiles, String pattern)
	{
		String strippedPattern = pattern.indexOf("-*")==-1?pattern:pattern.substring(0,pattern.lastIndexOf("-*"));
		for(int i=0;i<allFiles.length;i++)
		{
			if(allFiles[i].getName().startsWith(strippedPattern))
				return allFiles[i];
		}
		return null;
	}

	/**
	 * @see ISoapServerDependency#getFilesToCopy()
	 */
	public TargetedFileList[] getFilesToCopy()
	{
		return (TargetedFileList[])_filesToCopy.toArray(new TargetedFileList[_filesToCopy.size()]);
	}	
}

class CustomFileFilter implements FileFilter
{
	String fileExtension;
	
	CustomFileFilter(String extension)
	{
		fileExtension = extension;
	}
	
	public boolean accept(File pathname) 
	{
		if(!pathname.isFile())
			return false;
		if(fileExtension.equals("*"))
			return true;
		return pathname.getName().endsWith(fileExtension);		
 	}	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

public class EclipseConfigurationData
{
	public static final String ADDITIONAL_JARS = "jars";
	public static final String INSTANCES = "instances";
	public static final String PROGRESS_MONITOR = "progress_monitor";
	public static final String AXIS2_FILES = "axis2_files";
	public static final String PROJECT_LOCATION = "location";
	public static final String PROJECT_NAME = "project_name";
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.ws.muse.descriptor.DescriptorFactory;
import org.apache.ws.muse.descriptor.DocumentRoot;
import org.apache.ws.muse.descriptor.ResourceTypeType;
import org.apache.ws.muse.descriptor.WsdlType;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.tptp.wsdm.tooling.editor.dde.util.internal.DdeUtil;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.MyDescriptorResourceFactoryImpl;

/**
 * This class acts as a way during the Code Generation of MRT to capture doing WSDL 
 * resolution so that it can be done later on, or on
 * another thread since this would be time-consuming.
 */
public class MRTCodeGenerationDelegate implements CodeGenerationDelegate
{
	private ManageableResourceType _mrt;
	private MrtPreProcessor _mrtPreProcessor;
	private String _ddFilePath;
	private IFile _mrtFile;
	private DocumentRoot _ddRoot;
	
	/**
	 * Constructor of the class
	 * @param mrtFile
	 */
	public MRTCodeGenerationDelegate(IFile mrtFile)
	{
		_mrtFile = mrtFile;
		URI mrtURI = URI.createPlatformResourceURI(mrtFile.getFullPath()
				.toString());
		_mrt = MrtUtils.loadMRT(mrtURI);
		_mrtPreProcessor = new MrtPreProcessor(_mrt);
	}

	/**
	 * Creates the DD file. 
	 * The method returns a DescriptorHelper which
	 * aggregates all of the work that was done.
	 * 
	 * @param progressMonitor 	A progress monitor to 
	 * 							show the progress done during this 
	 * 							task. 
	 * @throws Exception
	 */
	public DescriptorHelper run(SubProgressMonitor progressMonitor)
			throws Exception
	{
		byte[] serializedDD = createDD();
		Map mrtObjectMap = _mrtPreProcessor.getMrtObjectMap();
		return new DescriptorHelper(this, new ByteArrayInputStream(serializedDD), mrtObjectMap, false);
	}
	
	private byte[] createDD()
	{
		_mrtPreProcessor.preProcess();
		_ddRoot = _mrtPreProcessor.getDDDocumentRoot();
		ResourceSet resourceSet = new ResourceSetImpl();
		resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap()
		.put(Resource.Factory.Registry.DEFAULT_EXTENSION,
				new MyDescriptorResourceFactoryImpl());
		URI uri = URI.createURI("dummy.xml");
		Resource resource = resourceSet.createResource(uri);
		resource.getContents().add(_ddRoot);
		Map map = new HashMap();
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		try 
		{
			resource.save(baos, map);
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		}
		return baos.toByteArray();
	}
	
	private String createDDFilePath()
	{
		IPath ddIPath = _mrtFile.getFullPath().removeFileExtension()
				.addFileExtension("dd");
		return ddIPath.toString();
	}

	/**
	 * Create and return a new instance of given ResourceTypeType. Only
	 * ContextPath, JavaIdFactoryClass, JavaResourceClass and WsdlType fields
	 * have been copied.
	 */
	public static ResourceTypeType cloneResourceType(ResourceTypeType rt)
	{
		ResourceTypeType clone = DescriptorFactory.eINSTANCE
				.createResourceTypeType();
		clone.setContextPath(rt.getContextPath());
		clone.setJavaIdFactoryClass(rt.getJavaIdFactoryClass());
		clone.setJavaResourceClass(rt.getJavaResourceClass());
		WsdlType wClone = DescriptorFactory.eINSTANCE.createWsdlType();
		wClone.setWsdlFile(rt.getWsdl().getWsdlFile());
		wClone.setWsdlPortType(rt.getWsdl().getWsdlPortType());
		clone.setWsdl(wClone);
		return clone;
	}

	/**
	 * This method will persist the extra artifacts generated at codegen time.
	 */
	public void persistArtifacts() 
	{
		_mrtPreProcessor.persistArtifacts();
		persistDDFile();		
	}
	
	private void persistDDFile()
	{
		_ddFilePath = createDDFilePath();
		DdeUtil.serializeDescriptorRoot(_ddRoot, URI.createPlatformResourceURI(_ddFilePath));
	}

	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	public void inspectMetadata(ManageableResourceType mrt,
			MetadataDescriptor metadata) 
	{
		_mrtPreProcessor.inspectMetadata(mrt, metadata);		
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.io.File;
import java.lang.reflect.InvocationTargetException;

import org.apache.muse.tools.generator.analyzer.Analyzer;
import org.apache.muse.tools.generator.analyzer.SimpleAnalyzer;
import org.apache.muse.tools.generator.projectizer.Projectizer;
import org.apache.muse.tools.generator.synthesizer.ServerSynthesizer;
import org.apache.muse.tools.generator.synthesizer.Synthesizer;
import org.apache.muse.tools.generator.util.ConfigurationData;
import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.ILog;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.swt.graphics.Image;
import org.eclipse.tptp.wsdm.tooling.editor.internal.Activator;
import org.eclipse.tptp.wsdm.tooling.nls.messages.mrt.internal.Messages;
import org.eclipse.tptp.wsdm.tooling.preferences.internal.Axis2ServerLocationPreferencePage;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.eclipse.ui.INewWizard;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;
import org.w3c.dom.Document;

/**
 * This wizard accepts projectizer parameters, runtime environment and other
 * general parameters from the user so as to invoke Wsdl2Java
 */
public class NewProjectWizard extends Wizard implements INewWizard {

	private static ILog LOG = null;

	// We can't use internal classes, hence using view ID directly
	private static String TASK_VIEW_ID = "org.eclipse.ui.views.TaskList";

	private static String PLUGIN_ID = "org.eclipse.tptp.wsdm.tooling.editor.mrt";

	private GenerationOptionsPage _generationOptionsPage;

	private String _projectName;

	private boolean _overwrite;

	private boolean _shouldPersistArtifacts;

	private Projectizer _projectizer;

	private Synthesizer _synthesizer;

	private Analyzer _analyzer;

	private String _baseAddress;

	private CodeGenerationDelegate _codeGenerationDelegate;

	private Document[] _mergedWsdlDocuments;

	private MetadataDescriptor[] _mergedRMDs;

	private DescriptorHelper _helper;

	private String _serverLocation;

	private boolean _isAxis2Project;
	private boolean updatePreference;

	private String _projectLocation;

	private TargetedFileList[] _requiredAxis2Files;

	private boolean _licenseAccepted = false;

	/**
	 * Class that creates the Code Generation Wizard to create new Project
	 * 
	 * @param codeGenerationDelegate
	 */
	public NewProjectWizard(CodeGenerationDelegate codeGenerationDelegate) {
		setWindowTitle(Messages.HOOKUP_WIZARD_TXT7);
		setNeedsProgressMonitor(true);

		_codeGenerationDelegate = codeGenerationDelegate;
	}

	public void addPages() {
		_generationOptionsPage = new GenerationOptionsPage();
		addPage(_generationOptionsPage);

		// TODO AME why is this hardcoded here? why is it getting reloaded?
		Image imgTP = EclipseUtils.loadImage(PlatformUI.getWorkbench().getDisplay(),
				"icons/wizban/newEndpointProject_wiz.gif");
		ImageDescriptor imgDescrTP = ExtendedImageRegistry.INSTANCE.getImageDescriptor(imgTP);
		setDefaultPageImageDescriptor(imgDescrTP);
	}

	private void popupAxis2LicenseDialog() {
		IPreferenceStore store = Activator.getPlugin().getPreferenceStore();
		String preferencesLocation = store.getString(Axis2ServerLocationPreferencePage.SERVER_LOCATION_PREFERENCE_KEY);
		if (!_serverLocation.equals(preferencesLocation)) {
			int result = new Axis2LicenseDialog().showWindow();
			_licenseAccepted = (result == Axis2LicenseDialog.AGREE);
		} else
			_licenseAccepted = true;

	}

	private void performFinish(IProgressMonitor monitor) throws InvocationTargetException {
		try {
			monitor.beginTask(Messages.CODE_GEN_START, 7);

			if (_isAxis2Project) {
				try {
					// Step 1: Validate the server path
					monitor.subTask(Messages.CODE_GEN_VALIDATE_SLOCATION);
					// Step 2 : Update the Preferences, if needed
					if (updatePreference) {
						IPreferenceStore store = Activator.getPlugin().getPreferenceStore();
						store.setValue(Axis2ServerLocationPreferencePage.SERVER_LOCATION_PREFERENCE_KEY,
								_serverLocation);
						// Update the Lib and module location
					}
					_requiredAxis2Files = _generationOptionsPage.getAxis2FilesToCopy();
				} catch (Exception e) {
					throw new RuntimeException(e);
				}
			}
			try {
				monitor.subTask(Messages.CODE_GEN_STEP1);
				_helper = _codeGenerationDelegate.run(new SubProgressMonitor(monitor, 1));

				monitor.worked(1);
			} catch (Exception e) {
				throw new RuntimeException(e);
				// TODO AME Why is this not defined?
				// throw new InvocationTargetException(new
				// Exception(Messages.HOOKUP_WIZARD_ERROR4, e));
			}

			try {
				monitor.subTask(Messages.CODE_GEN_STEP2);
				_mergedWsdlDocuments = _helper.getWsdlDocuments(_baseAddress);
				_mergedRMDs = _helper.getMergedRMDs();
				monitor.worked(1);
			} catch (Exception e) {
				e.printStackTrace();
				throw new RuntimeException(e);
			}

			try {
				monitor.subTask(Messages.CODE_GEN_STEP3);
				runProjectizer(monitor);
				monitor.worked(1);
			} catch (Exception e) {
				throw new InvocationTargetException(new Exception(Messages.CODE_GEN_FAILED_ERROR_, e));
			}

			if (_shouldPersistArtifacts) {
				monitor.subTask(Messages.CODE_GEN_STEP4);
				_codeGenerationDelegate.persistArtifacts();
				monitor.worked(1);
			}
		} finally {
			monitor.done();
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.wizard.Wizard#performFinish()
	 */
	public boolean performFinish() {
		_projectizer = _generationOptionsPage.getProjectizer();
		_synthesizer = _generationOptionsPage.getSynthesizer();
		_analyzer = _generationOptionsPage.getAnalyzer();
		_overwrite = _generationOptionsPage.canOverwrite();
		_shouldPersistArtifacts = _generationOptionsPage.shouldPersistArtifacts();
		_projectName = _generationOptionsPage.getProjectName();
		_baseAddress = _generationOptionsPage.getBaseAddress();
		_isAxis2Project = _generationOptionsPage.isAxis2Project();
		_projectName = _generationOptionsPage.getProjectName();
		_projectLocation = _generationOptionsPage.getProjectLocation();

		if (_isAxis2Project) {
			_serverLocation = _generationOptionsPage.getPreferenceServerLocation();
		}

		IRunnableWithProgress runnable = new IRunnableWithProgress() {
			public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
				performFinish(monitor);
			}
		};
		
		_generationOptionsPage.saveCombo();

		try {
			getContainer().run(true, false, runnable);
			openTasksView();
			
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			handle(Messages.CODE_GEN_FAILED_ERROR_, e);
		}

		return false;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.IWorkbenchWizard#init(org.eclipse.ui.IWorkbench,
	 *      org.eclipse.jface.viewers.IStructuredSelection)
	 */
	public void init(IWorkbench workbench, IStructuredSelection selection) {
		// do nothing
	}

	private void runProjectizer(IProgressMonitor monitor) throws Exception {
		ConfigurationData data = new ConfigurationData();

		data.addParameter(EclipseConfigurationData.AXIS2_FILES, _requiredAxis2Files);

		data.addParameter(ConfigurationData.DESCRIPTOR_DOCUMENT, _helper.getDescriptorDocument());
		data.addParameter(EclipseConfigurationData.ADDITIONAL_JARS, _helper.getJarFiles());
		data.addParameter(EclipseConfigurationData.INSTANCES, _helper.getInstances());
		data.addParameter(EclipseConfigurationData.PROJECT_NAME, _projectName);
		data.addParameter(ConfigurationData.OVERWRITE, Boolean.valueOf(_overwrite));
		data.addParameter(EclipseConfigurationData.PROJECT_LOCATION, _projectLocation);
		data.addParameter(ConfigurationData.WSDL_DOCUMENT_LIST, _mergedWsdlDocuments);
		data.addParameter(ConfigurationData.METADATA_DESCRIPTOR_LIST, _mergedRMDs);
		data.addParameter(ConfigurationData.GENERATE_CUSTOM_HEADERS, Boolean.FALSE);

		// check if the analyzer is null, if it is then default to the
		// SimpleAnalyzer
		if (_analyzer == null) {
			_analyzer = new SimpleAnalyzer();
		}

		// check if the synthesizer is null, if it is then default to the
		// ServerSynthesizer
		if (_synthesizer == null) {
			_synthesizer = new ServerSynthesizer();
		}

		// Below, we make a new SubProgressMonitor for
		// each codegeneration component since we can't reuse the progress
		// monitor

		data.addParameter(EclipseConfigurationData.PROGRESS_MONITOR, new SubProgressMonitor(monitor, 1));

		monitor.subTask(Messages.CODE_GEN_SUBTASK1);
		data = _analyzer.analyze(data);
		monitor.worked(1);

		data.addParameter(EclipseConfigurationData.PROGRESS_MONITOR, new SubProgressMonitor(monitor, 1));

		monitor.subTask(Messages.CODE_GEN_SUBTASK2);
		data = _synthesizer.synthesize(data);
		monitor.worked(1);

		data.addParameter(EclipseConfigurationData.PROGRESS_MONITOR, new SubProgressMonitor(monitor, 1));

		monitor.subTask(Messages.CODE_GEN_SUBTASK3);
		_projectizer.projectize(data);
		monitor.worked(1);
	}

	private void handle(String message, Exception e) {
		_generationOptionsPage.setErrorMessage(message);
		WsdmToolingLog.log(IStatus.ERROR, IStatus.OK, message, e);
	}
	
	private void openTasksView() {
		IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
		ViewPart view = (ViewPart) page.findView(TASK_VIEW_ID);

		// If the page isn't showing then show it
		if (view == null) {
			try {
				page.showView(TASK_VIEW_ID);
			} catch (PartInitException e) {
				WsdmToolingLog.logError(e.getMessage(), e);
			}
		}else{
			page.activate(view);
		}
	}
	
	public boolean canFinish() {
		return _generationOptionsPage.isPageComplete();
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import org.eclipse.core.runtime.IExecutableExtension;

/**
 * Interface to represent Soap Library dependency used in Tooling codegeneration. 
 */

public interface ISoapServerDependency extends IExecutableExtension
{
	/**
	 * Returns null if the given Server Home has all the required soap jar files.
	 */
	String validateSoapServerHome(String serverHome);
	
	/**
	 * Returns the absolute path of all the required soap jar files. 
	 */
	TargetedFileList[] getFilesToCopy();
	
	/**
	 * Returns the absolute path of the lib folder. 
	 */
//	String getServerLibLocation(String serverName);
	
	/**
	 * Returns the absolute path of the modules folder. 
	 */
//	String getServerModulesLocation(String serverName);

	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;

/**
 * This class acts as a way to capture doing WSDL resolution (which could
 * include WSDL manipulation like merging) so that it can be done later on, or
 * on another thread since this would be time-consuming.
 */
public interface CodeGenerationDelegate
{

	/**
	 * Do any work related to code generation. This kind of work is passed to
	 * this delegate so that it can be run in a separate thread. This can take a
	 * (optional) progress monitor which can be used to report progress done in
	 * this task. The method returns a DescriptorHelper which aggregates all of
	 * the work that was done.
	 * 
	 * @param progressMonitor
	 *            A progress monitor to show the progress done during this task.
	 * 
	 * @throws Exception
	 */
	DescriptorHelper run(SubProgressMonitor progressMonitor) throws Exception;
	
	/**
	 * Persist the extra artifacts generated during codegeneration such as SubscriptionManager.mrt etc.
	 */
	void persistArtifacts();
	
	/**
	 * Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
	 * merged RMD document for it by having the rules/relationships in it. 
	 */
	void inspectMetadata(ManageableResourceType mrt, MetadataDescriptor metadata);
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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
 * $Id: CodeGenerationData.java,v 1.2 2007/05/07 09:15:10 dnsmith Exp $
 * 
 * Contributors:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import org.apache.muse.tools.generator.analyzer.Analyzer;
import org.apache.muse.tools.generator.projectizer.Projectizer;
import org.apache.muse.tools.generator.synthesizer.Synthesizer;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;

class CodeGenerationData {				
	private Analyzer _analyzer;
	private Synthesizer _synthesizer;
	private Projectizer _projectizer;
	
	private int _servicePort;
	private String _servicePath;
	private String _container;
	private String _platform;
	
	public CodeGenerationData(IConfigurationElement[] elements) {
		for (int i = 0; i < elements.length; i++)
		{
			String name = elements[i].getName();
						
			if(name.equals("description")) {
				extractDescription(elements[i]);
			} else if (name.equals("projectizer")) {
				extractProjectizer(elements[i]);
			} else if (name.equals("synthesizer")) {
				extractSynthesizer(elements[i]);
			} else if (name.equals("analyzer")) {
				extractAnalyzer(elements[i]);
			}
		}
	}
	
	private void extractDescription(IConfigurationElement configurationElement) {
		_container = configurationElement.getAttribute("container");
		_platform = configurationElement.getAttribute("platform");
	}
	
	private void extractProjectizer(IConfigurationElement configurationElement) {
		String port = configurationElement.getAttribute("servicePort");
		if(port != null && port.length() != 0) {
			_servicePort = Integer.parseInt(port);
		}
		_servicePath = configurationElement.getAttribute("servicePath");
		_projectizer = (Projectizer) createExecutable(configurationElement);
	}
	
	private void extractSynthesizer(IConfigurationElement configurationElement) {
		_synthesizer = (Synthesizer) createExecutable(configurationElement);			
	}
	
	private void extractAnalyzer(IConfigurationElement configurationElement) {
		_analyzer = (Analyzer) createExecutable(configurationElement);
	}	
	
	private Object createExecutable(IConfigurationElement configurationElement) {
		try {
			return configurationElement.createExecutableExtension("class");
		} catch (CoreException e) {
			throw new RuntimeException(configurationElement.getAttribute("class"));
		}
	}
	
	public Analyzer getAnalyzer() {
		return _analyzer;
	}

	public Synthesizer getSynthesizer() {
		return _synthesizer;
	}

	public Projectizer getProjectizer() {
		return _projectizer;
	}

	public int getServicePort() {
		return _servicePort;
	}

	public String getServicePath() {
		return _servicePath;
	}

	public String getContainer() {
		return _container;
	}

	public String getPlatform() {
		return _platform;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Andrew Eberbach (aeberbac@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import javax.xml.namespace.QName;

import org.apache.muse.core.descriptor.DescriptorConstants;
import org.apache.muse.util.xml.XmlUtils;
import org.apache.muse.ws.addressing.WsaConstants;
import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.util.URI;
import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

/**
 * A class that takes some of the pain out of working with the deployment
 * descriptor. Note, there's no EMF in this approach, just plain old XML.
 */
public class DescriptorHelper
{

	/**
	 * File Extension of MRT files
	 */
	private static final String MRT_EXTN = ".mrt";

	/**
	 * Element name constants
	 */
	public static final QName ADDITIONAL_JARS_QNAME = new QName(
			DescriptorConstants.NAMESPACE_URI, "additional-jars");
	public static final QName JAR_PATH_QNAME = new QName(
			DescriptorConstants.NAMESPACE_URI, "jar-path");
	public static final QName INITIAL_INSTANCES_QNAME = new QName(
			DescriptorConstants.NAMESPACE_URI, "initial-instances");
	public static final QName REFERENCE_PARAMETERS_QNAME = new QName(
			DescriptorConstants.NAMESPACE_URI, "referenceParameters");

	/**
	 * Constant for empty files
	 */
	private static final File[] EMPTY_FILES = new File[0];

	/**
	 * Constant for empty instances.
	 */
	private static final Object[][] EMPTY_INSTANCES = new Object[0][0];

	/**
	 * Constant for the xmlns prefix on namespace binding declarations
	 */
	private static final Object XMLNS_PREFIX = "xmlns";

	/**
	 * The descriptor document we pull out of the <code>Root</code> element
	 */
	private Document _descriptorDocument;

	/**
	 * A list of jar files that we pull out of the
	 * <code>Root/additional-jars</code> element
	 */
	private File[] _jarFiles;

	/**
	 * A list of instances which is really just a n by 2 list of arrays. The
	 * sub-arrays have the instance-path (<code>String</code>) as the first
	 * element and the reference parameters (<code>Element</code>) as the
	 * second element. This is tacky, but otherwise I'd be making a pretty
	 * useless "Pair" class.
	 */
	private Object[][] _instances;
	
	private IFile ddIFile;
	
	/**
	 * Descriptor file stores the MRT file reference in Wsdl-File element.
	 * When we do the codegeneration we generate some extra MRTs such as SubscriptionManager,
	 * so we pass the map of these MRTs to this class.
	 * Key will be the persisted location of MRT and value will be the ManageableREsourceType object.
	 */
	private Map _mrtObjectMap = new HashMap();
	
	private CodeGenerationDelegate _codeGenerationDelegate = null;

	/**
	 * A do-something constructor. Take a file, if that file is null, then load
	 * up a default template. Otherwise load up the file and pull out the
	 * instances, descriptor and additional jars. For the null file case, there
	 * will be no instances of additional-jars, hence the constants defined
	 * above.
	 * 
	 * @param file - The file to analyze, can be null.
	 * @throws Exception - If anything goes wrong.
	 */
	public DescriptorHelper(CodeGenerationDelegate codeGenerationDelegate, IFile descriptorFile) throws Exception
	{
		this(codeGenerationDelegate, new File(descriptorFile.getLocation().toString()));
		ddIFile = descriptorFile;		
	}

	/**
	 * A do-something constructor. Take a file, if that file is null, then load
	 * up a default template. Otherwise load up the file and pull out the
	 * instances, descriptor and additional jars. For the null file case, there
	 * will be no instances of additional-jars, hence the constants defined
	 * above.
	 * 
	 * @param file - The file to analyze, can be null.
	 * @throws Exception - If anything goes wrong.
	 */
	public DescriptorHelper(CodeGenerationDelegate codeGenerationDelegate, File file) throws Exception
	{
		this(codeGenerationDelegate, new FileInputStream(file), null);
	}
	
	/**
	 * A do-something constructor. Take a inputstream, if that inputstream is null, then load
	 * up a default template. Otherwise load up the inputstream and pull out the
	 * instances, descriptor and additional jars. For the null inputstream case, there
	 * will be no instances of additional-jars, hence the constants defined
	 * above.
	 * 
	 * @param inputstream - The inputstream to analyze, can be null.
	 * @param mrtObjectMap - The map of MRTLocation-MRTObject pair, can be null.
	 * @throws Exception - If anything goes wrong.
	 */
	public DescriptorHelper(CodeGenerationDelegate codeGenerationDelegate, InputStream inputStream, Map mrtObjectMap, boolean extractExtraInfo) throws Exception
	{
		if(mrtObjectMap!=null)
			_mrtObjectMap = mrtObjectMap;
		_codeGenerationDelegate = codeGenerationDelegate;
		
		Document rootDocument = XmlUtils.createDocument(inputStream);

		_descriptorDocument = extractDescriptorDocument(rootDocument);
		
		if(extractExtraInfo) {
			_instances = extractInstances(rootDocument);
			_jarFiles = extractJarFiles(rootDocument);
		} else {
			_instances = null;
			_jarFiles = null;
		}
		// Add Muse tools.jar
		if(_jarFiles == null)
			_jarFiles = new File[0];
		String toolsJarLocation = getMuseToolsJarLocation();
		if(toolsJarLocation == null)
			return;
		List jars = Arrays.asList(_jarFiles);
		List allJars = new ArrayList();
		allJars.addAll(jars);		
		allJars.add(new File(toolsJarLocation));
		_jarFiles = (File[])allJars.toArray(new File[allJars.size()]);		
	}
	
	public DescriptorHelper(CodeGenerationDelegate codeGenerationDelegate, InputStream inputStream, Map mrtObjectMap) throws Exception {
		this(codeGenerationDelegate, inputStream, mrtObjectMap, true);
	}

	/**
	 * Extract the instances from the initial-instances element.
	 * 
	 * TODO this needs to be updated when the initial instances element actually
	 * works.
	 * 
	 * @param rootDocument
	 * @return
	 */
	private Object[][] extractInstances(Document rootDocument)
	{
		Element[] initialInstancesElements = XmlUtils.findInSubTree(
				rootDocument.getDocumentElement(), INITIAL_INSTANCES_QNAME);
		if (initialInstancesElements.length == 0)
		{
			return EMPTY_INSTANCES;
		}

		// sorry about this, maybe someday java will have a Pair type
		Object[][] instances = new Object[initialInstancesElements.length][2];

		for (int i = 0; i < initialInstancesElements.length; i++)
		{
			Element contextElement = XmlUtils.findFirstInSubTree(
					initialInstancesElements[i],
					DescriptorConstants.CONTEXT_PATH_QNAME);
			instances[i][0] = XmlUtils.extractText(contextElement);
			Element instancesElement = XmlUtils.findFirstInSubTree(
					initialInstancesElements[i], REFERENCE_PARAMETERS_QNAME);
			
			Element referenceParametersElement = XmlUtils.createElement(WsaConstants.PARAMETERS_QNAME);
			
			Element[] referenceParameters = XmlUtils.getAllElements(instancesElement);
			Document owner = referenceParametersElement.getOwnerDocument();
			for(int j=0; j < referenceParameters.length; j++) {
				referenceParametersElement.appendChild(owner.importNode(referenceParameters[j], true));
			}
			instances[i][1] = referenceParametersElement;	
		}

		return instances;
	}

	/**
	 * Extract the jars from the additional jars element. Just read through each
	 * element, take the text content (which should be an absolute path) and put
	 * it into a <code>File</code> object. Returns a list of these
	 * <code>File</code>s.
	 * 
	 * @param rootDocument
	 *            The <code>Root</code> element-containing
	 *            <code>Document</code>
	 * 
	 * @return A list of <code>File</code>s for each path found under
	 *         additional-jars
	 */
	private File[] extractJarFiles(Document rootDocument)
	{
		Element additionalJarsElement = XmlUtils.findFirstInSubTree(
				rootDocument.getDocumentElement(), ADDITIONAL_JARS_QNAME);
		if (additionalJarsElement == null)
		{
			return EMPTY_FILES;
		}

		Element[] jarPaths = XmlUtils.findInSubTree(additionalJarsElement,
				JAR_PATH_QNAME);
		if (jarPaths.length == 0)
		{
			return EMPTY_FILES;
		}

		File[] files = new File[jarPaths.length];

		for (int i = 0; i < jarPaths.length; i++)
		{
			files[i] = new File(XmlUtils.extractText(jarPaths[i]));
		}		
		return files;
	}
	
	private String getMuseToolsJarLocation()
	{
		URL url = FileLocator.find(org.apache.muse.tools.Activator.getDefault().getBundle(), new Path("runtime/tools.jar"), null);
		try 
		{
			url = FileLocator.resolve(url);			
			return url.getFile();
		}
		catch (IOException ioe)
		{
			WsdmToolingLog.logError(ioe.getMessage(), ioe);
		}
		return null;
	}

	/**
	 * Get the Muse descriptor out of the document. Just looks for the
	 * <code>DescriptorConstants.MUSE_QNAME</code> QName.
	 * 
	 * @param rootDocument
	 *            The <code>Root</code> element-containing
	 *            <code>Document</code>
	 * @return The new <code>Document</code> that has as its document element
	 *         the muse descriptor
	 */
	private Document extractDescriptorDocument(Document rootDocument)
	{
		Element museElement = XmlUtils.findFirstInSubTree(rootDocument
				.getDocumentElement(), DescriptorConstants.MUSE_QNAME);
		Document descriptorDocument = XmlUtils.createDocument();
		descriptorDocument.appendChild(descriptorDocument.importNode(
				museElement, true));

		copyNamespacePrefixes(rootDocument.getDocumentElement(),
				descriptorDocument.getDocumentElement());
		
		museElement = XmlUtils.getElement(descriptorDocument,DescriptorConstants.MUSE_QNAME);
		adjustCustomSerializers(museElement);

		return descriptorDocument;
	}

	/**
	 * Given a source <code>Element</code> and a destination
	 * <code>Element</code> copy all of the namespace prefixese from the
	 * source to the destination. This is really horrid because of DOM's API
	 * being what it is and we treat the declarations as attributes. Yes, we do
	 * check to make sure we don't do double prefix declarations.
	 * 
	 * TODO this should go into a namespace utility class, I've had to write
	 * this in about 3 places now.
	 * 
	 * @param source
	 *            The source <code>Element</code>
	 * @param destination
	 *            The destination <code>Element</code>
	 */
	private void copyNamespacePrefixes(Element source, Element destination)
	{
		NamedNodeMap attributes = source.getAttributes();
		int size = attributes.getLength();
		for (int i = 0; i < size; i++)
		{
			Node nextAttribute = attributes.item(i);
			String prefix = nextAttribute.getPrefix();

			if (prefix == null || !prefix.equals(XMLNS_PREFIX))
			{
				continue;
			}

			if (destination.hasAttribute(nextAttribute.getNodeName()))
			{
				continue;
			}

			destination.setAttribute(nextAttribute.getNodeName(), nextAttribute
					.getNodeValue());
		}
	}
	
	/**
	 * Descriptor editor stores the xsd-serializer-type for custom-serializer as
	 * 
	 * <custom-serializer>
	 * 		<xsd-serializer-type>{http://www.eclipse.org/TP}StateType</xsd-serializer-type>
	 * <custom-serializer>
	 * 
	 * We have to convert the QName to prefix:localpart format so we adjust this part as
	 * 
	 * <custom-serializer>
	 * 		<xsd-serializer-type xmlns:pfx="http://www.eclipse.org/TP">pfx:StateType</xsd-serializer-type>
	 * <custom-serializer>
	 *   
	 */
	private void adjustCustomSerializers(Element museElement)
	{
		Element[] serializerElements = XmlUtils.getElements(museElement, DescriptorConstants.CUSTOM_SERIALIZER_QNAME);
		for(int i=0;i<serializerElements.length;i++)
		{
			// TODO Replace the QName with MUSE constant in MUSE 2.2
			Element xsdSerializerElement = XmlUtils.getElement(serializerElements[i], new QName(DescriptorConstants.NAMESPACE_URI,"xsd-serializable-type"));
			String qNameAsString = XmlUtils.extractText(xsdSerializerElement);
			if(qNameAsString!=null && !qNameAsString.equals(""))
			{
				try
				{
					QName qname = QName.valueOf(qNameAsString);
					String namespace = qname.getNamespaceURI();
					String localPart = qname.getLocalPart();
					if(namespace.equals(""))
						break;
					xsdSerializerElement.setAttribute("pfx", namespace);
					XmlUtils.setElementText(xsdSerializerElement, "pfx:"+localPart);									
				}
				catch(IllegalArgumentException e)
				{
					WsdmToolingLog.logError(e.getMessage(), e);
				}				
			}			
		}
	}
	
	/**
	 * Returns the Descriptor document
	 * @return Document
	 */
	public Document getDescriptorDocument()
	{
		return _descriptorDocument;
	}
	/**
	 * Returns the Jar files
	 * @return File[]
	 */
	public File[] getJarFiles()
	{
		return _jarFiles;
	}

	/**
	 * Returns the instances
	 * @return Object[][]
	 */
	public Object[][] getInstances()
	{
		return _instances;
	}

	/**
	 * Go through the parsed Muse descriptor associated with this object and
	 * find all of the MRT files referenced therein. For each MRT file use
	 * <code>WsdlMerge</code> to merge the MRT's WSDL into a consolidate WSDL.
	 * Return the Muse Descriptor document-order list of the WSDL files.
	 * The passed map will contain the MRT file location as key and MRT object as value.
	 * So first search the map for MRT if not found then load the MRT from location.
	 * 
	 * @return A list of merged WSDL files as gathered from the deployment
	 *         descriptor
	 * 
	 * @see org.eclipse.tptp.wsdm.tooling.wizard.mrt.internal.WsdlResolverDelegate#getWsdlDocuments()
	 */
	public Document[] getWsdlDocuments(String baseAddress)
	{
		Element[] resourceTypes = XmlUtils.findInSubTree(_descriptorDocument
				.getDocumentElement(), DescriptorConstants.RESOURCE_TYPE_QNAME);
		int mrtCount = resourceTypes.length;
		Document[] mergedWSDLs = new Document[mrtCount];

		for (int i = 0; i < mrtCount; i++)
		{
			Element wsdlFileElement = XmlUtils.findFirstInSubTree(
					resourceTypes[i], DescriptorConstants.WSDL_FILE_QNAME);

			String wsdlPath = XmlUtils.extractText(wsdlFileElement);
			String mrtPath = getMRTPathFromWSDLPath(wsdlPath);
			ManageableResourceType mrt = null;
			String serviceAddress = null;
			if(_mrtObjectMap!=null && _mrtObjectMap.containsKey(mrtPath))
			{
				mrt = (ManageableResourceType) _mrtObjectMap.get(mrtPath);
				serviceAddress = baseAddress+"/"+mrt.getIdentifier();
			}
			else
			{
				IWorkspace workspace = ResourcesPlugin.getWorkspace();
				IWorkspaceRoot root = workspace.getRoot();
				IPath mrtFilePath = root.findMember(mrtPath).getFullPath();
				URI uri = URI.createFileURI(mrtFilePath.toString());
				mrt = MrtUtils.loadMRT(uri);
				serviceAddress = makeServiceAddress(baseAddress, mrtFilePath);
			}
			if(mrt!=null)
			{
				try
				{
					mergedWSDLs[i] = MrtMerge.createMergedWSDL(mrt, serviceAddress);
				}
				catch (Exception e)
				{
					e.printStackTrace();
					// TODO AME add externalized message
					throw new RuntimeException(e);
				}
			}
			else
			{
				// TODO AME add externalized message
				throw new RuntimeException();
			}
		}
		return mergedWSDLs;
	}

	/**
	 * Given a base address add the service name. This is done by getting the
	 * name of the MRT file and stripping off the file extension.
	 * 
	 * @param baseAddress
	 *            Base address
	 * @param file
	 *            MRT file to use
	 * @return the combined address
	 */
	private String makeServiceAddress(String baseAddress, IPath file)
	{
		String fileName = file.toFile().getName();
		fileName = fileName.substring(0, fileName.lastIndexOf("."));
		return baseAddress + "/" + fileName;
	}

	private String getMRTPathFromWSDLPath(String fileName)
	{
		return fileName.substring(0, fileName.lastIndexOf(".")) + MRT_EXTN;
	}
	
	/**
	 * Adds the additional jar files to Descriptor file.
	 *  
	 * @param serverLocation
	 * 			Parent directory of Axis2-lib folder.
	 * 
	 * @param axis2files
	 * 			Axis2 jar files path.
	 */
	public void addAdditionalJars(String serverLocation, String[] axis2files)
	{
		List additionalJarFiles = new LinkedList();
		if(_jarFiles!=null)
			additionalJarFiles.addAll(Arrays.asList(_jarFiles));
		for(int i = 0 ; i < axis2files.length ; i++ )
			additionalJarFiles.add(new File(serverLocation + File.separator + axis2files[i]));
		_jarFiles = (File[]) additionalJarFiles.toArray(new File[additionalJarFiles.size()]);
	}

	/**
	 * Go through the parsed Muse descriptor associated with this object and
	 * find all of the MRT files referenced therein. For each MRT file create
	 * a merged RMD document.
	 * 
	 * @return A list of merged RMD documents as gathered from the deployment
	 *         descriptor
	 * 
	 */
	public MetadataDescriptor[] getMergedRMDs() 
	{
		Element[] resourceTypes = XmlUtils.findInSubTree(_descriptorDocument
				.getDocumentElement(), DescriptorConstants.RESOURCE_TYPE_QNAME);
		int mrtCount = resourceTypes.length;
		MetadataDescriptor[] mergedRMDs = new MetadataDescriptor[mrtCount];

		for (int i = 0; i < mrtCount; i++)
		{
			Element wsdlFileElement = XmlUtils.findFirstInSubTree(
					resourceTypes[i], DescriptorConstants.WSDL_FILE_QNAME);

			String wsdlPath = XmlUtils.extractText(wsdlFileElement);
			String mrtPath = getMRTPathFromWSDLPath(wsdlPath);
			ManageableResourceType mrt = null;
			String serviceAddress = null;
			if(_mrtObjectMap!=null && _mrtObjectMap.containsKey(mrtPath))
			{
				mrt = (ManageableResourceType) _mrtObjectMap.get(mrtPath);				
			}
			else
			{
				IWorkspace workspace = ResourcesPlugin.getWorkspace();
				IWorkspaceRoot root = workspace.getRoot();
				IPath mrtFilePath = root.findMember(mrtPath).getFullPath();
				URI uri = URI.createFileURI(mrtFilePath.toString());
				mrt = MrtUtils.loadMRT(uri);				
			}
			if(mrt!=null)
			{
				try
				{
					mergedRMDs[i] = MrtMerge.createMergedRMD(mrt);
					_codeGenerationDelegate.inspectMetadata(mrt, mergedRMDs[i]);
				}
				catch (Exception e)
				{
					throw new RuntimeException(e);
				}
			}
			else
			{
				throw new RuntimeException();
			}
		}		
		return mergedRMDs;		
	} 	
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal;

import java.io.File;
import java.io.InputStream;
import java.net.URI;
import java.net.URL;
import java.net.URLConnection;

import org.apache.muse.core.AbstractEnvironment;
import org.apache.muse.util.xml.XmlUtils;
import org.apache.muse.ws.addressing.EndpointReference;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
import org.osgi.framework.Bundle;
import org.w3c.dom.Document;

public class EclipseEnvironment extends AbstractEnvironment
{

	public EndpointReference getDeploymentEPR()
	{
		// TODO Auto-generated method stub
		return null;
	}

	public File getRealDirectory()
	{
		// TODO Auto-generated method stub
		return null;
	}

	public Document getDocument(String path)
	{
		try
		{
			if(isHttpScheme(path))
			{
				URLConnection conn = new URL(path).openConnection();
				InputStream stream = conn.getInputStream();
				return XmlUtils.createDocument(stream);
			}			
		}
		catch(Exception e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}
		
		
		try
		{
			if (!isBuiltin(path))
			{
				IFile wsdlFile = EclipseUtils.getIFile(ResourcesPlugin
						.getWorkspace().getRoot(), path);
				return XmlUtils.createDocument(wsdlFile.getLocation().toFile()
						.getAbsoluteFile());
			}
			else
			{
				String substr = path.substring(path.indexOf("platform:/plugin/")+"platform:/plugin/".length());
				String contributorPlugin = substr.substring(0,substr.indexOf('/'));
				String relativePath = substr.substring(substr.indexOf('/')+1);
				
				Bundle bundle = Platform.getBundle(contributorPlugin);
				return XmlUtils.createDocument(FileLocator.openStream(bundle,
						new Path(relativePath), false));
			}
		}
		catch (Exception e)
		{
			WsdmToolingLog.logError(e.getMessage(), e);
		}
		return null;
	}

	/**
	 * Utility method to see if the path is referring to something in the
	 * plugins or in the workspace.
	 * 
	 * @param path
	 *            A path to examine
	 * @return true if the path starts with <code>"platform:/plugin"</code>
	 */
	private boolean isBuiltin(String path)
	{
		return path.startsWith("platform:/plugin");
	}
	
	private boolean isHttpScheme(String path)
	{
		try{
			URI uri = URI.create(path);		
			String scheme = uri.getScheme();
			if(scheme != null && uri.getScheme().equals("http"))
				return true;
		}catch(Exception e){
			// nuthing to do, just return false
		}
		return false;
	}

	public String createRelativePath(String original, String relative)
	{

		// If the relative path starts with "platform:/" then it
		// is an absolute path, so just return it instead.
		if (relative.startsWith("platform:/"))
		{
			return relative;
		}

		return super.createRelativePath(original, relative);
	}
}

Lines 22-28 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/internal/projectizer/EclipseProxyProjectizer.java (-1 / +1 lines)
22	import org.apache.muse.util.FileUtils;	22	import org.apache.muse.util.FileUtils;
23	import org.eclipse.core.runtime.FileLocator;	23	import org.eclipse.core.runtime.FileLocator;
24	import org.eclipse.core.runtime.Platform;	24	import org.eclipse.core.runtime.Platform;
25	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.EclipseConfigurationData;	25	import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.EclipseConfigurationData;
26	import org.eclipse.tptp.wsdm.tooling.internal.util.JavaProjectHelper;	26	import org.eclipse.tptp.wsdm.tooling.internal.util.JavaProjectHelper;
27		27
28		28




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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
 * $Id: EclipseOsgiMiniProjectizer.java,v 1.2 2007/05/07 09:15:19 dnsmith Exp $
 * 
 * Contributors:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.tptp.wsdm.tooling.internal.projectizer;

import org.apache.muse.tools.generator.projectizer.OsgiMiniProjectizer;

public class EclipseOsgiMiniProjectizer extends OsgiMiniProjectizer {

}




import org.apache.muse.util.FileUtils;
import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
import org.apache.muse.ws.wsdl.WsdlUtils;
import org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.EclipseConfigurationData;
import org.eclipse.tptp.wsdm.tooling.internal.util.PluginProjectHelper;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

	private File[] _additionalJars;
	private Object[][] _instances;

	private int _resourceCounter = 0;

	private String _projectLocation;

	private String _projectName;

		
		loadParameters(data);		
		
		PluginProjectHelper helper = createProject(_projectLocation, _projectName);		
		
		_targetDirectory = helper.getProjectDirectory();
		
		File descriptorFile = new File(_targetDirectory, EclipseOsgiProjectizerConstants.MUSE_DESCRIPTOR_FILE);
				
		File javaSourceDir = new File(_targetDirectory, OsgiProjectizerConstants.JAVA_SRC_DIR);
				
		createJavaSources(javaSourceDir, _filesMaps);
		createArtifacts(javaSourceDir);						
						
		helper.refreshProject();
	}
	
	protected void createArtifacts(File javaSourceDir) throws Exception {
		createActivatorFile(javaSourceDir, EclipseOsgiProjectizerConstants.ACTIVATOR_FILE_RESOURCE);
		
		File routerEntriesDir = new File(_targetDirectory,OsgiProjectizerConstants.ROUTER_ENTRIES_DIR);
		
		File descriptorFile = new File(_targetDirectory, EclipseOsgiProjectizerConstants.MUSE_DESCRIPTOR_FILE);
		
		File wsdldir = new File(_targetDirectory, OsgiProjectizerConstants.WSDL_DIR);
		
		createManifest(_targetDirectory, EclipseOsgiProjectizerConstants.OSGI_MANIFEST_FILE_RESOURCE, EclipseOsgiProjectizerConstants.OSGI_MANIFEST_FILE);				
		
		for(int i=0; i < _capabilitiesList.length; i++) {

		}
		
		createBuildProperties(_targetDirectory, EclipseOsgiProjectizerConstants.BUILD_PROPERTIES_FILE_RESOURCE, EclipseOsgiProjectizerConstants.BUILD_PROPERTIES_FILE);
	}
	
	protected void loadParameters(ConfigurationData data) {
		super.loadParameters(data);
		_additionalJars = (File[])data.getParameter(EclipseConfigurationData.ADDITIONAL_JARS);
		_instances = (Object[][])data.getParameter(EclipseConfigurationData.INSTANCES);
		_projectName = (String)data.getParameter(EclipseConfigurationData.PROJECT_NAME);
		_projectLocation = (String)data.getParameter(EclipseConfigurationData.PROJECT_LOCATION);
	}
		
	protected void createRouterEntries(File routerEntriesDir, Object[][] instances)
			throws Exception {
			
		for(int i=0; i < instances.length; i++) {
			Object[] instancePair = instances[i];
		for(int i=0; i < _instances.length; i++) {
			Object[] instancePair = _instances[i];
			
			//
			//This is really tacky, but it's the only real way to do this

			Element instanceElement = (Element) instancePair[1];
			
			File serviceDir = new File(routerEntriesDir, resourcePathName);				
			File routerEntryFile = new File(serviceDir, getResourceFileName(i));
			
			writeToFileCheck(instanceElement, routerEntryFile);				
		}
	}
	
	/**
	 * Get the name of a resource-instance file with the appropriate counter. This is 
	 * really just a string-replace of the PLACE_HOLDER value with the given counter
	 * 
	 * @param counter	The number to use in the string replace
	 * @return 			The string with PLACE_HOLDER replaced by the string value of counter
	 */
	protected String getResourceFileName(int counter) {
		return Axis2ProjectizerConstants.RESOURCE_FILE.replaceFirst(PLACE_HOLDER, String.valueOf(counter));
		_projectLocation = (String)data.getParameter(EclipseConfigurationData.PROJECT_LOCATION);
	}

	protected void createManifest(File baseTargetDir, String manifestFileResource, String manifestFileName) throws Exception {

		
		String packageName = getSymbolicName().toString();
		
		Object[] filler = { getSymbolicName(), makeActivatorName(packageName), getSymbolicName()};
		String newManifest = loadString(manifestTemplateIS, filler);
		
		newManifest = addAdditionalJars(newManifest);

		writeToFileCheck(newManifest, manifestFile);
	}
	
	protected String makeActivatorName(String packageName) {
		return packageName + "." + EclipseOsgiProjectizerConstants.ACTIVATOR_CLASSNAME;
	}

	private String addAdditionalJars(String newManifest) throws IOException {
		ByteArrayInputStream bais = new ByteArrayInputStream(newManifest.getBytes());
		Manifest manifest = null;			




import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.tptp.wsdm.tooling.provisional.util.ProjectHelper;

public class JavaProjectHelper extends ProjectHelper {

	IProject _project = null;

	public JavaProjectHelper(String location, String projectName, String natureId) throws Exception {
		if(natureId == null) {
			natureId = JavaCore.NATURE_ID;
		}
		_project = getProject(location, projectName, natureId, true);		
		initializeClasspath();
	}
	
	public JavaProjectHelper(String location, String projectName) throws Exception {
		this(location, projectName, JavaCore.NATURE_ID);
	}

	protected void initializeClasspath() throws JavaModelException {
		IJavaProject javaProj = JavaCore.create(_project);
		javaProj.setRawClasspath(new IClasspathEntry[] {}, null);
		addClasspathEntry(JavaRuntime.getDefaultJREContainerEntry());

Lines 21-28 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/internal/util/PluginProjectHelper.java (-2 / +2 lines)
21	private static final String PLUGIN_NATURE = "org.eclipse.pde.PluginNature"; //$NON-NLS-1$	21	private static final String PLUGIN_NATURE = "org.eclipse.pde.PluginNature"; //$NON-NLS-1$
22		22
23	public PluginProjectHelper(String projectLocation, String projectName) throws Exception {	23	public PluginProjectHelper(String projectLocation, String projectName) throws Exception {
24	super(projectLocation, projectName);	24	super(projectLocation, projectName, JavaCore.NATURE_ID);
25	addNature(PLUGIN_NATURE);	25	initializeClasspath();
26	IClasspathEntry cpe = JavaCore.newContainerEntry(Path.fromOSString("org.eclipse.pde.core.requiredPlugins")); //$NON-NLS-1$	26	IClasspathEntry cpe = JavaCore.newContainerEntry(Path.fromOSString("org.eclipse.pde.core.requiredPlugins")); //$NON-NLS-1$
27	addClasspathEntry(cpe);	27	addClasspathEntry(cpe);
28	}	28	}




/*******************************************************************************
 * Copyright (c) 2006, 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.provisional.util;

import java.net.URI;

import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.resources.ICommand;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;

public abstract class ProjectHelper {

	protected IProject getProject(String location, String name) throws CoreException {
		IWorkspace workspace = ResourcesPlugin.getWorkspace();
		IWorkspaceRoot root = workspace.getRoot();	

		IProjectDescription desc= workspace.newProjectDescription(name);

		URI projectURI = location==null?null:URIUtil.toURI(location);
		desc.setLocationURI(projectURI);
		
		IProject project = root.getProject(name);
		
		if(project != null) {
			project.create(desc, null);
			project.open(null);
		}
		
		return project;
	}
	
	public void addNature(String natureId) throws CoreException {		
		IProject project = getProject();
		IProjectDescription description = project.getDescription();
		String[] natures = description.getNatureIds();
		String[] newNatures = new String[natures.length + 1];
		System.arraycopy(natures, 0, newNatures, 0, natures.length);
		newNatures[natures.length] = natureId;
		description.setNatureIds(newNatures);
		project.setDescription(description, null);
	}
	
	public void refreshProject() throws Exception {
		getProject().refreshLocal(IFile.DEPTH_INFINITE, null);    	
	}
	
	public void addBuilder(String builder) throws CoreException {
		IProjectDescription desc = getProject().getDescription();
		ICommand command = desc.newCommand();
		command.setBuilderName(builder);
		ICommand[] commands = desc.getBuildSpec();
		ICommand[] nc = new ICommand[commands.length + 1];
		System.arraycopy(commands, 0, nc, 0, commands.length);
		nc[commands.length] = command;
		desc.setBuildSpec(nc);
		getProject().setDescription(desc, null);
	}
	
	public abstract IProject getProject();
}




            servicePath="/"
            servicePort="80"/>
   </extension>
   <extension
         point="org.eclipse.tptp.wsdm.editor.codeGeneration">
      <description
            container="Mini"
            platform="OSGi">
      </description>
      <projectizer
            class="org.eclipse.tptp.wsdm.tooling.internal.projectizer.EclipseOsgiProjectizer"
            name="OSGi mini"
            servicePath="/"
            servicePort="80">
      </projectizer>
   </extension>
</plugin>

Lines 21-24 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
21	Bundle-ClassPath: .,runtime/code-generation.jar	21	Bundle-ClassPath: .,runtime/code-generation.jar
22	Bundle-Vendor: %plugin.provider	22	Bundle-Vendor: %plugin.provider
23	Bundle-RequiredExecutionEnvironment: J2SE-1.4	23	Bundle-RequiredExecutionEnvironment: J2SE-1.4
24	Export-Package: org.eclipse.tptp.wsdm.tooling.provisional.util	24	Export-Package: org.eclipse.tptp.wsdm.tooling.internal.util;x-friends:="org.eclipse.tptp.wsdm.tooling.codegeneration.j2ee"




package org.eclipse.tptp.wsdm.tooling.internal.util;

import org.eclipse.core.runtime.IProgressMonitor;

public class ProgressMonitorHelper {
	
	private IProgressMonitor _monitor;

	public ProgressMonitorHelper(IProgressMonitor monitor) {
		_monitor = monitor;
	}
	
	public void finishProgressMonitor() {
		if (_monitor != null) {
			_monitor.done();
		}
	}

	public void recordProgress(int i) {
		if (_monitor != null) {
			_monitor.worked(1);
		}
	}

	public void startProgressMonitor(int i) {
		if(_monitor != null) {
			_monitor.beginTask("Running Projectizer", i);
		}
	}

	public void recordProgress() {
		recordProgress(1);
	}
}




/*******************************************************************************
 * Copyright (c) 2006, 2007 IBM Corporation and others.
 * 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:
 * 	Balan Subramanian (bsubram@us.ibm.com)
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.internal.util;

import java.io.File;
import java.net.URI;
import java.net.URL;

import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.resources.ICommand;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;

public abstract class ProjectHelper {
	
	protected IProject getProject(String location, String name, String natureId, boolean create) throws CoreException {
		IWorkspace workspace = ResourcesPlugin.getWorkspace();
		IWorkspaceRoot root = workspace.getRoot();	

		IProjectDescription desc= workspace.newProjectDescription(name);

		URI projectURI = location==null?null:URIUtil.toURI(location);
		desc.setLocationURI(projectURI);
		
		if(natureId != null) {
			addNature(natureId, desc);
		}
		
		IProject project = root.getProject(name);
		
		if(create && project != null) {
			project.create(desc, null);
			project.open(null);
		}
		
		return project;
	}
	
	private void addNature(String natureId, IProjectDescription description) throws CoreException {		
		String[] natures = description.getNatureIds();
		String[] newNatures = new String[natures.length + 1];
		System.arraycopy(natures, 0, newNatures, 0, natures.length);
		newNatures[natures.length] = natureId;
		description.setNatureIds(newNatures);		
	}
	
	public void refreshProject() throws Exception {
		getProject().refreshLocal(IFile.DEPTH_INFINITE, null);    	
	}
	
	public void addBuilder(String builder) throws CoreException {
		IProjectDescription desc = getProject().getDescription();
		ICommand command = desc.newCommand();
		command.setBuilderName(builder);
		ICommand[] commands = desc.getBuildSpec();
		ICommand[] nc = new ICommand[commands.length + 1];
		System.arraycopy(commands, 0, nc, 0, commands.length);
		nc[commands.length] = command;
		desc.setBuildSpec(nc);
		getProject().setDescription(desc, null);
	}
	
	public static File toFile(URL url) {
		return new File(url.getFile());
	}
	
	public abstract IProject getProject();
}

Return to bug 179329

Lines 7-13 Link Here

(-)plugin.xml (-1 / +13 lines)
7	container="Axis2"	7	container="Axis2"
8	platform="J2EE"/>	8	platform="J2EE"/>
9	<projectizer	9	<projectizer
10	class="org.eclipse.tptp.wsdm.tooling.internal.projectizer.EclipseAxis2Projectizer"	10	class="org.eclipse.tptp.wsdm.tooling.internal.projectizer.EclipseJ2EEAxis2Projectizer"
11	name="Axis2 J2EE"	11	name="Axis2 J2EE"
12	servicePath="/services"	12	servicePath="/services"
13	servicePort="8080"/>	13	servicePort="8080"/>
Lines 16-19 Link Here
16	point="org.eclipse.ui.startup">	16	point="org.eclipse.ui.startup">
17	<startup class="org.eclipse.tptp.wsdm.tooling.internal.codegeneration.Activator"/>	17	<startup class="org.eclipse.tptp.wsdm.tooling.internal.codegeneration.Activator"/>
18	</extension>	18	</extension>
		19	<extension
		20	point="org.eclipse.tptp.wsdm.editor.codeGeneration">
		21	<description
		22	container="Mini"
		23	platform="J2EE">
		24	</description>
		25	<projectizer
		26	class="org.eclipse.tptp.wsdm.tooling.internal.projectizer.EclipseJ2EEMiniProjectizer"
		27	name="J2EE Mini"
		28	servicePort="8080">
		29	</projectizer>
		30	</extension>
19	</plugin>	31	</plugin>

Added Link Here

(-)resources/mini/web.xml (+13 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
3	<display-name>Apache Muse Servlet</display-name>
4	<servlet>
5	<display-name>Apache Muse Servlet</display-name>
6	<servlet-name>ApacheMuseServlet</servlet-name>
7	<servlet-class>org.apache.muse.core.platform.mini.MiniServlet</servlet-class>
8	</servlet>
9	<servlet-mapping>
10	<servlet-name>ApacheMuseServlet</servlet-name>
11	<url-pattern>/*</url-pattern>
12	</servlet-mapping>
13	</web-app>

Removed Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/codegen/mrt/provisional/RelationshipInspector.java (-405 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Balan Subramanian (bsubram@us.ibm.com)
10	* IBM Corporation - initial API and implementation
11	*******************************************************************************/
12	package org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional;
13
14	import java.io.ByteArrayInputStream;
15	import java.io.IOException;
16	import java.io.InputStream;
17	import java.util.ArrayList;
18	import java.util.Iterator;
19	import java.util.List;
20
21	import javax.wsdl.Operation;
22	import javax.xml.namespace.QName;
23
24	import org.apache.muse.util.xml.XmlUtils;
25	import org.apache.muse.ws.addressing.WsaConstants;
26	import org.apache.muse.ws.addressing.soap.SoapFault;
27	import org.apache.muse.ws.resource.metadata.MetadataDescriptor;
28	import org.apache.ws.muse.descriptor.CapabilityType;
29	import org.apache.ws.muse.descriptor.DescriptorFactory;
30	import org.apache.ws.muse.descriptor.DocumentRoot;
31	import org.apache.ws.muse.descriptor.InitParamType;
32	import org.apache.ws.muse.descriptor.InitialInstancesType;
33	import org.apache.ws.muse.descriptor.ReferenceParametersType;
34	import org.apache.ws.muse.descriptor.ResourceTypeType;
35	import org.apache.ws.muse.descriptor.WsdlType;
36	import org.eclipse.core.resources.IFile;
37	import org.eclipse.core.runtime.CoreException;
38	import org.eclipse.core.runtime.NullProgressMonitor;
39	import org.eclipse.emf.common.util.URI;
40	import org.eclipse.emf.ecore.impl.EStructuralFeatureImpl;
41	import org.eclipse.emf.ecore.resource.Resource;
42	import org.eclipse.emf.ecore.resource.ResourceSet;
43	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
44	import org.eclipse.emf.ecore.util.FeatureMap;
45	import org.eclipse.emf.ecore.util.BasicExtendedMetaData.EStructuralFeatureExtendedMetaData;
46	import org.eclipse.emf.ecore.xml.type.AnyType;
47	import org.eclipse.tptp.wsdm.tooling.editor.mrt.relationship.internal.RelationshipUtils;
48	import org.eclipse.tptp.wsdm.tooling.model.addressing.AttributedURIType;
49	import org.eclipse.tptp.wsdm.tooling.model.addressing.EndpointReferenceType;
50	import org.eclipse.tptp.wsdm.tooling.model.capabilities.Capability;
51	import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceType;
52	import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.ManageableResourceTypeFactory;
53	import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.Relationship;
54	import org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.RelationshipParticipantType;
55	import org.eclipse.tptp.wsdm.tooling.util.internal.CustomMrtResourceFactoryImpl;
56	import org.eclipse.tptp.wsdm.tooling.util.internal.EclipseUtils;
57	import org.eclipse.tptp.wsdm.tooling.util.internal.MrtUtils;
58	import org.eclipse.tptp.wsdm.tooling.util.internal.WsdlUtils;
59	import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmConstants;
60	import org.eclipse.tptp.wsdm.tooling.util.internal.WsdmToolingLog;
61	import org.w3c.dom.Document;
62	import org.w3c.dom.Element;
63	import org.w3c.dom.Text;
64
65	public class RelationshipInspector implements MrtInspector
66	{
67
68	private String _mrtParentDirName;
69
70	private DocumentRoot _root;
71
72	private ResourceTypeType _relationshipResourceType;
73
74	private ManageableResourceType _relationshipResourceMRT;
75
76	/**
77	* Constructor of the class
78	* @param root
79	*/
80	public RelationshipInspector(DocumentRoot root)
81	{
82	_root = root;
83	}
84
85	public ManageableResourceType getExtraGeneratedMrt()
86	{
87	return _relationshipResourceMRT;
88	}
89
90	public String getExtraGeneratedMrtPersistanceLocation()
91	{
92	return _mrtParentDirName+"/RelationshipResource.mrt";
93	}
94
95	public InitialInstancesType[] getInitialInstances()
96	{
97	InitialInstancesType instance = DescriptorFactory.eINSTANCE
98	.createInitialInstancesType();
99	ResourceTypeType rtClone = MRTCodeGenerationDelegate
100	.cloneResourceType(_relationshipResourceType);
101	instance.setResourceType(rtClone);
102	ReferenceParametersType refParam = DescriptorFactory.eINSTANCE
103	.createReferenceParametersType();
104	instance.setReferenceParameters(refParam);
105	return new InitialInstancesType[] { instance };
106	}
107
108	public ResourceTypeType inspect(Capability[] mrtCapabilities)
109	{
110	for (int i = 0; i < mrtCapabilities.length; i++)
111	{
112	if (hasRelationshipCapability(mrtCapabilities[i]))
113	return createRelationshipResourceType();
114	}
115	return null;
116	}
117
118	private ResourceTypeType createRelationshipResourceType()
119	{
120	createRelationshipResourceMrt();
121	_relationshipResourceType = createRelationshipResourceMuseType();
122	return _relationshipResourceType;
123	}
124
125	private void createRelationshipResourceMrt()
126	{
127	org.eclipse.tptp.wsdm.tooling.model.manageableResourceType.DocumentRoot documentRoot = ManageableResourceTypeFactory.eINSTANCE.createDocumentRoot();
128	_relationshipResourceMRT = ManageableResourceTypeFactory.eINSTANCE
129	.createManageableResourceType();
130	documentRoot.setManageableResource(_relationshipResourceMRT);
131	_relationshipResourceMRT.setIdentifier("RelationshipResource");
132	_relationshipResourceMRT
133	.setNamespace("http://docs.oasis-open.org/wsdm/muws2-2.xsd/RelationshipResource");
134	_relationshipResourceMRT
135	.getImplements()
136	.add(WsdmConstants.MEX_CAPABILITY_LOCATION);
137	_relationshipResourceMRT
138	.getImplements()
139	.add(WsdmConstants.GET_CAPABILITY_LOCATION);
140	_relationshipResourceMRT
141	.getImplements()
142	.add(WsdmConstants.SET_CAPABILITY_LOCATION);
143	_relationshipResourceMRT
144	.getImplements()
145	.add(WsdmConstants.QUERY_CAPABILITY_LOCATION);
146	_relationshipResourceMRT
147	.getImplements()
148	.add(WsdmConstants.RELATIONSHIP_RESOURCE_CAPABILITY_LOCATION);
149	}
150
151	private ResourceTypeType createRelationshipResourceMuseType()
152	{
153	ResourceTypeType resourceType = DescriptorFactory.eINSTANCE
154	.createResourceTypeType();
155	resourceType.setContextPath("/RelationshipResource");
156	resourceType
157	.setJavaIdFactoryClass(WsdmConstants.MUSE_RESOURCE_ID_FACTORY_CLASS);
158	resourceType
159	.setJavaResourceClass(WsdmConstants.MUSE_RESOURCE_CLASS);
160
161	WsdlType wsdlType = DescriptorFactory.eINSTANCE.createWsdlType();
162	wsdlType.setWsdlFile(_mrtParentDirName + "/"
163	+ "RelationshipResource.wsdl");
164	_root.getXMLNSPrefixMap().put("rel",
165	"http://docs.oasis-open.org/wsdm/muws2-2.xsd/RelationshipResource");
166	wsdlType.setWsdlPortType("rel:PortType");
167	resourceType.setWsdl(wsdlType);
168
169	CapabilityType metadataExchange = DescriptorFactory.eINSTANCE
170	.createCapabilityType();
171	metadataExchange
172	.setCapabilityUri("http://schemas.xmlsoap.org/ws/2004/09/mex");
173	metadataExchange.setJavaCapabilityClass("");
174
175	CapabilityType getCapability = DescriptorFactory.eINSTANCE
176	.createCapabilityType();
177	getCapability
178	.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Get");
179	getCapability.setJavaCapabilityClass("");
180
181	CapabilityType setCapability = DescriptorFactory.eINSTANCE
182	.createCapabilityType();
183	setCapability
184	.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Set");
185	setCapability.setJavaCapabilityClass("");
186
187	CapabilityType queryCapability = DescriptorFactory.eINSTANCE
188	.createCapabilityType();
189	queryCapability
190	.setCapabilityUri("http://docs.oasis-open.org/wsrf/rpw-2/Query");
191	queryCapability.setJavaCapabilityClass("");
192
193	CapabilityType relationshipResource = DescriptorFactory.eINSTANCE
194	.createCapabilityType();
195	relationshipResource
196	.setCapabilityUri("http://docs.oasis-open.org/wsdm/muws/capabilities/RelationshipResource");
197	relationshipResource
198	.setJavaCapabilityClass("");
199
200	InitParamType noValidateParam = DescriptorFactory.eINSTANCE
201	.createInitParamType();
202	noValidateParam.setParamName("validate-wsrp-schema");
203	noValidateParam.setParamValue("false");
204
205	resourceType.getCapability().add(metadataExchange);
206	resourceType.getCapability().add(getCapability);
207	resourceType.getCapability().add(setCapability);
208	resourceType.getCapability().add(queryCapability);
209	resourceType.getCapability().add(relationshipResource);
210
211	resourceType.getInitParam().add(noValidateParam);
212
213	return resourceType;
214	}
215
216	private boolean hasRelationshipCapability(Capability capability)
217	{
218	boolean hasRelationshipNS = "http://docs.oasis-open.org/wsdm/muws2-2.xsd".equals(capability.getNamespace());
219	String capabilityURI = capability.getWsdlDefinition().getNamespace("capabilityURI");
220	boolean hasRelationshipURI = "http://docs.oasis-open.org/wsdm/muws/capabilities/Relationships".equals(capabilityURI);
221	boolean hasRelationshipName = capability.getName().equals("Relationships");
222	Operation[] operations = capability.getWsdlDefinition().getOperations();
223	if (operations == null \|\| operations.length < 1)
224	return false;
225	boolean hasQueryRelationshipsOp = WsdlUtils.getOperationName(operations[0])
226	.equals("QueryRelationshipsByType");
227	return hasRelationshipNS && hasRelationshipURI && hasRelationshipName && hasQueryRelationshipsOp;
228	}
229
230	public void persistArtifacts()
231	{
232	ResourceSet rs = new ResourceSetImpl();
233	rs.getResourceFactoryRegistry().getExtensionToFactoryMap()
234	.put(Resource.Factory.Registry.DEFAULT_EXTENSION, new CustomMrtResourceFactoryImpl());
235	byte[] rawNewMRT = MrtUtils.serializeMRT(_relationshipResourceMRT, rs, URI
236	.createURI("dummy.xml"), true);
237	InputStream stream = new ByteArrayInputStream(rawNewMRT);
238
239	try
240	{
241	String relationshipResourceMrt = _mrtParentDirName + "/"
242	+ "RelationshipResource.mrt";
243	IFile relationshipResourceMrtFile = EclipseUtils.getIFile(relationshipResourceMrt);
244	if (relationshipResourceMrtFile.exists())
245	{
246	relationshipResourceMrtFile.setContents(stream, true, true,
247	new NullProgressMonitor());
248	}
249	else
250	{
251	relationshipResourceMrtFile.create(stream, true,
252	new NullProgressMonitor());
253	}
254	try
255	{
256	stream.close();
257	}
258	catch (IOException e)
259	{
260	WsdmToolingLog.logError(e.getMessage(), e);
261	}
262	}
263	catch (CoreException e)
264	{
265	WsdmToolingLog.logError(e.getMessage(), e);
266	}
267	}
268
269	public void setMrtParentDirectory(String mrtParentDir)
270	{
271	_mrtParentDirName = mrtParentDir;
272	}
273
274	/**
275	* Inspects the given manageable resource type for servicegroup/relationship kind of resource type and update the given
276	* merged RMD document for it by having the rules/relationships in it.
277	*/
278	public void inspectMetadata(ManageableResourceType mrt, MetadataDescriptor rmd)
279	{
280	boolean hasRelationshipCapability = false;
281	Capability[] mrtCapabilities = new Capability[0];
282	try
283	{
284	mrtCapabilities = MrtUtils.getCapabilities(mrt);
285	}
286	catch (Exception e)
287	{
288	WsdmToolingLog.logError(e.getMessage(), e);
289	}
290	for (int i = 0; i < mrtCapabilities.length; i++)
291	{
292	if (hasRelationshipCapability(mrtCapabilities[i]))
293	{
294	hasRelationshipCapability = true;
295	break;
296	}
297	}
298	if(hasRelationshipCapability)
299	{
300	List relationships = mrt.getRelationshipDefinitions();
301	List initialValues = new ArrayList();
302	for(int i=0;i<relationships.size();i++)
303	{
304	Relationship relationship = (Relationship) relationships.get(i);
305	Element value = createRelationshipElement(relationship);
306	initialValues.add(value);
307	}
308	if(!initialValues.isEmpty());
309	try
310	{
311	rmd.setInitialValues(new QName(WsdmConstants.MUWS_P2_NS,"Relationship"), initialValues);
312	}
313	catch (SoapFault e)
314	{
315	WsdmToolingLog.logError(e.getMessage(), e);
316	}
317	}
318	}
319
320	private Element createRelationshipElement(Relationship relationship)
321	{
322	Document document = XmlUtils.createDocument();
323	Element relationshipElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P2_NS,"Relationship"));
324
325	Element nameElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P2_NS,"Name"));
326	Text name = document.createTextNode(relationship.getName());
327	nameElement.appendChild(name);
328	relationshipElement.appendChild(nameElement);
329
330	Element typeElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P2_NS,"Type"));
331	QName typeQName = RelationshipUtils.getRelationshipType(relationship);
332	Element element = XmlUtils.createElement(document, typeQName);
333	typeElement.appendChild(element);
334	relationshipElement.appendChild(typeElement);
335
336	List participants = relationship.getParticipant();
337	for(int i=0;i<participants.size();i++)
338	{
339	RelationshipParticipantType participant = (RelationshipParticipantType) participants.get(i);
340	Element participantElement = createParticipantElement(participant, document);
341	relationshipElement.appendChild(participantElement);
342	}
343	return relationshipElement;
344	}
345
346	private Element createParticipantElement(RelationshipParticipantType participant, Document document)
347	{
348	Element participantElement = XmlUtils.createElement(document,new QName(WsdmConstants.MUWS_P2_NS,"Participant"));
349
350	// Create epr element
351	Element manageabilityEprElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P1_NS,"ManageabilityEndpointReference"));
352	EndpointReferenceType epr = (EndpointReferenceType) participant.getManageabilityEndpointReference().get(0);
353	AttributedURIType uri = epr.getAddress();
354	Element addressElement = XmlUtils.createElement(document, new QName("http://www.w3.org/2005/08/addressing", "Address"));
355	Text address = document.createTextNode(uri.getValue());
356	addressElement.appendChild(address);
357	manageabilityEprElement.appendChild(addressElement);
358	participantElement.appendChild(manageabilityEprElement);
359
360	// Create reference parameter element
361	Element referenceParameterElement = XmlUtils.createElement(document, WsaConstants.PARAMETERS_QNAME);
362	manageabilityEprElement.appendChild(referenceParameterElement);
363	org.eclipse.tptp.wsdm.tooling.model.addressing.ReferenceParametersType refParams = epr.getReferenceParameters();
364	FeatureMap fm = refParams.getAny();
365	Iterator it = fm.iterator();
366	while (it.hasNext())
367	{
368	Object obj = it.next();
369	if(obj instanceof EStructuralFeatureImpl.ContainmentUpdatingFeatureMapEntry)
370	{
371	EStructuralFeatureImpl.ContainmentUpdatingFeatureMapEntry containmentEntry = (EStructuralFeatureImpl.ContainmentUpdatingFeatureMapEntry)obj;
372	EStructuralFeatureExtendedMetaData metadata = ((EStructuralFeatureImpl)containmentEntry.getEStructuralFeature()).getExtendedMetaData();
373	String namespace = metadata.getNamespace();
374	String name = metadata.getName();
375	String value = "";
376	Object containmentEntryValue = containmentEntry.getValue();
377	if(containmentEntryValue instanceof AnyType)
378	{
379	AnyType anyType = (AnyType) containmentEntryValue;
380	value = (String) anyType.getMixed().valueListIterator().next();
381	}
382	Element paramElement = XmlUtils.createElement(document, new QName(namespace, name));
383	XmlUtils.setElementText(paramElement, value);
384	referenceParameterElement.appendChild(paramElement);
385	}
386	}
387
388	// Create resource id element
389	Element resourceIdElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P1_NS,"ResourceId"));
390	Text resourceId = document.createTextNode(participant.getResourceId());
391	resourceIdElement.appendChild(resourceId);
392	participantElement.appendChild(resourceIdElement);
393
394	// Create role element
395	Element roleElement = XmlUtils.createElement(document, new QName(WsdmConstants.MUWS_P2_NS,"Role"));
396	Text role = document.createTextNode(participant.getRole());
397	roleElement.appendChild(role);
398	participantElement.appendChild(roleElement);
399
400	return participantElement;
401	}
402
403
404
405	}

Lines 6-12 Link Here

(-)schema/axisValidator.exsd (-6 / +6 lines)
6	<meta.schema plugin="org.eclipse.tptp.wsdm.editor" id="axisValidator" name="axisValidator"/>	6	<meta.schema plugin="org.eclipse.tptp.wsdm.editor" id="axisValidator" name="axisValidator"/>
7	</appInfo>	7	</appInfo>
8	<documentation>	8	<documentation>
9	This extension point will be used for validation of Axis2 required files(Jar files and Module files).	9	This extension point will be used for validation of Axis2 required files(Jar files and Module files). This extension point is meant for internal use only and tool extenders are not expected to use this extension point in 4.4.
10	</documentation>	10	</documentation>
11	</annotation>	11	</annotation>
12		12
Lines 55-64 Link Here
55	<attribute name="validator" type="string" use="required">	55	<attribute name="validator" type="string" use="required">
56	<annotation>	56	<annotation>
57	<documentation>	57	<documentation>
58	Specify the class that validates the Axis Server Location. Specified class should extend "org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.SoapServerDependency" class and should implement the interface "org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.ISoapServerDependency".	58	Specify the class that validates the Axis Server Location. Specified class should extend "org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.SoapServerDependency" class and should implement the interface "org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.ISoapServerDependency".
59	</documentation>	59	</documentation>
60	<appInfo>	60	<appInfo>
61	<meta.attribute kind="java" basedOn="org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.SoapServerDependency:org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.ISoapServerDependency"/>	61	<meta.attribute kind="java" basedOn="org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.SoapServerDependency:org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.ISoapServerDependency"/>
62	</appInfo>	62	</appInfo>
63	</annotation>	63	</annotation>
64	</attribute>	64	</attribute>
Lines 105-111 Link Here
105	name="Axis2 Validator"	105	name="Axis2 Validator"
106	point="org.eclipse.tptp.wsdm.editor.axisValidator">	106	point="org.eclipse.tptp.wsdm.editor.axisValidator">
107	<axisValidator	107	<axisValidator
108	validator="org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.Axis2ServerDependency">	108	validator="org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.Axis2ServerDependency">
109	<requiredFiles>	109	<requiredFiles>
110	<relativeFilePath>lib/annogen-*.jar</relativeFilePath>	110	<relativeFilePath>lib/annogen-*.jar</relativeFilePath>
111	<relativeFilePath>lib/axiom-api-*.jar</relativeFilePath>	111	<relativeFilePath>lib/axiom-api-*.jar</relativeFilePath>
Lines 123-129 Link Here
123	<meta.section type="apiInfo"/>	123	<meta.section type="apiInfo"/>
124	</appInfo>	124	</appInfo>
125	<documentation>	125	<documentation>
126	Provided validator class must implement the "org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.ISoapServerDependency" interface.	126	Provided validator class must implement the "org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.ISoapServerDependency" interface. This extension point is meant for internal use only and tool extenders are not expected to use this extension point in 4.4.
127	</documentation>	127	</documentation>
128	</annotation>	128	</annotation>
129		129
Lines 132-138 Link Here
132	<meta.section type="implementation"/>	132	<meta.section type="implementation"/>
133	</appInfo>	133	</appInfo>
134	<documentation>	134	<documentation>
135	Provided validator class can extend the "org.eclipse.tptp.wsdm.tooling.codegen.mrt.provisional.SoapServerDependency" class to get the required files specified in extension point.	135	Provided validator class can extend the "org.eclipse.tptp.wsdm.tooling.codegen.mrt.internal.SoapServerDependency" class to get the required files specified in extension point. This extension point is meant for internal use only and tool extenders are not expected to use this extension point in 4.4.
136	</documentation>	136	</documentation>
137	</annotation>	137	</annotation>
138		138

Lines 25-43 Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/internal/util/JavaProjectHelper.java (-5 / +10 lines)
25	import org.eclipse.jdt.core.JavaCore;	25	import org.eclipse.jdt.core.JavaCore;
26	import org.eclipse.jdt.core.JavaModelException;	26	import org.eclipse.jdt.core.JavaModelException;
27	import org.eclipse.jdt.launching.JavaRuntime;	27	import org.eclipse.jdt.launching.JavaRuntime;
28	import org.eclipse.tptp.wsdm.tooling.provisional.util.ProjectHelper;
29		28
30	public class JavaProjectHelper extends ProjectHelper {	29	public class JavaProjectHelper extends ProjectHelper {
31		30
32	IProject _project = null;	31	IProject _project = null;
33		32
34	public JavaProjectHelper(String location, String projectName) throws Exception {	33	public JavaProjectHelper(String location, String projectName, String natureId) throws Exception {
35	_project = getProject(location, projectName);	34	if(natureId == null) {
36	addNature(JavaCore.NATURE_ID);	35	natureId = JavaCore.NATURE_ID;
		36	}
		37	_project = getProject(location, projectName, natureId, true);
37	initializeClasspath();	38	initializeClasspath();
38	}	39	}
		40
		41	public JavaProjectHelper(String location, String projectName) throws Exception {
		42	this(location, projectName, JavaCore.NATURE_ID);
		43	}
39		44
40	private void initializeClasspath() throws JavaModelException {	45	protected void initializeClasspath() throws JavaModelException {
41	IJavaProject javaProj = JavaCore.create(_project);	46	IJavaProject javaProj = JavaCore.create(_project);
42	javaProj.setRawClasspath(new IClasspathEntry[] {}, null);	47	javaProj.setRawClasspath(new IClasspathEntry[] {}, null);
43	addClasspathEntry(JavaRuntime.getDefaultJREContainerEntry());	48	addClasspathEntry(JavaRuntime.getDefaultJREContainerEntry());

Removed Link Here

(-)src/org/eclipse/tptp/wsdm/tooling/provisional/util/ProjectHelper.java (-76 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Balan Subramanian (bsubram@us.ibm.com)
10	* IBM Corporation - initial API and implementation
11	*******************************************************************************/
12
13	package org.eclipse.tptp.wsdm.tooling.provisional.util;
14
15	import java.net.URI;
16
17	import org.eclipse.core.filesystem.URIUtil;
18	import org.eclipse.core.resources.ICommand;
19	import org.eclipse.core.resources.IFile;
20	import org.eclipse.core.resources.IProject;
21	import org.eclipse.core.resources.IProjectDescription;
22	import org.eclipse.core.resources.IWorkspace;
23	import org.eclipse.core.resources.IWorkspaceRoot;
24	import org.eclipse.core.resources.ResourcesPlugin;
25	import org.eclipse.core.runtime.CoreException;
26
27	public abstract class ProjectHelper {
28
29	protected IProject getProject(String location, String name) throws CoreException {
30	IWorkspace workspace = ResourcesPlugin.getWorkspace();
31	IWorkspaceRoot root = workspace.getRoot();
32
33	IProjectDescription desc= workspace.newProjectDescription(name);
34
35	URI projectURI = location==null?null:URIUtil.toURI(location);
36	desc.setLocationURI(projectURI);
37
38	IProject project = root.getProject(name);
39
40	if(project != null) {
41	project.create(desc, null);
42	project.open(null);
43	}
44
45	return project;
46	}
47
48	public void addNature(String natureId) throws CoreException {
49	IProject project = getProject();
50	IProjectDescription description = project.getDescription();
51	String[] natures = description.getNatureIds();
52	String[] newNatures = new String[natures.length + 1];
53	System.arraycopy(natures, 0, newNatures, 0, natures.length);
54	newNatures[natures.length] = natureId;
55	description.setNatureIds(newNatures);
56	project.setDescription(description, null);
57	}
58
59	public void refreshProject() throws Exception {
60	getProject().refreshLocal(IFile.DEPTH_INFINITE, null);
61	}
62
63	public void addBuilder(String builder) throws CoreException {
64	IProjectDescription desc = getProject().getDescription();
65	ICommand command = desc.newCommand();
66	command.setBuilderName(builder);
67	ICommand[] commands = desc.getBuildSpec();
68	ICommand[] nc = new ICommand[commands.length + 1];
69	System.arraycopy(commands, 0, nc, 0, commands.length);
70	nc[commands.length] = command;
71	desc.setBuildSpec(nc);
72	getProject().setDescription(desc, null);
73	}
74
75	public abstract IProject getProject();
76	}

Lines 24-27 Link Here

(-)plugin.xml (+13 lines)
24	servicePath="/"	24	servicePath="/"
25	servicePort="80"/>	25	servicePort="80"/>
26	</extension>	26	</extension>
		27	<extension
		28	point="org.eclipse.tptp.wsdm.editor.codeGeneration">
		29	<description
		30	container="Mini"
		31	platform="OSGi">
		32	</description>
		33	<projectizer
		34	class="org.eclipse.tptp.wsdm.tooling.internal.projectizer.EclipseOsgiProjectizer"
		35	name="OSGi mini"
		36	servicePath="/"
		37	servicePort="80">
		38	</projectizer>
		39	</extension>
27	</plugin>	40	</plugin>