public void ProcessEndState(EndStateImpl endState, ExecutionContextImpl executionContext, DbSession dbSession)
{
delegationService.RunActionsForEvent(EventType.PROCESS_INSTANCE_END, endState.ProcessDefinition.Id, executionContext, dbSession);
executionContext.CreateLog(EventType.PROCESS_INSTANCE_END);
FlowImpl rootFlow = (FlowImpl)executionContext.GetFlow();
rootFlow.ActorId = null;
rootFlow.End = DateTime.Now;
rootFlow.Node = endState; // setting the node is not necessary if this method is called
// from processTransition, but it is necessary if this method is
// called from cancelProcessInstance in the component-impl.
ProcessInstanceImpl processInstance = (ProcessInstanceImpl)executionContext.GetProcessInstance();
FlowImpl superProcessFlow = (FlowImpl)processInstance.SuperProcessFlow;
if (superProcessFlow != null)
{
log.Debug("reactivating the super process...");
// create the execution context for the parent-process
ExecutionContextImpl superExecutionContext = new ExecutionContextImpl(executionContext.PreviousActorId, superProcessFlow, executionContext.DbSession, executionContext.GetOrganisationComponent());
superExecutionContext.SetInvokedProcessContext(executionContext);
// delegate the attributeValues
ProcessStateImpl processState = (ProcessStateImpl)superProcessFlow.Node;
Object[] completionData = delegationHelper.DelegateProcessTermination(processState.ProcessInvokerDelegation, superExecutionContext);
IDictionary attributeValues = (IDictionary)completionData[0];
String transitionName = (String)completionData[1];
TransitionImpl transition = transitionRepository.GetTransition(transitionName, processState, executionContext.DbSession);
// process the super process transition
ProcessTransition(transition, superExecutionContext, dbSession);
}
}
public AttributeInstanceImpl FindAttributeInstanceInScope(String attributeName, FlowImpl scope,DbSession dbSession)
{
AttributeInstanceImpl attributeInstance = null;
while (attributeInstance == null)
{
IList attributes = this.FindAttributeInstanceByName(attributeName, scope.Id, dbSession);
IEnumerator iter = attributes.GetEnumerator();
if (iter.MoveNext())
{
attributeInstance = (AttributeInstanceImpl)iter.Current;
if (iter.MoveNext())
{
throw new NetBpm.Util.DB.DbException("duplicate value");
}
}
else
{
if (!scope.IsRootFlow())
{
scope = (FlowImpl)scope.Parent;
}
else
{
log.Warn("couldn't find attribute-instance '" + attributeName + "' in scope of flow '" + scope + "'");
break;
}
}
}
return attributeInstance;
}
public void ProcessActivityState(ActivityStateImpl activityState, ExecutionContextImpl executionContext, DbSession dbSession)
{
// first set the flow-state to the activity-state
FlowImpl flow = (FlowImpl)executionContext.GetFlow();
log.Debug("processing activity-state '" + activityState + "' for flow '" + executionContext.GetFlow() + "'");
// execute the actions scheduled for this assignment
delegationService.RunActionsForEvent(EventType.BEFORE_ACTIVITYSTATE_ASSIGNMENT, activityState.Id, executionContext, dbSession);
String actorId = null;
String role = activityState.ActorRoleName;
DelegationImpl assignmentDelegation = activityState.AssignmentDelegation;
if (assignmentDelegation != null)
{
// delegate the assignment of the activity-state
actorId = delegationHelper.DelegateAssignment(activityState.AssignmentDelegation, executionContext);
if ((Object)actorId == null)
{
throw new SystemException("invalid process definition : assigner of activity-state '" + activityState.Name + "' returned null instead of a valid actorId");
}
log.Debug("setting actor of flow " + flow + " to " + actorId);
}
else
{
// get the assigned actor from the specified attribute instance
if ((Object)role != null)
{
IActor actor = (IActor)executionContext.GetAttribute(role);
if (actor == null)
{
throw new SystemException("invalid process definition : activity-state must be assigned to role '" + role + "' but that attribute instance is null");
}
actorId = actor.Id;
}
else
{
throw new SystemException("invalid process definition : activity-state '" + activityState.Name + "' does not have an assigner or a role");
}
}
flow.ActorId = actorId;
// If necessary, store the actor in the role
if ((string.IsNullOrEmpty(role) == false) && (assignmentDelegation != null))
{
executionContext.StoreRole(actorId, activityState);
}
// the client of performActivity wants to be Informed of the people in charge of the process
executionContext.AssignedFlows.Add(flow);
// log the assignment
executionContext.CreateLog(actorId, EventType.AFTER_ACTIVITYSTATE_ASSIGNMENT);
executionContext.AddLogDetail(new ObjectReferenceImpl(activityState));
// execute the actions scheduled for this assignment
delegationService.RunActionsForEvent(EventType.AFTER_ACTIVITYSTATE_ASSIGNMENT, activityState.Id, executionContext, dbSession);
}
public void SaveActivity(String authenticatedActorId, Int64 flowId, IDictionary attributeValues, DbSession dbSession, IOrganisationService organisationComponent)
{
// get the flow
FlowImpl flow = (FlowImpl)dbSession.Load(typeof(FlowImpl), flowId);
// create the execution-context
ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, flow, dbSession, organisationComponent);
executionContext.StoreAttributeValues(attributeValues);
}
public ExecutionContextImpl(String actorId, FlowImpl flow, DbSession dbSession, IOrganisationService organisationComponent)
{
this._actorId = actorId;
this._flow = flow;
this._processInstance = (ProcessInstanceImpl)flow.ProcessInstance;
this._processDefinition = (ProcessDefinitionImpl)_processInstance.ProcessDefinition;
this._dbSession = dbSession;
this._organisationComponent = organisationComponent;
this._assignedFlows = new ArrayList();
}
public ActivityFormImpl(FlowImpl flow, IList fields, IDictionary attributeValues)
{
this._flow = flow;
this._processInstance = flow.ProcessInstance;
this._processDefinition = _processInstance.ProcessDefinition;
this._activityState = (IActivityState)flow.Node;
this._fields = fields;
this._attributeValues = attributeValues;
InitTransitionNames(flow.Node);
}
public ExecutionContextImpl(String actorId, FlowImpl flow, DbSession dbSession, IOrganisationService organisationComponent)
{
this._actorId = actorId;
this._flow = flow;
this._processInstance = (ProcessInstanceImpl) flow.ProcessInstance;
this._processDefinition = (ProcessDefinitionImpl) _processInstance.ProcessDefinition;
this._dbSession = dbSession;
this._organisationComponent = organisationComponent;
this._assignedFlows = new ArrayList();
}
public ActivityFormImpl(FlowImpl flow, IList fields, IDictionary attributeValues)
{
this._flow = flow;
this._processInstance = flow.ProcessInstance;
this._processDefinition = _processInstance.ProcessDefinition;
this._activityState = (IActivityState) flow.Node;
this._fields = fields;
this._attributeValues = attributeValues;
InitTransitionNames(flow.Node);
}
private void CancelFlowRecursive(FlowImpl flow, DateTime now)
{
flow.End = now;
flow.ActorId = null;
IEnumerator iter = flow.Children.GetEnumerator();
while (iter.MoveNext())
{
CancelFlowRecursive((FlowImpl)iter.Current, now);
}
}
public ForkedFlow ForkFlow(TransitionImpl transition, FlowImpl parentFlow, IDictionary attributeValues)
{
// create the subflow
FlowImpl subFlow = new FlowImpl(transition.Name, parentFlow, (ProcessBlockImpl)transition.From.ProcessBlock);
parentFlow.Children.Add(subFlow);
// save it
//_dbSession.SaveOrUpdate(subFlow);
// add the transition and the flow to the set of created sub-flows
return new ForkedFlow(transition, subFlow);
}
public FlowImpl(String name, FlowImpl parent, ProcessBlockImpl processBlock)
{
this._name = name;
this._start = DateTime.Now;
this._processInstance = parent.ProcessInstance;
this._subProcessInstances = null;
this._parent = parent;
this._children = null;
this._logs = new ListSet();
this._parentReactivation = true;
CreateAttributeInstances(processBlock.Attributes);
}
public FlowImpl(String name, FlowImpl parent, ProcessBlockImpl processBlock)
{
this._name = name;
this._start = DateTime.Now;
this._processInstance = parent.ProcessInstance;
this._subProcessInstances = null;
this._parent = parent;
this._children = null;
this._logs = new ListSet();
this._parentReactivation = true;
CreateAttributeInstances(processBlock.Attributes);
}
public void ProcessActivityState(ActivityStateImpl activityState, FlowImpl flow, DbSession dbSession)
{
String actorId = null;
String role = activityState.ActorRoleName;
DelegationImpl assignmentDelegation = activityState.AssignmentDelegation;
if (assignmentDelegation != null)
{
var delegateParameters = activityState.AssignmentDelegation.ParseConfiguration();
actorExpressionResolverService.CurrentScope = flow;
actorExpressionResolverService.DbSession = dbSession;
actorId = actorExpressionResolverService.ResolveArgument(delegateParameters["expression"].ToString()).Id;
if ((Object)actorId == null)
{
throw new SystemException("invalid process definition : assigner of activity-state '" + activityState.Name + "' returned null instead of a valid actorId");
}
}
else
{
if ((Object)role != null)
{
IActor actor = null;
var attr = attributeRepository.FindAttributeInstanceInScope(role, flow, dbSession);
if (attr != null)
actor = (IActor)attr.GetValue();
if (actor == null)
{
throw new SystemException("invalid process definition : activity-state must be assigned to role '" + role + "' but that attribute instance is null");
}
actorId = actor.Id;
}
else
{
throw new SystemException("invalid process definition : activity-state '" + activityState.Name + "' does not have an assigner or a role");
}
}
flow.ActorId = actorId;
// If necessary, store the actor in the role
if ((string.IsNullOrEmpty(role) == false) && (assignmentDelegation != null))
{
//executionContext.StoreRole(actorId, activityState);
}
// the client of performActivity wants to be Informed of the people in charge of the process
//executionContext.AssignedFlows.Add(flow);
}
//@todo delete parameter organisationComponent
public void DelegateActivity(String authenticatedActorId, Int64 flowId, String delegateActorId, DbSession dbSession, IOrganisationService organisationComponent)
{
// first check if the actor is allowed to delegate this activity
authorizationHelper.CheckDelegateActivity(authenticatedActorId, flowId, delegateActorId, dbSession);
// reassign the flow
FlowImpl flow = (FlowImpl)dbSession.Load(typeof(FlowImpl), flowId);
flow.ActorId = delegateActorId;
// flush the updates to the db
dbSession.Update(flow);
dbSession.Flush();
}
public IFlow GetFlow(String authenticatedActorId, Int64 flowId, Relations relations, DbSession dbSession)
{
// first check if the actor is allowed to get this flow
authorizationHelper.CheckGetFlow(authenticatedActorId, flowId, dbSession);
FlowImpl flow = null;
flow = (FlowImpl)dbSession.Load(typeof(FlowImpl), flowId);
if (relations != null)
{
relations.Resolve(flow);
}
return(flow);
}
//private const String queryFindActionsByEventType = "select a from a in class NetBpm.Workflow.Definition.Impl.ActionImpl " +
// "where a.EventType = ? " +
// " and a.DefinitionObjectId = ? ";
//public void RunActionsForEvent(EventType eventType, Int64 definitionObjectId, ExecutionContextImpl executionContext)
//{
// log.Debug("processing '" + eventType + "' events for executionContext " + executionContext);
// DbSession dbSession = executionContext.DbSession;
// // find all actions for definitionObject on the given eventType
// Object[] values = new Object[] {eventType, definitionObjectId};
// IType[] types = new IType[] {DbType.INTEGER, DbType.LONG};
// IList actions = dbSession.Find(queryFindActionsByEventType, values, types);
// IEnumerator iter = actions.GetEnumerator();
// log.Debug("list" + actions);
// while (iter.MoveNext())
// {
// ActionImpl action = (ActionImpl) iter.Current;
// log.Debug("action: " + action);
// delegationHelper.DelegateAction(action.ActionDelegation, executionContext);
// }
// log.Debug("ende runActionsForEvent!");
//}
public void ProcessTransition(TransitionImpl transition, ExecutionContextImpl executionContext, DbSession dbSession)
{
log.Debug("processing transition '" + transition + "' for flow '" + executionContext.GetFlow() + "'");
// trigger all the actions scheduled for this transition
delegationService.RunActionsForEvent(EventType.TRANSITION, transition.Id, executionContext, dbSession);
// first set the state of the execution context and the flow
// to the node that is going to be processed
FlowImpl flow = (FlowImpl)executionContext.GetFlow();
NodeImpl destination = (NodeImpl)transition.To;
flow.Node = destination;
executionContext.SetNode(destination);
// note : I want to keep the engine methods grouped in this class, that is why I
// didn't use inheritance but used an instanceof-switch instead.
if (destination is ActivityStateImpl)
{
ProcessActivityState((ActivityStateImpl)destination, executionContext, dbSession);
}
else if (destination is ProcessStateImpl)
{
ProcessProcessState((ProcessStateImpl)destination, executionContext, dbSession);
}
else if (destination is DecisionImpl)
{
ProcessDecision((DecisionImpl)destination, executionContext, dbSession);
}
else if (destination is ForkImpl)
{
ProcessFork((ForkImpl)destination, executionContext, dbSession);
}
else if (destination is JoinImpl)
{
ProcessJoin((JoinImpl)destination, executionContext, dbSession);
}
else if (destination is EndStateImpl)
{
ProcessEndState((EndStateImpl)destination, executionContext, dbSession);
}
else
{
throw new SystemException("");
}
}
public void ForkFlow(TransitionImpl transition, IDictionary attributeValues)
{
// create the subflow
FlowImpl subFlow = new FlowImpl(transition.Name, _flow, (ProcessBlockImpl)_node.ProcessBlock);
_flow.Children.Add(subFlow);
// save it
_dbSession.SaveOrUpdate(subFlow);
// store the attributeValues
this._flow = subFlow;
StoreAttributeValues(attributeValues);
this._flow = (FlowImpl)this._flow.Parent;
// add the transition and the flow to the set of created sub-flows
this._forkedFlows.Add(new ForkedFlow(transition, subFlow));
}
public IActivityForm GetActivityForm(String authenticatedActorId, Int64 flowId, DbSession dbSession, IOrganisationService organisationComponent)
{
IActivityForm activityForm = null;
// First check if the actor is allowed to get this form
authorizationHelper.CheckGetActivityForm(authenticatedActorId, flowId, dbSession);
FlowImpl flow = (FlowImpl)dbSession.Load(typeof(FlowImpl), flowId);
StateImpl state = (StateImpl)flow.Node;
// create an executionContext for easy attributeValue retrieval
ExecutionContextImpl executionContext = new ExecutionContextImpl(null, flow, dbSession, organisationComponent);
// create a convenient map from the attribute-names to the fields
IList fields = fieldRepository.FindFieldsByState(state.Id, dbSession);
IDictionary attributeValues = new Hashtable();
IEnumerator iter = fields.GetEnumerator();
while (iter.MoveNext())
{
FieldImpl field = (FieldImpl)iter.Current;
if (FieldAccessHelper.IsReadable(field.Access) || FieldAccessHelper.IsWritable(field.Access))
{
// activity form contains only readable or writeable fields
String attributeName = field.Attribute.Name;
if (executionContext.GetAttribute(attributeName) != null)
{
// attribute might not exist (this will cause a warning already being logged previusly)
attributeValues[attributeName] = executionContext.GetAttribute(attributeName);
}
}
}
activityForm = new ActivityFormImpl(flow, fields, attributeValues);
return(activityForm);
}
public void CancelFlow(String authenticatedActorId, Int64 flowId, DbSession dbSession, IOrganisationService organisationComponent)
{
// first check if the actor is allowed to cancel this flow
authorizationHelper.CheckCancelFlow(authenticatedActorId, flowId, dbSession);
FlowImpl flow = (FlowImpl)dbSession.Load(typeof(FlowImpl), flowId);
log.Info("actor '" + authenticatedActorId + "' cancels flow '" + flowId + "'...");
// only perform the cancel if this flow is not finished yet
if (!flow.EndHasValue)
{
ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, flow, dbSession, organisationComponent);
executionContext.CreateLog(authenticatedActorId, EventType.FLOW_CANCEL);
if (flow.IsRootFlow())
{
// set the flow in the end-state
log.Debug("setting root flow to the end state...");
EndStateImpl endState = (EndStateImpl)flow.ProcessInstance.ProcessDefinition.EndState;
engine.ProcessEndState(endState, executionContext, dbSession);
}
else
{
// set the flow in the join
ConcurrentBlockImpl concurrentBlock = (ConcurrentBlockImpl)flow.Node.ProcessBlock;
JoinImpl join = (JoinImpl)concurrentBlock.Join;
log.Debug("setting concurrent flow to join '" + join + "'");
engine.ProcessJoin(join, executionContext, dbSession);
}
// flush the updates to the db
dbSession.Update(flow);
dbSession.Flush();
}
}
public void ProcessFork(ForkImpl fork, ExecutionContextImpl executionContext, DbSession dbSession)
{
log.Debug("forking flow " + executionContext.GetFlow());
// First initialize the children of the flow to be forked
FlowImpl flow = (FlowImpl)executionContext.GetFlow();
flow.Children = new ListSet();
// Then initialise the forked flows in the execution context
executionContext.ForkedFlows = new ArrayList();
DelegationImpl delegation = fork.ForkDelegation;
if (delegation != null)
{
delegationHelper.DelegateFork(fork.ForkDelegation, executionContext);
}
else
{
// execute the default fork behaviour
IEnumerator iter = fork.LeavingTransitions.GetEnumerator();
while (iter.MoveNext())
{
TransitionImpl transition = (TransitionImpl)iter.Current;
executionContext.ForkFlow(transition, null);
}
}
// create the fork event & remember the parent flow
FlowImpl parentFlow = (FlowImpl)executionContext.GetFlow();
executionContext.CreateLog(EventType.FORK);
// log the event
executionContext.SetFlow(parentFlow);
IList forkedFlows = executionContext.ForkedFlows;
IEnumerator iter2 = forkedFlows.GetEnumerator();
while (iter2.MoveNext())
{
ForkedFlow forkedFlow = (ForkedFlow)iter2.Current;
log.Debug("adding object reference [" + forkedFlow.Flow + "] to flow [" + parentFlow + "]");
executionContext.AddLogDetail(new ObjectReferenceImpl(forkedFlow.Flow));
}
// loop over all flows that were forked in the ForkHandler implementation
iter2 = forkedFlows.GetEnumerator();
while (iter2.MoveNext())
{
ForkedFlow forkedFlow = (ForkedFlow)iter2.Current;
// trigger actions, scheduled after the creation and setting of the attributeValues
// but before the fork is being processed
delegationService.RunActionsForEvent(EventType.FORK, fork.Id, executionContext, dbSession);
// then process the forked flow transition
executionContext.SetFlow(forkedFlow.Flow);
ProcessTransition(forkedFlow.Transition, executionContext, dbSession);
}
}
public void ProcessJoin(JoinImpl join, ExecutionContextImpl executionContext, DbSession dbSession)
{
// First set the state of the flow to finished
FlowImpl joiningFlow = (FlowImpl)executionContext.GetFlow();
joiningFlow.End = DateTime.Now;
joiningFlow.ActorId = null;
joiningFlow.Node = join; // setting the node is not necessary if this method is called
// from processTransition, but it is necessary if this method is
// called from cancelFlow in the component-impl.
// if parent-reactivation of the flow is true, this means that the parent-flow
// not yet has been reactivated. In that case we have to see if it needs to be
// reactivated. In the other case (parent-reactivation is false) we don't
// need to do anything because this means that the parent-flow was already
// reactivated before.
if (!false.Equals(joiningFlow.ParentReactivation))
{
// check if the parent needs to be reactivated
bool parentReactivation = false;
IList concurrentFlows = executionContext.GetOtherActiveConcurrentFlows();
if (concurrentFlows.Count == 0)
{
// if no concurrent flows are present any more, reactivation is forced
parentReactivation = true;
}
else
{
// if other concurrent flows are present, the decision to reactivate is left
// to the join-delegation (if there is one specified)
DelegationImpl joinDelegation = join.JoinDelegation;
// if no joinDelegation was specified, parentReactivation remains false
// so the behaviour is like an and-join. (=sunchronizing merge)
if (joinDelegation != null)
{
parentReactivation = delegationHelper.DelegateJoin(join.JoinDelegation, executionContext);
}
}
if (parentReactivation)
{
// make sure the other concurrent flows will not reactivate the
// parent again
IEnumerator iter = concurrentFlows.GetEnumerator();
while (iter.MoveNext())
{
//UPGRADE_TODO: Methode "java.util.Iterator.next" wurde in 'IEnumerator.Current' konvertiert und weist ein anderes Verhalten auf. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1073_javautilIteratornext"'
FlowImpl concurrentFlow = (FlowImpl)iter.Current;
concurrentFlow.ParentReactivation = false;
}
// reactivate the parent by first setting the parentflow into the executionContext
FlowImpl parentFlow = (FlowImpl)joiningFlow.Parent;
executionContext.SetFlow(parentFlow);
// and then process the (single, checked at process-archive-parsing-time) leaving transition.
ISet leavingTransitions = join.LeavingTransitions;
iter = leavingTransitions.GetEnumerator();
if (iter.MoveNext())
{
TransitionImpl leavingTransition = (TransitionImpl)iter.Current;
ProcessTransition(leavingTransition, executionContext, dbSession);
}
else
{
// no transition throw exception?
}
}
}
}
public void SetFlow(IFlow flow)
{
this._flow = (FlowImpl) flow;
}
public void ForkFlow(TransitionImpl transition, IDictionary attributeValues)
{
// create the subflow
FlowImpl subFlow = new FlowImpl(transition.Name, _flow, (ProcessBlockImpl) _node.ProcessBlock);
_flow.Children.Add(subFlow);
// save it
_dbSession.Save(subFlow);
// store the attributeValues
this._flow = subFlow;
StoreAttributeValues(attributeValues);
this._flow = (FlowImpl) this._flow.Parent;
// add the transition and the flow to the set of created sub-flows
this._forkedFlows.Add(new ForkedFlow(transition, subFlow));
}
public ForkedFlow(TransitionImpl transition, FlowImpl flow)
{
this._transition = transition;
this._flow = flow;
}
public void SetFlow(IFlow flow)
{
this._flow = (FlowImpl)flow;
}
private void ProcessEndState(EndStateImpl endState, FlowImpl flow,DbSession dbSession)
{
flow.ActorId = null;
flow.End = DateTime.Now;
flow.Node = endState;
}
public IProcessInstance StartProcessInstance(String authenticatedActorId, Int64 processDefinitionId, IDictionary attributeValues, String transitionName, Relations relations, DbSession dbSession, IOrganisationService organisationComponent)
{
ProcessInstanceImpl processInstance = null;
// First check if the actor is allowed to start this instance
authorizationHelper.CheckStartProcessInstance(authenticatedActorId, processDefinitionId, attributeValues, transitionName, dbSession);
// get the process-definition and its start-state
ProcessDefinitionImpl processDefinition = (ProcessDefinitionImpl)definitionRepository.GetProcessDefinition(processDefinitionId, null, dbSession);
StartStateImpl startState = (StartStateImpl)processDefinition.StartState;
log.Info("actor '" + authenticatedActorId + "' starts an instance of process '" + processDefinition.Name + "'...");
processInstance = new ProcessInstanceImpl(authenticatedActorId, processDefinition);
FlowImpl rootFlow = (FlowImpl)processInstance.RootFlow;
ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, rootFlow, dbSession, organisationComponent);
// save the process instance to allow hibernate queries
dbSession.Save(processInstance);
//dbSession.Lock(processInstance,LockMode.Upgrade);
delegationService.RunActionsForEvent(EventType.BEFORE_PERFORM_OF_ACTIVITY, startState.Id, executionContext, dbSession);
// store the attributes
executionContext.CreateLog(authenticatedActorId, EventType.PROCESS_INSTANCE_START);
//LogImpl logImpl = rootFlow.CreateLog(authenticatedActorId, EventType.PROCESS_INSTANCE_START);//new add
executionContext.CheckAccess(attributeValues, startState);
//startState.CheckAccess(attributeValues);
//看來也找不到AttributeInstance
executionContext.StoreAttributeValues(attributeValues);
// if this activity has a role-name, save the actor in the corresponding attribute
executionContext.StoreRole(authenticatedActorId, startState);
// run the actions
delegationService.RunActionsForEvent(EventType.PROCESS_INSTANCE_START, processDefinitionId, executionContext, dbSession);
// from here on, we consider the actor as being the previous actor
executionContext.SetActorAsPrevious();
// process the start-transition
TransitionImpl startTransition = transitionRepository.GetTransition(transitionName, startState, dbSession);
engine.ProcessTransition(startTransition, executionContext, dbSession);
// run the actions
delegationService.RunActionsForEvent(EventType.AFTER_PERFORM_OF_ACTIVITY, startState.Id, executionContext, dbSession);
// flush the updates to the db
dbSession.Update(processInstance);
dbSession.Flush();
//@portme
/* if (relations != null)
* {
* relations.resolve(processInstance);
* }
*/
return(processInstance);
}
public void ProcessTransition(TransitionImpl transition, FlowImpl flow, DbSession dbSession)
{
NodeImpl destination = (NodeImpl)transition.To;
flow.Node = destination;
if (destination is ActivityStateImpl)
{
ProcessActivityState((ActivityStateImpl)destination, flow, dbSession);
}
else if (destination is ProcessStateImpl)
{
//ProcessProcessState((ProcessStateImpl)destination, executionContext, dbSession);
}
else if (destination is DecisionImpl)
{
ProcessDecision((DecisionImpl)destination, flow, dbSession);
}
else if (destination is ForkImpl)
{
ProcessFork((ForkImpl)destination, flow, dbSession);
}
else if (destination is JoinImpl)
{
ProcessJoin((JoinImpl)destination, flow, dbSession);
}
else if (destination is EndStateImpl)
{
ProcessEndState((EndStateImpl)destination, flow,dbSession);
}
else
{
throw new SystemException("");
}
}
public void ProcessJoin(JoinImpl join, FlowImpl joiningFlow, DbSession dbSession)
{
joiningFlow.End = DateTime.Now;
joiningFlow.ActorId = null;
joiningFlow.Node = join;
if (false != joiningFlow.ParentReactivation)
{
bool parentReactivation = false;
IList concurrentFlows = flowRepository.GetOtherActiveConcurrentFlows(joiningFlow.Id, dbSession);
if (concurrentFlows.Count == 0)
{
parentReactivation = true;
}
else
{
//DelegationImpl joinDelegation = join.JoinDelegation;
//if (joinDelegation != null)
//{
// IJoinHandler joiner = (IJoinHandler)joinDelegation.GetDelegate();
// IDictionary attributes = joinDelegation.ParseConfiguration();
// parentReactivation = delegationHelper.DelegateJoin(join.JoinDelegation, executionContext);
//}
}
if (parentReactivation)
{
IEnumerator iter = concurrentFlows.GetEnumerator();
while (iter.MoveNext())
{
FlowImpl concurrentFlow = (FlowImpl)iter.Current;
concurrentFlow.ParentReactivation = false;
}
// reactivate the parent by first setting the parentflow into the executionContext
FlowImpl parentFlow = (FlowImpl)joiningFlow.Parent;
//executionContext.SetFlow(parentFlow);
// and then process the (single, checked at process-archive-parsing-time) leaving transition.
ISet leavingTransitions = join.LeavingTransitions;
iter = leavingTransitions.GetEnumerator();
if (iter.MoveNext())
{
TransitionImpl leavingTransition = (TransitionImpl)iter.Current;
ProcessTransition(leavingTransition, parentFlow, dbSession);
}
else
{
// no transition throw exception?
}
}
}
}
public void ProcessProcessState(ProcessStateImpl processState, ExecutionContextImpl executionContext, DbSession dbSession)
{
// TODO : try to group similarities between this method and ExecutionComponentImpl.startProcessInstance and
// group them in a common method
// provide a convenient local var for the database session
//DbSession dbSession = executionContext.DbSession;
// get the sub-process-definition and its start-state
ProcessDefinitionImpl subProcessDefinition = (ProcessDefinitionImpl)processState.SubProcess;
StartStateImpl startState = (StartStateImpl)subProcessDefinition.StartState;
log.Info("processState '" + processState.Name + "' starts an instance of process '" + subProcessDefinition.Name + "'...");
// get the actor that is supposed to start this process instance
IActor subProcessStarter = actorExpressionResolver.ResolveArgument(processState.ActorExpression, executionContext);
String subProcessStarterId = subProcessStarter.Id;
// create the process-instance
ProcessInstanceImpl subProcessInstance = new ProcessInstanceImpl(subProcessStarterId, subProcessDefinition);
FlowImpl rootFlow = (FlowImpl)subProcessInstance.RootFlow;
// attach the subProcesInstance to the parentFlow
FlowImpl superProcessFlow = (FlowImpl)executionContext.GetFlow();
superProcessFlow.SetSubProcessInstance(subProcessInstance);
subProcessInstance.SuperProcessFlow = superProcessFlow;
// create the execution context for the sub-process
ExecutionContextImpl subExecutionContext = new ExecutionContextImpl(subProcessStarterId, rootFlow, dbSession, executionContext.GetOrganisationComponent());
// save the process instance to allow hibernate queries
dbSession.Save(subProcessInstance);
// add the log
executionContext.CreateLog(EventType.SUB_PROCESS_INSTANCE_START);
executionContext.AddLogDetail(new ObjectReferenceImpl(subProcessInstance));
// delegate the attributeValues
Object[] processInvocationData = delegationHelper.DelegateProcessInvocation(processState.ProcessInvokerDelegation, subExecutionContext);
String transitionName = (String)processInvocationData[0];
IDictionary attributeValues = (IDictionary)processInvocationData[1];
// store the attributes
subExecutionContext.CreateLog(subProcessStarterId, EventType.PROCESS_INSTANCE_START);
subExecutionContext.StoreAttributeValues(attributeValues);
subExecutionContext.StoreRole(subProcessStarterId, startState);
// log event & trigger actions
delegationService.RunActionsForEvent(EventType.SUB_PROCESS_INSTANCE_START, processState.Id, subExecutionContext, dbSession);
delegationService.RunActionsForEvent(EventType.PROCESS_INSTANCE_START, subProcessDefinition.Id, subExecutionContext, dbSession);
// from here on, we consider the actor as being the previous actor
subExecutionContext.SetActorAsPrevious();
// process the start-transition
TransitionImpl startTransition = transitionRepository.GetTransition(transitionName, startState, dbSession);
ProcessTransition(startTransition, subExecutionContext, dbSession);
// add the assigned flows of the subContext to the parentContext
executionContext.AssignedFlows.AddRange(subExecutionContext.AssignedFlows);
// flush the updates to the db
dbSession.Update(subProcessInstance);
dbSession.Flush();
}
private void Resolve(FlowImpl flow, Relations relations, DbSession dbSession)
{
// resolve the flow
if (relations != null)
{
log.Debug("resolving relations : '" + relations + "' on flow '" + flow + "'");
relations.Resolve(flow);
}
// resolve the flow-details
IEnumerator iter = flow.Logs.GetEnumerator();
while (iter.MoveNext())
{
LogImpl logImpl = (LogImpl) iter.Current;
IEnumerator detailsIter = logImpl.Details.GetEnumerator();
while (detailsIter.MoveNext())
{
LogDetailImpl LogDetailImpl = (LogDetailImpl) detailsIter.Current;
LogDetailImpl.Resolve(dbSession);
}
}
// resolve the attribute values
iter = flow.AttributeInstances.GetEnumerator();
while (iter.MoveNext())
{
AttributeInstanceImpl attributeInstance = (AttributeInstanceImpl) iter.Current;
log.Debug("resolving attribute instance : " + attributeInstance.GetValue());
}
// resolve the child-flows
iter = flow.Children.GetEnumerator();
while (iter.MoveNext())
{
FlowImpl subFlow = (FlowImpl) iter.Current;
Resolve(subFlow, relations, dbSession);
}
// resolve the sub-process-flows
IProcessInstance subProcessInstance = flow.GetSubProcessInstance();
if (subProcessInstance != null)
{
Resolve((FlowImpl) subProcessInstance.RootFlow, relations, dbSession);
}
}
public IList PerformActivity(String authenticatedActorId, Int64 flowId, IDictionary attributeValues, String transitionName, Relations relations, DbSession dbSession, IOrganisationService organisationComponent)
{
IList assignedFlows = null;
// get the flow
FlowImpl flow = (FlowImpl)dbSession.Load(typeof(FlowImpl), flowId);
dbSession.Lock(flow.ProcessInstance, LockMode.Upgrade);
ActivityStateImpl activityState = (ActivityStateImpl)flow.Node;
// TODO : check which part can move to the DefaultAuthorizationHandler
if ((Object)flow.ActorId == null)
{
throw new SystemException("the flow on which you try to perform an activity is not assigned to an actor");
}
else
{
if ((Object)authenticatedActorId == null)
{
throw new AuthorizationException("you can't perform an activity because you are not authenticated");
}
// else if ( ! authenticatedActorId.equals( flow.getActorId() ) ) {
// throw new AuthorizationException( "activity '" + activityState.getName() + "' in flow " + flow.getId() + " is not assigned to the authenticated actor (" + authenticatedActorId + ") but to " + flow.getActorId() );
// }
}
// first check if the actor is allowed to perform this activity
authorizationHelper.CheckPerformActivity(authenticatedActorId, flowId, attributeValues, transitionName, dbSession);
log.Info("actor '" + authenticatedActorId + "' performs activity '" + activityState.Name + "'...");
// create the execution-context
ExecutionContextImpl executionContext = new ExecutionContextImpl(authenticatedActorId, flow, dbSession, organisationComponent);
// if this activity has a role-name, save the actor in the corresponding attribute
// attributeValues = state.addRoleAttributeValue( attributeValues, authenticatedActorId, organisationComponent );
// log event & trigger actions
delegationService.RunActionsForEvent(EventType.BEFORE_PERFORM_OF_ACTIVITY, activityState.Id, executionContext, dbSession);
// store the supplied attribute values
executionContext.CreateLog(authenticatedActorId, EventType.PERFORM_OF_ACTIVITY);
executionContext.AddLogDetail(new ObjectReferenceImpl(activityState));
executionContext.CheckAccess(attributeValues, activityState);
executionContext.StoreAttributeValues(attributeValues);
// log event & trigger actions
delegationService.RunActionsForEvent(EventType.PERFORM_OF_ACTIVITY, activityState.Id, executionContext, dbSession);
// from here on, we consider the actor as being the previous actor
//因為繼續往下跑，ActorId就有可能轉換成下一關卡的處理人員
//所以previousActorId就是現在的登入人員
executionContext.SetActorAsPrevious();
// select and process the transition
TransitionImpl startTransition = transitionRepository.GetTransition(transitionName, activityState, dbSession);
engine.ProcessTransition(startTransition, executionContext, dbSession);
// log event & trigger actions
delegationService.RunActionsForEvent(EventType.AFTER_PERFORM_OF_ACTIVITY, activityState.Id, executionContext, dbSession);
assignedFlows = executionContext.AssignedFlows;
// flush the updates to the db
dbSession.Update(flow.ProcessInstance);
dbSession.Flush();
if (relations != null)
{
relations.Resolve(assignedFlows);
}
dbSession.Update(flow.ProcessInstance);
return(assignedFlows);
}
private void CancelFlowRecursive(FlowImpl flow, DateTime now)
{
flow.End = now;
flow.ActorId = null;
IEnumerator iter = flow.Children.GetEnumerator();
while (iter.MoveNext())
{
CancelFlowRecursive((FlowImpl) iter.Current, now);
}
}
public AttributeInstanceImpl(AttributeImpl attribute, FlowImpl scope)
{
this._valueText = attribute.InitialValue;
this._attribute = attribute;
this._scope = scope;
}
public void ProcessDecision(DecisionImpl decision, FlowImpl flow, DbSession dbSession)
{
//var delegateParameters = delegationService.ParseConfiguration(decision.DecisionDelegation);
//IDecisionHandler decisionHandler = (IDecisionHandler)delegationService.GetDelegate(decision.DecisionDelegation);
var attributes = decision.DecisionDelegation.ParseConfiguration();
string transiationName = new EvaluationDecision().Decide(attributes["attribute"].ToString());
TransitionImpl selectedTransition = this.GetTransition(transiationName, decision, dbSession);
//// delegate the decision
//TransitionImpl selectedTransition = delegationHelper.DelegateDecision(decision.DecisionDelegation, executionContext);
//// process the selected transition
ProcessTransition(selectedTransition, flow, dbSession);
}
public ForkedFlow(TransitionImpl transition, FlowImpl flow)
{
this._transition = transition;
this._flow = flow;
}
public AttributeInstanceImpl(AttributeImpl attribute, FlowImpl scope)
{
this._valueText = attribute.InitialValue;
this._attribute = attribute;
this._scope = scope;
}
public void ProcessFork(ForkImpl fork, FlowImpl flow, DbSession dbSession)
{
// First initialize the children of the flow to be forked
flow.Children = new ListSet();
DelegationImpl delegation = fork.ForkDelegation;
IList<ForkedFlow> forkedFlows = new List<ForkedFlow>();
if (delegation != null)
{
//delegationHelper.DelegateFork(fork.ForkDelegation, executionContext);
}
else
{
// execute the default fork behaviour
IEnumerator iter = fork.LeavingTransitions.GetEnumerator();
while (iter.MoveNext())
{
TransitionImpl transition = (TransitionImpl)iter.Current;
forkedFlows.Add(this.ForkFlow(transition, flow,null));
}
}
IEnumerator iter2 = forkedFlows.GetEnumerator();
while (iter2.MoveNext())
{
ForkedFlow forkedFlow = (ForkedFlow)iter2.Current;
}
// loop over all flows that were forked in the ForkHandler implementation
iter2 = forkedFlows.GetEnumerator();
while (iter2.MoveNext())
{
ForkedFlow forkedFlow = (ForkedFlow)iter2.Current;
ProcessTransition(forkedFlow.Transition, forkedFlow.Flow, dbSession);
}
}