1.5/plugins/org.eclipse.epf.library.ui/src/org/eclipse/epf/library/ui/actions/ProcessDeleteAction.java

//------------------------------------------------------------------------------
// Copyright (c) 2005, 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:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.library.ui.actions;

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

import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.emf.common.command.BasicCommandStack;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.edit.command.RemoveCommand;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.epf.library.edit.TngAdapterFactory;
import org.eclipse.epf.library.edit.command.DeleteMethodElementCommand;
import org.eclipse.epf.library.edit.command.IActionManager;
import org.eclipse.epf.library.edit.command.IResourceAwareCommand;
import org.eclipse.epf.library.edit.process.BreakdownElementWrapperItemProvider;
import org.eclipse.epf.library.edit.process.command.DeleteRoleDescriptor;
import org.eclipse.epf.library.edit.process.command.DeleteTaskDescriptor;
import org.eclipse.epf.library.edit.process.command.DeleteTeamProfile;
import org.eclipse.epf.library.edit.process.command.DeleteUnusedDescriptorsCommand;
import org.eclipse.epf.library.edit.process.command.DeleteWorkProductDescriptor;
import org.eclipse.epf.library.edit.process.command.ProcessElementDeleteCommand;
import org.eclipse.epf.library.edit.process.command.RemoveUnusedDescriptorsCommand;
import org.eclipse.epf.library.ui.LibraryUIResources;
import org.eclipse.epf.uma.Descriptor;
import org.eclipse.epf.uma.RoleDescriptor;
import org.eclipse.epf.uma.TaskDescriptor;
import org.eclipse.epf.uma.TeamProfile;
import org.eclipse.epf.uma.WorkProductDescriptor;
import org.eclipse.epf.uma.util.AssociationHelper;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;

/**
 * Implements the delete action for the process elements.
 * 
 * @author Shilpa Toraskar
 * @author Phong Nguyen Le
 * @since 1.0
 */
public class ProcessDeleteAction extends MethodElementDeleteAction {

	private boolean deletionConfirmed = false;

	private HashSet<Descriptor> removedDescriptors;

	/**
	 * Creates a new instance
	 */
	public ProcessDeleteAction() {
		super();
	}

	/**
	 * Creates a new instance
	 * 
	 * @param domain
	 *            the editing domain
	 */
	public ProcessDeleteAction(EditingDomain domain) {
		super(domain);
	}

	/**
	 * Creates a new instance
	 * 
	 * @param domain
	 *            the editing domain
	 * @param confirm
	 *            if <code>true</code>, displays a prompt to ask for user
	 *            confirmation
	 */
	public ProcessDeleteAction(EditingDomain domain, boolean confirm) {
		super(domain, confirm);
	}

	/**
	 * @see MethodElementDeleteAction#createMethodElementDeleteCommand()
	 */
	public DeleteMethodElementCommand createMethodElementDeleteCommand() {
		return new ProcessElementDeleteCommand(RemoveCommand.create(domain,
				selection), selection, confirm);
	}

	/**
	 * Runs the delete action given the action manager
	 * 
	 * @param actionMgr
	 *            the action manager
	 */
	public void run(IActionManager actionMgr) {
		if (confirmDelete()) {
			for (Iterator itor = selection.iterator(); itor.hasNext();) {
				// remove references
				removeReferences(actionMgr, itor.next());
			}

			// delete element
			domain.getCommandStack().execute(command);
		}
	}

	protected void saveCurrentEditor() {
	}

	/**
	 * @see MethodElementDeleteAction#getDeleteConfirmationMessage()
	 */
	protected String getDeleteConfirmationMessage() {
		return LibraryUIResources.ProcessDeleteAction_deletecofirm_text; 
	}

	protected Command createDeleteUnusedDescriptorsCommand(Collection<Descriptor> descriptors, Collection<?> deletedElements) {
		return new DeleteUnusedDescriptorsCommand(
				descriptors, false, deletedElements) {

			protected Command delete(List elements) {
				return ProcessDeleteAction.delete(elements);
			}

			// protected void selectDescriptorsToDelete(List
			// descriptorsToDelete) {
			// String msg =
			// AuthoringUIResources.ProcessDeleteAction_selectDescriptorsToDelete;
			// Object[] descriptors =
			// ReferenceSelection.getReferences(descriptorsToDelete,
			// msg);
			// descriptorsToDelete.retainAll(Arrays.asList(descriptors));
			// }
		};
	}
	
	/**
	 * @see MethodElementDeleteAction#run()
	 */
	public void run() {
		if (confirmDelete()) {
			// collection the related descriptors before the elements got
			// deleted
			//
			Collection<Descriptor> descriptors = new HashSet<Descriptor>();
			for (Iterator<?> iter = selection.iterator(); iter.hasNext();) {
				Object element = iter.next();
				addRelatedDescriptors(descriptors, element);
			}

			Command cmd = command;

			// delete elements
			//
			cmd.execute();

			// Check reference confirmation and if confirmed set
			// deletionconfirmed to true
			// If any deletion happens in sequence, will check for
			// deletionconfirmed variable
			// and proceeds remaining deletion sequence. (eg:
			// AbstractDiagramEditor - DeleteAction()).
			if (((DeleteMethodElementCommand) cmd).executed) {
				deletionConfirmed = true;

				Collection<?> deletedElements = cmd.getResult();
				Command deleteUnusedDescriptorsCommand = createDeleteUnusedDescriptorsCommand(descriptors, deletedElements);
				try {
					deleteUnusedDescriptorsCommand.execute();
				} catch (OperationCanceledException e) {
					//
				} finally {
					deleteUnusedDescriptorsCommand.dispose();
				}
			}

			// save the current editor
			//
			saveCurrentEditor();
		}
	}

	private static void addRelatedDescriptors(
			Collection<Descriptor> descriptors, Object element) {
		if (element instanceof TaskDescriptor) {
			TaskDescriptor taskDesc = (TaskDescriptor) element;
			descriptors.addAll(taskDesc.getAdditionallyPerformedBy());
			descriptors.addAll(taskDesc.getAssistedBy());
			descriptors.addAll(taskDesc.getPerformedPrimarilyBy());
			descriptors.addAll(taskDesc.getMandatoryInput());
			descriptors.addAll(taskDesc.getExternalInput());
			descriptors.addAll(taskDesc.getOptionalInput());
			descriptors.addAll(taskDesc.getOutput());
		} else if (element instanceof RoleDescriptor) {
			RoleDescriptor roleDesc = (RoleDescriptor) element;
			descriptors.addAll(AssociationHelper
					.getAssistedTaskDescriptors(roleDesc));
			descriptors.addAll(AssociationHelper
					.getAdditionalTaskDescriptors(roleDesc));
			descriptors.addAll(AssociationHelper
					.getPrimaryTaskDescriptors(roleDesc));
			descriptors.addAll(roleDesc.getResponsibleFor());
		}
	}

	private void removeReferences(IActionManager actionMgr, Object obj) {
		IResourceAwareCommand cmd = null;
		boolean force = !confirm;
		if (obj instanceof TaskDescriptor) {
			cmd = new DeleteTaskDescriptor((TaskDescriptor) obj, force);
		} else if (obj instanceof RoleDescriptor) {
			cmd = new DeleteRoleDescriptor((RoleDescriptor) obj, force);
		} else if (obj instanceof WorkProductDescriptor) {
			cmd = new DeleteWorkProductDescriptor((WorkProductDescriptor) obj,
					force);
		} else if (obj instanceof TeamProfile) {
			cmd = new DeleteTeamProfile((TeamProfile) obj);
		}
		if (cmd != null) {
			if (actionMgr != null) {
				actionMgr.execute(cmd);

			} else {
				cmd.execute();
			}
			if (cmd instanceof RemoveUnusedDescriptorsCommand) {
				removedDescriptors
						.addAll(((RemoveUnusedDescriptorsCommand) cmd)
								.getRemovedDescriptors());
			}
		}
	}

	/**
	 * @see org.eclipse.emf.edit.ui.action.CommandActionHandler#updateSelection(org.eclipse.jface.viewers.IStructuredSelection)
	 */
	public boolean updateSelection(IStructuredSelection selection) {
		boolean ret = super.updateSelection(filterSelection(selection));
		return ret;
	}

	/**
	 * Filters selection.
	 * 
	 * @param selection
	 * @return New Selection
	 */
	public static IStructuredSelection filterSelection(
			IStructuredSelection selection) {
		ArrayList<Object> list = new ArrayList<Object>();
		for (Iterator iter = selection.iterator(); iter.hasNext();) {
			Object element = iter.next();
			if (element instanceof BreakdownElementWrapperItemProvider
					&& ((BreakdownElementWrapperItemProvider) element)
							.isReadOnly()) {
				continue;
			} else {
				list.add(element);
			}
		}

		return new StructuredSelection(list);
	}

	/**
	 * If deletion confirmed, set confirmation and child process can use the
	 * confirmation to proceed for the deletion of remaining.
	 * 
	 * @return boolean
	 */
	public boolean isDeletionConfirmed() {
		return deletionConfirmed;
	}

	/**
	 * Return command
	 * 
	 * @return cmd
	 */
	protected Command getCommand() {
		return command;
	}

	/**
	 * Convenience method to delete process elements without UI action
	 * 
	 * @param elements
	 * @return the executed delete command if some of the given elements have
	 *         been successfully deleted, <code>null</code> otherwise
	 * @exception OperationCanceledException
	 *                if user canceled this deletion operation
	 */
	public static Command delete(Collection elements) {
		ProcessDeleteAction deleteAction = new ProcessDeleteAction(null, false) {
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.epf.authoring.ui.actions.MethodElementDeleteAction#createCommand(java.util.Collection)
			 */
			public Command createCommand(Collection selection) {
				domain = new AdapterFactoryEditingDomain(
						TngAdapterFactory.INSTANCE
								.getProcessComposedAdapterFactory(),
						new BasicCommandStack());

				return super.createCommand(selection);
			}

		};
		if (deleteAction.updateSelection(new StructuredSelection(new ArrayList(
				elements)))) {
			deleteAction.run();
			if (!deleteAction.isDeletionConfirmed()) {
				throw new OperationCanceledException();
			}
			return deleteAction.getCommand();
		}
		return null;
	}

}