/*
* (c) Copyright 2010-2011 AgileBirds
*
* This file is part of OpenFlexo.
*
* OpenFlexo is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenFlexo is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenFlexo. If not, see <http://www.gnu.org/licenses/>.
*
*/
package org.openflexo.foundation.wkf;
/*
* FlexoWorkflow.java
* Project WorkflowEditor
*
* Created by benoit on Mar 3, 2004
*/
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.openflexo.foundation.AttributeDataModification;
import org.openflexo.foundation.FlexoModelObject;
import org.openflexo.foundation.Inspectors;
import org.openflexo.foundation.TargetType;
import org.openflexo.foundation.action.FlexoActionizer;
import org.openflexo.foundation.dm.DMCardinality;
import org.openflexo.foundation.dm.DMEntity;
import org.openflexo.foundation.dm.DMProperty;
import org.openflexo.foundation.dm.DMPropertyImplementationType;
import org.openflexo.foundation.dm.DMType;
import org.openflexo.foundation.dm.ProcessDMEntity;
import org.openflexo.foundation.dm.eo.DMEOAttribute;
import org.openflexo.foundation.dm.eo.DMEOEntity;
import org.openflexo.foundation.dm.eo.EOAccessException;
import org.openflexo.foundation.help.ApplicationHelpEntryPoint;
import org.openflexo.foundation.ie.OperationComponentInstance;
import org.openflexo.foundation.ie.TabComponentInstance;
import org.openflexo.foundation.ie.cl.OperationComponentDefinition;
import org.openflexo.foundation.ie.cl.TabComponentDefinition;
import org.openflexo.foundation.ie.widget.IETabWidget;
import org.openflexo.foundation.imported.dm.ProcessAlreadyImportedException;
import org.openflexo.foundation.rm.DuplicateResourceException;
import org.openflexo.foundation.rm.FlexoProject;
import org.openflexo.foundation.rm.FlexoProjectReference;
import org.openflexo.foundation.rm.FlexoResource;
import org.openflexo.foundation.rm.FlexoWorkflowResource;
import org.openflexo.foundation.rm.FlexoXMLStorageResource;
import org.openflexo.foundation.rm.ImportedProcessLibraryCreated;
import org.openflexo.foundation.rm.ImportedRoleLibraryCreated;
import org.openflexo.foundation.rm.InvalidFileNameException;
import org.openflexo.foundation.rm.ProjectData;
import org.openflexo.foundation.rm.ProjectRestructuration;
import org.openflexo.foundation.rm.ResourceType;
import org.openflexo.foundation.rm.SaveResourceException;
import org.openflexo.foundation.rm.XMLStorageResourceData;
import org.openflexo.foundation.utils.FlexoFont;
import org.openflexo.foundation.utils.FlexoIndexManager;
import org.openflexo.foundation.utils.FlexoModelObjectReference;
import org.openflexo.foundation.utils.FlexoProjectFile;
import org.openflexo.foundation.validation.FixProposal;
import org.openflexo.foundation.validation.Validable;
import org.openflexo.foundation.validation.ValidationError;
import org.openflexo.foundation.validation.ValidationIssue;
import org.openflexo.foundation.validation.ValidationRule;
import org.openflexo.foundation.wkf.MetricsDefinition.MetricsType;
import org.openflexo.foundation.wkf.MetricsValue.MetricsValueOwner;
import org.openflexo.foundation.wkf.action.AddMetricsDefinition;
import org.openflexo.foundation.wkf.action.DeleteMetricsDefinition;
import org.openflexo.foundation.wkf.dm.ProcessInserted;
import org.openflexo.foundation.wkf.dm.ProcessRemoved;
import org.openflexo.foundation.wkf.edge.FlexoPostCondition;
import org.openflexo.foundation.wkf.node.AbstractActivityNode;
import org.openflexo.foundation.wkf.node.FlexoNode;
import org.openflexo.foundation.wkf.node.NodeType;
import org.openflexo.foundation.wkf.node.OperationNode;
import org.openflexo.foundation.wkf.node.PetriGraphNode;
import org.openflexo.foundation.wkf.node.SubProcessNode;
import org.openflexo.foundation.xml.FlexoWorkflowBuilder;
import org.openflexo.inspector.InspectableObject;
import org.openflexo.localization.FlexoLocalization;
import org.openflexo.toolbox.PropertyChangeListenerRegistrationManager;
import org.openflexo.toolbox.ToolBox;
import org.openflexo.ws.client.PPMWebService.PPMProcess;
import org.openflexo.xmlcode.XMLMapping;
/**
* A FlexoWorkflow represent all the processes defined in corresponding project, and their hierarchy. A FlexoWorkflow always codes one and
* only one FlexoProcess as the root process. Despite of that fact, more than one FlexoProcess could have no parent process: those which are
* not declared as root process are said as "processes without context".
*
* @author benoit,sylvain
*/
public class FlexoWorkflow extends FlexoFolderContainerNode implements XMLStorageResourceData, InspectableObject {
public static final String ALL_ASSIGNABLE_ROLES = "allAssignableRoles";
public enum GraphicalProperties {
CONNECTOR_REPRESENTATION("connectorRepresentation"),
COMPONENT_FONT("componentFont"),
ROLE_FONT("roleFont"),
EVENT_FONT("eventFont"),
ACTION_FONT("actionFont"),
OPERATION_FONT("operationFont"),
ACTIVITY_FONT("activityFont"),
ARTEFACT_FONT("artefactFont"),
EDGE_FONT("edgeFont"),
SHOW_MESSAGES("showMessages"),
SHOW_WO_NAME("showWOName"),
SHOW_SHADOWS("showShadows"),
USE_TRANSPARENCY("useTransparency");
private String serializationName;
GraphicalProperties(String s) {
this.serializationName = s;
}
public String getSerializationName() {
return serializationName;
}
}
private static final Logger logger = Logger.getLogger(FlexoWorkflow.class.getPackage().getName());
private FlexoWorkflowResource _resource;
private FlexoProcessNode _rootProcessNode;
private Vector<FlexoProcessNode> _topLevelNodeProcesses;
private Vector<FlexoProcessNode> importedRootNodeProcesses;
private RoleList _roleList;
private RoleList importedRoleList;
private List<Role> allAssignableRoles;
private String projectURI;
public static FlexoActionizer<AddMetricsDefinition, FlexoWorkflow, WorkflowModelObject> addProcessMetricsDefinitionActionizer;
public static FlexoActionizer<AddMetricsDefinition, FlexoWorkflow, WorkflowModelObject> addActivityMetricsDefinitionActionizer;
public static FlexoActionizer<AddMetricsDefinition, FlexoWorkflow, WorkflowModelObject> addOperationMetricsDefinitionActionizer;
public static FlexoActionizer<AddMetricsDefinition, FlexoWorkflow, WorkflowModelObject> addEdgeMetricsDefinitionActionizer;
public static FlexoActionizer<AddMetricsDefinition, FlexoWorkflow, WorkflowModelObject> addArtefactMetricsDefinitionActionizer;
public static FlexoActionizer<DeleteMetricsDefinition, MetricsDefinition, MetricsDefinition> deleteMetricsDefinitionActionizer;
public FlexoWorkflow(FlexoWorkflowBuilder builder) {
this(builder.getProject());
builder.workflow = this;
setFlexoResource(builder.resource);
initializeDeserialization(builder);
}
/**
* Create a new FlexoWorkflow.
*/
public FlexoWorkflow(FlexoProject project) {
super(project, null);
_topLevelNodeProcesses = new Vector<FlexoProcessNode>();
importedRootNodeProcesses = new Vector<FlexoProcessNode>();
processMetricsDefinitions = new Vector<MetricsDefinition>();
activityMetricsDefinitions = new Vector<MetricsDefinition>();
operationMetricsDefinitions = new Vector<MetricsDefinition>();
edgeMetricsDefinitions = new Vector<MetricsDefinition>();
artefactMetricsDefinitions = new Vector<MetricsDefinition>();
try {
setName(project.getProjectName());
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public FlexoWorkflowResource getFlexoResource() {
return _resource;
}
@Override
public FlexoXMLStorageResource getFlexoXMLFileResource() {
return _resource;
}
@Override
public XMLMapping getXMLMapping() {
return getProject().getXmlMappings().getWorkflowMapping();
}
/**
* Returns reference to the main object in which this XML-serializable object is contained relating to storing scheme: here it's the
* workflow itself
*
* @return this
*/
@Override
public XMLStorageResourceData getXMLResourceData() {
return this;
}
@Override
public FlexoWorkflow getWorkflow() {
return this;
}
/**
* Creates and returns a newly created workflow
*
* @return a newly created workflow
* @throws InvalidFileNameException
*/
public static FlexoWorkflow createNewWorkflow(FlexoProject project) {
if (logger.isLoggable(Level.FINE)) {
logger.fine("BEGIN createNewWorkflow(), project=" + project);
}
FlexoWorkflow newWorkflow = new FlexoWorkflow(project);
File wkfFile = ProjectRestructuration.getExpectedWorkflowFile(project, project.getProjectName());
FlexoProjectFile workflowFile = new FlexoProjectFile(wkfFile, project);
FlexoWorkflowResource wkfRes = null;
try {
wkfRes = new FlexoWorkflowResource(project, newWorkflow, workflowFile);
} catch (InvalidFileNameException e2) {
// TODO Auto-generated catch block
e2.printStackTrace();
}
try {
project.registerResource(wkfRes);
} catch (DuplicateResourceException e) {
if (logger.isLoggable(Level.WARNING)) {
logger.warning("Exception raised: " + e.getClass().getName() + ". See console for details.");
}
e.printStackTrace();
}
newWorkflow.createDefaultProcessMetricsDefinitions();
newWorkflow.createDefaultActivityMetricsDefinitions();
newWorkflow.createDefaultOperationMetricsDefinitions();
newWorkflow.createDefaultEdgeMetricsDefinitions();
newWorkflow.createDefaultArtefactMetricsDefinitions();
// FlexoProcess.createNewRootProcess(newWorkflow);
try {
wkfRes.saveResourceData();
} catch (Exception e1) {
// Warns about the exception
if (logger.isLoggable(Level.WARNING)) {
logger.warning("Exception raised: " + e1.getClass().getName() + ". See console for details.");
}
e1.printStackTrace();
}
if (logger.isLoggable(Level.FINE)) {
logger.fine("END createNewWorkflow(), project=" + project);
}
return newWorkflow;
}
@Override
public String getFullyQualifiedName() {
return getProject().getProjectName() + ".WORKFLOW";
}
@Override
public void setFlexoResource(FlexoResource resource) {
_resource = (FlexoWorkflowResource) resource;
registerOnProject();
}
@Override
public String getName() {
if (isCache()) {
return super.getName();
} else {
return getProject().getDisplayName();
}
}
/**
* Save this object using ResourceManager scheme Additionally save all known processes related to this workflow
*
* Overrides
*
* @see org.openflexo.foundation.rm.FlexoResourceData#save()
* @see org.openflexo.foundation.rm.FlexoResourceData#save()
*/
@Override
public void save() throws SaveResourceException {
_resource.saveResourceData();
}
public String getWorkflowName() {
return getName();
}
public void setWorkflowName(String newName) throws Exception {
super.setName(newName);
}
public File getFile() {
return _resource.getResourceFile().getFile();
}
public Vector<FlexoProcessNode> _getTopLevelNodeProcesses() {
return _topLevelNodeProcesses;
}
public void _setTopLevelNodeProcesses(Vector<FlexoProcessNode> topLevelProcesses) {
_topLevelNodeProcesses = topLevelProcesses;
}
public void addToTopLevelNodeProcesses(FlexoProcessNode processNode) {
if (!_topLevelNodeProcesses.contains(processNode)) {
if (isDeserializing() && processNode.getFatherProcessNode() != null) {
logger.severe("Found a sub process ('" + processNode.getName() + "') at top level -> Ignoring !");
return;
}
_topLevelNodeProcesses.add(processNode);
processNode.setFatherProcessNode(null);
if (!isDeserializing()) {
processNode.setIndexValue(_getTopLevelNodeProcesses().size());
FlexoIndexManager.reIndexObjectOfArray(_getTopLevelNodeProcesses().toArray(new FlexoProcessNode[0]));
}
clearOrphanProcesses();
setChanged();
notifyObservers(new ProcessInserted(processNode.getProcess(), null));
}
}
public void removeFromTopLevelNodeProcesses(FlexoProcessNode processNode) {
if (_topLevelNodeProcesses.contains(processNode)) {
_topLevelNodeProcesses.remove(processNode);
clearOrphanProcesses();
setChanged();
notifyObservers(new ProcessRemoved(processNode.getProcess(), null));
}
}
private Vector<FlexoProcessNode> orphanProcesses;
public Vector<FlexoProcessNode> getOrphanProcesses() {
if (orphanProcesses == null) {
orphanProcesses = new Vector<FlexoProcessNode>();
for (Enumeration<FlexoProcessNode> en = getSortedTopLevelProcesses(); en.hasMoreElements();) {
FlexoProcessNode node = en.nextElement();
if (node.getParentFolder() == null) {
node.setIndex(orphanProcesses.size() + 1);
orphanProcesses.add(node);
}
}
}
return orphanProcesses;
}
public Enumeration<FlexoProcessNode> getSortedOrphanSubprocesses() {
disableObserving();
FlexoProcessNode[] o = FlexoIndexManager.sortArray(getOrphanProcesses().toArray(new FlexoProcessNode[0]));
enableObserving();
return ToolBox.getEnumeration(o);
}
public void clearOrphanProcesses() {
orphanProcesses = null;
getPropertyChangeSupport().firePropertyChange("sortedOrphanSubprocesses", this.orphanProcesses, null);
}
public Vector<FlexoProcessNode> getImportedRootNodeProcesses() {
return importedRootNodeProcesses;
}
public void setImportedRootNodeProcesses(Vector<FlexoProcessNode> importedRootNodeProcesses) {
this.importedRootNodeProcesses = importedRootNodeProcesses;
}
public void addToImportedRootNodeProcesses(FlexoProcessNode processNode) {
if (!importedRootNodeProcesses.contains(processNode)) {
if (isDeserializing() && processNode.getFatherProcessNode() != null) {
logger.severe("Found a sub process ('" + processNode.getName() + "') at top level -> Ignoring !");
return;
}
importedRootNodeProcesses.add(processNode);
processNode.setFatherProcessNode(null);
if (!isDeserializing()) {
processNode.setIndexValue(getImportedRootNodeProcesses().size());
FlexoIndexManager.reIndexObjectOfArray(getImportedRootNodeProcesses().toArray(new FlexoProcessNode[0]));
}
setChanged();
notifyObservers(new ProcessInserted(processNode.getProcess(), null));
}
}
public void removeFromImportedRootNodeProcesses(FlexoProcessNode processNode) {
if (importedRootNodeProcesses.contains(processNode)) {
importedRootNodeProcesses.remove(processNode);
setChanged();
notifyObservers(new ProcessRemoved(processNode.getProcess(), null));
}
}
public Vector<FlexoProcess> getTopLevelFlexoProcesses() {
Vector<FlexoProcess> v = new Vector<FlexoProcess>();
for (FlexoProcessNode node : _getTopLevelNodeProcesses()) {
v.add(node.getProcess());
}
return v;
}
public Vector<FlexoProcess> getImportedProcesses() {
Vector<FlexoProcess> v = new Vector<FlexoProcess>();
for (FlexoProcessNode node : getImportedRootNodeProcesses()) {
v.add(node.getProcess());
}
return v;
}
public Vector<FlexoProcess> getNotDeletedImportedProcesses() {
Vector<FlexoProcess> v = new Vector<FlexoProcess>();
for (FlexoProcessNode node : getImportedRootNodeProcesses()) {
if (!node.getProcess().isDeletedOnServer()) {
v.add(node.getProcess());
}
}
return v;
}
public FlexoProcess getImportedProcessWithURI(String uri) {
return getObjectWithURI(getImportedProcesses(), uri);
}
public FlexoProcess getProcessWithURI(String uri) {
return getObjectWithURI(getAllFlexoProcesses(), uri);
}
public FlexoProcess getRecursivelyImportedProcessWithURI(String uri) {
return getRecursivelyImportedProcessWithURI(getImportedProcesses(), uri);
}
public static FlexoProcess getRecursivelyImportedProcessWithURI(Vector<FlexoProcess> processes, String uri) {
FlexoProcess fip = getObjectWithURI(processes, uri);
if (fip == null) {
Enumeration<FlexoProcess> en = processes.elements();
while (en.hasMoreElements() && fip == null) {
FlexoProcess p = en.nextElement();
fip = getRecursivelyImportedProcessWithURI(p.getSubProcesses(), uri);
}
}
return fip;
}
public FlexoProcess importProcess(PPMProcess process) throws ProcessAlreadyImportedException, InvalidFileNameException,
DuplicateResourceException, InvalidParentProcessException, InvalidProcessReferencesException {
FlexoProcess fip = getImportedProcessWithURI(process.getUri());
if (fip != null) {
throw new ProcessAlreadyImportedException(process, fip);
}
fip = getRecursivelyImportedProcessWithURI(process.getUri());
if (fip != null) {
fip.setParentProcess(null);
try {
fip.updateFromObject(process);
} catch (Exception e) {
e.printStackTrace();
}
} else {
fip = FlexoProcess.createImportedProcessFromProcess(this, process);
}
return fip;
}
// Used by templates in doc
public Enumeration<FlexoProcessNode> getSortedTopLevelProcesses() {
disableObserving();
FlexoProcessNode[] o = FlexoIndexManager.sortArray(_getTopLevelNodeProcesses().toArray(new FlexoProcessNode[0]));
enableObserving();
return ToolBox.getEnumeration(o);
}
public Enumeration<FlexoProcessNode> getSortedTopLevelImportedProcesses() {
disableObserving();
FlexoProcessNode[] o = FlexoIndexManager.sortArray(getImportedRootNodeProcesses().toArray(new FlexoProcessNode[0]));
enableObserving();
return ToolBox.getEnumeration(o);
}
public Enumeration<FlexoProcess> getSortedImportedProcesses() {
disableObserving();
Vector<FlexoProcess> vector = new Vector<FlexoProcess>();
Enumeration<FlexoProcessNode> en = getSortedTopLevelImportedProcesses();
while (en.hasMoreElements()) {
vector.add(en.nextElement().getProcess());
}
enableObserving();
return vector.elements();
}
private void addProcesses(Vector<FlexoProcessNode> temp, FlexoProcessNode process) {
temp.add(process);
for (Enumeration<FlexoProcessNode> e = process.getSubProcesses().elements(); e.hasMoreElements();) {
FlexoProcessNode currentProcessNode = e.nextElement();
addProcesses(temp, currentProcessNode);
}
}
public Vector<SubProcessNode> getAllSubProcessNodeUsingProcess(FlexoProcess process) {
Vector<SubProcessNode> v = new Vector<SubProcessNode>();
for (FlexoProcess p : getAllFlexoProcesses()) {
Enumeration<SubProcessNode> en1 = p.getAllSubProcessNodes().elements();
while (en1.hasMoreElements()) {
SubProcessNode node = en1.nextElement();
if (node.getSubProcess() == process) {
v.add(node);
}
}
}
return v;
}
/**
* TODO: optimize me later ! Return an enumeration of all processes, by recursively explore the tree
*
* @return an Enumeration of FlexoProcessNode elements
*/
public Enumeration<FlexoProcessNode> allLocalProcessNodes() {
return getAllLocalProcessNodes().elements();
}
/**
* TODO: optimize me later ! Return an vector of all processes, by recursively explore the tree
*
* @return an Vector of FlexoProcessNode elements
*/
public Vector<FlexoProcessNode> getAllLocalProcessNodes() {
Vector<FlexoProcessNode> temp = new Vector<FlexoProcessNode>();
for (Enumeration<FlexoProcessNode> en = _topLevelNodeProcesses.elements(); en.hasMoreElements();) {
FlexoProcessNode aTopLevelProcessNode = en.nextElement();
addProcesses(temp, aTopLevelProcessNode);
}
return temp;
}
/**
* TODO: optimize me later ! Return number of processes
*
* @return int: number of processes declared in this workflow
*/
public int allLocalProcessesCount() {
return getAllLocalProcessNodes().size();
}
/**
* TODO: optimize me later ! Return a Vector of all FlexoProcess objects defined in this workflow
*
* @return Vector of FlexoProcess
*/
public Vector<FlexoProcess> getAllLocalFlexoProcesses() {
// TODO: optimize me
Vector<FlexoProcess> returned = new Vector<FlexoProcess>();
for (Enumeration<FlexoProcessNode> e = allLocalProcessNodes(); e.hasMoreElements();) {
FlexoProcessNode currentProcessNode = e.nextElement();
FlexoProcess process = currentProcessNode.getProcess();
if (process != null) {
if (!returned.contains(process)) {
returned.add(process);
}
} else {
if (logger.isLoggable(Level.SEVERE)) {
logger.severe("ProcessNode:" + currentProcessNode.getName() + " have a null FlexoProcess, remove it !");
}
currentProcessNode.delete();
removeFromTopLevelNodeProcesses(currentProcessNode);
setChanged();
}
}
return returned;
}
/**
* TODO: optimize me later ! Return an enumeration of all processes, by recursively explore the tree
*
* @return an Enumeration of FlexoProcessNode elements
*/
public Enumeration<FlexoProcessNode> allImportedProcessNodes() {
return getAllImportedProcessNodes().elements();
}
/**
* TODO: optimize me later ! Return an vector of all processes, by recursively explore the tree
*
* @return an Vector of FlexoProcessNode elements
*/
private Vector<FlexoProcessNode> getAllImportedProcessNodes() {
Vector<FlexoProcessNode> temp = new Vector<FlexoProcessNode>();
for (Enumeration<FlexoProcessNode> en = importedRootNodeProcesses.elements(); en.hasMoreElements();) {
FlexoProcessNode aTopLevelProcessNode = en.nextElement();
addProcesses(temp, aTopLevelProcessNode);
}
return temp;
}
/**
* TODO: optimize me later ! Return number of processes
*
* @return int: number of processes declared in this workflow
*/
public int allImportedProcessesCount() {
return getAllImportedProcessNodes().size();
}
/**
* TODO: optimize me later ! Return a Vector of all FlexoProcess objects defined in this workflow
*
* @return Vector of FlexoProcess
*/
public Vector<FlexoProcess> getAllImportedFlexoProcesses() {
// TODO: optimize me
Vector<FlexoProcess> returned = new Vector<FlexoProcess>();
for (Enumeration<FlexoProcessNode> e = allImportedProcessNodes(); e.hasMoreElements();) {
FlexoProcessNode currentProcessNode = e.nextElement();
FlexoProcess process = currentProcessNode.getProcess();
if (process != null) {
if (!returned.contains(process)) {
returned.add(process);
}
} else {
if (logger.isLoggable(Level.SEVERE)) {
logger.severe("ProcessNode:" + currentProcessNode.getName() + " have a null FlexoProcess, remove it !");
}
currentProcessNode.delete();
removeFromTopLevelNodeProcesses(currentProcessNode);
setChanged();
}
}
return returned;
}
/**
* TODO: optimize me later ! Return an enumeration of all processes, by recursively explore the tree
*
* @return an Enumeration of FlexoProcessNode elements
*/
public Enumeration<FlexoProcessNode> allProcessNodes() {
return getAllProcessNodes().elements();
}
/**
* TODO: optimize me later ! Return an vector of all processes, by recursively explore the tree
*
* @return an Vector of FlexoProcessNode elements
*/
private Vector<FlexoProcessNode> getAllProcessNodes() {
Vector<FlexoProcessNode> temp = new Vector<FlexoProcessNode>();
temp.addAll(getAllLocalProcessNodes());
temp.addAll(getAllImportedProcessNodes());
return temp;
}
/**
* TODO: optimize me later ! Return number of processes
*
* @return int: number of processes declared in this workflow
*/
public int allProcessesCount() {
return getAllProcessNodes().size();
}
/**
* TODO: optimize me later ! Return a Vector of all FlexoProcess objects defined in this workflow
*
* @return Vector of FlexoProcess
*/
public Vector<FlexoProcess> getAllFlexoProcesses() {
// TODO: optimize me
Vector<FlexoProcess> returned = new Vector<FlexoProcess>();
for (Enumeration<FlexoProcessNode> e = allProcessNodes(); e.hasMoreElements();) {
FlexoProcessNode currentProcessNode = e.nextElement();
FlexoProcess process = currentProcessNode.getProcess();
if (process != null) {
if (!returned.contains(process)) {
returned.add(process);
}
} else {
if (logger.isLoggable(Level.SEVERE)) {
logger.severe("ProcessNode:" + currentProcessNode.getName() + " have a null FlexoProcess, remove it !");
}
currentProcessNode.delete();
}
}
return returned;
}
public Vector<FlexoProcess> getAllLocalTopLevelFlexoProcesses() {
Vector<FlexoProcess> returned = new Vector<FlexoProcess>();
for (Enumeration<FlexoProcessNode> e = allLocalProcessNodes(); e.hasMoreElements();) {
FlexoProcessNode currentProcessNode = e.nextElement();
FlexoProcess process = currentProcessNode.getProcess();
if (process != null) {
if (!returned.contains(process)) {
returned.add(process);
}
} else {
if (logger.isLoggable(Level.SEVERE)) {
logger.severe("ProcessNode:" + currentProcessNode.getName() + " have a null FlexoProcess, remove it !");
}
currentProcessNode.delete();
}
}
return returned;
}
public Vector<FlexoProcess> getAllImportedTopLevelFlexoProcesses() {
Vector<FlexoProcess> returned = new Vector<FlexoProcess>();
for (Enumeration<FlexoProcessNode> e = allImportedProcessNodes(); e.hasMoreElements();) {
FlexoProcessNode currentProcessNode = e.nextElement();
FlexoProcess process = currentProcessNode.getProcess();
if (process != null) {
if (!returned.contains(process)) {
returned.add(process);
}
} else {
if (logger.isLoggable(Level.SEVERE)) {
logger.severe("ProcessNode:" + currentProcessNode.getName() + " have a null FlexoProcess, remove it !");
}
currentProcessNode.delete();
}
}
return returned;
}
public Vector<FlexoProcess> getAllTopLevelFlexoProcesses() {
Vector<FlexoProcess> returned = new Vector<FlexoProcess>();
for (Enumeration<FlexoProcessNode> e = allProcessNodes(); e.hasMoreElements();) {
FlexoProcessNode currentProcessNode = e.nextElement();
FlexoProcess process = currentProcessNode.getProcess();
if (process != null) {
if (!returned.contains(process)) {
returned.add(process);
}
} else {
if (logger.isLoggable(Level.SEVERE)) {
logger.severe("ProcessNode:" + currentProcessNode.getName() + " have a null FlexoProcess, remove it !");
}
currentProcessNode.delete();
}
}
return returned;
}
/**
* Return a Vector of all embedded WKFObjects
*
* @return a Vector of WKFObject instances
*/
public Vector<FlexoModelObject> getAllEmbeddedWKFObjects() {
Vector<FlexoModelObject> returned = new Vector<FlexoModelObject>();
returned.add(this);
Vector<FlexoProcess> allProcesses = getAllFlexoProcesses();
for (Enumeration<FlexoProcess> e = allProcesses.elements(); e.hasMoreElements();) {
FlexoProcess p = e.nextElement();
returned.addAll(p.getAllEmbeddedWKFObjects());
}
returned.addAll(getAllImportedFlexoProcesses());
return returned;
}
public FlexoProcess getLocalFlexoProcessWithName(String name) {
for (Enumeration<FlexoProcessNode> e = allLocalProcessNodes(); e.hasMoreElements();) {
FlexoProcess process = e.nextElement().getProcess();
if (process != null) {
if (process.getName().equals(name)) {
return process;
}
}
}
if (logger.isLoggable(Level.FINE)) {
logger.fine("Could not find process named " + name);
}
return null;
}
public FlexoProcessNode getLocalFlexoProcessNodeWithFlexoID(long flexoID) {
for (Enumeration<FlexoProcessNode> e = allLocalProcessNodes(); e.hasMoreElements();) {
FlexoProcessNode process = e.nextElement();
if (process != null) {
if (process.getFlexoID() == flexoID) {
return process;
}
}
}
if (logger.isLoggable(Level.FINE)) {
logger.fine("Could not find process node with ID " + flexoID);
}
return null;
}
public FlexoProcess getLocalFlexoProcessWithFlexoID(long flexoID) {
for (Enumeration<FlexoProcessNode> e = allLocalProcessNodes(); e.hasMoreElements();) {
FlexoProcess process = e.nextElement().getProcess();
if (process != null) {
if (process.getFlexoID() == flexoID) {
return process;
}
}
}
if (logger.isLoggable(Level.FINE)) {
logger.fine("Could not find process with ID " + flexoID);
}
return null;
}
@Override
public String toString() {
return "WORKFLOW";
}
// ==========================================================================
// ============================= Instance methods
// ===========================
// ==========================================================================
public Vector<OperationComponentInstance> getAllOperationInstantiatingTab(TabComponentDefinition tabDef) {
Vector<OperationComponentInstance> reply = new Vector<OperationComponentInstance>();
Enumeration<OperationComponentInstance> en = getAllComponentInstances().elements();
OperationComponentInstance ci = null;
while (en.hasMoreElements()) {
ci = en.nextElement();
Enumeration<TabComponentInstance> en2 = ci.getOperationComponentDefinition().getWOComponent().getAllTabComponentInstances()
.elements();
TabComponentInstance tabci = null;
while (en2.hasMoreElements()) {
tabci = en2.nextElement();
if (tabci.getComponentDefinition().equals(tabDef)) {
if (!reply.contains(ci)) {
reply.add(ci);
}
}
}
}
return reply;
}
public void _setRootProcessNode(FlexoProcessNode processNode) {
if (_rootProcessNode != processNode) {
FlexoProcessNode old = _rootProcessNode;
_rootProcessNode = processNode;
setChanged();
notifyAttributeModification("rootProcessNode", old, _rootProcessNode);
// Ugly hack
if (old != null) {
old.setChanged();
old.notifyAttributeModification("rootProcessNode", old, _rootProcessNode);
}
if (_rootProcessNode != null) {
_rootProcessNode.setChanged();
_rootProcessNode.notifyAttributeModification("rootProcessNode", old, _rootProcessNode);
}
}
}
public FlexoProcessNode _getRootProcessNode() {
return _rootProcessNode;
}
public FlexoProcess getRootProcess() {
if (_getRootProcessNode() != null) {
return _getRootProcessNode().getProcess();
} else {
if (_getTopLevelNodeProcesses().size() > 0) {
logger.warning("No root process found, choosing first one !");
setRootProcess(_getTopLevelNodeProcesses().firstElement().getProcess());
return getRootProcess();
} else {
return null;
}
}
}
public FlexoProcess getRootFlexoProcess() {
return getRootProcess();
}
public void setRootProcess(FlexoProcess aProcess) {
_setRootProcessNode(aProcess.getProcessNode());
}
/*
* public Vector getAllComponents() { Vector answer = new Vector(); _getRootProcessNode().getAllComponents(answer); return answer; }
*/
public Vector<OperationComponentInstance> getAllComponentInstances() {
Vector<OperationComponentInstance> answer = new Vector<OperationComponentInstance>();
Enumeration<FlexoProcess> en = getAllLocalFlexoProcesses().elements();
while (en.hasMoreElements()) {
FlexoProcess p = en.nextElement();
answer.addAll(p.getAllComponentInstances());
}
return answer;
}
public Vector<OperationComponentInstance> getAllComponentInstances(OperationComponentDefinition cd) {
Vector<OperationNode> ops = new Vector<OperationNode>();
Vector<OperationComponentInstance> answer = new Vector<OperationComponentInstance>();
if (cd != null) {
Enumeration<OperationComponentInstance> en = getAllComponentInstances().elements();
while (en.hasMoreElements()) {
OperationComponentInstance ci = en.nextElement();
if (cd.equals(ci.getComponentDefinition()) && !ops.contains(ci.getOperationNode())) {
ops.add(ci.getOperationNode());
answer.add(ci);
}
}
}
return answer;
}
public Enumeration<FlexoProcess> getSortedProcesses() {
disableObserving();
Vector<FlexoProcess> vector = new Vector<FlexoProcess>();
addSubProcesses(vector, getSortedTopLevelProcesses());
enableObserving();
return vector.elements();
}
private void addSubProcesses(Vector<FlexoProcess> vector, Enumeration<FlexoProcessNode> en) {
while (en.hasMoreElements()) {
FlexoProcessNode processNode = en.nextElement();
vector.add(processNode.getProcess());
addSubProcesses(vector, processNode.getSortedSubprocesses());
}
}
// ==========================================================================
// ============================= Accessors
// ==================================
// ==========================================================================
/**
* @param baseName
* @param node
* @return
*/
public String findNextDefaultProcessName(String baseName) {
int i = 2;
String tryMe = baseName;
while (getLocalFlexoProcessWithName(tryMe) != null) {
tryMe = baseName + i;
i++;
}
return tryMe;
}
public Role getDefaultRole() {
if (getRoleList() != null) {
return getRoleList().getDefaultRole();
}
return null;
}
/**
* @return
*/
public RoleList getRoleList() {
if (_roleList == null && !isDeserializing() && !isSerializing()) {
_roleList = new RoleList(getProject(), this);
}
if (_roleList != null && !isDeserializing()) {
_roleList.assertDefaultRoleHasBeenCreated();
}
return _roleList;
}
/**
* @param list
*/
public void setRoleList(RoleList list) {
_roleList = list;
}
/**
* @return
*/
public RoleList getImportedRoleList() {
return getImportedRoleList(false);
}
public RoleList getImportedRoleList(boolean createIfNotExist) {
if (importedRoleList == null && !isDeserializing() && !isSerializing() && createIfNotExist) {
importedRoleList = new RoleList(getProject(), this);
setChanged();
notifyObservers(new ImportedRoleLibraryCreated());
}
return importedRoleList;
}
/**
* @param list
*/
public void setImportedRoleList(RoleList list) {
importedRoleList = list;
}
@Override
public void notifyAttributeModification(String attributeName, Object oldValue, Object newValue) {
setChanged();
notifyObservers(new AttributeDataModification(attributeName, oldValue, newValue));
}
public boolean getUseTransparency() {
return _booleanGraphicalPropertyForKey(GraphicalProperties.USE_TRANSPARENCY.getSerializationName(), true);
}
public boolean getUseTransparency(boolean defaultValue) {
return _booleanGraphicalPropertyForKey(GraphicalProperties.USE_TRANSPARENCY.getSerializationName(), defaultValue);
}
public void setUseTransparency(boolean value) {
if (value != getUseTransparency()) {
_setGraphicalPropertyForKey(value, GraphicalProperties.USE_TRANSPARENCY.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.USE_TRANSPARENCY.getSerializationName(), !value, value);
}
}
public boolean getShowShadows() {
return _booleanGraphicalPropertyForKey(GraphicalProperties.SHOW_SHADOWS.getSerializationName(), true);
}
public boolean getShowShadows(boolean defaultValue) {
return _booleanGraphicalPropertyForKey(GraphicalProperties.SHOW_SHADOWS.getSerializationName(), defaultValue);
}
public void setShowShadows(boolean value) {
if (value != getShowShadows()) {
_setGraphicalPropertyForKey(value, GraphicalProperties.SHOW_SHADOWS.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.SHOW_SHADOWS.getSerializationName(), !value, value);
}
}
public boolean getShowWOName() {
return _booleanGraphicalPropertyForKey(GraphicalProperties.SHOW_WO_NAME.getSerializationName(), true);
}
public boolean getShowWOName(boolean defaultValue) {
return _booleanGraphicalPropertyForKey(GraphicalProperties.SHOW_WO_NAME.getSerializationName(), defaultValue);
}
public void setShowWOName(boolean value) {
if (value != getShowWOName()) {
_setGraphicalPropertyForKey(value, GraphicalProperties.SHOW_WO_NAME.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.SHOW_WO_NAME.getSerializationName(), !value, value);
}
}
public boolean getShowMessages() {
return _booleanGraphicalPropertyForKey(GraphicalProperties.SHOW_MESSAGES.getSerializationName(), true);
}
public boolean getShowMessages(boolean defaultValue) {
return _booleanGraphicalPropertyForKey(GraphicalProperties.SHOW_MESSAGES.getSerializationName(), defaultValue);
}
public void setShowMessages(boolean value) {
if (value != getShowMessages()) {
_setGraphicalPropertyForKey(value, GraphicalProperties.SHOW_MESSAGES.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.SHOW_MESSAGES.getSerializationName(), !value, value);
}
}
public FlexoFont getActivityFont() {
return _fontGraphicalPropertyForKey(GraphicalProperties.ACTIVITY_FONT.getSerializationName(), FlexoFont.SANS_SERIF);
}
public FlexoFont getActivityFont(FlexoFont defaultValue) {
return _fontGraphicalPropertyForKey(GraphicalProperties.ACTIVITY_FONT.getSerializationName(), defaultValue);
}
public void setActivityFont(FlexoFont textFont) {
boolean needChanged = !hasGraphicalPropertyForKey(GraphicalProperties.ACTIVITY_FONT.getSerializationName())
|| !_graphicalPropertyForKey(GraphicalProperties.ACTIVITY_FONT.getSerializationName()).equals(textFont);
if (needChanged) {
_setGraphicalPropertyForKey(textFont, GraphicalProperties.ACTIVITY_FONT.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.ACTIVITY_FONT.getSerializationName(), null, textFont);
}
}
public FlexoFont getOperationFont() {
return _fontGraphicalPropertyForKey(GraphicalProperties.OPERATION_FONT.getSerializationName(), FlexoFont.SANS_SERIF);
}
public FlexoFont getOperationFont(FlexoFont defaultValue) {
return _fontGraphicalPropertyForKey(GraphicalProperties.OPERATION_FONT.getSerializationName(), defaultValue);
}
public void setOperationFont(FlexoFont textFont) {
boolean needChanged = !hasGraphicalPropertyForKey(GraphicalProperties.OPERATION_FONT.getSerializationName())
|| !_graphicalPropertyForKey(GraphicalProperties.OPERATION_FONT.getSerializationName()).equals(textFont);
if (needChanged) {
_setGraphicalPropertyForKey(textFont, GraphicalProperties.OPERATION_FONT.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.OPERATION_FONT.getSerializationName(), null, textFont);
}
}
public FlexoFont getActionFont() {
return _fontGraphicalPropertyForKey(GraphicalProperties.ACTION_FONT.getSerializationName(), FlexoFont.SANS_SERIF);
}
public FlexoFont getActionFont(FlexoFont defaultValue) {
return _fontGraphicalPropertyForKey(GraphicalProperties.ACTION_FONT.getSerializationName(), defaultValue);
}
public void setActionFont(FlexoFont textFont) {
boolean needChanged = !hasGraphicalPropertyForKey(GraphicalProperties.ACTION_FONT.getSerializationName())
|| !_graphicalPropertyForKey(GraphicalProperties.ACTION_FONT.getSerializationName()).equals(textFont);
if (needChanged) {
logger.info("Was:" + _graphicalPropertyForKey(GraphicalProperties.ACTION_FONT.getSerializationName()));
logger.info("Is now:" + textFont);
logger.info("Equals:" + _graphicalPropertyForKey(GraphicalProperties.ACTION_FONT.getSerializationName()).equals(textFont));
_setGraphicalPropertyForKey(textFont, GraphicalProperties.ACTION_FONT.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.ACTION_FONT.getSerializationName(), null, textFont);
}
}
public FlexoFont getEventFont() {
return _fontGraphicalPropertyForKey(GraphicalProperties.EVENT_FONT.getSerializationName(), FlexoFont.SANS_SERIF);
}
public FlexoFont getEventFont(FlexoFont defaultValue) {
return _fontGraphicalPropertyForKey(GraphicalProperties.EVENT_FONT.getSerializationName(), defaultValue);
}
public void setEventFont(FlexoFont textFont) {
boolean needChanged = !hasGraphicalPropertyForKey(GraphicalProperties.EVENT_FONT.getSerializationName())
|| !_graphicalPropertyForKey(GraphicalProperties.EVENT_FONT.getSerializationName()).equals(textFont);
if (needChanged) {
_setGraphicalPropertyForKey(textFont, GraphicalProperties.EVENT_FONT.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.EVENT_FONT.getSerializationName(), null, textFont);
}
}
public FlexoFont getRoleFont() {
return _fontGraphicalPropertyForKey(GraphicalProperties.ROLE_FONT.getSerializationName(), FlexoFont.SANS_SERIF);
}
public FlexoFont getRoleFont(FlexoFont defaultValue) {
return _fontGraphicalPropertyForKey(GraphicalProperties.ROLE_FONT.getSerializationName(), defaultValue);
}
public void setRoleFont(FlexoFont textFont) {
boolean needChanged = !hasGraphicalPropertyForKey(GraphicalProperties.ROLE_FONT.getSerializationName())
|| !_graphicalPropertyForKey(GraphicalProperties.ROLE_FONT.getSerializationName()).equals(textFont);
if (needChanged) {
_setGraphicalPropertyForKey(textFont, GraphicalProperties.ROLE_FONT.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.ROLE_FONT.getSerializationName(), null, textFont);
}
}
public FlexoFont getComponentFont() {
return _fontGraphicalPropertyForKey(GraphicalProperties.COMPONENT_FONT.getSerializationName(), FlexoFont.SANS_SERIF);
}
public FlexoFont getComponentFont(FlexoFont defaultValue) {
return _fontGraphicalPropertyForKey(GraphicalProperties.COMPONENT_FONT.getSerializationName(), defaultValue);
}
public void setComponentFont(FlexoFont textFont) {
boolean needChanged = !hasGraphicalPropertyForKey(GraphicalProperties.COMPONENT_FONT.getSerializationName())
|| !_graphicalPropertyForKey(GraphicalProperties.COMPONENT_FONT.getSerializationName()).equals(textFont);
if (needChanged) {
_setGraphicalPropertyForKey(textFont, GraphicalProperties.COMPONENT_FONT.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.COMPONENT_FONT.getSerializationName(), null, textFont);
}
}
public FlexoFont getArtefactFont() {
return _fontGraphicalPropertyForKey(GraphicalProperties.ARTEFACT_FONT.getSerializationName(), FlexoFont.SANS_SERIF);
}
public FlexoFont getArtefactFont(FlexoFont defaultValue) {
return _fontGraphicalPropertyForKey(GraphicalProperties.ARTEFACT_FONT.getSerializationName(), defaultValue);
}
public void setArtefactFont(FlexoFont textFont) {
boolean needChanged = !hasGraphicalPropertyForKey(GraphicalProperties.ARTEFACT_FONT.getSerializationName())
|| !_graphicalPropertyForKey(GraphicalProperties.ARTEFACT_FONT.getSerializationName()).equals(textFont);
if (needChanged) {
_setGraphicalPropertyForKey(textFont, GraphicalProperties.ARTEFACT_FONT.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.ARTEFACT_FONT.getSerializationName(), null, textFont);
}
}
public FlexoFont getEdgeFont() {
return _fontGraphicalPropertyForKey(GraphicalProperties.EDGE_FONT.getSerializationName(), FlexoFont.SANS_SERIF);
}
public FlexoFont getEdgeFont(FlexoFont defaultValue) {
return _fontGraphicalPropertyForKey(GraphicalProperties.EDGE_FONT.getSerializationName(), defaultValue);
}
public void setEdgeFont(FlexoFont textFont) {
boolean needChanged = !hasGraphicalPropertyForKey(GraphicalProperties.EDGE_FONT.getSerializationName())
|| !_graphicalPropertyForKey(GraphicalProperties.EDGE_FONT.getSerializationName()).equals(textFont);
if (needChanged) {
_setGraphicalPropertyForKey(textFont, GraphicalProperties.EDGE_FONT.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.EDGE_FONT.getSerializationName(), null, textFont);
}
}
public Object getConnectorRepresentation() {
return _graphicalPropertyForKey(GraphicalProperties.CONNECTOR_REPRESENTATION.getSerializationName());
}
public Object getConnectorRepresentation(Object defaultValue) {
return _objectGraphicalPropertyForKey(GraphicalProperties.CONNECTOR_REPRESENTATION.getSerializationName(), defaultValue);
}
public void setConnectorRepresentation(Object connectorRepresentation) {
boolean needChanged = !hasGraphicalPropertyForKey(GraphicalProperties.CONNECTOR_REPRESENTATION.getSerializationName())
|| !_graphicalPropertyForKey(GraphicalProperties.CONNECTOR_REPRESENTATION.getSerializationName()).equals(
connectorRepresentation);
if (needChanged) {
_setGraphicalPropertyForKey(connectorRepresentation, GraphicalProperties.CONNECTOR_REPRESENTATION.getSerializationName());
setChanged();
notifyAttributeModification(GraphicalProperties.CONNECTOR_REPRESENTATION.getSerializationName(), null, connectorRepresentation);
}
}
public Vector<Role> getAllRoles() {
Vector<Role> reply = new Vector<Role>();
reply.addAll(getRoleList().getRoles());
if (getImportedRoleList() != null) {
reply.addAll(getImportedRoleList().getRoles());
}
return reply;
}
public void clearAssignableRolesCache() {
allAssignableRoles = null;
if (manager != null) {
manager.delete();
}
manager = null;
notifyAttributeModification(ALL_ASSIGNABLE_ROLES, null, null);
}
private PropertyChangeListenerRegistrationManager manager;
public List<Role> getAllAssignableRoles() {
if (allAssignableRoles == null) {
manager = new PropertyChangeListenerRegistrationManager();
allAssignableRoles = new ArrayList<Role>();
RoleList roleList = getRoleList();
appendRoles(roleList, allAssignableRoles);
if (!isCache()) {
if (getProject().getProjectData() != null) {
manager.addListener(ProjectData.IMPORTED_PROJECTS, new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent evt) {
clearAssignableRolesCache();
}
}, getProject().getProjectData());
for (FlexoProjectReference ref : getProject().getProjectData().getImportedProjects()) {
manager.addListener(FlexoProjectReference.WORKFLOW, new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent evt) {
clearAssignableRolesCache();
}
}, ref);
if (ref.getWorkflow() != null) {
allAssignableRoles.addAll(ref.getWorkflow().getAllAssignableRoles());
manager.addListener(ALL_ASSIGNABLE_ROLES, new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent evt) {
clearAssignableRolesCache();
}
}, ref.getWorkflow());
}
}
} else {
manager.addListener(FlexoProject.PROJECT_DATA, new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent evt) {
clearAssignableRolesCache();
}
}, getProject());
}
}
allAssignableRoles = Collections.unmodifiableList(allAssignableRoles);
}
return allAssignableRoles;
}
private void appendRoles(RoleList roleList, List<Role> reply) {
if (roleList != null) {
for (Role r : roleList.getRoles()) {
if (r.getIsAssignable()) {
reply.add(r);
}
}
}
}
public Vector<Role> getAllSortedRoles() {
Vector<Role> reply = new Vector<Role>();
reply.addAll(getRoleList().getSortedRolesVector());
if (getImportedRoleList() != null) {
reply.addAll(getImportedRoleList().getSortedRolesVector());
}
return reply;
}
public Role getRoleWithURI(String uri) {
Role reply = getRoleList().getImportedObjectWithURI(uri);
if (reply == null && getImportedRoleList() != null) {
reply = getImportedRoleList().getImportedObjectWithURI(uri);
}
return reply;
}
private FlexoImportedProcessLibrary importedProcessLibrary;
public FlexoImportedProcessLibrary getImportedProcessLibrary() {
if (importedProcessLibrary == null && getImportedProcesses().size() > 0) {
importedProcessLibrary = new FlexoImportedProcessLibrary(this);
setChanged(false);
notifyObservers(new ImportedProcessLibraryCreated());
}
return importedProcessLibrary;
}
/**
* @return
*/
public Enumeration<Role> getSortedRoles() {
return getRoleList().getSortedRoles();
}
// ========================================================================
// ========================= Validable interface ==========================
// ========================================================================
/**
* Return a vector of all embedded objects on which the validation will be performed
*
* @return a Vector of Validable objects
*/
@Override
public Vector<Validable> getAllEmbeddedValidableObjects() {
Vector<Validable> returned = new Vector<Validable>();
returned.add(this);
Vector allProcesses = getAllFlexoProcesses();
for (Enumeration e = allProcesses.elements(); e.hasMoreElements();) {
FlexoProcess p = (FlexoProcess) e.nextElement();
returned.addAll(p.getAllEmbeddedValidableObjects());
}
returned.addAll(getRoleList().getAllEmbeddedValidableObjects());
if (getImportedRoleList() != null) {
returned.addAll(getImportedRoleList().getAllEmbeddedValidableObjects());
}
returned.addAll(getProcessMetricsDefinitions());
returned.addAll(getActivityMetricsDefinitions());
returned.addAll(getOperationMetricsDefinitions());
return returned;
}
public static class WorkflowMustHaveARootProcess extends ValidationRule<WorkflowMustHaveARootProcess, FlexoWorkflow> {
public WorkflowMustHaveARootProcess() {
super(FlexoWorkflow.class, "workflow_must_have_a_root_process");
}
@Override
public ValidationIssue<WorkflowMustHaveARootProcess, FlexoWorkflow> applyValidation(FlexoWorkflow workflow) {
if (workflow.getRootFlexoProcess() == null) {
return new ValidationError<WorkflowMustHaveARootProcess, FlexoWorkflow>(this, workflow,
"workflow_($object.name)_has_no_root_process");
}
return null;
}
}
public static class BusinessDataClassMustHaveAStatusColumn extends
ValidationRule<BusinessDataClassMustHaveAStatusColumn, FlexoWorkflow> {
public BusinessDataClassMustHaveAStatusColumn() {
super(FlexoWorkflow.class, "business_data_class_must_have_a_status_column");
}
@Override
public ValidationIssue<BusinessDataClassMustHaveAStatusColumn, FlexoWorkflow> applyValidation(FlexoWorkflow workflow) {
for (FlexoProcess p : workflow.getAllLocalFlexoProcesses()) {
if (p.getBusinessDataType() == null) {
continue;
}
Enumeration<DMProperty> en = p.getBusinessDataType().getProperties().elements();
boolean found = false;
while (en.hasMoreElements() && !found) {
DMProperty prop = en.nextElement();
if (prop.getName() != null && prop.getName().toLowerCase().startsWith("status") && prop.getType() != null
&& prop.getType().isString()) {
found = true;
}
}
if (!found) {
return new ValidationError<BusinessDataClassMustHaveAStatusColumn, FlexoWorkflow>(this, workflow,
"business_data_class_must_have_a_status_column", new CreateStatusProperty(p.getBusinessDataType()));
}
}
return null;
}
public static class CreateStatusProperty extends FixProposal {
private DMEntity entity;
/**
* @param aMessage
*/
public CreateStatusProperty(DMEntity e) {
super("create_status_property");
this.entity = e;
}
/**
* Overrides fixAction
*
* @see org.openflexo.foundation.validation.FixProposal#fixAction()
*/
@Override
protected void fixAction() {
if (entity instanceof DMEOEntity) {
DMEOEntity eo = (DMEOEntity) entity;
DMEOAttribute att;
try {
att = DMEOAttribute.createsNewDMEOAttribute(eo.getDMModel(), eo, "status", false, true,
DMPropertyImplementationType.PUBLIC_ACCESSORS_PRIVATE_FIELD);
att.setPrototype(eo.getDMModel().getEOPrototypeRepository().getPrototypeNamed("str10"));
eo.registerProperty(att);
} catch (EOAccessException e) {
e.printStackTrace();
}
} else {
DMProperty prop = new DMProperty(entity.getDMModel(), "status", DMType.makeResolvedDMType(entity.getDMModel()
.getDMEntity(String.class)), DMCardinality.SINGLE, false, true,
DMPropertyImplementationType.PUBLIC_ACCESSORS_PRIVATE_FIELD);
entity.registerProperty(prop, true);
}
}
}
/**
* Overrides isValidForTarget
*
* @see org.openflexo.foundation.validation.ValidationRule#isValidForTarget(TargetType)
*/
@Override
public boolean isValidForTarget(TargetType targetType) {
return true;
// return targetType!=CodeType.PROTOTYPE;
}
}
public static class BusinessDataMustNotBeReadOnly extends ValidationRule<BusinessDataMustNotBeReadOnly, FlexoWorkflow> {
public BusinessDataMustNotBeReadOnly() {
super(FlexoWorkflow.class, "business_data_class_must_not_be_read_only");
}
@Override
public ValidationIssue<BusinessDataMustNotBeReadOnly, FlexoWorkflow> applyValidation(FlexoWorkflow workflow) {
for (FlexoProcess p : workflow.getAllLocalFlexoProcesses()) {
if (p.getBusinessDataType() == null) {
continue;
}
if (p.getBusinessDataType().getIsReadOnly()) {
return new ValidationError<BusinessDataMustNotBeReadOnly, FlexoWorkflow>(this, workflow,
"business_data_must_not_be_readonly");
}
}
return null;
}
/**
* Overrides isValidForTarget
*
* @see org.openflexo.foundation.validation.ValidationRule#isValidForTarget(TargetType)
*/
@Override
public boolean isValidForTarget(TargetType targetType) {
return true;
}
}
/**
* Overrides getClassNameKey
*
* @see org.openflexo.foundation.FlexoModelObject#getClassNameKey()
*/
@Override
public String getClassNameKey() {
return "workflow";
}
public Vector<TabComponentInstance> getAllTabInstances(TabComponentDefinition definition) {
Vector<TabComponentInstance> reply = new Vector<TabComponentInstance>();
Enumeration<OperationComponentInstance> operations = getAllComponentInstances().elements();
Vector<IETabWidget> tabs = new Vector<IETabWidget>();
while (operations.hasMoreElements()) {
operations.nextElement().getComponentDefinition().getWOComponent().getAllTabWidget(tabs);
}
Enumeration<IETabWidget> en = tabs.elements();
IETabWidget t = null;
while (en.hasMoreElements()) {
t = en.nextElement();
if (t.getTabComponentDefinition().equals(definition) && !reply.contains(t.getComponentInstance())) {
reply.add(t.getComponentInstance());
}
}
return reply;
}
public List<ApplicationHelpEntryPoint> getAllHelpEntryPoints() {
Vector<ApplicationHelpEntryPoint> answer = new Vector<ApplicationHelpEntryPoint>();
Enumeration<FlexoModelObject> en = getAllEmbeddedWKFObjects().elements();
while (en.hasMoreElements()) {
FlexoModelObject p = en.nextElement();
if (p instanceof FlexoProcess && ((FlexoProcess) p).isImported()) {
continue;
}
if (p instanceof ApplicationHelpEntryPoint) {
if (p instanceof PetriGraphNode) {
if (!((PetriGraphNode) p).getDontGenerateRecursive()) {
if (p instanceof FlexoNode) {
if (((FlexoNode) p).getNodeType() != NodeType.BEGIN && ((FlexoNode) p).getNodeType() != NodeType.END) {
if (p instanceof OperationNode) {
if (((OperationNode) p).getComponentInstance() != null) {
answer.add((ApplicationHelpEntryPoint) p);
}
} else {
answer.add((ApplicationHelpEntryPoint) p);
}
}
} else {
answer.add((ApplicationHelpEntryPoint) p);
}
}
} else {
answer.add((ApplicationHelpEntryPoint) p);
}
}
}
return answer;
}
/**
* Recovery method use to detect and repair inconsistencies in the model regarding Process and ProcessDMEntities.
*/
public void checkProcessDMEntitiesConsistency() {
int processCount = getAllLocalFlexoProcesses().size();
int processDMEntityCount = getProject().getDataModel().getProcessInstanceRepository().getEntities().size();
if (processCount != processDMEntityCount) {
logger.severe("Found : " + processCount + " but there is " + processDMEntityCount + " processDMEntity");
}
Vector<DMEntity> entities = new Vector<DMEntity>(getProject().getDataModel().getProcessInstanceRepository().getEntities().values());
Enumeration<FlexoProcess> en = getAllLocalFlexoProcesses().elements();
while (en.hasMoreElements()) {
FlexoProcess process = en.nextElement();
if (process.isImported()) {
continue;
}
ProcessDMEntity processEntity = process.getProcessDMEntity();
if (processEntity == null) {
logger.severe("No process entity found for " + process.getName());
}
if (entities.contains(processEntity)) {
entities.remove(processEntity);
} else {
logger.severe("Found process entity found for " + process.getName() + " but was not in ProcessInstanceRepository.");
}
}
if (entities.size() > 0) {
logger.severe("Got " + entities.size() + " without processes !");
Enumeration<DMEntity> en2 = entities.elements();
while (en2.hasMoreElements()) {
en2.nextElement().delete();
}
}
// now ensure that all process instances are in a package
en = getAllLocalFlexoProcesses().elements();
while (en.hasMoreElements()) {
FlexoProcess process = en.nextElement();
ProcessDMEntity processEntity = process.getProcessDMEntity();
if (processEntity.getPackage().isDefaultPackage()) {
logger.severe("Process entity for " + process.getName() + " is in default package :-( I put it in a package :-)");
processEntity.moveToPackage(process.getExecutionGroupName());
}
}
}
private Vector<MetricsDefinition> processMetricsDefinitions;
private Vector<MetricsDefinition> activityMetricsDefinitions;
private Vector<MetricsDefinition> operationMetricsDefinitions;
private Vector<MetricsDefinition> edgeMetricsDefinitions;
private Vector<MetricsDefinition> artefactMetricsDefinitions;
public Vector<MetricsDefinition> getProcessMetricsDefinitions() {
return processMetricsDefinitions;
}
public void setProcessMetricsDefinitions(Vector<MetricsDefinition> definitions) {
this.processMetricsDefinitions = definitions;
setChanged();
}
public void addToProcessMetricsDefinitions(MetricsDefinition definition) {
if (!processMetricsDefinitions.contains(definition)) {
processMetricsDefinitions.add(definition);
if (definition.getAlwaysDefined()) {
updateProcessModelObjects(definition);
}
setChanged();
notifyObservers(new MetricsDefinitionAdded(definition, "processMetricsDefinitions"));
}
}
public boolean removeFromProcessMetricsDefinitions(MetricsDefinition definition) {
boolean b = processMetricsDefinitions.remove(definition);
if (b) {
setChanged();
notifyObservers(new MetricsDefinitionAdded(definition, "processMetricsDefinitions"));
}
return b;
}
public void updateMetricsForProcess(FlexoProcess process) {
for (MetricsDefinition definition : getProcessMetricsDefinitions()) {
if (definition.getAlwaysDefined()) {
updateMetricsValueOwner(definition, process);
}
}
}
public Vector<MetricsDefinition> getActivityMetricsDefinitions() {
return activityMetricsDefinitions;
}
public void setActivityMetricsDefinitions(Vector<MetricsDefinition> definitions) {
this.activityMetricsDefinitions = definitions;
setChanged();
}
public void addToActivityMetricsDefinitions(MetricsDefinition definition) {
if (!activityMetricsDefinitions.contains(definition)) {
activityMetricsDefinitions.add(definition);
if (definition.getAlwaysDefined()) {
updateProcessModelObjects(definition);
}
setChanged();
notifyObservers(new MetricsDefinitionAdded(definition, "activityMetricsDefinitions"));
}
}
public boolean removeFromActivityMetricsDefinitions(MetricsDefinition definition) {
boolean b = activityMetricsDefinitions.remove(definition);
if (b) {
setChanged();
notifyObservers(new MetricsDefinitionAdded(definition, "activityMetricsDefinitions"));
}
return b;
}
public void updateMetricsForActivity(AbstractActivityNode activity) {
for (MetricsDefinition definition : getActivityMetricsDefinitions()) {
if (definition.getAlwaysDefined()) {
updateMetricsValueOwner(definition, activity);
}
}
}
public Vector<MetricsDefinition> getOperationMetricsDefinitions() {
return operationMetricsDefinitions;
}
public void setOperationMetricsDefinitions(Vector<MetricsDefinition> definitions) {
this.operationMetricsDefinitions = definitions;
setChanged();
}
public void addToOperationMetricsDefinitions(MetricsDefinition definition) {
if (!operationMetricsDefinitions.contains(definition)) {
operationMetricsDefinitions.add(definition);
if (definition.getAlwaysDefined()) {
updateProcessModelObjects(definition);
}
setChanged();
notifyObservers(new MetricsDefinitionAdded(definition, "operationMetricsDefinitions"));
}
}
public boolean removeFromOperationMetricsDefinitions(MetricsDefinition definition) {
boolean b = operationMetricsDefinitions.remove(definition);
if (b) {
setChanged();
notifyObservers(new MetricsDefinitionAdded(definition, "operationMetricsDefinitions"));
}
return b;
}
public void updateMetricsForOperation(OperationNode operation) {
for (MetricsDefinition definition : getOperationMetricsDefinitions()) {
if (definition.getAlwaysDefined()) {
updateMetricsValueOwner(definition, operation);
}
}
}
public Vector<MetricsDefinition> getEdgeMetricsDefinitions() {
return edgeMetricsDefinitions;
}
public void setEdgeMetricsDefinitions(Vector<MetricsDefinition> definitions) {
this.edgeMetricsDefinitions = definitions;
setChanged();
}
public void addToEdgeMetricsDefinitions(MetricsDefinition definition) {
if (!edgeMetricsDefinitions.contains(definition)) {
edgeMetricsDefinitions.add(definition);
if (definition.getAlwaysDefined()) {
updateProcessModelObjects(definition);
}
setChanged();
notifyObservers(new MetricsDefinitionAdded(definition, "edgeMetricsDefinitions"));
}
}
public boolean removeFromEdgeMetricsDefinitions(MetricsDefinition definition) {
boolean b = edgeMetricsDefinitions.remove(definition);
if (b) {
setChanged();
notifyObservers(new MetricsDefinitionAdded(definition, "edgeMetricsDefinitions"));
}
return b;
}
public void updateMetricsForEdge(FlexoPostCondition edge) {
for (MetricsDefinition definition : getEdgeMetricsDefinitions()) {
if (definition.getAlwaysDefined()) {
updateMetricsValueOwner(definition, edge);
}
}
}
public Vector<MetricsDefinition> getArtefactMetricsDefinitions() {
return artefactMetricsDefinitions;
}
public void setArtefactMetricsDefinitions(Vector<MetricsDefinition> definitions) {
this.artefactMetricsDefinitions = definitions;
setChanged();
}
public void addToArtefactMetricsDefinitions(MetricsDefinition definition) {
if (!artefactMetricsDefinitions.contains(definition)) {
artefactMetricsDefinitions.add(definition);
if (definition.getAlwaysDefined()) {
updateProcessModelObjects(definition);
}
setChanged();
notifyObservers(new MetricsDefinitionAdded(definition, "artefactMetricsDefinitions"));
}
}
public boolean removeFromArtefactMetricsDefinitions(MetricsDefinition definition) {
boolean b = artefactMetricsDefinitions.remove(definition);
if (b) {
setChanged();
notifyObservers(new MetricsDefinitionAdded(definition, "artefactMetricsDefinitions"));
}
return b;
}
public void updateMetricsForArtefact(WKFArtefact artefact) {
for (MetricsDefinition definition : getArtefactMetricsDefinitions()) {
if (definition.getAlwaysDefined()) {
updateMetricsValueOwner(definition, artefact);
}
}
}
public void removeFromMetricsDefinition(MetricsDefinition definition) {
boolean ok = removeFromProcessMetricsDefinitions(definition);
if (!ok) {
ok = removeFromActivityMetricsDefinitions(definition);
}
if (!ok) {
ok = removeFromOperationMetricsDefinitions(definition);
}
if (!ok) {
removeFromEdgeMetricsDefinitions(definition);
}
if (!ok) {
removeFromArtefactMetricsDefinitions(definition);
}
}
public void addProcessMetricsDefinition() {
if (addProcessMetricsDefinitionActionizer != null) {
addProcessMetricsDefinitionActionizer.run(this, null);
}
}
public void addActivityMetricsDefinition() {
if (addActivityMetricsDefinitionActionizer != null) {
addActivityMetricsDefinitionActionizer.run(this, null);
}
}
public void addOperationMetricsDefinition() {
if (addOperationMetricsDefinitionActionizer != null) {
addOperationMetricsDefinitionActionizer.run(this, null);
}
}
public void addEdgeMetricsDefinition() {
if (addEdgeMetricsDefinitionActionizer != null) {
addEdgeMetricsDefinitionActionizer.run(this, null);
}
}
public void addArtefactMetricsDefinition() {
if (addArtefactMetricsDefinitionActionizer != null) {
addArtefactMetricsDefinitionActionizer.run(this, null);
}
}
public void deleteMetricsDefinition(MetricsDefinition definition) {
if (deleteMetricsDefinitionActionizer != null) {
deleteMetricsDefinitionActionizer.run(definition, null);
}
}
public void createDefaultProcessMetricsDefinitions() {
MetricsDefinition md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("process_time"));
md.setType(MetricsType.TIME);
md.setDescription(FlexoLocalization.localizedForKey("process_time_description"));
addToProcessMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("lead_time"));
md.setType(MetricsType.TIME);
md.setDescription(FlexoLocalization.localizedForKey("lead_time_description"));
addToProcessMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("percent_complete_and_accurate"));
md.setType(MetricsType.TEXT);
md.setDescription(FlexoLocalization.localizedForKey("percent_complete_and_accurate_description"));
addToProcessMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("demand_rate"));
md.setType(MetricsType.TEXT);
md.setDescription(FlexoLocalization.localizedForKey("demand_rate_description"));
addToProcessMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("inventory"));
md.setType(MetricsType.TEXT);
md.setDescription(FlexoLocalization.localizedForKey("inventory_description"));
addToProcessMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("typical_batch_size_or_practices"));
md.setType(MetricsType.NUMBER);
md.setDescription(FlexoLocalization.localizedForKey("typical_batch_size_or_practices_description"));
addToProcessMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("available_time"));
md.setType(MetricsType.TIME);
md.setDescription(FlexoLocalization.localizedForKey("available_time_description"));
addToProcessMetricsDefinitions(md);
}
public void createDefaultActivityMetricsDefinitions() {
MetricsDefinition md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("process_time"));
md.setType(MetricsType.TIME);
md.setDescription(FlexoLocalization.localizedForKey("process_time_description"));
addToActivityMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("lead_time"));
md.setType(MetricsType.TIME);
md.setDescription(FlexoLocalization.localizedForKey("lead_time_description"));
addToActivityMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("percent_complete_and_accurate"));
md.setType(MetricsType.TEXT);
md.setDescription(FlexoLocalization.localizedForKey("percent_complete_and_accurate_description"));
addToActivityMetricsDefinitions(md);
}
public void createDefaultOperationMetricsDefinitions() {
MetricsDefinition md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("process_time"));
md.setType(MetricsType.TIME);
md.setDescription(FlexoLocalization.localizedForKey("process_time_description"));
addToOperationMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("lead_time"));
md.setType(MetricsType.TIME);
md.setDescription(FlexoLocalization.localizedForKey("lead_time_description"));
addToOperationMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("percent_complete_and_accurate"));
md.setType(MetricsType.TEXT);
md.setDescription(FlexoLocalization.localizedForKey("percent_complete_and_accurate_description"));
addToOperationMetricsDefinitions(md);
}
public void createDefaultEdgeMetricsDefinitions() {
MetricsDefinition md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("probability"));
md.setType(MetricsType.DOUBLE);
md.setDescription(FlexoLocalization.localizedForKey("probability_description"));
md.setAlwaysDefined(true);
addToEdgeMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("rate"));
md.setType(MetricsType.NUMBER);
md.setDescription(FlexoLocalization.localizedForKey("rate_description"));
addToEdgeMetricsDefinitions(md);
}
public void createDefaultArtefactMetricsDefinitions() {
MetricsDefinition md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("process_time"));
md.setType(MetricsType.TIME);
md.setDescription(FlexoLocalization.localizedForKey("process_time_description"));
addToArtefactMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("lead_time"));
md.setType(MetricsType.TIME);
md.setDescription(FlexoLocalization.localizedForKey("lead_time_description"));
addToArtefactMetricsDefinitions(md);
md = new MetricsDefinition(getProject(), this);
md.setName(FlexoLocalization.localizedForKey("percent_complete_and_accurate"));
md.setType(MetricsType.TEXT);
md.setDescription(FlexoLocalization.localizedForKey("percent_complete_and_accurate_description"));
addToArtefactMetricsDefinitions(md);
}
@Override
public String getInspectorName() {
return Inspectors.WKF.WORKFLOW_INSPECTOR;
}
public void updateProcessModelObjects(MetricsDefinition metricsDefinition) {
if (isDeserializing()) {
return;
}
if (metricsDefinition.isProcessMetricsDefinition()) {
for (FlexoProcess process : getAllLocalFlexoProcesses()) {
updateMetricsValueOwner(metricsDefinition, process);
}
} else if (metricsDefinition.isActivityMetricsDefinition()) {
for (FlexoProcess process : getAllLocalFlexoProcesses()) {
for (AbstractActivityNode activity : process.getAllEmbeddedAbstractActivityNodes()) {
updateMetricsValueOwner(metricsDefinition, activity);
}
}
} else if (metricsDefinition.isOperationMetricsDefinition()) {
for (FlexoProcess process : getAllLocalFlexoProcesses()) {
for (OperationNode operation : process.getAllEmbeddedOperationNodes()) {
updateMetricsValueOwner(metricsDefinition, operation);
}
}
} else if (metricsDefinition.isEdgeMetricsDefinition()) {
for (FlexoProcess process : getAllLocalFlexoProcesses()) {
for (FlexoPostCondition postCondition : process.getAllPostConditions()) {
updateMetricsValueOwner(metricsDefinition, postCondition);
}
}
} else if (metricsDefinition.isArtefactMetricsDefinition()) {
for (FlexoProcess process : getAllLocalFlexoProcesses()) {
for (WKFArtefact artefact : process.getAllEmbeddedArtefacts()) {
updateMetricsValueOwner(metricsDefinition, artefact);
}
}
}
}
/**
* @param metricsDefinition
* @param alwaysDefined
* @param process
*/
private void updateMetricsValueOwner(MetricsDefinition metricsDefinition, MetricsValueOwner owner) {
MetricsValue found = null;
for (MetricsValue mv : owner.getMetricsValues()) {
if (mv.getMetricsDefinition() == metricsDefinition) {
found = mv;
break;
}
}
boolean alwaysDefined = metricsDefinition.getAlwaysDefined();
if (alwaysDefined && found == null) {
MetricsValue mv = new MetricsValue(owner.getProcess());
mv.setMetricsDefinition(metricsDefinition);
owner.addToMetricsValues(mv);
} else if (!alwaysDefined && found != null && found.getValue() == null) {
found.delete();
}
}
public String getProjectURI() {
if (isCache()) {
return getFlexoResource().getProjectURI();
} else {
return getProject().getURI();
}
}
public Role getCachedRole(FlexoModelObjectReference<Role> reference) {
if (reference.getObject() != null) {
return reference.getObject();
} else {
ProjectData data = getProject().getProjectData();
if (data != null) {
String projectURI = reference.getEnclosingProjectIdentifier();
if (projectURI != null) {
FlexoProjectReference projectRef = data.getProjectReferenceWithURI(projectURI, true);
if (projectRef != null) {
return projectRef.getWorkflow().getRoleList().getRoleWithFlexoID(reference.getFlexoID());
}
} else {
if (reference.getResourceIdentifier() != null) {
String projectName = reference.getResourceIdentifier().substring(ResourceType.WORKFLOW.getName().length() + 1);
List<FlexoProjectReference> refs = data.getProjectReferenceWithName(projectName, true);
for (FlexoProjectReference ref : refs) {
FlexoWorkflow workflow = ref.getWorkflow();
if (workflow == null) {
continue;
}
Role r = workflow.getRoleList().getRoleWithFlexoID(reference.getFlexoID());
if (r != null) {
reference._setEnclosingProjectIdentifier(ref.getURI());
return r;
}
}
for (FlexoProjectReference ref : data.getImportedProjects()) {
FlexoWorkflow workflow = ref.getWorkflow();
if (workflow == null) {
continue;
}
Role r = workflow.getRoleList().getRoleWithFlexoID(reference.getFlexoID());
if (r != null) {
reference._setEnclosingProjectIdentifier(ref.getURI());
return r;
}
}
}
}
}
}
return null;
}
@Override
public boolean isCache() {
return getFlexoResource() != null && getFlexoResource().isCache();
}
@Override
public FlexoModelObject getUncachedObject() {
return super.getUncachedObject();
}
@Override
public FlexoProcessNode getProcessNode() {
return null;
}
}