//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 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.edit.process.command;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import org.eclipse.emf.common.CommonPlugin;
import org.eclipse.emf.common.command.BasicCommandStack;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.util.AbstractTreeIterator;
import org.eclipse.emf.common.util.WrappedException;
import org.eclipse.emf.ecore.EObject;
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.IConfigurator;
import org.eclipse.epf.library.edit.LibraryEditResources;
import org.eclipse.epf.library.edit.Providers;
import org.eclipse.epf.library.edit.TngAdapterFactory;
import org.eclipse.epf.library.edit.command.BatchCommand;
import org.eclipse.epf.library.edit.command.IResourceAwareCommand;
import org.eclipse.epf.library.edit.ui.UserInteractionHelper;
import org.eclipse.epf.library.edit.util.Messenger;
import org.eclipse.epf.library.edit.util.ProcessUtil;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.Deliverable;
import org.eclipse.epf.uma.Descriptor;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.Role;
import org.eclipse.epf.uma.RoleDescriptor;
import org.eclipse.epf.uma.Task;
import org.eclipse.epf.uma.TaskDescriptor;
import org.eclipse.epf.uma.TeamProfile;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.epf.uma.WorkProduct;
import org.eclipse.epf.uma.WorkProductDescriptor;
/**
* Command for one-way synchronization from method to process.
*
* @author Phong Nguyen Le - Nov 22, 2005
* @since 1.0
*/
public class SynchronizeCommand extends CompoundCommand implements
IResourceAwareCommand {
private Collection elements;
private IConfigurator configurator;
protected boolean aborted;
private ArrayList deleteList;
protected boolean preExecSuccessful;
protected List deleteCommandList;
protected boolean successful;
private MethodConfiguration config;
private Set synchFeatures;
private DeleteUnusedDescriptorsCommand deleteUnusedDescriptorsCommand;
private Collection activities;
private boolean showSuccessfulMsg = true;
private boolean intialized;
private BatchCommand batchCommand = new BatchCommand(false);
private Map<VariabilityElement, VariabilityElement> replacerToBaseMap = new HashMap<VariabilityElement, VariabilityElement>();
// private Object UIContext;
/**
* Constructs a SynchronizeCommand that use the process default
* configuration to synchronize all the synchronizable features
*
* @param elements
* a list of BreakdownElement objects
*/
public SynchronizeCommand(String label, Collection elements) {
super(label);
this.elements = elements;
}
/**
* Constructs a SynchronizeCommand that use the given configuration
* and list of synchronizable features to synchronize
*
* @param elements
* @param config the configuration
* @param synchFeatures the synchronizable features
*/
public SynchronizeCommand(Collection elements, MethodConfiguration config, Set synchFeatures, boolean showSuccessfulMsg) {
super(LibraryEditResources.AutoSynchronizeCommand_label);
this.elements = elements;
this.config = config;
this.synchFeatures = synchFeatures;
this.showSuccessfulMsg = showSuccessfulMsg;
}
public void setMethodConfiguration(MethodConfiguration config) {
this.config = config;
if(configurator != null) {
configurator.setMethodConfiguration(config);
}
}
public void setSynchronizationFeatures(Set synchFeatures) {
this.synchFeatures = synchFeatures;
}
private boolean doInitialize() {
commandList.clear();
if (elements == null || elements.isEmpty()) {
return false;
}
deleteCommandList = new ArrayList();
deleteList = new ArrayList();
activities = new ArrayList();
for (Iterator iter = elements.iterator(); iter.hasNext();) {
Object element = (Object) iter.next();
addToDeleteList(element, deleteList);
if(element instanceof Activity) {
activities.add(element);
}
}
elements.removeAll(deleteList);
for (Iterator<?> iter = elements.iterator(); iter.hasNext();) {
Object object = iter.next();
if (object instanceof Descriptor) {
if(!deleteList.contains(object)) {
Descriptor descriptor = (Descriptor) object;
if (descriptor.getIsSynchronizedWithSource().booleanValue()) {
if(descriptor.getSuperActivities() == null) {
// descriptor is used by TeamProfile to represent a role or used by a deliverable descriptor to
// represent a deliverable part
//
if(descriptor instanceof WorkProductDescriptor && ((WorkProductDescriptor)descriptor).getWorkProduct() instanceof Deliverable) {
append(new SynchronizeDeliverableDescriptorCommand((WorkProductDescriptor) descriptor, synchFeatures, config));
}
else {
append(new BasicSynchronizeDescriptorCommand(descriptor, synchFeatures, config));
}
}
else {
Activity act = descriptor.getSuperActivities();
if (object instanceof TaskDescriptor) {
Task task = ((TaskDescriptor) object).getTask();
if (task != null) {
if(replacerToBaseMap.containsKey(task)) {
task = (Task) replacerToBaseMap.get(task);
}
append(new WBSDropCommand(act, Collections
.singletonList(task),
Collections
.singletonList((TaskDescriptor)object), config, synchFeatures));
}
} else if (object instanceof RoleDescriptor) {
Role role = ((RoleDescriptor) object).getRole();
if (role != null) {
if(replacerToBaseMap.containsKey(role)) {
role = (Role) replacerToBaseMap.get(role);
}
append(new OBSDropCommand(act, Collections
.singletonList(role), config, synchFeatures, configurator));
}
} else if (object instanceof WorkProductDescriptor) {
WorkProduct wp = ((WorkProductDescriptor) object)
.getWorkProduct();
if (wp != null) {
if(replacerToBaseMap.containsKey(wp)) {
wp = (WorkProduct) replacerToBaseMap.get(wp);
}
append(new PBSDropCommand(act, Collections
.singletonList(wp), config, synchFeatures, configurator));
}
}
}
}
else {
appendRemoveDuplicateGuidanceRefCommand(descriptor);
}
}
} else if (object instanceof Activity) {
appendCommands((Activity) object);
} else if (object instanceof TeamProfile) {
appendCommands((TeamProfile)object);
}
}
return !deleteList.isEmpty() || !commandList.isEmpty() || !activities.isEmpty();
}
public boolean initilize() {
boolean b = isPrepared;
try {
// since Eclipse 3.3, CompoundCommand.append() throws IllegalStateException if isPrepared is already set
// but this method is called after isPrepared is set in canExecute() and it makes many calls to append()
// work-around is to unset isPrepared at beginning of this method and set it back to old value at method end.
//
isPrepared = false;
return intialized = doInitialize();
}
finally {
isPrepared = b;
}
}
/**
* @return the intialized
*/
public boolean isIntialized() {
return intialized;
}
/**
* @param activity
*/
private void appendCommands(Activity activity) {
List<Task> tasks = new ArrayList<Task>();
List<TaskDescriptor> tds = new ArrayList<TaskDescriptor>();
List<Role> roles = new ArrayList<Role>();
List<WorkProduct> workProducts = new ArrayList<WorkProduct>();
List<Activity> activities = new ArrayList<Activity>();
for (Iterator<?> iter = activity.getBreakdownElements().iterator(); iter
.hasNext();) {
Object element = iter.next();
if (element instanceof Descriptor) {
if(!deleteList.contains(element)) {
Descriptor descriptor = ((Descriptor) element);
if (descriptor.getIsSynchronizedWithSource()
.booleanValue()) {
if (element instanceof TaskDescriptor) {
Task task = ((TaskDescriptor) element).getTask();
if (task != null) {
if(replacerToBaseMap.containsKey(task)) {
task = (Task) replacerToBaseMap.get(task);
}
tasks.add(task);
tds.add((TaskDescriptor) element);
}
} else if (element instanceof RoleDescriptor) {
Role role = ((RoleDescriptor) element).getRole();
if (role != null) {
if(replacerToBaseMap.containsKey(role)) {
role = (Role) replacerToBaseMap.get(role);
}
roles.add(role);
}
} else if (element instanceof WorkProductDescriptor) {
WorkProduct wp = ((WorkProductDescriptor) element)
.getWorkProduct();
if (wp != null) {
if(replacerToBaseMap.containsKey(wp)) {
wp = (WorkProduct) replacerToBaseMap.get(wp);
}
workProducts.add(wp);
}
}
} else {
appendRemoveDuplicateGuidanceRefCommand(descriptor);
}
}
} else if (element instanceof Activity) {
activities.add((Activity) element);
} else if (element instanceof TeamProfile) {
appendCommands((TeamProfile)element);
}
}
if (!tasks.isEmpty()) {
append(new WBSDropCommand(activity, tasks, tds, config, synchFeatures));
}
if (!roles.isEmpty()) {
append(new OBSDropCommand(activity, roles, config, synchFeatures, configurator));
}
if (!workProducts.isEmpty()) {
append(new PBSDropCommand(activity, workProducts, config,
synchFeatures, configurator));
}
for (Iterator<Activity> iter = activities.iterator(); iter.hasNext();) {
appendCommands(iter.next());
}
}
private void appendRemoveDuplicateGuidanceRefCommand(Descriptor descriptor) {
append(new RemoveDuplicateReferenceCommand(descriptor, ProcessCommandUtil.CONTENT_ELEMENT_GUIDANCE_REFERENCES, config));
}
private void appendCommands(TeamProfile team) {
Iterator iter = new AbstractTreeIterator(team, false) {
/**
*
*/
private static final long serialVersionUID = 1L;
protected Iterator getChildren(Object object) {
if(object instanceof TeamProfile) {
TeamProfile team = ((TeamProfile)object);
List children = new ArrayList(team.getSubTeam());
children.addAll(team.getTeamRoles());
return children.iterator();
}
else {
return Collections.EMPTY_LIST.iterator();
}
}
};
while(iter.hasNext()) {
Object obj = iter.next();
// synch only own role descriptor of team profile
//
if(obj instanceof RoleDescriptor && ((RoleDescriptor)obj).getSuperActivities() == null) {
append(new BasicSynchronizeDescriptorCommand((Descriptor) obj, synchFeatures, config));
}
}
}
/*
* (non-Javadoc)
*
* @see com.ibm.library.edit.command.IResourceAwareCommand#getModifiedResources()
*/
public Collection getModifiedResources() {
HashSet modifiedResources = new HashSet();
for (Iterator iter = commandList.iterator(); iter.hasNext();) {
Object cmd = iter.next();
if(cmd instanceof IResourceAwareCommand) {
modifiedResources.addAll(((IResourceAwareCommand)cmd).getModifiedResources());
}
}
return modifiedResources;
}
// public void setUIContext(Object UIContext) {
// this.UIContext = UIContext;
// }
/*
* (non-Javadoc)
*
* @see org.eclipse.emf.common.command.CompoundCommand#execute()
*/
public void execute() {
// delete all descriptors whose linked element are no longer in the
// configuration
//
if (!deleteList.isEmpty()) {
Command cmd = delete(deleteList);
if (cmd != null) {
deleteCommandList.add(cmd);
}
}
batchCommand.execute();
if (!aborted) {
// IRunnableWithProgress runnable = new IRunnableWithProgress() {
//
// public void run(IProgressMonitor monitor)
// throws InvocationTargetException, InterruptedException {
// preExecSuccessful = preExecute();
// }
//
// };
//
// UserInteractionHelper.runWithProgress(runnable, false, null);
//
// if (preExecSuccessful) {
// try {
// BusyIndicator.showWhile(Display.getCurrent(), new Runnable() {
//
// public void run() {
// superRedo();
// successful = true;
// }
//
// });
// }
// catch(RuntimeException e) {
// LibraryEditPlugin.getDefault().getMsgDialog().displayError(getLabel(), e.toString());
// }
// }
Runnable runnable = new Runnable() {
public void run() {
preExecSuccessful = preExecute();
if(preExecute()) {
superRedo();
successful = true;
}
}
};
UserInteractionHelper.runInUI(runnable, getLabel());
if (successful) {
if(!activities.isEmpty()) {
if(deleteUnusedDescriptorsCommand == null) {
deleteUnusedDescriptorsCommand = new DeleteUnusedDescriptorsCommand(elements, true, deleteList) {
protected Command delete(List elements) {
return SynchronizeCommand.this.delete(elements);
}
};
deleteCommandList.add(deleteUnusedDescriptorsCommand);
}
deleteUnusedDescriptorsCommand.execute();
}
if (showSuccessfulMsg) {
if(!replacerToBaseMap.isEmpty()) {
refreshViewer();
}
Messenger.INSTANCE.showInfo(
LibraryEditResources.SynchronizeCompleteDialog_Title,
LibraryEditResources.AutoSynchronizeCommand_sucessful);
}
}
}
}
private void refreshViewer() {
if(elements.isEmpty()) return;
Process proc = TngUtil.getOwningProcess(elements.iterator().next());
if(proc != null) {
for (int i = 0; i < TngAdapterFactory.processAdapterFactories.length; i++) {
AdapterFactory adapterFactory = TngAdapterFactory.processAdapterFactories[i];
ProcessUtil.refreshViewer(adapterFactory, proc);
}
}
}
private void superRedo() {
super.redo();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.emf.common.command.CompoundCommand#redo()
*/
public void redo() {
execute();
}
public boolean isSucessful() {
return successful;
}
protected boolean preExecute() {
for (ListIterator commands = commandList.listIterator(); commands
.hasNext();) {
Object command = commands.next();
if(command instanceof BSDropCommand && !((BSDropCommand)command).preExecute()) {
return false;
}
// be polite to other threads (no effect on some platforms)
//
Thread.yield();
}
return true;
}
/**
* Deletes the specified elements
* @param elements
* @return the executed command that deleted the given elements
*/
protected Command delete(List elements) {
EditingDomain domain = new AdapterFactoryEditingDomain(
TngAdapterFactory.INSTANCE.getProcessComposedAdapterFactory(),
new BasicCommandStack());
Command cmd = new ProcessElementDeleteCommand(RemoveCommand.create(domain,
elements), elements);
cmd.execute();
return cmd;
}
private IConfigurator getConfigurator() {
if (configurator == null) {
MethodConfiguration config = this.config;
if(config == null) {
Process proc = TngUtil.getOwningProcess((BreakdownElement) elements
.iterator().next());
config = proc.getDefaultContext();
}
configurator = Providers.getConfiguratorFactory()
.createConfigurator(config);
}
return configurator;
}
/**
* @param element
* @param deleteList
*/
private void addToDeleteList(Object element, List deleteList) {
if (element instanceof Descriptor) {
if (!getConfigurator().accept(element)) {
MethodElement linkedElement = ProcessUtil.getAssociatedElement((Descriptor) element);
if(linkedElement instanceof VariabilityElement && TngUtil.isReplacer((VariabilityElement) linkedElement)) {
// if the linked element of the descriptor is a replacer, delete the descriptor in this synchronization
// only if the base of linked element is not in the configuration
//
VariabilityElement base = ((VariabilityElement)linkedElement).getVariabilityBasedOnElement();
while(base != null && TngUtil.isContributorOrReplacer(base)) {
base = base.getVariabilityBasedOnElement();
}
if(base != null) {
if(!getConfigurator().accept(base)) {
deleteList.add(element);
}
else {
batchCommand.addFeatureValue((EObject) element,
ProcessUtil.getLinkReference((Descriptor) element), base);
replacerToBaseMap.put((VariabilityElement) linkedElement, base);
}
}
}
else {
deleteList.add(element);
}
}
} else if (element instanceof Activity) {
for (Iterator iter = ((Activity) element).getBreakdownElements()
.iterator(); iter.hasNext();) {
addToDeleteList(iter.next(), deleteList);
}
}
}
private void superUndo() {
super.undo();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.emf.common.command.CompoundCommand#undo()
*/
public void undo() {
UserInteractionHelper.getUIHelper().runWithBusyIndicator(new Runnable() {
public void run() {
if (!deleteCommandList.isEmpty()) {
for (ListIterator commands = deleteCommandList
.listIterator(deleteCommandList.size()); commands
.hasPrevious();) {
try {
Command command = (Command) commands.previous();
command.undo();
} catch (RuntimeException exception) {
// Skip over the command that threw the exception.
//
commands.next();
try {
// Iterate forward over the undone commands to
// redo them.
//
while (commands.hasNext()) {
Command command = (Command) commands.next();
command.redo();
}
} catch (RuntimeException nestedException) {
CommonPlugin.INSTANCE
.log(new WrappedException(
CommonPlugin.INSTANCE
.getString("_UI_IgnoreException_exception"), nestedException).fillInStackTrace()); //$NON-NLS-1$
}
throw exception;
}
}
}
superUndo();
batchCommand.undo();
}
});
}
/*
* (non-Javadoc)
*
* @see org.eclipse.emf.common.command.CompoundCommand#prepare()
*/
protected boolean prepare() {
return true;
}
/* (non-Javadoc)
* @see org.eclipse.emf.common.command.CompoundCommand#dispose()
*/
public void dispose() {
if(activities != null) {
activities.clear();
}
if(deleteCommandList != null) {
for (Iterator iter = deleteCommandList.iterator(); iter.hasNext();) {
Command cmd = (Command) iter.next();
cmd.dispose();
}
}
if(deleteList != null) {
deleteList.clear();
}
super.dispose();
}
}