Attachment #122018 for bug #260459

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

Lines 49-55 Link Here

(-)META-INF/MANIFEST.MF (-2 / +9 lines)
49	org.eclipse.jst.j2ee.project.facet,	49	org.eclipse.jst.j2ee.project.facet,
50	org.eclipse.jst.j2ee.refactor,	50	org.eclipse.jst.j2ee.refactor,
51	org.eclipse.jst.j2ee.refactor.listeners,	51	org.eclipse.jst.j2ee.refactor.listeners,
52	org.eclipse.jst.j2ee.refactor.operations	52	org.eclipse.jst.j2ee.refactor.operations,
		53	org.eclipse.jst.javaee.ltk.core,
		54	org.eclipse.jst.javaee.ltk.core.change,
		55	org.eclipse.jst.javaee.ltk.core.descriptor,
		56	org.eclipse.jst.javaee.ltk.core.nls,
		57	org.eclipse.jst.javaee.ltk.core.participant
53	Require-Bundle: org.eclipse.emf.edit;bundle-version="[2.2.0,3.0.0)",	58	Require-Bundle: org.eclipse.emf.edit;bundle-version="[2.2.0,3.0.0)",
54	org.eclipse.jem.workbench;bundle-version="[2.0.0,3.0.0)",	59	org.eclipse.jem.workbench;bundle-version="[2.0.0,3.0.0)",
55	org.eclipse.jst.j2ee.core;bundle-version="[1.1.0,1.2.0)",	60	org.eclipse.jst.j2ee.core;bundle-version="[1.1.0,1.2.0)",
Lines 81-86 Link Here
81	org.eclipse.wst.common.environment;bundle-version="[1.0.100,1.1.0)",	86	org.eclipse.wst.common.environment;bundle-version="[1.0.100,1.1.0)",
82	org.eclipse.core.expressions;bundle-version="[3.4.0,4.0.0)",	87	org.eclipse.core.expressions;bundle-version="[3.4.0,4.0.0)",
83	org.eclipse.core.commands;bundle-version="[3.4.0,4.0.0)",	88	org.eclipse.core.commands;bundle-version="[3.4.0,4.0.0)",
84	org.eclipse.core.filesystem;bundle-version="[1.2.0,2.0.0)"	89	org.eclipse.core.filesystem;bundle-version="[1.2.0,2.0.0)",
		90	org.eclipse.ltk.core.refactoring;bundle-version="3.4.1",
		91	org.eclipse.jst.j2ee.ejb;bundle-version="1.1.203"
85	Eclipse-LazyStart: true	92	Eclipse-LazyStart: true
86	Bundle-RequiredExecutionEnvironment: J2SE-1.5	93	Bundle-RequiredExecutionEnvironment: J2SE-1.5

Lines 518-524 Link Here

(-)j2eeplugin/org/eclipse/jst/j2ee/internal/plugin/J2EEPlugin.java (-1 / +1 lines)
518	final ProjectRefactoringListener listener = new ProjectRefactoringListener();//ProjectDependencyCache.getCache());	518	final ProjectRefactoringListener listener = new ProjectRefactoringListener();//ProjectDependencyCache.getCache());
519	// register the project rename/delete refactoring listener	519	// register the project rename/delete refactoring listener
520	ResourcesPlugin.getWorkspace().addResourceChangeListener(listener,	520	ResourcesPlugin.getWorkspace().addResourceChangeListener(listener,
521	IResourceChangeEvent.POST_CHANGE \| IResourceChangeEvent.PRE_DELETE);	521	IResourceChangeEvent.POST_CHANGE );
522		522
523	// register the IElementChangedLister that updates the .component file in	523	// register the IElementChangedLister that updates the .component file in
524	// response to .classpath changes	524	// response to .classpath changes

Lines 763-766 Link Here

(-)plugin.xml (+10 lines)
763	</propertyTester>	763	</propertyTester>
764	</extension>	764	</extension>
765		765
		766	<extension
		767	point="org.eclipse.ltk.core.refactoring.deleteParticipants">
		768	<deleteParticipant
		769	class="org.eclipse.jst.javaee.ltk.core.participant.JavaEERefactoringParticipant"
		770	id="JavaEERefactoringParticipant"
		771	name="JavaEERefactoringParticipant">
		772	<enablement></enablement>
		773	</deleteParticipant>
		774	</extension>
		775
766	</plugin>	776	</plugin>




package org.eclipse.jst.javaee.ltk.core;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.Status;
import org.osgi.framework.BundleContext;

/**
 * The activator class controls the plug-in life cycle
 */
public class JavaEERefactoringPlugin extends Plugin {

	// The plug-in ID
	public static final String PLUGIN_ID = "com.ibm.etools.javaee.ltk.core";

	// The shared instance
	private static JavaEERefactoringPlugin plugin;
	
	/**
	 * The constructor
	 */
	public JavaEERefactoringPlugin() {
	}

	public void start(BundleContext context) throws Exception {
		super.start(context);
		plugin = this;
	}

	public void stop(BundleContext context) throws Exception {
		plugin = null;
		super.stop(context);
	}

	
	public static JavaEERefactoringPlugin getDefault() {
		return plugin;
	}
	
	public static void logError(String message) {
		Platform.getLog(Platform.getBundle(PLUGIN_ID)).log( createStatus(IStatus.ERROR, message));
	}

	public static void logError(Throwable exception) {
		Platform.getLog(Platform.getBundle(PLUGIN_ID)).log( createStatus(IStatus.ERROR, exception.getMessage(), exception));
	}

	public static void logError(CoreException exception) {
		Platform.getLog(Platform.getBundle(PLUGIN_ID)).log( exception.getStatus() );
	}
	
	public static IStatus createStatus(int severity, String message, Throwable exception) {
		return new Status(severity, PLUGIN_ID, message, exception);
	}

	public static IStatus createStatus(int severity, String message) {
		return createStatus(severity, message, null);
	}

}




package org.eclipse.jst.javaee.ltk.core.change;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.jst.javaee.ejb.EJBJar;
import org.eclipse.jst.javaee.ejb.EnterpriseBeans;
import org.eclipse.jst.javaee.ejb.SessionBean;
import org.eclipse.jst.javaee.ltk.core.nls.RefactoringResourceHandler;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;


public class DeleteSessionBeanChange extends Change {

	SessionBean sBean = null;
	EJBJar ejbJar = null;
	public DeleteSessionBeanChange(EJBJar jar , SessionBean sb){
		sBean = sb;
		ejbJar = jar;
		
	}
	@Override
	public Object getModifiedElement() {
		return null;
	}

	@Override
	public String getName() {
		String name = NLS.bind(
				RefactoringResourceHandler.Delete_SB_From_DD, new Object[] { sBean.getEjbClass() });
		return name;	
		}

	@Override
	public void initializeValidationData(IProgressMonitor pm) {
	
	}

	@Override
	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException,
			OperationCanceledException {
		return null;
	}

	@Override
	public Change perform(IProgressMonitor pm) throws CoreException {
		deleteEnterpriseBean();
		return null;
	}

	protected void deleteEnterpriseBean() {
		if (ejbJar != null) {
			
			EnterpriseBeans ebs = ejbJar.getEnterpriseBeans();
			ebs.getSessionBeans().remove(sBean);
			ejbJar.setEnterpriseBeans(ebs);
		}
		
	}
}




package org.eclipse.jst.javaee.ltk.core.change;

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.ExecutionException;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
import org.eclipse.jst.j2ee.application.internal.operations.UpdateManifestDataModelProperties;
import org.eclipse.jst.j2ee.application.internal.operations.UpdateManifestDataModelProvider;
import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifest;
import org.eclipse.jst.j2ee.internal.J2EEConstants;
import org.eclipse.jst.j2ee.internal.common.CreationConstants;
import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
import org.eclipse.jst.j2ee.model.IModelProvider;
import org.eclipse.jst.j2ee.model.ModelProviderManager;
import org.eclipse.jst.j2ee.project.JavaEEProjectUtilities;
import org.eclipse.jst.javaee.ltk.core.JavaEERefactoringPlugin;
import org.eclipse.jst.javaee.ltk.core.nls.RefactoringResourceHandler;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.ChangeDescriptor;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.internal.resources.VirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
import org.eclipse.wst.common.frameworks.datamodel.IDataModel;


public class NonEARModuleReferenceRemoveChange extends Change {

	
	public NonEARModuleReferenceRemoveChange(IProject referencingEARProject, IProject projectToRemove) {
		super();
		this.referencingModuleProject = referencingEARProject;
		this.projectToRemove = projectToRemove;
		this.referencingModuleProjectComp = (VirtualComponent)ComponentCore.createComponent(referencingEARProject);
		cachedRefs = referencingModuleProjectComp.getReferences();
		this.projectToRemoveComp = ComponentCore.createComponent(projectToRemove);
	}
	
	IProject referencingModuleProject = null;
	VirtualComponent referencingModuleProjectComp = null;
	IProject projectToRemove = null;
	IVirtualComponent projectToRemoveComp = null;
	IVirtualReference[] cachedRefs = null;
	@Override
	public Object getModifiedElement() {
		return null;
	}

	@Override
	public String getName() {
		
		String name = NLS.bind(
				RefactoringResourceHandler.Remove_JavaEE_References,
				new Object[] {projectToRemove.getName()});
		
		name += referencingModuleProject.getName();
		return name;
		
	}

	@Override
	public void initializeValidationData(IProgressMonitor pm) {
	
	}

	@Override
	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException,
			OperationCanceledException {
		return null;
	}

	@Override
	public Change perform(IProgressMonitor pm) throws CoreException {
		
		try {
			removeModuleDependency();
			if(isEJBClientDeletion()){
				updateEJBDDWithEJBClientDeletion();
			}
		} catch (ExecutionException e) {
			JavaEERefactoringPlugin.logError(e);
		}
		return null;
	}
	
	public ChangeDescriptor getDescriptor() {
		return null;
	}
	
	private boolean isEJBClientDeletion(){
		
		if(!JavaEEProjectUtilities.isEJBProject(referencingModuleProject))
			return false;
		Properties props = referencingModuleProjectComp.getMetaProperties();
		String clientCompName = props.getProperty(CreationConstants.EJB_CLIENT_NAME);
		if(clientCompName == null || clientCompName.isEmpty()){
			return false;
		}
			
		 if(clientCompName.equals(projectToRemove.getName())){
			 return true;
		 }
	        return false;
	}
	
	
	/*
	 * Remove the client JAR entry from the deployment descriptor
	 * This method is to be used only to remove EJB Client jar entry from
	 * EJB DD
	 */
	private void updateEJBDDWithEJBClientDeletion() {
		IModelProvider ejbModel = ModelProviderManager.getModelProvider(referencingModuleProject);
        ejbModel.modify(new Runnable() {
            public void run() {
                IModelProvider writableEjbModel = ModelProviderManager.getModelProvider(referencingModuleProject);
                Object modelObject = writableEjbModel.getModelObject();
                
                if (modelObject instanceof org.eclipse.jst.javaee.ejb.EJBJar) {
                    org.eclipse.jst.javaee.ejb.EJBJar ejbres = (org.eclipse.jst.javaee.ejb.EJBJar) writableEjbModel.getModelObject();
                    if (ejbres != null)
                    	ejbres.setEjbClientJar(null);
                }
                else {
                    org.eclipse.jst.j2ee.ejb.EJBJar ejbres = (org.eclipse.jst.j2ee.ejb.EJBJar) writableEjbModel.getModelObject();
                    ejbres.setEjbClientJar(null);
                }
            	Properties props = referencingModuleProjectComp.getMetaProperties();
            	props.remove(CreationConstants.CLIENT_JAR_URI);
            	props.remove(CreationConstants.EJB_CLIENT_NAME);
            	referencingModuleProjectComp.clearMetaProperties();
            	referencingModuleProjectComp.setMetaProperties(props);
         		
            }
        },null);
	}

	
	
	protected void removeModuleDependency() throws ExecutionException {
		
		// create IVirtualComponents for the dependent and the refactored project
		final IVirtualComponent dependentComp = referencingModuleProjectComp;
		final IVirtualComponent refactoredComp = projectToRemoveComp;
		final IProgressMonitor monitor = new NullProgressMonitor();
		// Does the dependent project have a .component reference on the refactored project?
		final IVirtualReference ref = hadReference();
		final boolean webLibDep = hasWebLibDependency(ref);
		
		// remove the component reference on the deleted project
		if (refactoredComp != null) {
			removeReferencedComponents(monitor);
		}
		
		// update the manifest
			updateManifestDependency(true);
	}
	
	
	protected void updateManifestDependency(final boolean remove) throws ExecutionException {
		final IVirtualComponent dependentComp = referencingModuleProjectComp;
		IProject project= dependentComp.getProject();
		if(project.isAccessible()){
			final String dependentProjName = referencingModuleProject.getName();
			final String refactoredProjName = projectToRemove.getName();
			final IVirtualFile vf = dependentComp.getRootFolder().getFile(new Path(J2EEConstants.MANIFEST_URI) );
			final IFile manifestmf = vf.getUnderlyingFile();
			// adding this check for https://bugs.eclipse.org/bugs/show_bug.cgi?id=170074
			// (some adopters have non-jst.ear module projects that are missing manifests)
			if (!manifestmf.exists()) {  
				return;
			}
			final IProgressMonitor monitor = new NullProgressMonitor();
			final IDataModel updateManifestDataModel = DataModelFactory.createDataModel(new UpdateManifestDataModelProvider());
			updateManifestDataModel.setProperty(UpdateManifestDataModelProperties.PROJECT_NAME, dependentProjName);
			updateManifestDataModel.setBooleanProperty(UpdateManifestDataModelProperties.MERGE, false);
			updateManifestDataModel.setProperty(UpdateManifestDataModelProperties.MANIFEST_FILE, manifestmf);
			final ArchiveManifest manifest = J2EEProjectUtilities.readManifest(manifestmf);
			String[] cp = manifest.getClassPathTokenized();
			List cpList = new ArrayList();
			String newCp = refactoredProjName + ".jar";//$NON-NLS-1$
			for (int i = 0; i < cp.length; i++) {
				if (!cp[i].equals(newCp)) {
					cpList.add(cp[i]);
				}
			}
			if (!remove) {
				cpList.add(newCp);
			}
			updateManifestDataModel.setProperty(UpdateManifestDataModelProperties.JAR_LIST, cpList);
			try {
				updateManifestDataModel.getDefaultOperation().execute(monitor, null );
			} catch (org.eclipse.core.commands.ExecutionException e) {
				JavaEERefactoringPlugin.logError(e);
			}
		}
	}
	
	protected void removeReferencedComponents(IProgressMonitor monitor) {
		
		if (referencingModuleProjectComp == null || !referencingModuleProjectComp.getProject().isAccessible() || referencingModuleProjectComp.isBinary()) return;
		
		IVirtualReference [] existingReferencesArray = cachedRefs;
		if(existingReferencesArray == null || existingReferencesArray.length == 0){
			return;
		}
		
		List existingReferences = new ArrayList();
		for(int i=0;i<existingReferencesArray.length; i++){
			existingReferences.add(existingReferencesArray[i]);
		}
		
		List targetprojectList = new ArrayList();
			if (projectToRemoveComp==null )
				return;

			IVirtualReference ref = findMatchingReference(existingReferences, projectToRemoveComp, null);
			//if a ref was found matching the specified deployPath, then remove it
			if(ref != null){
				removeRefereneceInComponent(referencingModuleProjectComp, ref);
				existingReferences.remove(ref);
				//after removing the ref, check to see if it was the last ref removed to that component
				//and if it was, then also remove the project reference
				ref = findMatchingReference(existingReferences, projectToRemoveComp);
				if(ref == null){
					IProject targetProject = projectToRemoveComp.getProject();
					targetprojectList.add(targetProject);
				}
			}
		
		
		try {
			ProjectUtilities.removeReferenceProjects(referencingModuleProjectComp.getProject(),targetprojectList);
		} catch (CoreException e) {
			JavaEERefactoringPlugin.logError(e);
		}		
		
	}
	
	private IVirtualReference findMatchingReference(List existingReferences, IVirtualComponent comp) {
		return findMatchingReference(existingReferences, comp, null);
	}

	protected void removeRefereneceInComponent(IVirtualComponent component, IVirtualReference reference) {
		((VirtualComponent)component.getComponent()).removeReference(reference);
	}
	
	private IVirtualReference findMatchingReference(List existingReferences, IVirtualComponent comp, IPath path) {
		for(int i=0;i<existingReferences.size(); i++){
			IVirtualReference ref = (IVirtualReference)existingReferences.get(i);
			IVirtualComponent c = ref.getReferencedComponent();
			if(c != null && c.getName().equals(comp.getName())){
				if(path == null){
					return ref;
				} else if(path.equals(ref.getRuntimePath())){
					return ref;
				}
			}
		}
		return null;
	}
	
	
	/**
	 * Does the dependent project have a .component reference on the refactored project?
	 * @return IVirtualReference or null if one didn't exist.
	 */
	protected IVirtualReference hadReference() {
		final IVirtualComponent refactoredComp = projectToRemoveComp;
		if (refactoredComp == null) {
			return null;
		}
		final IVirtualReference[] refs = cachedRefs;
		IVirtualReference ref = null;
		for (int i = 0; i < refs.length; i++) {
			if (refs[i].getReferencedComponent().equals(refactoredComp)) {
				ref = refs[i];
				break;
			}
		}
		return ref;
	}
	
	/**
	 * Does the dependent project have a .project reference on the refactored project?
	 * (dynamic project refs don't count)
	 * @return True if a project reference exists.
	 */
	protected boolean hadProjectReference() {
		try {
			final IProject[] refs = referencingModuleProject.getDescription().getReferencedProjects();
			final IProject refactoredProject= projectToRemove;
			for (int i = 0; i < refs.length; i++) {
				if (refs[i].equals(refactoredProject)) {
					return true;
				}
			} 
		} catch (CoreException ce) {
			JavaEERefactoringPlugin.logError(ce);
		}
		return false;
	}
	
	/**
	 * Returns true if the dependency was a web library dependency. 
	 * @param ref
	 * @return
	 */
	protected static boolean hasWebLibDependency(final IVirtualReference ref) {
		if (ref == null) {
			return false;
		}
		return ref.getRuntimePath().equals(new Path("/WEB-INF/lib")); //$NON-NLS-1$
	}

}




package org.eclipse.jst.javaee.ltk.core.change;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.jst.javaee.ejb.EJBJar;
import org.eclipse.jst.javaee.ejb.EnterpriseBeans;
import org.eclipse.jst.javaee.ejb.EntityBean;
import org.eclipse.jst.javaee.ltk.core.nls.RefactoringResourceHandler;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;


public class DeleteEntityBeanChange extends Change {

	EntityBean eBean = null;
	EJBJar ejbJar = null;
	
	public DeleteEntityBeanChange(EJBJar jar, EntityBean eb){
		eBean = eb;
		ejbJar = jar;
	}

	public Object getModifiedElement() {
		return null;
	}

	public String getName() {
		String name = NLS.bind(
				RefactoringResourceHandler.Delete_EB_From_DD, new Object[] { eBean.getEjbClass() });
		return name;
	}

	@Override
	public void initializeValidationData(IProgressMonitor pm) {
	}

	@Override
	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException,
			OperationCanceledException {
		return null;
	}

	@Override
	public Change perform(IProgressMonitor pm) throws CoreException {
		deleteEnterpriseBean();
		return null;
	}

	protected void deleteEnterpriseBean() {
		if (ejbJar != null) {
			EnterpriseBeans ebs = ejbJar.getEnterpriseBeans();
			ebs.getEntityBeans().remove(eBean);
			ejbJar.setEnterpriseBeans(ebs);
		}
	}
}




package org.eclipse.jst.javaee.ltk.core.change;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.resource.DeleteResourceChange;

public class DeleteEJBClientProjectChange extends DeleteResourceChange {

	IProject ejbClientProject = null;
	
	public DeleteEJBClientProjectChange(IPath resourcePath, boolean forceOutOfSync, boolean forceDelete) {
		super(resourcePath, forceOutOfSync, forceDelete);
		}
	
	public DeleteEJBClientProjectChange(IProject clientProj, boolean forceOutOfSync, boolean forceDelete) {
		super(clientProj.getFullPath(), forceOutOfSync, forceDelete);
		ejbClientProject = clientProj;
	}
	
	public Change perform(IProgressMonitor pm) throws CoreException {
		if(!ejbClientProject.isAccessible())
			return null;
		return super.perform(pm);
	}
}




package org.eclipse.jst.javaee.ltk.core.change;

import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.resource.DeleteResourceChange;

public class DeleteJavaEEResourceChange extends DeleteResourceChange {

	IPath currentResourcePath = null;
	public DeleteJavaEEResourceChange(IPath resourcePath, boolean forceOutOfSync) {
		super(resourcePath, forceOutOfSync);
	}

	public DeleteJavaEEResourceChange(IPath resourcePath, boolean forceOutOfSync, boolean deleteContent) {
		super(resourcePath, forceOutOfSync, deleteContent);
		currentResourcePath = resourcePath;
	}
	
	public Change perform(IProgressMonitor pm) throws CoreException {
		
		if(ResourcesPlugin.getWorkspace().getRoot().findMember(currentResourcePath) == null || !(ResourcesPlugin.getWorkspace().getRoot().findMember(currentResourcePath).isAccessible()))
			return null;
		return super.perform(pm);
	}
}




package org.eclipse.jst.javaee.ltk.core.descriptor;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.ltk.core.refactoring.Refactoring;
import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;

public class EARReferenceRemoveDescriptor extends RefactoringDescriptor {

	public EARReferenceRemoveDescriptor(){
		super (null, null, null, null, -1);
	}
	protected EARReferenceRemoveDescriptor(String id, String project,
			String description, String comment, int flags) {
		super(id, project, description, comment, flags);
		// TODO Auto-generated constructor stub
	}

	@Override
	public Refactoring createRefactoring(RefactoringStatus status)
			throws CoreException {
		// TODO Auto-generated method stub
		return null;
	}
	
	

}




package org.eclipse.jst.javaee.ltk.core.change;

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

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
import org.eclipse.jst.j2ee.internal.common.classpath.J2EEComponentClasspathUpdater;
import org.eclipse.jst.j2ee.model.IEARModelProvider;
import org.eclipse.jst.j2ee.model.ModelProviderManager;
import org.eclipse.jst.javaee.ltk.core.JavaEERefactoringPlugin;
import org.eclipse.jst.javaee.ltk.core.nls.RefactoringResourceHandler;
import org.eclipse.jst.jee.application.ICommonApplication;
import org.eclipse.jst.jee.application.ICommonModule;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.ChangeDescriptor;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.internal.resources.VirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;


public class EARReferenceRemoveChange extends Change {

	
	public EARReferenceRemoveChange(IProject referencingEARProject, IProject projectToRemove) {
		super();
		this.referencingEARProject = referencingEARProject;
		this.projectToRemove = projectToRemove;
		this.referencingEARProjectComp = ComponentCore.createComponent(referencingEARProject);
		cachedRefs = referencingEARProjectComp.getReferences();
		this.projectToRemoveComp = ComponentCore.createComponent(projectToRemove);
		earModel = (IEARModelProvider)ModelProviderManager.getModelProvider(referencingEARProject);
		moduleURI = earModel.getModuleURI(projectToRemoveComp);
	}

	IProject referencingEARProject = null;
	IVirtualComponent referencingEARProjectComp = null;
	IProject projectToRemove = null;
	IVirtualComponent projectToRemoveComp = null;
	IVirtualReference[] cachedRefs = null;
	IEARModelProvider earModel = null;
	String moduleURI = null;
	@Override
	public Object getModifiedElement() {
		return null;
	}

	@Override
	public String getName() {
		String name = NLS.bind( RefactoringResourceHandler.Remove_JavaEE_References, 
				new Object[] {projectToRemove.getName()});
		name += referencingEARProject.getName();
		return name;
	}

	@Override
	public void initializeValidationData(IProgressMonitor pm) {
	}

	@Override
	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException,
			OperationCanceledException {
	return null;
	}

	@Override
	public Change perform(IProgressMonitor pm) throws CoreException {
		updateEARDD();
		removeReferencedComponents(pm);
		return null;
	}
	
	public ChangeDescriptor getDescriptor() {
		return null;
	}
	
	private void updateEARDD() {
		if (!referencingEARProject.isAccessible())
			return;
		J2EEComponentClasspathUpdater.getInstance().queueUpdateEAR(referencingEARProject);
		
		earModel.modify(new Runnable() {
			public void run() {
				ICommonApplication application = (ICommonApplication)earModel.getModelObject();
				if (application == null)
					return;
				IVirtualComponent moduleComponent = projectToRemoveComp.getComponent();
				if(!moduleComponent.isBinary()){
					J2EEComponentClasspathUpdater.getInstance().queueUpdateModule(moduleComponent.getProject());
				}
			
				removeModule(application, moduleURI); 
				IVirtualFile vFile = referencingEARProjectComp.getRootFolder().getFile(moduleURI);
				IFile iFile = vFile.getUnderlyingFile();
				if(iFile.exists()){
					try {
						iFile.delete(true, new NullProgressMonitor());
					} catch (CoreException e) {
						JavaEERefactoringPlugin.logError(e);
					}
				}
			
			}
		}, null);
	}
	
	protected void removeModule(ICommonApplication application, String moduleURI) {
		ICommonModule module = application.getFirstEARModule(moduleURI);
		application.getEARModules().remove(module);
	}
	
	protected void removeReferencedComponents(IProgressMonitor monitor) {
		
		if (referencingEARProjectComp == null || !referencingEARProjectComp.getProject().isAccessible() || referencingEARProjectComp.isBinary()) return;
		
		IVirtualReference [] existingReferencesArray = cachedRefs;
		if(existingReferencesArray == null || existingReferencesArray.length == 0){
			return;
		}
		List existingReferences = new ArrayList();
		for(int i=0;i<existingReferencesArray.length; i++){
			existingReferences.add(existingReferencesArray[i]);
		}
		List targetprojectList = new ArrayList();
		if (projectToRemoveComp==null )
				return;
		IVirtualReference ref = findMatchingReference(existingReferences, projectToRemoveComp, null);
		//if a ref was found matching the specified deployPath, then remove it
		if(ref != null){
			removeRefereneceInComponent(referencingEARProjectComp, ref);
			existingReferences.remove(ref);
			//after removing the ref, check to see if it was the last ref removed to that component
			//and if it was, then also remove the project reference
			ref = findMatchingReference(existingReferences, projectToRemoveComp);
			if(ref == null){
				IProject targetProject = projectToRemoveComp.getProject();
				targetprojectList.add(targetProject);
			}
		}
		
		try {
			ProjectUtilities.removeReferenceProjects(referencingEARProjectComp.getProject(),targetprojectList);
		} catch (CoreException e) {
			JavaEERefactoringPlugin.logError(e);
		}		
		
	}
	
	private IVirtualReference findMatchingReference(List existingReferences, IVirtualComponent comp) {
		return findMatchingReference(existingReferences, comp, null);
	}

	protected void removeRefereneceInComponent(IVirtualComponent component, IVirtualReference reference) {
		((VirtualComponent)component.getComponent()).removeReference(reference);
	}
	
	private IVirtualReference findMatchingReference(List existingReferences, IVirtualComponent comp, IPath path) {
		for(int i=0;i<existingReferences.size(); i++){
			IVirtualReference ref = (IVirtualReference)existingReferences.get(i);
			IVirtualComponent c = ref.getReferencedComponent();
			if(c != null && c.getName().equals(comp.getName())){
				if(path == null){
					return ref;
				} else if(path.equals(ref.getRuntimePath())){
					return ref;
				}
			}
		}
		return null;
	}


}




package org.eclipse.jst.javaee.ltk.core.nls;
/*
 * Licensed Material - Property of IBM 
 * (C) Copyright IBM Corp. 2001, 2002 - All Rights Reserved. 
 * US Government Users Restricted Rights - Use, duplication or disclosure 
 * restricted by GSA ADP Schedule Contract with IBM Corp. 
 */

import org.eclipse.osgi.util.NLS;

public class RefactoringResourceHandler extends NLS {

	private static final String BUNDLE_NAME = "refactoring";//$NON-NLS-1$
	
	public static String Delete_EB_From_DD;
	public static String Delete_MDB_From_DD;
	public static String Delete_SB_From_DD;
	public static String Remove_JavaEE_References;
	public static String JavaEE_Refactorings_Participant_title;
	
	
	private RefactoringResourceHandler() {
		// Do not instantiate
	}
	
	static {
		NLS.initializeMessages(BUNDLE_NAME, RefactoringResourceHandler.class);
	}	
}




package org.eclipse.jst.javaee.ltk.core.change;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.jst.javaee.ejb.EJBJar;
import org.eclipse.jst.javaee.ejb.EnterpriseBeans;
import org.eclipse.jst.javaee.ejb.MessageDrivenBean;
import org.eclipse.jst.javaee.ltk.core.nls.RefactoringResourceHandler;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;


public class DeleteMDBChange extends Change {

	MessageDrivenBean mBean = null;
	EJBJar ejbJar = null;
	public DeleteMDBChange(EJBJar jar, MessageDrivenBean mdb){
		mBean = mdb;
		ejbJar = jar;
		
	}
	@Override
	public Object getModifiedElement() {
		return null;
	}

	@Override
	public String getName() {
		String name = NLS.bind(
				RefactoringResourceHandler.Delete_MDB_From_DD,
				new Object[] { mBean.getEjbClass() });
		return name;	
		}

	@Override
	public void initializeValidationData(IProgressMonitor pm) {
	}

	@Override
	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException,
			OperationCanceledException {
		return null;
	}

	@Override
	public Change perform(IProgressMonitor pm) throws CoreException {
		deleteEnterpriseBean();
		return null;
	}

	
	protected void deleteEnterpriseBean() {
		if (ejbJar != null) {
			EnterpriseBeans ebs = ejbJar.getEnterpriseBeans();
			ebs.getMessageDrivenBeans().remove(mBean);
			ejbJar.setEnterpriseBeans(ebs);
		}
	}

}




package org.eclipse.jst.javaee.ltk.core.participant;

import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.jst.j2ee.ejb.componentcore.util.EJBArtifactEdit;
import org.eclipse.jst.j2ee.project.JavaEEProjectUtilities;
import org.eclipse.jst.javaee.ltk.core.change.DeleteEJBClientProjectChange;
import org.eclipse.jst.javaee.ltk.core.change.EARReferenceRemoveChange;
import org.eclipse.jst.javaee.ltk.core.change.NonEARModuleReferenceRemoveChange;
import org.eclipse.jst.javaee.ltk.core.nls.RefactoringResourceHandler;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.CompositeChange;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.ltk.core.refactoring.participants.CheckConditionsContext;
import org.eclipse.ltk.core.refactoring.participants.DeleteParticipant;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.common.componentcore.internal.builder.IDependencyGraph;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;


public class JavaEERefactoringParticipant extends DeleteParticipant {

	private IProject projectToDelete = null;
	private IProject ejbClientProject = null;
	@Override
	public RefactoringStatus checkConditions(IProgressMonitor pm,
			CheckConditionsContext context) throws OperationCanceledException {
		
		return new RefactoringStatus();
	}

	@Override
	public Change createChange(IProgressMonitor pm) throws CoreException,
			OperationCanceledException {

		CompositeChange result= null;
		result = createChangeObjects(result,projectToDelete);
		
		if(ejbClientProject != null){
			
			result = createChangeObjects (result, ejbClientProject);
			DeleteEJBClientProjectChange dc= new DeleteEJBClientProjectChange(ejbClientProject, true, true);
			result.add(dc);
		}
		
		return result;
	}
	
	
	private CompositeChange createChangeObjects(CompositeChange compositeChange, IProject projectToBeDeleted){
		Set<IProject> referencingComponents = IDependencyGraph.INSTANCE.getReferencingComponents(projectToBeDeleted);
		IProject[] dependentProjectList = (IProject[]) referencingComponents.toArray(new IProject[referencingComponents.size()]);
	
		if (dependentProjectList.length > 0){
			if(compositeChange == null){
			compositeChange = new CompositeChange(getName());
			}
			
			for (int i = 0; i < dependentProjectList.length; i++){
				IProject dependentProject = dependentProjectList[i];
				if(JavaEEProjectUtilities.isEARProject(dependentProjectList[i])){
					EARReferenceRemoveChange ec = new EARReferenceRemoveChange(dependentProject, projectToBeDeleted);
					compositeChange.add(ec);
				}else{
					NonEARModuleReferenceRemoveChange nc = new NonEARModuleReferenceRemoveChange(dependentProject, projectToBeDeleted);
					compositeChange.add(nc);
				}
			}
		}
		
		return compositeChange;
	}
	
	
	private IProject getClientProject(IProject ejbProject) {

		if( ejbProject.exists() && ejbProject.isAccessible()){
			EJBArtifactEdit edit = null;
			try {
				edit = EJBArtifactEdit.getEJBArtifactEditForRead( ejbProject );
				if (edit != null){
					IVirtualComponent clientComp = edit.getEJBClientJarModule();
					if( clientComp != null ){
						return clientComp.getProject();
					}
				}
			} finally {
				if(edit != null)
					edit.dispose();
			}
		}
		return null;
	}


	@Override
	public String getName() {
		
		String name = NLS.bind(
				RefactoringResourceHandler.JavaEE_Refactorings_Participant_title,
				new Object[] { projectToDelete.getName() });
		return name;
	}

	@Override
	protected boolean initialize(Object element) {
		if(!(element instanceof IProject))
			return false;
		projectToDelete = (IProject) element;
		if(JavaEEProjectUtilities.isEJBProject(projectToDelete)){
			ejbClientProject = getClientProject(projectToDelete);
		}
		return true;
	}

}

Added Link Here

(-)property_files/refactoring.properties (+5 lines)
1	Delete_EB_From_DD=Delete Entity Bean ( {0} ) from DD
2	Delete_MDB_From_DD=Delete Message Driven Bean ( {0} ) from DD
3	Delete_SB_From_DD=Delete Session Bean ( {0} ) from DD
4	Remove_JavaEE_References=Remove Java EE References to {0} in
5	JavaEE_Refactorings_Participant_title=Java EE Refactorings for {0}

Return to bug 260459

Added Link Here

(-)ltkbasedrefactoring/org/eclipse/jst/javaee/ltk/core/JavaEERefactoringPlugin.java (+62 lines)
1	package org.eclipse.jst.javaee.ltk.core;
2
3	import org.eclipse.core.runtime.CoreException;
4	import org.eclipse.core.runtime.IStatus;
5	import org.eclipse.core.runtime.Platform;
6	import org.eclipse.core.runtime.Plugin;
7	import org.eclipse.core.runtime.Status;
8	import org.osgi.framework.BundleContext;
9
10	/**
11	* The activator class controls the plug-in life cycle
12	*/
13	public class JavaEERefactoringPlugin extends Plugin {
14
15	// The plug-in ID
16	public static final String PLUGIN_ID = "com.ibm.etools.javaee.ltk.core";
17
18	// The shared instance
19	private static JavaEERefactoringPlugin plugin;
20
21	/**
22	* The constructor
23	*/
24	public JavaEERefactoringPlugin() {
25	}
26
27	public void start(BundleContext context) throws Exception {
28	super.start(context);
29	plugin = this;
30	}
31
32	public void stop(BundleContext context) throws Exception {
33	plugin = null;
34	super.stop(context);
35	}
36
37
38	public static JavaEERefactoringPlugin getDefault() {
39	return plugin;
40	}
41
42	public static void logError(String message) {
43	Platform.getLog(Platform.getBundle(PLUGIN_ID)).log( createStatus(IStatus.ERROR, message));
44	}
45
46	public static void logError(Throwable exception) {
47	Platform.getLog(Platform.getBundle(PLUGIN_ID)).log( createStatus(IStatus.ERROR, exception.getMessage(), exception));
48	}
49
50	public static void logError(CoreException exception) {
51	Platform.getLog(Platform.getBundle(PLUGIN_ID)).log( exception.getStatus() );
52	}
53
54	public static IStatus createStatus(int severity, String message, Throwable exception) {
55	return new Status(severity, PLUGIN_ID, message, exception);
56	}
57
58	public static IStatus createStatus(int severity, String message) {
59	return createStatus(severity, message, null);
60	}
61
62	}

Added Link Here

(-)ltkbasedrefactoring/org/eclipse/jst/javaee/ltk/core/change/DeleteSessionBeanChange.java (+62 lines)
1	package org.eclipse.jst.javaee.ltk.core.change;
2
3	import org.eclipse.core.runtime.CoreException;
4	import org.eclipse.core.runtime.IProgressMonitor;
5	import org.eclipse.core.runtime.OperationCanceledException;
6	import org.eclipse.jst.javaee.ejb.EJBJar;
7	import org.eclipse.jst.javaee.ejb.EnterpriseBeans;
8	import org.eclipse.jst.javaee.ejb.SessionBean;
9	import org.eclipse.jst.javaee.ltk.core.nls.RefactoringResourceHandler;
10	import org.eclipse.ltk.core.refactoring.Change;
11	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
12	import org.eclipse.osgi.util.NLS;
13
14
15	public class DeleteSessionBeanChange extends Change {
16
17	SessionBean sBean = null;
18	EJBJar ejbJar = null;
19	public DeleteSessionBeanChange(EJBJar jar , SessionBean sb){
20	sBean = sb;
21	ejbJar = jar;
22
23	}
24	@Override
25	public Object getModifiedElement() {
26	return null;
27	}
28
29	@Override
30	public String getName() {
31	String name = NLS.bind(
32	RefactoringResourceHandler.Delete_SB_From_DD, new Object[] { sBean.getEjbClass() });
33	return name;
34	}
35
36	@Override
37	public void initializeValidationData(IProgressMonitor pm) {
38
39	}
40
41	@Override
42	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException,
43	OperationCanceledException {
44	return null;
45	}
46
47	@Override
48	public Change perform(IProgressMonitor pm) throws CoreException {
49	deleteEnterpriseBean();
50	return null;
51	}
52
53	protected void deleteEnterpriseBean() {
54	if (ejbJar != null) {
55
56	EnterpriseBeans ebs = ejbJar.getEnterpriseBeans();
57	ebs.getSessionBeans().remove(sBean);
58	ejbJar.setEnterpriseBeans(ebs);
59	}
60
61	}
62	}

Added Link Here

(-)ltkbasedrefactoring/org/eclipse/jst/javaee/ltk/core/change/NonEARModuleReferenceRemoveChange.java (+330 lines)
1	package org.eclipse.jst.javaee.ltk.core.change;
2
3	import java.util.ArrayList;
4	import java.util.List;
5	import java.util.Properties;
6	import java.util.concurrent.ExecutionException;
7
8	import org.eclipse.core.resources.IFile;
9	import org.eclipse.core.resources.IProject;
10	import org.eclipse.core.runtime.CoreException;
11	import org.eclipse.core.runtime.IPath;
12	import org.eclipse.core.runtime.IProgressMonitor;
13	import org.eclipse.core.runtime.NullProgressMonitor;
14	import org.eclipse.core.runtime.OperationCanceledException;
15	import org.eclipse.core.runtime.Path;
16	import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
17	import org.eclipse.jst.j2ee.application.internal.operations.UpdateManifestDataModelProperties;
18	import org.eclipse.jst.j2ee.application.internal.operations.UpdateManifestDataModelProvider;
19	import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifest;
20	import org.eclipse.jst.j2ee.internal.J2EEConstants;
21	import org.eclipse.jst.j2ee.internal.common.CreationConstants;
22	import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
23	import org.eclipse.jst.j2ee.model.IModelProvider;
24	import org.eclipse.jst.j2ee.model.ModelProviderManager;
25	import org.eclipse.jst.j2ee.project.JavaEEProjectUtilities;
26	import org.eclipse.jst.javaee.ltk.core.JavaEERefactoringPlugin;
27	import org.eclipse.jst.javaee.ltk.core.nls.RefactoringResourceHandler;
28	import org.eclipse.ltk.core.refactoring.Change;
29	import org.eclipse.ltk.core.refactoring.ChangeDescriptor;
30	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
31	import org.eclipse.osgi.util.NLS;
32	import org.eclipse.wst.common.componentcore.ComponentCore;
33	import org.eclipse.wst.common.componentcore.internal.resources.VirtualComponent;
34	import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
35	import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
36	import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
37	import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
38	import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
39
40
41	public class NonEARModuleReferenceRemoveChange extends Change {
42
43
44	public NonEARModuleReferenceRemoveChange(IProject referencingEARProject, IProject projectToRemove) {
45	super();
46	this.referencingModuleProject = referencingEARProject;
47	this.projectToRemove = projectToRemove;
48	this.referencingModuleProjectComp = (VirtualComponent)ComponentCore.createComponent(referencingEARProject);
49	cachedRefs = referencingModuleProjectComp.getReferences();
50	this.projectToRemoveComp = ComponentCore.createComponent(projectToRemove);
51	}
52
53	IProject referencingModuleProject = null;
54	VirtualComponent referencingModuleProjectComp = null;
55	IProject projectToRemove = null;
56	IVirtualComponent projectToRemoveComp = null;
57	IVirtualReference[] cachedRefs = null;
58	@Override
59	public Object getModifiedElement() {
60	return null;
61	}
62
63	@Override
64	public String getName() {
65
66	String name = NLS.bind(
67	RefactoringResourceHandler.Remove_JavaEE_References,
68	new Object[] {projectToRemove.getName()});
69
70	name += referencingModuleProject.getName();
71	return name;
72
73	}
74
75	@Override
76	public void initializeValidationData(IProgressMonitor pm) {
77
78	}
79
80	@Override
81	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException,
82	OperationCanceledException {
83	return null;
84	}
85
86	@Override
87	public Change perform(IProgressMonitor pm) throws CoreException {
88
89	try {
90	removeModuleDependency();
91	if(isEJBClientDeletion()){
92	updateEJBDDWithEJBClientDeletion();
93	}
94	} catch (ExecutionException e) {
95	JavaEERefactoringPlugin.logError(e);
96	}
97	return null;
98	}
99
100	public ChangeDescriptor getDescriptor() {
101	return null;
102	}
103
104	private boolean isEJBClientDeletion(){
105
106	if(!JavaEEProjectUtilities.isEJBProject(referencingModuleProject))
107	return false;
108	Properties props = referencingModuleProjectComp.getMetaProperties();
109	String clientCompName = props.getProperty(CreationConstants.EJB_CLIENT_NAME);
110	if(clientCompName == null \|\| clientCompName.isEmpty()){
111	return false;
112	}
113
114	if(clientCompName.equals(projectToRemove.getName())){
115	return true;
116	}
117	return false;
118	}
119
120
121	/*
122	* Remove the client JAR entry from the deployment descriptor
123	* This method is to be used only to remove EJB Client jar entry from
124	* EJB DD
125	*/
126	private void updateEJBDDWithEJBClientDeletion() {
127	IModelProvider ejbModel = ModelProviderManager.getModelProvider(referencingModuleProject);
128	ejbModel.modify(new Runnable() {
129	public void run() {
130	IModelProvider writableEjbModel = ModelProviderManager.getModelProvider(referencingModuleProject);
131	Object modelObject = writableEjbModel.getModelObject();
132
133	if (modelObject instanceof org.eclipse.jst.javaee.ejb.EJBJar) {
134	org.eclipse.jst.javaee.ejb.EJBJar ejbres = (org.eclipse.jst.javaee.ejb.EJBJar) writableEjbModel.getModelObject();
135	if (ejbres != null)
136	ejbres.setEjbClientJar(null);
137	}
138	else {
139	org.eclipse.jst.j2ee.ejb.EJBJar ejbres = (org.eclipse.jst.j2ee.ejb.EJBJar) writableEjbModel.getModelObject();
140	ejbres.setEjbClientJar(null);
141	}
142	Properties props = referencingModuleProjectComp.getMetaProperties();
143	props.remove(CreationConstants.CLIENT_JAR_URI);
144	props.remove(CreationConstants.EJB_CLIENT_NAME);
145	referencingModuleProjectComp.clearMetaProperties();
146	referencingModuleProjectComp.setMetaProperties(props);
147
148	}
149	},null);
150	}
151
152
153
154	protected void removeModuleDependency() throws ExecutionException {
155
156	// create IVirtualComponents for the dependent and the refactored project
157	final IVirtualComponent dependentComp = referencingModuleProjectComp;
158	final IVirtualComponent refactoredComp = projectToRemoveComp;
159	final IProgressMonitor monitor = new NullProgressMonitor();
160	// Does the dependent project have a .component reference on the refactored project?
161	final IVirtualReference ref = hadReference();
162	final boolean webLibDep = hasWebLibDependency(ref);
163
164	// remove the component reference on the deleted project
165	if (refactoredComp != null) {
166	removeReferencedComponents(monitor);
167	}
168
169	// update the manifest
170	updateManifestDependency(true);
171	}
172
173
174	protected void updateManifestDependency(final boolean remove) throws ExecutionException {
175	final IVirtualComponent dependentComp = referencingModuleProjectComp;
176	IProject project= dependentComp.getProject();
177	if(project.isAccessible()){
178	final String dependentProjName = referencingModuleProject.getName();
179	final String refactoredProjName = projectToRemove.getName();
180	final IVirtualFile vf = dependentComp.getRootFolder().getFile(new Path(J2EEConstants.MANIFEST_URI) );
181	final IFile manifestmf = vf.getUnderlyingFile();
182	// adding this check for https://bugs.eclipse.org/bugs/show_bug.cgi?id=170074
183	// (some adopters have non-jst.ear module projects that are missing manifests)
184	if (!manifestmf.exists()) {
185	return;
186	}
187	final IProgressMonitor monitor = new NullProgressMonitor();
188	final IDataModel updateManifestDataModel = DataModelFactory.createDataModel(new UpdateManifestDataModelProvider());
189	updateManifestDataModel.setProperty(UpdateManifestDataModelProperties.PROJECT_NAME, dependentProjName);
190	updateManifestDataModel.setBooleanProperty(UpdateManifestDataModelProperties.MERGE, false);
191	updateManifestDataModel.setProperty(UpdateManifestDataModelProperties.MANIFEST_FILE, manifestmf);
192	final ArchiveManifest manifest = J2EEProjectUtilities.readManifest(manifestmf);
193	String[] cp = manifest.getClassPathTokenized();
194	List cpList = new ArrayList();
195	String newCp = refactoredProjName + ".jar";//$NON-NLS-1$
196	for (int i = 0; i < cp.length; i++) {
197	if (!cp[i].equals(newCp)) {
198	cpList.add(cp[i]);
199	}
200	}
201	if (!remove) {
202	cpList.add(newCp);
203	}
204	updateManifestDataModel.setProperty(UpdateManifestDataModelProperties.JAR_LIST, cpList);
205	try {
206	updateManifestDataModel.getDefaultOperation().execute(monitor, null );
207	} catch (org.eclipse.core.commands.ExecutionException e) {
208	JavaEERefactoringPlugin.logError(e);
209	}
210	}
211	}
212
213	protected void removeReferencedComponents(IProgressMonitor monitor) {
214
215	if (referencingModuleProjectComp == null \|\| !referencingModuleProjectComp.getProject().isAccessible() \|\| referencingModuleProjectComp.isBinary()) return;
216
217	IVirtualReference [] existingReferencesArray = cachedRefs;
218	if(existingReferencesArray == null \|\| existingReferencesArray.length == 0){
219	return;
220	}
221
222	List existingReferences = new ArrayList();
223	for(int i=0;i<existingReferencesArray.length; i++){
224	existingReferences.add(existingReferencesArray[i]);
225	}
226
227	List targetprojectList = new ArrayList();
228	if (projectToRemoveComp==null )
229	return;
230
231	IVirtualReference ref = findMatchingReference(existingReferences, projectToRemoveComp, null);
232	//if a ref was found matching the specified deployPath, then remove it
233	if(ref != null){
234	removeRefereneceInComponent(referencingModuleProjectComp, ref);
235	existingReferences.remove(ref);
236	//after removing the ref, check to see if it was the last ref removed to that component
237	//and if it was, then also remove the project reference
238	ref = findMatchingReference(existingReferences, projectToRemoveComp);
239	if(ref == null){
240	IProject targetProject = projectToRemoveComp.getProject();
241	targetprojectList.add(targetProject);
242	}
243	}
244
245
246	try {
247	ProjectUtilities.removeReferenceProjects(referencingModuleProjectComp.getProject(),targetprojectList);
248	} catch (CoreException e) {
249	JavaEERefactoringPlugin.logError(e);
250	}
251
252	}
253
254	private IVirtualReference findMatchingReference(List existingReferences, IVirtualComponent comp) {
255	return findMatchingReference(existingReferences, comp, null);
256	}
257
258	protected void removeRefereneceInComponent(IVirtualComponent component, IVirtualReference reference) {
259	((VirtualComponent)component.getComponent()).removeReference(reference);
260	}
261
262	private IVirtualReference findMatchingReference(List existingReferences, IVirtualComponent comp, IPath path) {
263	for(int i=0;i<existingReferences.size(); i++){
264	IVirtualReference ref = (IVirtualReference)existingReferences.get(i);
265	IVirtualComponent c = ref.getReferencedComponent();
266	if(c != null && c.getName().equals(comp.getName())){
267	if(path == null){
268	return ref;
269	} else if(path.equals(ref.getRuntimePath())){
270	return ref;
271	}
272	}
273	}
274	return null;
275	}
276
277
278	/**
279	* Does the dependent project have a .component reference on the refactored project?
280	* @return IVirtualReference or null if one didn't exist.
281	*/
282	protected IVirtualReference hadReference() {
283	final IVirtualComponent refactoredComp = projectToRemoveComp;
284	if (refactoredComp == null) {
285	return null;
286	}
287	final IVirtualReference[] refs = cachedRefs;
288	IVirtualReference ref = null;
289	for (int i = 0; i < refs.length; i++) {
290	if (refs[i].getReferencedComponent().equals(refactoredComp)) {
291	ref = refs[i];
292	break;
293	}
294	}
295	return ref;
296	}
297
298	/**
299	* Does the dependent project have a .project reference on the refactored project?
300	* (dynamic project refs don't count)
301	* @return True if a project reference exists.
302	*/
303	protected boolean hadProjectReference() {
304	try {
305	final IProject[] refs = referencingModuleProject.getDescription().getReferencedProjects();
306	final IProject refactoredProject= projectToRemove;
307	for (int i = 0; i < refs.length; i++) {
308	if (refs[i].equals(refactoredProject)) {
309	return true;
310	}
311	}
312	} catch (CoreException ce) {
313	JavaEERefactoringPlugin.logError(ce);
314	}
315	return false;
316	}
317
318	/**
319	* Returns true if the dependency was a web library dependency.
320	* @param ref
321	* @return
322	*/
323	protected static boolean hasWebLibDependency(final IVirtualReference ref) {
324	if (ref == null) {
325	return false;
326	}
327	return ref.getRuntimePath().equals(new Path("/WEB-INF/lib")); //$NON-NLS-1$
328	}
329
330	}

Added Link Here

(-)ltkbasedrefactoring/org/eclipse/jst/javaee/ltk/core/change/DeleteJavaEEResourceChange.java (+28 lines)
1	package org.eclipse.jst.javaee.ltk.core.change;
2
3	import org.eclipse.core.resources.ResourcesPlugin;
4	import org.eclipse.core.runtime.CoreException;
5	import org.eclipse.core.runtime.IPath;
6	import org.eclipse.core.runtime.IProgressMonitor;
7	import org.eclipse.ltk.core.refactoring.Change;
8	import org.eclipse.ltk.core.refactoring.resource.DeleteResourceChange;
9
10	public class DeleteJavaEEResourceChange extends DeleteResourceChange {
11
12	IPath currentResourcePath = null;
13	public DeleteJavaEEResourceChange(IPath resourcePath, boolean forceOutOfSync) {
14	super(resourcePath, forceOutOfSync);
15	}
16
17	public DeleteJavaEEResourceChange(IPath resourcePath, boolean forceOutOfSync, boolean deleteContent) {
18	super(resourcePath, forceOutOfSync, deleteContent);
19	currentResourcePath = resourcePath;
20	}
21
22	public Change perform(IProgressMonitor pm) throws CoreException {
23
24	if(ResourcesPlugin.getWorkspace().getRoot().findMember(currentResourcePath) == null \|\| !(ResourcesPlugin.getWorkspace().getRoot().findMember(currentResourcePath).isAccessible()))
25	return null;
26	return super.perform(pm);
27	}
28	}

Added Link Here

(-)ltkbasedrefactoring/org/eclipse/jst/javaee/ltk/core/nls/RefactoringResourceHandler.java (+29 lines)
1	package org.eclipse.jst.javaee.ltk.core.nls;
2	/*
3	* Licensed Material - Property of IBM
4	* (C) Copyright IBM Corp. 2001, 2002 - All Rights Reserved.
5	* US Government Users Restricted Rights - Use, duplication or disclosure
6	* restricted by GSA ADP Schedule Contract with IBM Corp.
7	*/
8
9	import org.eclipse.osgi.util.NLS;
10
11	public class RefactoringResourceHandler extends NLS {
12
13	private static final String BUNDLE_NAME = "refactoring";//$NON-NLS-1$
14
15	public static String Delete_EB_From_DD;
16	public static String Delete_MDB_From_DD;
17	public static String Delete_SB_From_DD;
18	public static String Remove_JavaEE_References;
19	public static String JavaEE_Refactorings_Participant_title;
20
21
22	private RefactoringResourceHandler() {
23	// Do not instantiate
24	}
25
26	static {
27	NLS.initializeMessages(BUNDLE_NAME, RefactoringResourceHandler.class);
28	}
29	}

Added Link Here

(-)ltkbasedrefactoring/org/eclipse/jst/javaee/ltk/core/participant/JavaEERefactoringParticipant.java (+120 lines)
1	package org.eclipse.jst.javaee.ltk.core.participant;
2
3	import java.util.Set;
4
5	import org.eclipse.core.resources.IProject;
6	import org.eclipse.core.runtime.CoreException;
7	import org.eclipse.core.runtime.IProgressMonitor;
8	import org.eclipse.core.runtime.OperationCanceledException;
9	import org.eclipse.jst.j2ee.ejb.componentcore.util.EJBArtifactEdit;
10	import org.eclipse.jst.j2ee.project.JavaEEProjectUtilities;
11	import org.eclipse.jst.javaee.ltk.core.change.DeleteEJBClientProjectChange;
12	import org.eclipse.jst.javaee.ltk.core.change.EARReferenceRemoveChange;
13	import org.eclipse.jst.javaee.ltk.core.change.NonEARModuleReferenceRemoveChange;
14	import org.eclipse.jst.javaee.ltk.core.nls.RefactoringResourceHandler;
15	import org.eclipse.ltk.core.refactoring.Change;
16	import org.eclipse.ltk.core.refactoring.CompositeChange;
17	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
18	import org.eclipse.ltk.core.refactoring.participants.CheckConditionsContext;
19	import org.eclipse.ltk.core.refactoring.participants.DeleteParticipant;
20	import org.eclipse.osgi.util.NLS;
21	import org.eclipse.wst.common.componentcore.internal.builder.IDependencyGraph;
22	import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
23
24
25	public class JavaEERefactoringParticipant extends DeleteParticipant {
26
27	private IProject projectToDelete = null;
28	private IProject ejbClientProject = null;
29	@Override
30	public RefactoringStatus checkConditions(IProgressMonitor pm,
31	CheckConditionsContext context) throws OperationCanceledException {
32
33	return new RefactoringStatus();
34	}
35
36	@Override
37	public Change createChange(IProgressMonitor pm) throws CoreException,
38	OperationCanceledException {
39
40	CompositeChange result= null;
41	result = createChangeObjects(result,projectToDelete);
42
43	if(ejbClientProject != null){
44
45	result = createChangeObjects (result, ejbClientProject);
46	DeleteEJBClientProjectChange dc= new DeleteEJBClientProjectChange(ejbClientProject, true, true);
47	result.add(dc);
48	}
49
50	return result;
51	}
52
53
54	private CompositeChange createChangeObjects(CompositeChange compositeChange, IProject projectToBeDeleted){
55	Set<IProject> referencingComponents = IDependencyGraph.INSTANCE.getReferencingComponents(projectToBeDeleted);
56	IProject[] dependentProjectList = (IProject[]) referencingComponents.toArray(new IProject[referencingComponents.size()]);
57
58	if (dependentProjectList.length > 0){
59	if(compositeChange == null){
60	compositeChange = new CompositeChange(getName());
61	}
62
63	for (int i = 0; i < dependentProjectList.length; i++){
64	IProject dependentProject = dependentProjectList[i];
65	if(JavaEEProjectUtilities.isEARProject(dependentProjectList[i])){
66	EARReferenceRemoveChange ec = new EARReferenceRemoveChange(dependentProject, projectToBeDeleted);
67	compositeChange.add(ec);
68	}else{
69	NonEARModuleReferenceRemoveChange nc = new NonEARModuleReferenceRemoveChange(dependentProject, projectToBeDeleted);
70	compositeChange.add(nc);
71	}
72	}
73	}
74
75	return compositeChange;
76	}
77
78
79	private IProject getClientProject(IProject ejbProject) {
80
81	if( ejbProject.exists() && ejbProject.isAccessible()){
82	EJBArtifactEdit edit = null;
83	try {
84	edit = EJBArtifactEdit.getEJBArtifactEditForRead( ejbProject );
85	if (edit != null){
86	IVirtualComponent clientComp = edit.getEJBClientJarModule();
87	if( clientComp != null ){
88	return clientComp.getProject();
89	}
90	}
91	} finally {
92	if(edit != null)
93	edit.dispose();
94	}
95	}
96	return null;
97	}
98
99
100	@Override
101	public String getName() {
102
103	String name = NLS.bind(
104	RefactoringResourceHandler.JavaEE_Refactorings_Participant_title,
105	new Object[] { projectToDelete.getName() });
106	return name;
107	}
108
109	@Override
110	protected boolean initialize(Object element) {
111	if(!(element instanceof IProject))
112	return false;
113	projectToDelete = (IProject) element;
114	if(JavaEEProjectUtilities.isEJBProject(projectToDelete)){
115	ejbClientProject = getClientProject(projectToDelete);
116	}
117	return true;
118	}
119
120	}