package org.activiti.designer.diagram;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.activiti.designer.ActivitiImageProvider;
import org.activiti.designer.eclipse.common.ActivitiBPMNDiagramConstants;
import org.activiti.designer.eclipse.extension.AbstractDiagramWorker;
import org.activiti.designer.eclipse.extension.validation.ProcessValidator;
import org.activiti.designer.eclipse.preferences.PreferencesUtil;
import org.activiti.designer.features.ChangeElementTypeFeature;
import org.activiti.designer.features.CreateBoundaryErrorFeature;
import org.activiti.designer.features.CreateBoundaryTimerFeature;
import org.activiti.designer.features.CreateBusinessRuleTaskFeature;
import org.activiti.designer.features.CreateCallActivityFeature;
import org.activiti.designer.features.CreateCustomServiceTaskFeature;
import org.activiti.designer.features.CreateEmbeddedSubProcessFeature;
import org.activiti.designer.features.CreateEndEventFeature;
import org.activiti.designer.features.CreateErrorEndEventFeature;
import org.activiti.designer.features.CreateExclusiveGatewayFeature;
import org.activiti.designer.features.CreateInclusiveGatewayFeature;
import org.activiti.designer.features.CreateMailTaskFeature;
import org.activiti.designer.features.CreateManualTaskFeature;
import org.activiti.designer.features.CreateParallelGatewayFeature;
import org.activiti.designer.features.CreateReceiveTaskFeature;
import org.activiti.designer.features.CreateScriptTaskFeature;
import org.activiti.designer.features.CreateServiceTaskFeature;
import org.activiti.designer.features.CreateStartEventFeature;
import org.activiti.designer.features.CreateTimerCatchingEventFeature;
import org.activiti.designer.features.CreateTimerStartEventFeature;
import org.activiti.designer.features.CreateUserTaskFeature;
import org.activiti.designer.features.DeleteSequenceFlowFeature;
import org.activiti.designer.features.ExpandCollapseSubProcessFeature;
import org.activiti.designer.features.SaveBpmnModelFeature;
import org.activiti.designer.integration.palette.PaletteEntry;
import org.activiti.designer.property.extension.CustomServiceTaskContext;
import org.activiti.designer.property.extension.util.ExtensionUtil;
import org.activiti.designer.util.eclipse.ActivitiUiUtil;
import org.activiti.designer.util.features.AbstractCreateBPMNFeature;
import org.activiti.designer.util.preferences.Preferences;
import org.apache.commons.lang.StringUtils;
import org.eclipse.bpmn2.BusinessRuleTask;
import org.eclipse.bpmn2.CallActivity;
import org.eclipse.bpmn2.ExclusiveGateway;
import org.eclipse.bpmn2.Gateway;
import org.eclipse.bpmn2.InclusiveGateway;
import org.eclipse.bpmn2.MailTask;
import org.eclipse.bpmn2.ManualTask;
import org.eclipse.bpmn2.ParallelGateway;
import org.eclipse.bpmn2.ReceiveTask;
import org.eclipse.bpmn2.ScriptTask;
import org.eclipse.bpmn2.SequenceFlow;
import org.eclipse.bpmn2.ServiceTask;
import org.eclipse.bpmn2.StartEvent;
import org.eclipse.bpmn2.SubProcess;
import org.eclipse.bpmn2.Task;
import org.eclipse.bpmn2.UserTask;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.graphiti.dt.IDiagramTypeProvider;
import org.eclipse.graphiti.features.ICreateConnectionFeature;
import org.eclipse.graphiti.features.ICreateFeature;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.ICustomContext;
import org.eclipse.graphiti.features.context.IDoubleClickContext;
import org.eclipse.graphiti.features.context.IPictogramElementContext;
import org.eclipse.graphiti.features.context.impl.CreateConnectionContext;
import org.eclipse.graphiti.features.context.impl.CreateContext;
import org.eclipse.graphiti.features.context.impl.CustomContext;
import org.eclipse.graphiti.features.custom.ICustomFeature;
import org.eclipse.graphiti.mm.pictograms.Anchor;
import org.eclipse.graphiti.mm.pictograms.AnchorContainer;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.palette.IPaletteCompartmentEntry;
import org.eclipse.graphiti.palette.IToolEntry;
import org.eclipse.graphiti.palette.impl.ObjectCreationToolEntry;
import org.eclipse.graphiti.palette.impl.PaletteCompartmentEntry;
import org.eclipse.graphiti.platform.IPlatformImageConstants;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.tb.ContextButtonEntry;
import org.eclipse.graphiti.tb.ContextMenuEntry;
import org.eclipse.graphiti.tb.DefaultToolBehaviorProvider;
import org.eclipse.graphiti.tb.IContextButtonPadData;
import org.eclipse.graphiti.tb.IContextMenuEntry;
import org.eclipse.graphiti.tb.IDecorator;
import org.eclipse.graphiti.tb.ImageDecorator;
import org.eclipse.graphiti.ui.internal.GraphitiUIPlugin;
import org.eclipse.graphiti.ui.internal.services.GraphitiUiInternal;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.swt.graphics.Image;
import org.eclipse.ui.PlatformUI;
import com.alfresco.designer.gui.features.CreateAlfrescoMailTaskFeature;
import com.alfresco.designer.gui.features.CreateAlfrescoScriptTaskFeature;
import com.alfresco.designer.gui.features.CreateAlfrescoStartEventFeature;
import com.alfresco.designer.gui.features.CreateAlfrescoUserTaskFeature;
// <SecureBPMN>
import eu.aniketos.securebpmn.features.CheckServiceTaskFeature;
import eu.aniketos.securebpmn.features.ListProcessVariablesFeature;
import eu.aniketos.securebpmn.features.PerformNtkAnalysisFeature;
import eu.aniketos.securebpmn.features.ValidateAslanLocalFeature;
import eu.aniketos.securebpmn.features.ValidateAslanWebFeature;
import eu.aniketos.securebpmn.visualization.rbac.RbacVisualization;
import org.eclipse.securebpmn2.AuthorizationConstraint;
import org.eclipse.securebpmn2.SecurityFlow;
import org.eclipse.graphiti.features.FeatureCheckerAdapter;
import org.eclipse.graphiti.features.IFeatureChecker;
import org.eclipse.graphiti.features.IFeatureCheckerHolder;
import org.activiti.designer.security.features.CreateSecurityBodFeature;
import org.activiti.designer.security.features.CreateSecuritySodFeature;
import org.activiti.designer.security.features.DeleteSecurityFlowFeature;
// </SecureBPMN>
public class ActivitiToolBehaviorProvider extends DefaultToolBehaviorProvider
// <SecureBPMN>
implements IFeatureCheckerHolder
// </SecureBPMN>
{
private static final Map<Class< ? extends ICreateFeature>, PaletteEntry> toolMapping = new HashMap<Class< ? extends ICreateFeature>, PaletteEntry>();
public ActivitiToolBehaviorProvider(IDiagramTypeProvider dtp) {
super(dtp);
// Setup tool mappings to palette entries
toolMapping.put(CreateStartEventFeature.class, PaletteEntry.START_EVENT);
toolMapping.put(CreateTimerStartEventFeature.class, PaletteEntry.TIMER_START_EVENT);
toolMapping.put(CreateAlfrescoStartEventFeature.class, PaletteEntry.ALFRESCO_START_EVENT);
toolMapping.put(CreateEndEventFeature.class, PaletteEntry.END_EVENT);
toolMapping.put(CreateErrorEndEventFeature.class, PaletteEntry.ERROR_END_EVENT);
toolMapping.put(CreateExclusiveGatewayFeature.class, PaletteEntry.EXCLUSIVE_GATEWAY);
toolMapping.put(CreateInclusiveGatewayFeature.class, PaletteEntry.INCLUSIVE_GATEWAY);
toolMapping.put(CreateMailTaskFeature.class, PaletteEntry.MAIL_TASK);
toolMapping.put(CreateManualTaskFeature.class, PaletteEntry.MANUAL_TASK);
toolMapping.put(CreateReceiveTaskFeature.class, PaletteEntry.RECEIVE_TASK);
toolMapping.put(CreateParallelGatewayFeature.class, PaletteEntry.PARALLEL_GATEWAY);
toolMapping.put(CreateScriptTaskFeature.class, PaletteEntry.SCRIPT_TASK);
toolMapping.put(CreateServiceTaskFeature.class, PaletteEntry.SERVICE_TASK);
toolMapping.put(CreateCallActivityFeature.class, PaletteEntry.CALL_ACTIVITY);
toolMapping.put(CreateEmbeddedSubProcessFeature.class, PaletteEntry.SUBPROCESS);
toolMapping.put(CreateUserTaskFeature.class, PaletteEntry.USER_TASK);
toolMapping.put(CreateAlfrescoUserTaskFeature.class, PaletteEntry.ALFRESCO_USER_TASK);
toolMapping.put(CreateBoundaryTimerFeature.class, PaletteEntry.BOUNDARY_TIMER);
toolMapping.put(CreateBoundaryErrorFeature.class, PaletteEntry.ERROR_END_EVENT);
toolMapping.put(CreateTimerCatchingEventFeature.class, PaletteEntry.BOUNDARY_TIMER);
toolMapping.put(CreateBusinessRuleTaskFeature.class, PaletteEntry.BUSINESSRULE_TASK);
toolMapping.put(CreateAlfrescoScriptTaskFeature.class, PaletteEntry.ALFRESCO_SCRIPT_TASK);
toolMapping.put(CreateAlfrescoMailTaskFeature.class, PaletteEntry.ALFRESCO_MAIL_TASK);
// <SecureBPMN>
toolMapping.put(CreateSecurityBodFeature.class, PaletteEntry.SECURITY_BOD);
toolMapping.put(CreateSecuritySodFeature.class, PaletteEntry.SECURITY_SOD);
// </SecureBPMN>
}
@Override
public ICustomFeature getDoubleClickFeature(IDoubleClickContext context) {
/*ICustomFeature customFeature = new ExpandCollapseSubProcessFeature(getFeatureProvider());
if (customFeature.canExecute(context)) {
return customFeature;
}*/
return super.getDoubleClickFeature(context);
}
@Override
public IContextButtonPadData getContextButtonPad(IPictogramElementContext context) {
IContextButtonPadData data = super.getContextButtonPad(context);
PictogramElement pe = context.getPictogramElement();
setGenericContextButtons(data, pe, CONTEXT_BUTTON_DELETE);
Object bo = getFeatureProvider().getBusinessObjectForPictogramElement(pe);
CreateConnectionContext connectionContext = new CreateConnectionContext();
connectionContext.setSourcePictogramElement(pe);
Anchor connectionAnchor = null;
if (pe instanceof Anchor) {
connectionAnchor = (Anchor) pe;
} else if (pe instanceof AnchorContainer) {
connectionAnchor = Graphiti.getPeService().getChopboxAnchor((AnchorContainer) pe);
}
connectionContext.setSourceAnchor(connectionAnchor);
if(pe.eContainer() instanceof ContainerShape == false) return data;
CreateContext taskContext = new CreateContext();
taskContext.setTargetContainer((ContainerShape) pe.eContainer());
taskContext.putProperty("org.activiti.designer.connectionContext", connectionContext);
if (bo instanceof StartEvent || bo instanceof Task || bo instanceof CallActivity || bo instanceof Gateway
// <SecureBPMN>
|| bo instanceof AuthorizationConstraint)
// </SecurePBMN>
{
CreateUserTaskFeature userTaskfeature = new CreateUserTaskFeature(getFeatureProvider());
ContextButtonEntry newUserTaskButton = new ContextButtonEntry(userTaskfeature, taskContext);
newUserTaskButton.setText("new user task"); //$NON-NLS-1$
newUserTaskButton.setDescription("Create a new task"); //$NON-NLS-1$
newUserTaskButton.setIconId(ActivitiImageProvider.IMG_USERTASK);
data.getDomainSpecificContextButtons().add(newUserTaskButton);
CreateExclusiveGatewayFeature exclusiveGatewayFeature = new CreateExclusiveGatewayFeature(getFeatureProvider());
ContextButtonEntry newExclusiveGatewayButton = new ContextButtonEntry(exclusiveGatewayFeature, taskContext);
newExclusiveGatewayButton.setText("new exclusive gateway"); //$NON-NLS-1$
newExclusiveGatewayButton.setDescription("Create a new exclusive gateway"); //$NON-NLS-1$
newExclusiveGatewayButton.setIconId(ActivitiImageProvider.IMG_GATEWAY_EXCLUSIVE);
data.getDomainSpecificContextButtons().add(newExclusiveGatewayButton);
CreateEndEventFeature endFeature = new CreateEndEventFeature(getFeatureProvider());
ContextButtonEntry newEndButton = new ContextButtonEntry(endFeature, taskContext);
newEndButton.setText("new end event"); //$NON-NLS-1$
newEndButton.setDescription("Create a new end event"); //$NON-NLS-1$
newEndButton.setIconId(ActivitiImageProvider.IMG_ENDEVENT_NONE);
data.getDomainSpecificContextButtons().add(newEndButton);
}
CreateConnectionContext ccc = new CreateConnectionContext();
ccc.setSourcePictogramElement(pe);
Anchor anchor = null;
if (pe instanceof Anchor) {
anchor = (Anchor) pe;
} else if (pe instanceof AnchorContainer) {
anchor = Graphiti.getPeService().getChopboxAnchor((AnchorContainer) pe);
}
ccc.setSourceAnchor(anchor);
ContextButtonEntry button = new ContextButtonEntry(null, context);
button.setText("Create connection"); //$NON-NLS-1$
button.setIconId(ActivitiImageProvider.IMG_EREFERENCE);
ICreateConnectionFeature[] features = getFeatureProvider().getCreateConnectionFeatures();
for (ICreateConnectionFeature feature : features) {
if (feature.isAvailable(ccc) && feature.canStartConnection(ccc))
button.addDragAndDropFeature(feature);
}
if (button.getDragAndDropFeatures().size() > 0) {
data.getDomainSpecificContextButtons().add(button);
}
if (bo instanceof StartEvent || bo instanceof Task || bo instanceof CallActivity || bo instanceof Gateway
// <SecureBPMN>
|| bo instanceof AuthorizationConstraint)
// </SecureBPMN>
{
ContextButtonEntry otherElementButton = new ContextButtonEntry(null, null);
otherElementButton.setText("new element"); //$NON-NLS-1$
otherElementButton.setDescription("Create a new element"); //$NON-NLS-1$
otherElementButton.setIconId(ActivitiImageProvider.NEW_ICON);
data.getDomainSpecificContextButtons().add(otherElementButton);
addContextButton(otherElementButton, new CreateServiceTaskFeature(getFeatureProvider()), taskContext,
"Create service task", "Create a new service task", ActivitiImageProvider.IMG_SERVICETASK);
addContextButton(otherElementButton, new CreateScriptTaskFeature(getFeatureProvider()), taskContext,
"Create script task", "Create a new script task", ActivitiImageProvider.IMG_SCRIPTTASK);
addContextButton(otherElementButton, new CreateUserTaskFeature(getFeatureProvider()), taskContext,
"Create user task", "Create a new user task", ActivitiImageProvider.IMG_USERTASK);
addContextButton(otherElementButton, new CreateMailTaskFeature(getFeatureProvider()), taskContext,
"Create mail task", "Create a new mail task", ActivitiImageProvider.IMG_MAILTASK);
addContextButton(otherElementButton, new CreateBusinessRuleTaskFeature(getFeatureProvider()), taskContext,
"Create business rule task", "Create a new business rule task", ActivitiImageProvider.IMG_BUSINESSRULETASK);
addContextButton(otherElementButton, new CreateManualTaskFeature(getFeatureProvider()), taskContext,
"Create manual task", "Create a new manual task", ActivitiImageProvider.IMG_MANUALTASK);
addContextButton(otherElementButton, new CreateReceiveTaskFeature(getFeatureProvider()), taskContext,
"Create receive task", "Create a new receive task", ActivitiImageProvider.IMG_RECEIVETASK);
addContextButton(otherElementButton, new CreateCallActivityFeature(getFeatureProvider()), taskContext,
"Create call activity", "Create a new call activiti", ActivitiImageProvider.IMG_CALLACTIVITY);
addContextButton(otherElementButton, new CreateExclusiveGatewayFeature(getFeatureProvider()), taskContext,
"Create exclusive gateway", "Create a new exclusive gateway", ActivitiImageProvider.IMG_GATEWAY_EXCLUSIVE);
addContextButton(otherElementButton, new CreateInclusiveGatewayFeature(getFeatureProvider()), taskContext,
"Create inclusive gateway", "Create a new inclusive gateway", ActivitiImageProvider.IMG_GATEWAY_INCLUSIVE);
addContextButton(otherElementButton, new CreateParallelGatewayFeature(getFeatureProvider()), taskContext,
"Create parallel gateway", "Create a new parallel gateway", ActivitiImageProvider.IMG_GATEWAY_PARALLEL);
addContextButton(otherElementButton, new CreateEndEventFeature(getFeatureProvider()), taskContext,
"Create end event", "Create a new end event", ActivitiImageProvider.IMG_ENDEVENT_NONE);
addContextButton(otherElementButton, new CreateErrorEndEventFeature(getFeatureProvider()), taskContext,
"Create error end event", "Create a new error end event", ActivitiImageProvider.IMG_ENDEVENT_ERROR);
addContextButton(otherElementButton, new CreateAlfrescoScriptTaskFeature(getFeatureProvider()), taskContext,
"Create alfresco script task", "Create a new alfresco script task", ActivitiImageProvider.IMG_SERVICETASK);
addContextButton(otherElementButton, new CreateAlfrescoUserTaskFeature(getFeatureProvider()), taskContext,
"Create alfresco user task", "Create a new alfresco user task", ActivitiImageProvider.IMG_USERTASK);
addContextButton(otherElementButton, new CreateAlfrescoMailTaskFeature(getFeatureProvider()), taskContext,
"Create alfresco mail task", "Create a new alfresco mail task", ActivitiImageProvider.IMG_MAILTASK);
// <SecureBPMN>
addContextButton(otherElementButton, new CreateSecurityBodFeature(getFeatureProvider()), taskContext,
"Create binding of duty", "Create a new binding of duty", ActivitiImageProvider.IMG_SECURITY_BOD);
addContextButton(otherElementButton, new CreateSecuritySodFeature(getFeatureProvider()), taskContext,
"Create separation of duty", "Create a new separation of duty", ActivitiImageProvider.IMG_SECURITY_SOD);
// </SecureBPMN>
ContextButtonEntry editElementButton = new ContextButtonEntry(null, null);
editElementButton.setText("change element type"); //$NON-NLS-1$
editElementButton.setDescription("Change the element type to another type"); //$NON-NLS-1$
editElementButton.setIconId(ActivitiImageProvider.EDIT_ICON);
data.getDomainSpecificContextButtons().add(editElementButton);
CustomContext customContext = new CustomContext();
customContext.putProperty("org.activiti.designer.changetype.pictogram", pe);
if(bo instanceof Task) {
addTaskButtons(editElementButton, (Task) bo, customContext);
} else if(bo instanceof Gateway) {
addGatewayButtons(editElementButton, (Gateway) bo, customContext);
}
}
return data;
}
private void addGatewayButtons(ContextButtonEntry otherElementButton, Gateway notGateway, CustomContext customContext) {
if(notGateway == null || !(notGateway instanceof ExclusiveGateway)) {
addContextButton(otherElementButton, new ChangeElementTypeFeature(getFeatureProvider(), "exclusivegateway"), customContext,
"Change to exclusive gateway", "Change to an exclusive gateway", ActivitiImageProvider.IMG_GATEWAY_EXCLUSIVE);
}
if(notGateway == null || !(notGateway instanceof InclusiveGateway)) {
addContextButton(otherElementButton, new ChangeElementTypeFeature(getFeatureProvider(), "inclusivegateway"), customContext,
"Change to inclusive gateway", "Change to an inclusive gateway", ActivitiImageProvider.IMG_GATEWAY_INCLUSIVE);
}
if(notGateway == null || !(notGateway instanceof ParallelGateway)) {
addContextButton(otherElementButton, new ChangeElementTypeFeature(getFeatureProvider(), "parallelgateway"), customContext,
"Change to parallel gateway", "Change to a parallel gateway", ActivitiImageProvider.IMG_GATEWAY_PARALLEL);
}
}
private void addTaskButtons(ContextButtonEntry otherElementButton, Task notTask, CustomContext customContext) {
if(notTask == null || notTask instanceof ServiceTask == false) {
addContextButton(otherElementButton, new ChangeElementTypeFeature(getFeatureProvider(), "servicetask"), customContext,
"Change to service task", "Change to a service task", ActivitiImageProvider.IMG_SERVICETASK);
}
if(notTask == null || notTask instanceof ScriptTask == false) {
addContextButton(otherElementButton, new ChangeElementTypeFeature(getFeatureProvider(), "scripttask"), customContext,
"Change to script task", "Change to a script task", ActivitiImageProvider.IMG_SCRIPTTASK);
}
if(notTask == null || notTask instanceof UserTask == false) {
addContextButton(otherElementButton, new ChangeElementTypeFeature(getFeatureProvider(), "usertask"), customContext,
"Change to user task", "Change to a user task", ActivitiImageProvider.IMG_USERTASK);
}
if(notTask == null || notTask instanceof MailTask == false) {;
addContextButton(otherElementButton, new ChangeElementTypeFeature(getFeatureProvider(), "mailtask"), customContext,
"Change to mail task", "Change to a mail task", ActivitiImageProvider.IMG_MAILTASK);
}
if(notTask == null || notTask instanceof BusinessRuleTask == false) {
addContextButton(otherElementButton, new ChangeElementTypeFeature(getFeatureProvider(), "businessruletask"), customContext,
"Change to business rule task", "Change to a business rule task", ActivitiImageProvider.IMG_BUSINESSRULETASK);
}
if(notTask == null || notTask instanceof ManualTask == false) {
addContextButton(otherElementButton, new ChangeElementTypeFeature(getFeatureProvider(), "manualtask"), customContext,
"Change to manual task", "Change to a manual task", ActivitiImageProvider.IMG_MANUALTASK);
}
if(notTask == null || notTask instanceof ReceiveTask == false) {
addContextButton(otherElementButton, new ChangeElementTypeFeature(getFeatureProvider(), "receivetask"), customContext,
"Change to receive task", "Change to a receive task", ActivitiImageProvider.IMG_RECEIVETASK);
}
}
private void addContextButton(ContextButtonEntry button, ChangeElementTypeFeature feature,
CustomContext customContext, String text, String description, String image) {
ContextButtonEntry newButton = new ContextButtonEntry(feature, customContext);
newButton.setText(text); //$NON-NLS-1$
newButton.setDescription(description); //$NON-NLS-1$
newButton.setIconId(image);
button.getContextButtonMenuEntries().add(newButton);
}
private void addContextButton(ContextButtonEntry button, AbstractCreateBPMNFeature feature,
CreateContext context, String text, String description, String image) {
ContextButtonEntry newButton = new ContextButtonEntry(feature, context);
newButton.setText(text); //$NON-NLS-1$
newButton.setDescription(description); //$NON-NLS-1$
newButton.setIconId(image);
button.getContextButtonMenuEntries().add(newButton);
}
@Override
public IContextMenuEntry[] getContextMenu(ICustomContext context) {
List<IContextMenuEntry> menuList = new ArrayList<IContextMenuEntry>();
if(context.getPictogramElements() != null) {
for (PictogramElement pictogramElement : context.getPictogramElements()) {
if(pictogramElement.getLink() == null) continue;
EList<EObject> boList = pictogramElement.getLink().getBusinessObjects();
if(boList != null) {
for (EObject bObject : boList) {
if(bObject instanceof SequenceFlow) {
ContextMenuEntry subMenuDelete = new ContextMenuEntry(new DeleteSequenceFlowFeature(getFeatureProvider()), context);
subMenuDelete.setText("Delete sequence flow"); //$NON-NLS-1$
subMenuDelete.setSubmenu(false);
menuList.add(subMenuDelete);
// <SecureBPMN>
} else if(bObject instanceof SecurityFlow){
ContextMenuEntry subMenuDelete = new ContextMenuEntry(new DeleteSecurityFlowFeature(getFeatureProvider()), context);
subMenuDelete.setText("Delete security flow"); //$NON-NLS-1$
subMenuDelete.setSubmenu(false);
menuList.add(subMenuDelete);
} else if (bObject instanceof ServiceTask) {
// Adding custom context menu entries.
ContextMenuEntry checkServiceTask = new ContextMenuEntry(new CheckServiceTaskFeature(getFeatureProvider()), context);
checkServiceTask.setText("Check ServiceTask"); //$NON-NLS-1$
checkServiceTask.setSubmenu(false);
menuList.add(checkServiceTask);
// </SecureBPMN>
}
}
}
}
}
// <SecureBPMN>
ContextMenuEntry subMenuSecureBPMN = new ContextMenuEntry(null, context);
subMenuSecureBPMN.setText("SecureBPMN Analyses"); //$NON-NLS-1$
subMenuSecureBPMN.setSubmenu(true);
/* adb: for the time being, provide only local analysis. First, the
* Web service options needs to be fixed (new formant) and, second, this
* selection should be made in the configuration pane ...
*
ContextMenuEntry subMenuSSoD = new ContextMenuEntry(null, context);
subMenuSSoD.setText("Static SoD Analysis"); //$NON-NLS-1$
subMenuSSoD.setSubmenu(true);
ContextMenuEntry validateSecurityViaBin = new ContextMenuEntry(new ValidateAslanLocalFeature(getFeatureProvider()), context);
validateSecurityViaBin.setText("local analysis"); //$NON-NLS-1$
validateSecurityViaBin.setSubmenu(false);
subMenuSSoD.add(validateSecurityViaBin);
ContextMenuEntry validateSecurityViaWS = new ContextMenuEntry(new ValidateAslanWebFeature(getFeatureProvider()), context);
validateSecurityViaWS.setText("via web service"); //$NON-NLS-1$
validateSecurityViaWS.setSubmenu(false);
subMenuSSoD.add(validateSecurityViaWS);
*/
ContextMenuEntry subMenuSSoD = new ContextMenuEntry(new ValidateAslanLocalFeature(getFeatureProvider()), context);
subMenuSSoD.setText("Anlyse static SoD"); //$NON-NLS-1$
subMenuSSoD.setSubmenu(false);
subMenuSecureBPMN.add(subMenuSSoD);
ContextMenuEntry subMenuNtK = new ContextMenuEntry(null, context);
subMenuNtK.setText("Need to Know Analysis"); //$NON-NLS-1$
subMenuNtK.setSubmenu(true);
ContextMenuEntry listProcessVars = new ContextMenuEntry(new ListProcessVariablesFeature(getFeatureProvider()), context);
listProcessVars.setText("List used process variables"); //$NON-NLS-1$
listProcessVars.setSubmenu(false);
subMenuNtK.add(listProcessVars);
ContextMenuEntry performNtkAnalysis = new ContextMenuEntry(new PerformNtkAnalysisFeature(getFeatureProvider()), context);
performNtkAnalysis.setText("Perform need-to-know analysis"); //$NON-NLS-1$
performNtkAnalysis.setSubmenu(false);
subMenuNtK.add(performNtkAnalysis);
subMenuSecureBPMN.add(subMenuNtK);
menuList.add(subMenuSecureBPMN);
// </SecureBPMN>
ContextMenuEntry subMenuExport = new ContextMenuEntry(new SaveBpmnModelFeature(getFeatureProvider()), context);
subMenuExport.setText("Export to BPMN 2.0 XML"); //$NON-NLS-1$
subMenuExport.setSubmenu(false);
menuList.add(subMenuExport);
ContextMenuEntry subMenuExpandOrCollapse = new ContextMenuEntry(new ExpandCollapseSubProcessFeature(getFeatureProvider()), context);
subMenuExpandOrCollapse.setText("Expand/Collapse Subprocess"); //$NON-NLS-1$
subMenuExpandOrCollapse.setSubmenu(false);
return menuList.toArray(new IContextMenuEntry[menuList.size()]);
}
@Override
public IPaletteCompartmentEntry[] getPalette() {
final IProject project = ActivitiUiUtil.getProjectFromDiagram(getDiagramTypeProvider().getDiagram());
final List<IPaletteCompartmentEntry> ret = new ArrayList<IPaletteCompartmentEntry>();
// add compartments from super class if not disabled
IPaletteCompartmentEntry[] superCompartments = super.getPalette();
// create new compartments
IPaletteCompartmentEntry connectionCompartmentEntry = new PaletteCompartmentEntry("Connection", null);
IPaletteCompartmentEntry eventCompartmentEntry = new PaletteCompartmentEntry("Event", null);
IPaletteCompartmentEntry taskCompartmentEntry = new PaletteCompartmentEntry("Task", null);
IPaletteCompartmentEntry gatewayCompartmentEntry = new PaletteCompartmentEntry("Gateway", null);
IPaletteCompartmentEntry boundaryEventCompartmentEntry = new PaletteCompartmentEntry("Boundary event", null);
IPaletteCompartmentEntry intermediateEventCompartmentEntry = new PaletteCompartmentEntry("Intermediate event", null);
IPaletteCompartmentEntry alfrescoCompartmentEntry = new PaletteCompartmentEntry("Alfresco", ActivitiImageProvider.IMG_ALFRESCO_LOGO);
// <SecureBPMN>
IPaletteCompartmentEntry securityCompartmentEntry = new PaletteCompartmentEntry("Security", null);
// </SecureBPMN>
for (int i = 0; i < superCompartments.length; i++) {
final IPaletteCompartmentEntry entry = superCompartments[i];
// Prune any disabled palette entries in the Objects compartment
if ("Objects".equals(entry.getLabel())) {
pruneDisabledPaletteEntries(project, entry);
}
}
for (IPaletteCompartmentEntry iPaletteCompartmentEntry : superCompartments) {
for (IToolEntry toolEntry : iPaletteCompartmentEntry.getToolEntries()) {
if ("sequenceflow".equalsIgnoreCase(toolEntry.getLabel())) {
connectionCompartmentEntry.getToolEntries().add(toolEntry);
// <SecureBPMN>
} else if ("securityflow".equalsIgnoreCase(toolEntry.getLabel())) {
connectionCompartmentEntry.getToolEntries().add(toolEntry);
// </SecureBPMN>
} else if ("startevent".equalsIgnoreCase(toolEntry.getLabel())) {
eventCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("timerstartevent".equalsIgnoreCase(toolEntry.getLabel())) {
eventCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("endevent".equalsIgnoreCase(toolEntry.getLabel())) {
eventCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("errorendevent".equalsIgnoreCase(toolEntry.getLabel())) {
eventCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("usertask".equalsIgnoreCase(toolEntry.getLabel())) {
taskCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("scripttask".equalsIgnoreCase(toolEntry.getLabel())) {
taskCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("servicetask".equalsIgnoreCase(toolEntry.getLabel())) {
taskCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("mailtask".equalsIgnoreCase(toolEntry.getLabel())) {
taskCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("manualtask".equalsIgnoreCase(toolEntry.getLabel())) {
taskCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("receivetask".equalsIgnoreCase(toolEntry.getLabel())) {
taskCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("businessruletask".equalsIgnoreCase(toolEntry.getLabel())) {
taskCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("timerboundaryevent".equalsIgnoreCase(toolEntry.getLabel())) {
boundaryEventCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("errorboundaryevent".equalsIgnoreCase(toolEntry.getLabel())) {
boundaryEventCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("timercatchingevent".equalsIgnoreCase(toolEntry.getLabel())) {
intermediateEventCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("parallelgateway".equalsIgnoreCase(toolEntry.getLabel())) {
gatewayCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("exclusivegateway".equalsIgnoreCase(toolEntry.getLabel())) {
gatewayCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("inclusivegateway".equalsIgnoreCase(toolEntry.getLabel())) {
gatewayCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("subprocess".equalsIgnoreCase(toolEntry.getLabel())) {
taskCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("callactivity".equalsIgnoreCase(toolEntry.getLabel())) {
taskCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("alfrescousertask".equalsIgnoreCase(toolEntry.getLabel())) {
alfrescoCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("alfrescostartevent".equalsIgnoreCase(toolEntry.getLabel())) {
alfrescoCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("alfrescoscripttask".equalsIgnoreCase(toolEntry.getLabel())) {
alfrescoCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("alfrescomailtask".equalsIgnoreCase(toolEntry.getLabel())) {
alfrescoCompartmentEntry.getToolEntries().add(toolEntry);
// <SecureBPMN>
}else if ("separationofduty".equalsIgnoreCase(toolEntry.getLabel())) {
securityCompartmentEntry.getToolEntries().add(toolEntry);
} else if ("bindingofduty".equalsIgnoreCase(toolEntry.getLabel())) {
securityCompartmentEntry.getToolEntries().add(toolEntry);
// </SecureBPMN>
}
}
}
// Always add the connection compartment
ret.add(connectionCompartmentEntry);
if (eventCompartmentEntry.getToolEntries().size() > 0) {
ret.add(eventCompartmentEntry);
}
if (taskCompartmentEntry.getToolEntries().size() > 0) {
ret.add(taskCompartmentEntry);
}
if (gatewayCompartmentEntry.getToolEntries().size() > 0) {
ret.add(gatewayCompartmentEntry);
}
if (boundaryEventCompartmentEntry.getToolEntries().size() > 0) {
ret.add(boundaryEventCompartmentEntry);
}
if (intermediateEventCompartmentEntry.getToolEntries().size() > 0) {
ret.add(intermediateEventCompartmentEntry);
}
if (PreferencesUtil.getBooleanPreference(Preferences.ALFRESCO_ENABLE) &&
alfrescoCompartmentEntry.getToolEntries().size() > 0) {
ret.add(alfrescoCompartmentEntry);
}
// <SecureBPMN>
if (securityCompartmentEntry.getToolEntries().size() > 0) {
ret.add(securityCompartmentEntry);
}
// </SecureBPMN>
final Map<String, List<CustomServiceTaskContext>> tasksInDrawers = new HashMap<String, List<CustomServiceTaskContext>>();
final List<CustomServiceTaskContext> customServiceTaskContexts = ExtensionUtil.getCustomServiceTaskContexts(project);
final ImageRegistry reg = GraphitiUIPlugin.getDefault().getImageRegistry();
for (final CustomServiceTaskContext taskContext : customServiceTaskContexts) {
if (reg.get(taskContext.getSmallImageKey()) == null) {
reg.put(taskContext.getSmallImageKey(),
new Image(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell().getDisplay(), taskContext.getSmallIconStream()));
}
if (reg.get(taskContext.getLargeImageKey()) == null) {
reg.put(taskContext.getLargeImageKey(),
new Image(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell().getDisplay(), taskContext.getLargeIconStream()));
}
if (reg.get(taskContext.getShapeImageKey()) == null) {
reg.put(taskContext.getShapeImageKey(),
new Image(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell().getDisplay(), taskContext.getShapeIconStream()));
}
}
for (final CustomServiceTaskContext taskContext : customServiceTaskContexts) {
if (!tasksInDrawers.containsKey(taskContext.getServiceTask().contributeToPaletteDrawer())) {
tasksInDrawers.put(taskContext.getServiceTask().contributeToPaletteDrawer(), new ArrayList<CustomServiceTaskContext>());
}
tasksInDrawers.get(taskContext.getServiceTask().contributeToPaletteDrawer()).add(taskContext);
}
for (final Entry<String, List<CustomServiceTaskContext>> drawer : tasksInDrawers.entrySet()) {
// Sort the list
Collections.sort(drawer.getValue());
final IPaletteCompartmentEntry paletteCompartmentEntry = new PaletteCompartmentEntry(drawer.getKey(), null);
for (final CustomServiceTaskContext currentDrawerItem : drawer.getValue()) {
final CreateCustomServiceTaskFeature feature = new CreateCustomServiceTaskFeature(getFeatureProvider(), currentDrawerItem.getServiceTask().getName(),
currentDrawerItem.getServiceTask().getDescription(), currentDrawerItem.getServiceTask().getClass().getCanonicalName());
final IToolEntry entry = new ObjectCreationToolEntry(currentDrawerItem.getServiceTask().getName(), currentDrawerItem.getServiceTask().getDescription(),
currentDrawerItem.getSmallImageKey(), null, feature);
paletteCompartmentEntry.getToolEntries().add(entry);
}
ret.add(paletteCompartmentEntry);
}
return ret.toArray(new IPaletteCompartmentEntry[ret.size()]);
}
/**
* Prunes the disabled palette entries from the
* {@link IPaletteCompartmentEntry}.
*
* @param entry
* the compartment being pruned
*/
private void pruneDisabledPaletteEntries(final IProject project, final IPaletteCompartmentEntry entry) {
final Set<PaletteEntry> disabledPaletteEntries = ExtensionUtil.getDisabledPaletteEntries(project);
if (!disabledPaletteEntries.isEmpty()) {
final Iterator<IToolEntry> entryIterator = entry.getToolEntries().iterator();
while (entryIterator.hasNext()) {
final IToolEntry toolEntry = entryIterator.next();
if (disabledPaletteEntries.contains(PaletteEntry.ALL)) {
entryIterator.remove();
} else {
if (toolEntry instanceof ObjectCreationToolEntry) {
final ObjectCreationToolEntry objToolEntry = (ObjectCreationToolEntry) toolEntry;
if (toolMapping.containsKey(objToolEntry.getCreateFeature().getClass())) {
if (disabledPaletteEntries.contains(toolMapping.get(objToolEntry.getCreateFeature().getClass()))) {
entryIterator.remove();
}
}
}
}
}
}
}
@Override
public IDecorator[] getDecorators(PictogramElement pe) {
IFeatureProvider featureProvider = getFeatureProvider();
Object bo = featureProvider.getBusinessObjectForPictogramElement(pe);
if (bo instanceof StartEvent) {
StartEvent startEvent = (StartEvent) bo;
if (startEvent.getOutgoing().size() != 1) {
IDecorator imageRenderingDecorator = new ImageDecorator(IPlatformImageConstants.IMG_ECLIPSE_ERROR_TSK);
imageRenderingDecorator.setMessage("A start event should have exactly one outgoing sequence flow"); //$NON-NLS-1$
return new IDecorator[] { imageRenderingDecorator };
}
/*} else if (bo instanceof SubProcess) {
SubProcess subProcess = (SubProcess) bo;
if (!subProcessDiagramExists(subProcess)) {
IDecorator imageRenderingDecorator = new ImageDecorator(IPlatformImageConstants.IMG_ECLIPSE_INFORMATION_TSK);
imageRenderingDecorator.setMessage("This subprocess does not have a diagram model yet");//$NON-NLS-1$
return new IDecorator[] { imageRenderingDecorator };
}*/
} else if (bo instanceof ServiceTask && bo instanceof EObject && ExtensionUtil.isCustomServiceTask((EObject) bo)) {
final Resource resource = pe.getLink().eResource();
final IResource res = ResourcesPlugin.getWorkspace().getRoot().findMember(resource.getURI().toPlatformString(true));
final List<IMarker> markers = getMarkers(res, (ServiceTask) bo);
if (markers.size() > 0) {
int maximumSeverity = 0;
try {
for (final IMarker marker : markers) {
final Object severity = marker.getAttribute(IMarker.SEVERITY);
if (severity != null && severity instanceof Integer) {
maximumSeverity = Math.max(maximumSeverity, (Integer) severity);
}
}
} catch (CoreException e) {
e.printStackTrace();
}
String decoratorImagePath = null;
switch (maximumSeverity) {
case IMarker.SEVERITY_INFO:
decoratorImagePath = IPlatformImageConstants.IMG_ECLIPSE_INFORMATION_TSK;
break;
case IMarker.SEVERITY_WARNING:
decoratorImagePath = IPlatformImageConstants.IMG_ECLIPSE_WARNING_TSK;
break;
default:
decoratorImagePath = IPlatformImageConstants.IMG_ECLIPSE_ERROR_TSK;
}
final ImageDecorator imageRenderingDecorator = new ImageDecorator(decoratorImagePath);
imageRenderingDecorator.setMessage("There are validation markers for the properties of this node");//$NON-NLS-1$
imageRenderingDecorator.setX(pe.getGraphicsAlgorithm().getWidth() / 2 - 10);
imageRenderingDecorator.setY(4);
return new IDecorator[] { imageRenderingDecorator };
} else {
return new IDecorator[] {};
}
}
return super.getDecorators(pe);
}
protected List<IMarker> getMarkers(IResource resource, ServiceTask serviceTask) {
final List<IMarker> result = new ArrayList<IMarker>();
try {
final IMarker[] markers = resource.findMarkers(ProcessValidator.MARKER_ID, true, IResource.DEPTH_INFINITE);
for (final IMarker marker : markers) {
Object attribute = marker.getAttribute(AbstractDiagramWorker.ATTRIBUTE_NODE_ID);
if (attribute != null) {
if (StringUtils.equals((String) attribute, serviceTask.getId())) {
result.add(marker);
}
}
}
} catch (CoreException e) {
e.printStackTrace();
}
return result;
}
private boolean subProcessDiagramExists(SubProcess subProcess) {
Resource resource = getDiagramTypeProvider().getDiagram().eResource();
URI uri = resource.getURI();
URI uriTrimmed = uri.trimFragment();
if (uriTrimmed.isPlatformResource()) {
String platformString = uriTrimmed.toPlatformString(true);
IResource fileResource = ResourcesPlugin.getWorkspace().getRoot().findMember(platformString);
if (fileResource != null) {
IProject project = fileResource.getProject();
final String parentDiagramName = uriTrimmed.trimFileExtension().lastSegment();
IFile file = project.getFile(String.format(ActivitiBPMNDiagramConstants.DIAGRAM_FOLDER + "%s.%s" + ActivitiBPMNDiagramConstants.DIAGRAM_EXTENSION,
parentDiagramName, subProcess.getId()));
Diagram diagram = GraphitiUiInternal.getEmfService().getDiagramFromFile(file, new ResourceSetImpl());
return diagram != null;
}
}
// Safe default assumption
return true;
}
// <SecureBPMN>
@Override
public IFeatureChecker getFeatureChecker() {
// TODO we can still create elements!
if (RbacVisualization.getInstance().isVisualizationRunning()) {
return new FeatureCheckerAdapter(false);
} else {
return new FeatureCheckerAdapter(true);
}
}
// </SecureBPMN>
}