/**
* @author Tom Baeyens
* @author Daniel Meyer
*/
public class ProcessDefinitionEntity extends ProcessDefinitionImpl
implements ProcessDefinition, PersistentObject, HasRevision {
private static final long serialVersionUID = 1L;
protected String key;
protected int revision = 1;
protected int version;
protected String category;
protected String deploymentId;
protected String resourceName;
protected Integer historyLevel;
protected StartFormHandler startFormHandler;
protected String diagramResourceName;
protected boolean isGraphicalNotationDefined;
protected Map<String, TaskDefinition> taskDefinitions;
protected boolean hasStartFormKey;
protected int suspensionState = SuspensionState.ACTIVE.getStateCode();
protected boolean isIdentityLinksInitialized = false;
protected List<IdentityLinkEntity> definitionIdentityLinkEntities =
new ArrayList<IdentityLinkEntity>();
protected Set<Expression> candidateStarterUserIdExpressions = new HashSet<Expression>();
protected Set<Expression> candidateStarterGroupIdExpressions = new HashSet<Expression>();
public ProcessDefinitionEntity() {
super(null);
}
public ExecutionEntity createProcessInstance(String businessKey, ActivityImpl initial) {
ExecutionEntity processInstance = null;
if (initial == null) {
processInstance = (ExecutionEntity) super.createProcessInstance();
} else {
processInstance = (ExecutionEntity) super.createProcessInstanceForInitial(initial);
}
CommandContext commandContext = Context.getCommandContext();
processInstance.setExecutions(new ArrayList<ExecutionEntity>());
processInstance.setProcessDefinition(processDefinition);
// Do not initialize variable map (let it happen lazily)
if (businessKey != null) {
processInstance.setBusinessKey(businessKey);
}
// reset the process instance in order to have the db-generated process instance id available
processInstance.setProcessInstance(processInstance);
String initiatorVariableName =
(String) getProperty(BpmnParse.PROPERTYNAME_INITIATOR_VARIABLE_NAME);
if (initiatorVariableName != null) {
String authenticatedUserId = Authentication.getAuthenticatedUserId();
processInstance.setVariable(initiatorVariableName, authenticatedUserId);
}
int historyLevel = Context.getProcessEngineConfiguration().getHistoryLevel();
// TODO: This smells bad, as the rest of the history is done via the ParseListener
if (historyLevel >= ProcessEngineConfigurationImpl.HISTORYLEVEL_ACTIVITY) {
HistoricProcessInstanceEntity historicProcessInstance =
new HistoricProcessInstanceEntity(processInstance);
commandContext.getSession(DbSqlSession.class).insert(historicProcessInstance);
// do basically the same as in ActivityInstanceStanrtHandler
IdGenerator idGenerator = Context.getProcessEngineConfiguration().getIdGenerator();
String processDefinitionId = processInstance.getProcessDefinitionId();
String processInstanceId = processInstance.getProcessInstanceId();
String executionId = processInstance.getId();
HistoricActivityInstanceEntity historicActivityInstance =
new HistoricActivityInstanceEntity();
historicActivityInstance.setId(idGenerator.getNextId());
historicActivityInstance.setProcessDefinitionId(processDefinitionId);
historicActivityInstance.setProcessInstanceId(processInstanceId);
historicActivityInstance.setExecutionId(executionId);
historicActivityInstance.setActivityId(processInstance.getActivityId());
historicActivityInstance.setActivityName(
(String) processInstance.getActivity().getProperty("name"));
historicActivityInstance.setActivityType(
(String) processInstance.getActivity().getProperty("type"));
Date now = ClockUtil.getCurrentTime();
historicActivityInstance.setStartTime(now);
commandContext.getDbSqlSession().insert(historicActivityInstance);
}
return processInstance;
}
public ExecutionEntity createProcessInstance(String businessKey) {
return createProcessInstance(businessKey, null);
}
public ExecutionEntity createProcessInstance() {
return createProcessInstance(null);
}
@Override
protected InterpretableExecution newProcessInstance(ActivityImpl activityImpl) {
ExecutionEntity processInstance = new ExecutionEntity(activityImpl);
processInstance.insert();
return processInstance;
}
public IdentityLinkEntity addIdentityLink(String userId, String groupId) {
IdentityLinkEntity identityLinkEntity = IdentityLinkEntity.createAndInsert();
getIdentityLinks().add(identityLinkEntity);
identityLinkEntity.setProcessDef(this);
identityLinkEntity.setUserId(userId);
identityLinkEntity.setGroupId(groupId);
identityLinkEntity.setType(IdentityLinkType.CANDIDATE);
return identityLinkEntity;
}
public void deleteIdentityLink(String userId, String groupId) {
List<IdentityLinkEntity> identityLinks =
Context.getCommandContext()
.getIdentityLinkManager()
.findIdentityLinkByProcessDefinitionUserAndGroup(id, userId, groupId);
for (IdentityLinkEntity identityLink : identityLinks) {
Context.getCommandContext()
.getDbSqlSession()
.delete(IdentityLinkEntity.class, identityLink.getId());
}
}
public List<IdentityLinkEntity> getIdentityLinks() {
if (!isIdentityLinksInitialized) {
definitionIdentityLinkEntities =
Context.getCommandContext()
.getIdentityLinkManager()
.findIdentityLinksByProcessDefinitionId(id);
isIdentityLinksInitialized = true;
}
return definitionIdentityLinkEntities;
}
public String toString() {
return "ProcessDefinitionEntity[" + id + "]";
}
// getters and setters //////////////////////////////////////////////////////
public Object getPersistentState() {
Map<String, Object> persistentState = new HashMap<String, Object>();
persistentState.put("suspensionState", this.suspensionState);
return persistentState;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public String getDescription() {
return (String) getProperty(BpmnParse.PROPERTYNAME_DOCUMENTATION);
}
public String getDeploymentId() {
return deploymentId;
}
public void setDeploymentId(String deploymentId) {
this.deploymentId = deploymentId;
}
public int getVersion() {
return version;
}
public void setVersion(int version) {
this.version = version;
}
public void setId(String id) {
this.id = id;
}
public String getResourceName() {
return resourceName;
}
public void setResourceName(String resourceName) {
this.resourceName = resourceName;
}
public Integer getHistoryLevel() {
return historyLevel;
}
public void setHistoryLevel(Integer historyLevel) {
this.historyLevel = historyLevel;
}
public StartFormHandler getStartFormHandler() {
return startFormHandler;
}
public void setStartFormHandler(StartFormHandler startFormHandler) {
this.startFormHandler = startFormHandler;
}
public Map<String, TaskDefinition> getTaskDefinitions() {
return taskDefinitions;
}
public void setTaskDefinitions(Map<String, TaskDefinition> taskDefinitions) {
this.taskDefinitions = taskDefinitions;
}
public String getCategory() {
return category;
}
public void setCategory(String category) {
this.category = category;
}
public String getDiagramResourceName() {
return diagramResourceName;
}
public void setDiagramResourceName(String diagramResourceName) {
this.diagramResourceName = diagramResourceName;
}
public boolean hasStartFormKey() {
return hasStartFormKey;
}
public boolean getHasStartFormKey() {
return hasStartFormKey;
}
public void setStartFormKey(boolean hasStartFormKey) {
this.hasStartFormKey = hasStartFormKey;
}
public void setHasStartFormKey(boolean hasStartFormKey) {
this.hasStartFormKey = hasStartFormKey;
}
public boolean isGraphicalNotationDefined() {
return isGraphicalNotationDefined;
}
public void setGraphicalNotationDefined(boolean isGraphicalNotationDefined) {
this.isGraphicalNotationDefined = isGraphicalNotationDefined;
}
public int getRevision() {
return revision;
}
public void setRevision(int revision) {
this.revision = revision;
}
public int getRevisionNext() {
return revision + 1;
}
public int getSuspensionState() {
return suspensionState;
}
public void setSuspensionState(int suspensionState) {
this.suspensionState = suspensionState;
}
public boolean isSuspended() {
return suspensionState == SuspensionState.SUSPENDED.getStateCode();
}
public Set<Expression> getCandidateStarterUserIdExpressions() {
return candidateStarterUserIdExpressions;
}
public void addCandidateStarterUserIdExpression(Expression userId) {
candidateStarterUserIdExpressions.add(userId);
}
public Set<Expression> getCandidateStarterGroupIdExpressions() {
return candidateStarterGroupIdExpressions;
}
public void addCandidateStarterGroupIdExpression(Expression groupId) {
candidateStarterGroupIdExpressions.add(groupId);
}
}
/**
* @author Tom Baeyens
* @author Joram Barrez
* @author Falko Menge
* @author Tijs Rademakers
*/
public class TaskEntity extends VariableScopeImpl
implements Task, DelegateTask, Serializable, PersistentObject, HasRevision {
public static final String DELETE_REASON_COMPLETED = "completed";
public static final String DELETE_REASON_DELETED = "deleted";
private static final long serialVersionUID = 1L;
protected int revision;
protected String owner;
protected String assignee;
protected DelegationState delegationState;
protected String parentTaskId;
protected String name;
protected String description;
protected int priority = DEFAULT_PRIORITY;
protected Date createTime; // The time when the task has been created
protected Date dueDate;
protected int suspensionState = SuspensionState.ACTIVE.getStateCode();
protected boolean isIdentityLinksInitialized = false;
protected List<IdentityLinkEntity> taskIdentityLinkEntities = new ArrayList<IdentityLinkEntity>();
protected String executionId;
protected ExecutionEntity execution;
protected String processInstanceId;
protected ExecutionEntity processInstance;
protected String processDefinitionId;
protected TaskDefinition taskDefinition;
protected String taskDefinitionKey;
protected boolean isDeleted;
protected String eventName;
protected List<VariableInstanceEntity> queryVariables;
public TaskEntity() {}
public TaskEntity(String taskId) {
this.id = taskId;
}
/** creates and initializes a new persistent task. */
public static TaskEntity createAndInsert(ActivityExecution execution) {
TaskEntity task = create();
task.insert((ExecutionEntity) execution);
return task;
}
public void insert(ExecutionEntity execution) {
CommandContext commandContext = Context.getCommandContext();
DbSqlSession dbSqlSession = commandContext.getDbSqlSession();
dbSqlSession.insert(this);
if (execution != null) {
execution.addTask(this);
}
commandContext.getHistoryManager().recordTaskCreated(this, execution);
}
public void update() {
// Needed to make history work: the setter will also update the historic task
setOwner(this.getOwner());
setAssignee(this.getAssignee());
setDelegationState(this.getDelegationState());
setName(this.getName());
setDescription(this.getDescription());
setPriority(this.getPriority());
setCreateTime(this.getCreateTime());
setDueDate(this.getDueDate());
setParentTaskId(this.getParentTaskId());
CommandContext commandContext = Context.getCommandContext();
DbSqlSession dbSqlSession = commandContext.getDbSqlSession();
dbSqlSession.update(this);
}
/**
* Creates a new task. Embedded state and create time will be initialized. But this task still
* will have to be persisted. See {@link #insert(ExecutionEntity)}.
*/
public static TaskEntity create() {
TaskEntity task = new TaskEntity();
task.isIdentityLinksInitialized = true;
task.createTime = ClockUtil.getCurrentTime();
return task;
}
public void complete() {
fireEvent(TaskListener.EVENTNAME_COMPLETE);
if (Authentication.getAuthenticatedUserId() != null && processInstanceId != null) {
getProcessInstance()
.involveUser(Authentication.getAuthenticatedUserId(), IdentityLinkType.PARTICIPANT);
}
Context.getCommandContext()
.getTaskEntityManager()
.deleteTask(this, TaskEntity.DELETE_REASON_COMPLETED, false);
if (executionId != null) {
ExecutionEntity execution = getExecution();
execution.removeTask(this);
execution.signal(null, null);
}
}
public void delegate(String userId) {
setDelegationState(DelegationState.PENDING);
if (getOwner() == null) {
setOwner(getAssignee());
}
setAssignee(userId);
}
public void resolve() {
setDelegationState(DelegationState.RESOLVED);
setAssignee(this.owner);
}
public Object getPersistentState() {
Map<String, Object> persistentState = new HashMap<String, Object>();
persistentState.put("assignee", this.assignee);
persistentState.put("owner", this.owner);
persistentState.put("name", this.name);
persistentState.put("priority", this.priority);
if (executionId != null) {
persistentState.put("executionId", this.executionId);
}
if (processDefinitionId != null) {
persistentState.put("processDefinitionId", this.processDefinitionId);
}
if (createTime != null) {
persistentState.put("createTime", this.createTime);
}
if (description != null) {
persistentState.put("description", this.description);
}
if (dueDate != null) {
persistentState.put("dueDate", this.dueDate);
}
if (parentTaskId != null) {
persistentState.put("parentTaskId", this.parentTaskId);
}
if (delegationState != null) {
persistentState.put("delegationState", this.delegationState);
}
persistentState.put("suspensionState", this.suspensionState);
return persistentState;
}
public int getRevisionNext() {
return revision + 1;
}
// variables ////////////////////////////////////////////////////////////////
@Override
protected VariableScopeImpl getParentVariableScope() {
if (getExecution() != null) {
return execution;
}
return null;
}
@Override
protected void initializeVariableInstanceBackPointer(VariableInstanceEntity variableInstance) {
variableInstance.setTaskId(id);
variableInstance.setExecutionId(executionId);
variableInstance.setProcessInstanceId(processInstanceId);
}
@Override
protected List<VariableInstanceEntity> loadVariableInstances() {
return Context.getCommandContext()
.getVariableInstanceEntityManager()
.findVariableInstancesByTaskId(id);
}
// execution ////////////////////////////////////////////////////////////////
public ExecutionEntity getExecution() {
if ((execution == null) && (executionId != null)) {
this.execution =
Context.getCommandContext().getExecutionEntityManager().findExecutionById(executionId);
}
return execution;
}
public void setExecution(DelegateExecution execution) {
if (execution != null) {
this.execution = (ExecutionEntity) execution;
this.executionId = this.execution.getId();
this.processInstanceId = this.execution.getProcessInstanceId();
this.processDefinitionId = this.execution.getProcessDefinitionId();
Context.getCommandContext()
.getHistoryManager()
.recordTaskExecutionIdChange(this.id, executionId);
} else {
this.execution = null;
this.executionId = null;
this.processInstanceId = null;
this.processDefinitionId = null;
}
}
// task assignment //////////////////////////////////////////////////////////
public IdentityLinkEntity addIdentityLink(String userId, String groupId, String type) {
IdentityLinkEntity identityLinkEntity = new IdentityLinkEntity();
getIdentityLinks().add(identityLinkEntity);
identityLinkEntity.setTask(this);
identityLinkEntity.setUserId(userId);
identityLinkEntity.setGroupId(groupId);
identityLinkEntity.setType(type);
identityLinkEntity.insert();
if (userId != null && processInstanceId != null) {
getProcessInstance().involveUser(userId, IdentityLinkType.PARTICIPANT);
}
return identityLinkEntity;
}
public void deleteIdentityLink(String userId, String groupId, String type) {
List<IdentityLinkEntity> identityLinks =
Context.getCommandContext()
.getIdentityLinkEntityManager()
.findIdentityLinkByTaskUserGroupAndType(id, userId, groupId, type);
for (IdentityLinkEntity identityLink : identityLinks) {
Context.getCommandContext()
.getIdentityLinkEntityManager()
.deleteIdentityLink(identityLink, true);
}
}
public Set<IdentityLink> getCandidates() {
Set<IdentityLink> potentialOwners = new HashSet<IdentityLink>();
for (IdentityLinkEntity identityLinkEntity : getIdentityLinks()) {
if (IdentityLinkType.CANDIDATE.equals(identityLinkEntity.getType())) {
potentialOwners.add(identityLinkEntity);
}
}
return potentialOwners;
}
public void addCandidateUser(String userId) {
addIdentityLink(userId, null, IdentityLinkType.CANDIDATE);
}
public void addCandidateUsers(Collection<String> candidateUsers) {
for (String candidateUser : candidateUsers) {
addCandidateUser(candidateUser);
}
}
public void addCandidateGroup(String groupId) {
addIdentityLink(null, groupId, IdentityLinkType.CANDIDATE);
}
public void addCandidateGroups(Collection<String> candidateGroups) {
for (String candidateGroup : candidateGroups) {
addCandidateGroup(candidateGroup);
}
}
public void addGroupIdentityLink(String groupId, String identityLinkType) {
addIdentityLink(null, groupId, identityLinkType);
}
public void addUserIdentityLink(String userId, String identityLinkType) {
addIdentityLink(userId, null, identityLinkType);
}
public void deleteCandidateGroup(String groupId) {
deleteGroupIdentityLink(groupId, IdentityLinkType.CANDIDATE);
}
public void deleteCandidateUser(String userId) {
deleteUserIdentityLink(userId, IdentityLinkType.CANDIDATE);
}
public void deleteGroupIdentityLink(String groupId, String identityLinkType) {
if (groupId != null) {
deleteIdentityLink(null, groupId, identityLinkType);
}
}
public void deleteUserIdentityLink(String userId, String identityLinkType) {
if (userId != null) {
deleteIdentityLink(userId, null, identityLinkType);
}
}
public List<IdentityLinkEntity> getIdentityLinks() {
if (!isIdentityLinksInitialized) {
taskIdentityLinkEntities =
Context.getCommandContext().getIdentityLinkEntityManager().findIdentityLinksByTaskId(id);
isIdentityLinksInitialized = true;
}
return taskIdentityLinkEntities;
}
@SuppressWarnings("unchecked")
public Map<String, Object> getActivityInstanceVariables() {
if (execution != null) {
return execution.getVariables();
}
return Collections.EMPTY_MAP;
}
public void setExecutionVariables(Map<String, Object> parameters) {
if (getExecution() != null) {
execution.setVariables(parameters);
}
}
public String toString() {
return "Task[id=" + id + ", name=" + name + "]";
}
// special setters //////////////////////////////////////////////////////////
public void setName(String taskName) {
this.name = taskName;
CommandContext commandContext = Context.getCommandContext();
if (commandContext != null) {
commandContext.getHistoryManager().recordTaskNameChange(id, taskName);
}
}
/* plain setter for persistence */
public void setNameWithoutCascade(String taskName) {
this.name = taskName;
}
public void setDescription(String description) {
this.description = description;
CommandContext commandContext = Context.getCommandContext();
if (commandContext != null) {
commandContext.getHistoryManager().recordTaskDescriptionChange(id, description);
}
}
/* plain setter for persistence */
public void setDescriptionWithoutCascade(String description) {
this.description = description;
}
public void setAssignee(String assignee) {
if (assignee == null && this.assignee == null) {
return;
}
this.assignee = assignee;
CommandContext commandContext = Context.getCommandContext();
// if there is no command context, then it means that the user is calling the
// setAssignee outside a service method. E.g. while creating a new task.
if (commandContext != null) {
commandContext.getHistoryManager().recordTaskAssigneeChange(id, assignee);
if (assignee != null && processInstanceId != null) {
getProcessInstance().involveUser(assignee, IdentityLinkType.PARTICIPANT);
}
fireEvent(TaskListener.EVENTNAME_ASSIGNMENT);
}
}
/* plain setter for persistence */
public void setAssigneeWithoutCascade(String assignee) {
this.assignee = assignee;
}
public void setOwner(String owner) {
if (owner == null && this.owner == null) {
return;
}
// if (owner!=null && owner.equals(this.owner)) {
// return;
// }
this.owner = owner;
CommandContext commandContext = Context.getCommandContext();
if (commandContext != null) {
commandContext.getHistoryManager().recordTaskOwnerChange(id, owner);
if (owner != null && processInstanceId != null) {
getProcessInstance().involveUser(owner, IdentityLinkType.PARTICIPANT);
}
}
}
/* plain setter for persistence */
public void setOwnerWithoutCascade(String owner) {
this.owner = owner;
}
public void setDueDate(Date dueDate) {
this.dueDate = dueDate;
CommandContext commandContext = Context.getCommandContext();
if (commandContext != null) {
commandContext.getHistoryManager().recordTaskDueDateChange(id, dueDate);
}
}
public void setDueDateWithoutCascade(Date dueDate) {
this.dueDate = dueDate;
}
public void setPriority(int priority) {
this.priority = priority;
CommandContext commandContext = Context.getCommandContext();
if (commandContext != null) {
commandContext.getHistoryManager().recordTaskPriorityChange(id, priority);
}
}
public void setPriorityWithoutCascade(int priority) {
this.priority = priority;
}
public void setParentTaskId(String parentTaskId) {
this.parentTaskId = parentTaskId;
CommandContext commandContext = Context.getCommandContext();
if (commandContext != null) {
commandContext.getHistoryManager().recordTaskParentTaskIdChange(id, parentTaskId);
}
}
public void setParentTaskIdWithoutCascade(String parentTaskId) {
this.parentTaskId = parentTaskId;
}
public void setTaskDefinitionKeyWithoutCascade(String taskDefinitionKey) {
this.taskDefinitionKey = taskDefinitionKey;
}
public void fireEvent(String taskEventName) {
TaskDefinition taskDefinition = getTaskDefinition();
if (taskDefinition != null) {
List<TaskListener> taskEventListeners = getTaskDefinition().getTaskListener(taskEventName);
if (taskEventListeners != null) {
for (TaskListener taskListener : taskEventListeners) {
ExecutionEntity execution = getExecution();
if (execution != null) {
setEventName(taskEventName);
}
try {
Context.getProcessEngineConfiguration()
.getDelegateInterceptor()
.handleInvocation(new TaskListenerInvocation(taskListener, (DelegateTask) this));
} catch (Exception e) {
throw new ActivitiException(
"Exception while invoking TaskListener: " + e.getMessage(), e);
}
}
}
}
// fire implicit listeners
ProcessEngineConfiguration cfg = Context.getProcessEngineConfiguration();
if (!(cfg instanceof ImplicitListeners)) return;
List<TaskListener> taskEventListeners =
((ImplicitListeners) cfg).getImplicitUserTaskListenersFor(taskEventName);
if (taskEventListeners != null) {
for (TaskListener taskListener : taskEventListeners) {
ExecutionEntity execution = getExecution();
if (execution != null) {
setEventName(taskEventName);
}
try {
Context.getProcessEngineConfiguration()
.getDelegateInterceptor()
.handleInvocation(new TaskListenerInvocation(taskListener, (DelegateTask) this));
} catch (Exception e) {
throw new ActivitiException(
"Exception while invoking TaskListener: " + e.getMessage(), e);
}
}
}
}
@Override
protected boolean isActivityIdUsedForDetails() {
return false;
}
// modified getters and setters /////////////////////////////////////////////
public void setTaskDefinition(TaskDefinition taskDefinition) {
this.taskDefinition = taskDefinition;
this.taskDefinitionKey = taskDefinition.getKey();
CommandContext commandContext = Context.getCommandContext();
if (commandContext != null) {
commandContext.getHistoryManager().recordTaskDefinitionKeyChange(this, taskDefinitionKey);
}
}
public TaskDefinition getTaskDefinition() {
if (taskDefinition == null && taskDefinitionKey != null) {
ProcessDefinitionEntity processDefinition =
Context.getProcessEngineConfiguration()
.getDeploymentManager()
.findDeployedProcessDefinitionById(processDefinitionId);
taskDefinition = processDefinition.getTaskDefinitions().get(taskDefinitionKey);
}
return taskDefinition;
}
// getters and setters //////////////////////////////////////////////////////
public int getRevision() {
return revision;
}
public void setRevision(int revision) {
this.revision = revision;
}
public String getName() {
return name;
}
public String getDescription() {
return description;
}
public Date getDueDate() {
return dueDate;
}
public int getPriority() {
return priority;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public String getExecutionId() {
return executionId;
}
public String getProcessInstanceId() {
return processInstanceId;
}
public String getProcessDefinitionId() {
return processDefinitionId;
}
public void setProcessDefinitionId(String processDefinitionId) {
this.processDefinitionId = processDefinitionId;
}
public String getAssignee() {
return assignee;
}
public String getTaskDefinitionKey() {
return taskDefinitionKey;
}
public void setTaskDefinitionKey(String taskDefinitionKey) {
this.taskDefinitionKey = taskDefinitionKey;
CommandContext commandContext = Context.getCommandContext();
if (commandContext != null) {
commandContext.getHistoryManager().recordTaskDefinitionKeyChange(this, taskDefinitionKey);
}
}
public String getEventName() {
return eventName;
}
public void setEventName(String eventName) {
this.eventName = eventName;
}
public void setExecutionId(String executionId) {
this.executionId = executionId;
}
public ExecutionEntity getProcessInstance() {
if (processInstance == null && processInstanceId != null) {
processInstance =
Context.getCommandContext()
.getExecutionEntityManager()
.findExecutionById(processInstanceId);
}
return processInstance;
}
public void setProcessInstance(ExecutionEntity processInstance) {
this.processInstance = processInstance;
}
public void setExecution(ExecutionEntity execution) {
this.execution = execution;
}
public void setProcessInstanceId(String processInstanceId) {
this.processInstanceId = processInstanceId;
}
public String getOwner() {
return owner;
}
public DelegationState getDelegationState() {
return delegationState;
}
public void setDelegationState(DelegationState delegationState) {
this.delegationState = delegationState;
}
public String getDelegationStateString() {
return (delegationState != null ? delegationState.toString() : null);
}
public void setDelegationStateString(String delegationStateString) {
this.delegationState =
(delegationStateString != null
? DelegationState.valueOf(DelegationState.class, delegationStateString)
: null);
}
public boolean isDeleted() {
return isDeleted;
}
public void setDeleted(boolean isDeleted) {
this.isDeleted = isDeleted;
}
public String getParentTaskId() {
return parentTaskId;
}
public Map<String, VariableInstanceEntity> getVariableInstances() {
ensureVariableInstancesInitialized();
return variableInstances;
}
public int getSuspensionState() {
return suspensionState;
}
public void setSuspensionState(int suspensionState) {
this.suspensionState = suspensionState;
}
public boolean isSuspended() {
return suspensionState == SuspensionState.SUSPENDED.getStateCode();
}
public Map<String, Object> getTaskLocalVariables() {
Map<String, Object> variables = new HashMap<String, Object>();
if (queryVariables != null) {
for (VariableInstanceEntity variableInstance : queryVariables) {
if (variableInstance.getId() != null && variableInstance.getTaskId() != null) {
variables.put(variableInstance.getName(), variableInstance.getValue());
}
}
}
return variables;
}
public Map<String, Object> getProcessVariables() {
Map<String, Object> variables = new HashMap<String, Object>();
if (queryVariables != null) {
for (VariableInstanceEntity variableInstance : queryVariables) {
if (variableInstance.getId() != null && variableInstance.getTaskId() == null) {
variables.put(variableInstance.getName(), variableInstance.getValue());
}
}
}
return variables;
}
public List<VariableInstanceEntity> getQueryVariables() {
return queryVariables;
}
public void setQueryVariables(List<VariableInstanceEntity> queryVariables) {
this.queryVariables = queryVariables;
}
}
