Java tutorial
/* * Copyright 2014 Effektif GmbH. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.effektif.workflow.impl.workflowinstance; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import com.effektif.workflow.impl.job.Job; import org.joda.time.LocalDateTime; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.effektif.workflow.api.WorkflowEngine; import com.effektif.workflow.api.model.RelativeTime; import com.effektif.workflow.api.model.TypedValue; import com.effektif.workflow.api.model.WorkflowInstanceId; import com.effektif.workflow.api.workflowinstance.ActivityInstance; import com.effektif.workflow.impl.conditions.ConditionImpl; import com.effektif.workflow.impl.data.DataTypeImpl; import com.effektif.workflow.impl.data.TypedValueImpl; import com.effektif.workflow.impl.data.types.ListTypeImpl; import com.effektif.workflow.impl.util.Lists; import com.effektif.workflow.impl.util.Time; import com.effektif.workflow.impl.workflow.ActivityImpl; import com.effektif.workflow.impl.workflow.BindingImpl; import com.effektif.workflow.impl.workflow.InputParameterImpl; import com.effektif.workflow.impl.workflow.TransitionImpl; /** * @author Tom Baeyens */ public class ActivityInstanceImpl extends ScopeInstanceImpl { public static final String STATE_STARTING = "starting"; public static final String STATE_STARTING_MULTI_CONTAINER = "startingMultiParent"; public static final String STATE_STARTING_MULTI_INSTANCE = "startingMultiInstance"; public static final String STATE_PROPAGATE_TO_PARENT = "propagateToParent"; public static final String STATE_JOINING = "joining"; /** @see WorkflowInstanceImpl#isWorkAsync(ActivityInstanceImpl) */ public static final Set<String> START_WORKSTATES = new HashSet<>( Lists.of(STATE_STARTING, STATE_STARTING_MULTI_CONTAINER, STATE_STARTING_MULTI_INSTANCE)); public static final Logger log = LoggerFactory.getLogger(WorkflowEngine.class); public String id; public ActivityImpl activity; public String workState; public WorkflowInstanceId calledWorkflowInstanceId; public List<String> transitionsTaken; public ActivityInstanceImpl() { } public ActivityInstanceImpl(ScopeInstanceImpl parent, ActivityImpl activity, String id) { super(parent, activity); this.id = id; this.activity = activity; } public ActivityInstance toActivityInstance() { return toActivityInstance(false); } public ActivityInstance toActivityInstance(boolean includeWorkState) { ActivityInstance activityInstance = new ActivityInstance(); activityInstance.setId(id); activityInstance.setActivityId(activity.id); activityInstance.setCalledWorkflowInstanceId(calledWorkflowInstanceId); toScopeInstance(activityInstance, includeWorkState); if (includeWorkState) { activityInstance.setPropertyOpt("workState", workState); } return activityInstance; } @Override protected String getActivityInstanceId() { return id; } public void execute() { if (workflow.workflowEngine.notifyActivityInstanceStarted(this)) { activity.activityType.execute(this); } } /** Default BPMN logic when an activity ends */ @Override public void onwards() { if (log.isDebugEnabled()) { log.debug("Onwards " + this); } // First we end the activity instance. // Subsequent invocations to end will be ignored. end(); boolean isTransitionTaken = false; // Take each outgoing transition 'in parallel' // Note that process concurrency is not the same as java multithreaded computation if (activity.hasOutgoingTransitions()) { for (TransitionImpl transition : activity.outgoingTransitions) { // Only take a transition if there is no condition or if the condition resolves to true. ConditionImpl condition = transition.condition; if (condition != null ? condition.eval(this) : true) { isTransitionTaken = true; takeTransition(transition); } } } // if there were no outgoing transitions or none of them could be taken, if (!isTransitionTaken) { // propagate the execution flow upwards to the parent propagateToParent(); } } public void endAndPropagateToParent() { end(); propagateToParent(); } public void end() { if (end == null) { if (hasOpenActivityInstances()) { throw new RuntimeException( "Can't end this activity instance. There are open activity instances: " + this); } setEnd(Time.now()); workflow.workflowEngine.notifyActivityInstanceEnded(this); destroyScopeInstance(); setWorkState(null); } } public void propagateToParent() { setWorkState(STATE_PROPAGATE_TO_PARENT); workflowInstance.addWork(this); } public void setWorkState(String workState) { // log.debug("Setting workstate of "+this+" from "+this.workState+" to "+workState); this.workState = workState; if (updates != null) { getUpdates().isWorkStateChanged = true; if (parent != null) { parent.propagateActivityInstanceChange(); } } } public void setJoining() { setWorkState(STATE_JOINING); } public boolean isJoining() { return STATE_JOINING.equals(workState); } public void removeJoining(ActivityInstanceImpl activityInstance) { activityInstance.setWorkState(null); } /** Starts the to (destination) activity in the current (parent) scope. * This methods will also end the current activity instance. * This method can be called multiple times in one start() */ public void takeTransition(TransitionImpl transition) { if (transition.id != null || activity.activityType.saveTransitionsTaken()) { addTransitionTaken(transition.id); } ActivityInstanceImpl toActivityInstance = null; ActivityImpl to = transition.to; if (to != null) { end(); if (log.isDebugEnabled()) { log.debug("Taking transition to " + to); } toActivityInstance = parent.createActivityInstance(to); } else { log.debug("Dangling transition. Propagating to parent."); end(); propagateToParent(); } workflow.workflowEngine.notifyTransitionTaken(this, transition, toActivityInstance); } protected void addTransitionTaken(String transitionId) { if (transitionsTaken == null) { transitionsTaken = new ArrayList<>(); } transitionsTaken.add(transitionId); if (updates != null) { getUpdates().isTransitionsTakenChanged = true; if (parent != null) { parent.propagateActivityInstanceChange(); } } } @Override public ActivityInstanceImpl findActivityInstance(String activityInstanceId) { if (activityInstanceId == null) { return null; } if (activityInstanceId.equals(this.id)) { return this; } return super.findActivityInstance(activityInstanceId); } public ActivityImpl getActivity() { return activity; } public void setActivity(ActivityImpl activityDefinition) { this.activity = activityDefinition; } public String toString() { String activityTypeName = activity.activityType.getActivityApiClass().getSimpleName(); String activityId = activity.id; String activityName = activity.activity.getName(); return "(" + activityTypeName + "|" + (activityName != null ? activityName + "|" : "") + (activityId != null ? activityId + "|" : "") + id + ")"; } public void setEnd(LocalDateTime end) { this.end = end; if (start != null && end != null) { this.duration = end.toDate().getTime() - start.toDate().getTime(); } if (updates != null) { updates.isEndChanged = true; if (parent != null) { parent.propagateActivityInstanceChange(); } } } @Override public ActivityInstanceImpl findActivityInstanceByActivityId(String activityDefinitionId) { if (activityDefinitionId == null) { return null; } if (activityDefinitionId.equals(activity.id)) { return this; } return super.findActivityInstanceByActivityId(activityDefinitionId); } @Override public boolean isWorkflowInstance() { return false; } public void setCalledWorkflowInstanceId(WorkflowInstanceId calledWorkflowInstanceId) { this.calledWorkflowInstanceId = calledWorkflowInstanceId; } public WorkflowInstanceId getCalledWorkflowInstanceId() { return calledWorkflowInstanceId; } @Override public ActivityInstanceUpdates getUpdates() { return (ActivityInstanceUpdates) updates; } public void trackUpdates(boolean isNew) { if (updates == null) { updates = new ActivityInstanceUpdates(isNew); } else { updates.reset(isNew); } super.trackUpdates(isNew); } public boolean hasActivityInstance(String activityInstanceId) { if (id != null && id.equals(activityInstanceId)) { return true; } return super.hasActivityInstance(activityInstanceId); } public String getId() { return id; } // TODO add the expected type for conversion? public <T> T getInputValue(String key) { if (activity == null || activity.activityType == null || activity.activityType.getInputs() == null) { return null; } InputParameterImpl parameter = (InputParameterImpl) activity.activityType.getInputs().get(key); TypedValueImpl typedValue = getInputTypedValue(parameter); return (T) (typedValue != null ? typedValue.value : null); } protected TypedValueImpl getInputTypedValue(InputParameterImpl parameter) { if (parameter != null) { if (parameter.binding != null) { return getTypedValue(parameter.binding); } if (parameter.bindings != null) { DataTypeImpl<?> listType = null; List<Object> values = new ArrayList<>(); for (BindingImpl<?> binding : parameter.bindings) { TypedValueImpl typedValue = getTypedValue(binding); if (typedValue != null) { if (typedValue.getValue() instanceof Collection) { if (listType == null && typedValue.getType() != null) { listType = typedValue.getType(); } Collection value = (Collection) typedValue.value; if (value != null) { values.addAll(value); } } else { if (listType == null && typedValue.getType() != null) { listType = new ListTypeImpl(typedValue.getType()); } values.add(typedValue.value); } } } return new TypedValueImpl(listType, values); } } return null; } public Map<String, TypedValueImpl> getInputValueImpls() { Map<String, TypedValueImpl> inputValues = new HashMap<>(); if (activity != null && activity.activityType != null && activity.activityType.getInputs() != null) { Map<String, InputParameterImpl> inputs = activity.activityType.getInputs(); for (String inputKey : inputs.keySet()) { InputParameterImpl inputParameter = inputs.get(inputKey); TypedValueImpl inputValue = getInputTypedValue(inputParameter); if (inputValue != null) { inputValues.put(inputKey, inputValue); } } } return inputValues; } public Map<String, TypedValue> getInputValues() { Map<String, TypedValue> inputValues = new HashMap<>(); Map<String, TypedValueImpl> inputValueImpls = getInputValueImpls(); if (inputValueImpls != null) { for (String key : inputValueImpls.keySet()) { TypedValueImpl typedValueImpl = inputValueImpls.get(key); inputValues.put(key, typedValueImpl.toTypedValue()); } } return inputValues; } }