protected void registerActionDefinitions() { actionDefinitions.clear(); for (ProcessDefinition processDef : processDefinitions) { String type = processDef.getResourceType(); String processName = processDef.getName(); if (processName.startsWith(type.toLowerCase())) { processName = processName.substring(type.length() + 1, processName.length()); } Map<String, ActionDefinition> actionDefs = actionDefinitions.get(type); if (actionDefs == null) { actionDefs = new HashMap<String, ActionDefinition>(); actionDefinitions.put(type, actionDefs); } ActionDefinition def = actionDefs.get(processName); if (def == null) { def = new ActionDefinition(); actionDefs.put(processName, def); } for (StateTransition transition : processDef.getStateTransitions()) { if (transition.getType() != StateTransition.Style.DONE) { def.getValidStates().add(transition.getFromState()); } } } }
@Override public ProcessDefinition getProcessDelegate(ProcessDefinition def) { String delegate = def.getProcessDelegateName(); if (delegate == null) { return null; } ProcessDefinition processDef = definitions.get(delegate); if (processDef == null) throw new ProcessNotFoundException("Failed to find ProcessDefinition for [" + delegate + "]"); return processDef; }
protected void registerActions() { actions.clear(); for (ProcessDefinition def : processDefinitions) { String resourceType = def.getResourceType(); Set<String> actions = this.actions.get(resourceType); if (resourceType == null) { continue; } if (def.getName().startsWith(resourceType.toLowerCase() + ".")) { if (actions == null) { actions = new LinkedHashSet<String>(); this.actions.put(resourceType, actions); } actions.add(def.getName().substring(resourceType.length() + 1)); } } }
protected void registerStates() { transitioningStates.clear(); for (ProcessDefinition def : processDefinitions) { Set<String> validStates = this.validStates.get(def.getResourceType()); Set<String> states = transitioningStates.get(def.getResourceType()); for (StateTransition transition : def.getStateTransitions()) { if (states == null) { states = new HashSet<String>(); transitioningStates.put(def.getResourceType(), states); } if (validStates == null) { validStates = new TreeSet<String>(); this.validStates.put(def.getResourceType(), validStates); } switch (transition.getType()) { case DONE: states.add(transition.getFromState()); break; case TRANSITIONING: states.add(transition.getToState()); break; default: } if (ObjectMetaDataManager.STATE_FIELD.equals(transition.getField())) { validStates.add(transition.getToState()); validStates.add(transition.getFromState()); } } } }
protected ProcessDefinition getById(String id) { for (ProcessDefinition def : processDefinitions) { if (def.getName().equals(id)) { return def; } } return null; }
protected void addTransitions(ProcessDefinition def, Set<String> nodes, StringBuilder buffer) { String doneName = getName(def); String name = def.getName(); String link = getLink(def); List<StateTransition> transitions = def.getStateTransitions(); for (StateTransition transition : transitions) { String from = getTransitionName(transition, transition.getFromState()); String to = getTransitionName(transition, transition.getToState()); buffer.append(" \"").append(from).append("\" -> \"").append(to).append("\""); if (transition.getType() == Style.TRANSITIONING) { buffer.append(" [style=\"dotted\" label=\"" + name + "\" URL=\"" + link + "\"]"); } if (transition.getType() == Style.DONE) { buffer.append(" [color=\"orange\" label=\"" + doneName + "\" URL=\"" + link + "\"]"); } buffer.append(";\n"); if (transition.getType() == Style.TRANSITIONING && !nodes.contains(to)) { buffer.append(" \"").append(to).append("\" [color=\"orange\"];\n"); nodes.add(to); } } }
@Override protected Object getByIdInternal(String type, String id, ListOptions options) { for (ProcessDefinition def : processDefinitions) { if (id.equalsIgnoreCase(def.getResourceType())) { return newResource(def.getResourceType(), options.getInclude()); } } return null; }
protected void runLogic() { inLogic = true; boolean shouldDelegate = false; try { instanceContext.setPhase(ProcessPhase.PRE_LISTENERS); shouldDelegate |= runHandlers(ProcessPhase.PRE_LISTENERS_DONE, instanceContext.getProcessDefinition().getPreProcessListeners()); instanceContext.setPhase(ProcessPhase.HANDLERS); shouldDelegate |= runHandlers(ProcessPhase.HANDLER_DONE, instanceContext.getProcessDefinition().getProcessHandlers()); instanceContext.setPhase(ProcessPhase.POST_LISTENERS); shouldDelegate |= runHandlers(ProcessPhase.POST_LISTENERS_DONE, instanceContext.getProcessDefinition().getPostProcessListeners()); if (shouldDelegate) { throw new ProcessCancelException("Process result triggered a delegation"); } } finally { inLogic = false; } instanceContext.setPhase(ProcessPhase.DONE); }
protected boolean shouldAbort(ProcessCancelException e) { ProcessDefinition def = context.getProcessManager().getProcessDelegate(instanceContext.getProcessDefinition()); if (def == null) { return true; } ProcessState state = def.constructProcessState(record); if (state.shouldCancel(record)) { return true; } ProcessInstanceContext newContext = new ProcessInstanceContext(); newContext.setProcessDefinition(def); newContext.setState(state); newContext.setPhase(ProcessPhase.STARTED); instanceContextHistory.push(instanceContext); instanceContext = newContext; return false; }
protected void openLog(EngineContext engineContext) { if (processLog == null) { ParentLog parentLog = engineContext.peekLog(); if (parentLog == null) { processLog = new ProcessLog(); } else { processLog = parentLog.newChildLog(); } } execution = processLog.newExecution(); execution.setProcessId(record.getId()); execution.setResourceType(instanceContext.getProcessDefinition().getResourceType()); execution.setResourceId(instanceContext.getState().getResourceId()); execution.setProcessName(instanceContext.getProcessDefinition().getName()); engineContext.pushLog(execution); }
@Override public void start() { String type = schemaFactory.getSchemaName(Agent.class); if (type == null) { return; } for (ProcessDefinition def : processDefinitions) { if (!type.equals(def.getResourceType())) { continue; } for (StateTransition transition : def.getStateTransitions()) { if (transition.getType() == StateTransition.Style.DONE) { transitioningToDone.put(transition.getFromState(), transition.getToState()); } } } }
public String getProcessDot(ProcessDefinition def) { StringBuilder buffer = new StringBuilder(); Set<String> nodes = new HashSet<String>(); buffer.append("digraph \"").append(def.getName()).append("\" {\n"); addTransitions(def, nodes, buffer); buffer.append("}\n"); return buffer.toString(); }
public String getResourceDot(String resourceType) { StringBuilder buffer = new StringBuilder(); Set<String> nodes = new HashSet<String>(); buffer.append("digraph \"").append(resourceType).append("\" {\n"); for (ProcessDefinition def : processDefinitions) { if (ObjectUtils.equals(resourceType, def.getResourceType())) { addTransitions(def, nodes, buffer); } } buffer.append("}\n"); return buffer.toString(); }
protected ProcessInstance createProcessInstance(ProcessRecord record, boolean schedule, boolean replay) { if (record == null) return null; ProcessDefinition processDef = definitions.get(record.getProcessName()); if (processDef == null) throw new ProcessNotFoundException("Failed to find ProcessDefinition for [" + record.getProcessName() + "]"); ProcessState state = processDef.constructProcessState(record); if (state == null) throw new ProcessNotFoundException("Failed to construct ProcessState for [" + record.getProcessName() + "]"); if (record.getId() == null && (schedule || !EngineContext.hasParentProcess())) record = processRecordDao.insert(record); ProcessServiceContext context = new ProcessServiceContext(lockManager, eventService, this, exceptionHandler, changeMonitors); DefaultProcessInstanceImpl process = new DefaultProcessInstanceImpl(context, record, processDef, state, schedule, replay); if (record.getId() != null) queue(process); return process; }
protected ProcessDefinitionApi toApi(ProcessDefinition def) { if (def == null) { return null; } ProcessDefinitionApi api = new ProcessDefinitionApi(); api.setName(def.getName()); api.setResourceType(def.getResourceType()); api.setStateTransitions(def.getStateTransitions()); if (def instanceof ExtensionBasedProcessDefinition) { api.setExtensionBased(true); api.setPreProcessListeners(((ExtensionBasedProcessDefinition) def).getPreProcessListenersExtensionPoint()); api.setProcessHandlers(((ExtensionBasedProcessDefinition) def).getProcessHandlersExtensionPoint()); api.setPostProcessListeners(((ExtensionBasedProcessDefinition) def).getPostProcessListenersExtensionPoint()); } return api; }
@Override public String getName() { return instanceContext.getProcessDefinition().getName(); }
@Override protected Object listInternal(SchemaFactory schemaFactory, String type, Map<Object, Object> criteria, ListOptions options) { Set<String> found = new HashSet<String>(); List<ResourceDefinition> result = new ArrayList<ResourceDefinition>(); for (ProcessDefinition def : processDefinitions) { String resourceType = def.getResourceType(); if (found.contains(resourceType)) { continue; } result.add(newResource(resourceType, options.getInclude())); found.add(resourceType); } return result; }
protected String getConfiguredChainProcess() { ProcessState state = instanceContext.getState(); ProcessDefinition processDefinition = instanceContext.getProcessDefinition(); if (state.getData().containsKey(processDefinition.getName() + ProcessLogic.CHAIN_PROCESS)) { return state.getData().get(processDefinition.getName() + ProcessLogic.CHAIN_PROCESS).toString(); } return null; }
protected String getLink(ProcessDefinition def) { return ApiContext.getUrlBuilder().resourceReferenceLink(ProcessDefinitionApi.class, def.getName()).toExternalForm(); }
@Override public String toString() { try { return "Process [" + instanceContext.getProcessDefinition().getName() + "] resource [" + instanceContext.getState().getResourceId() + "]"; } catch (NullPointerException e) { return super.toString(); } }