public override ValidationErrorCollection Validate(ValidationManager manager, object obj) { ValidationErrorCollection validationErrors = new ValidationErrorCollection(base.Validate(manager, obj)); SetStateActivity setState = obj as SetStateActivity; if (setState == null) { throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(StateActivity).FullName }), "obj"); } if (SetStateContainment.Validate(setState, validationErrors)) { if (string.IsNullOrEmpty(setState.TargetStateName)) { validationErrors.Add(new ValidationError(SR.GetString("Error_PropertyNotSet", new object[] { "TargetStateName" }), 0x116, false, "TargetStateName")); return(validationErrors); } StateActivity state = StateMachineHelpers.FindStateByName(StateMachineHelpers.GetRootState(StateMachineHelpers.FindEnclosingState(setState)), setState.TargetStateName); if (state == null) { validationErrors.Add(new ValidationError(SR.GetError_SetStateMustPointToAState(), 0x5f3, false, "TargetStateName")); return(validationErrors); } if (!StateMachineHelpers.IsLeafState(state)) { validationErrors.Add(new ValidationError(SR.GetError_SetStateMustPointToALeafNodeState(), 0x5f4, false, "TargetStateName")); } } return(validationErrors); }
private static void ValidateInitialState(StateActivity state, ValidationErrorCollection validationErrors) { string initialStateName = StateMachineHelpers.GetInitialStateName(state); if (string.IsNullOrEmpty(initialStateName)) { if (state.Activities.Count > 0) { validationErrors.Add(new ValidationError(SR.GetString("Error_PropertyNotSet", new object[] { "InitialStateName" }), 0x116, false, "InitialStateName")); } } else { StateActivity activity = StateMachineHelpers.FindStateByName(state, initialStateName); if (activity == null) { validationErrors.Add(new ValidationError(SR.GetError_InitialStateMustPointToAState(), 0x5f5, false, "InitialStateName")); } else { if (!StateMachineHelpers.IsLeafState(activity)) { validationErrors.Add(new ValidationError(SR.GetError_InitialStateMustPointToALeafNodeState(), 0x5f7, false, "InitialStateName")); } string completedStateName = StateMachineHelpers.GetCompletedStateName(state); if (initialStateName == completedStateName) { validationErrors.Add(new ValidationError(SR.GetError_InitialStateMustBeDifferentThanCompletedState(), 0x62c, false, "InitialStateName")); } } } }
private static void ValidateInitialState(StateActivity state, ValidationErrorCollection validationErrors) { string initialStateName = StateMachineHelpers.GetInitialStateName(state); if (String.IsNullOrEmpty(initialStateName)) { if (state.Activities.Count > 0) { // we only require an initial state if the state machine is // not empty validationErrors.Add(new ValidationError( SR.GetString(SR.Error_PropertyNotSet, StateMachineWorkflowActivity.InitialStateNamePropertyName), ErrorNumbers.Error_PropertyNotSet, false, StateMachineWorkflowActivity.InitialStateNamePropertyName)); } } else { StateActivity initialState = StateMachineHelpers.FindStateByName( state, initialStateName); if (initialState == null) { validationErrors.Add(new ValidationError( SR.GetError_InitialStateMustPointToAState(), ErrorNumbers.Error_InitialStateMustPointToAState, false, StateMachineWorkflowActivity.InitialStateNamePropertyName)); } else { if (!StateMachineHelpers.IsLeafState(initialState)) { validationErrors.Add(new ValidationError( SR.GetError_InitialStateMustPointToALeafNodeState(), ErrorNumbers.Error_InitialStateMustPointToALeafNodeState, false, StateMachineWorkflowActivity.InitialStateNamePropertyName)); } // InitialState cannot be the completed state string completedStateName = StateMachineHelpers.GetCompletedStateName(state); if (initialStateName == completedStateName) { validationErrors.Add(new ValidationError( SR.GetError_InitialStateMustBeDifferentThanCompletedState(), ErrorNumbers.Error_InitialStateMustBeDifferentThanCompletedState, false, StateMachineWorkflowActivity.InitialStateNamePropertyName)); } } } }
private ReadOnlyCollection <string> GetStateHistory() { StateMachineWorkflowActivity stateMachineWorkflow; if (this._sqlTrackingService == null) { this._sqlTrackingService = this._runtime.GetService <SqlTrackingService>(); if (this._sqlTrackingService == null) { throw new InvalidOperationException(SR.GetSqlTrackingServiceRequired()); } } if (this._sqlTrackingQuery == null) { this._sqlTrackingQuery = new SqlTrackingQuery(this._sqlTrackingService.ConnectionString); } Stack <string> stack = new Stack <string>(); try { stateMachineWorkflow = this.StateMachineWorkflow; } catch (InvalidOperationException) { return(new ReadOnlyCollection <string>(stack.ToArray())); } if ((this._sqlTrackingWorkflowInstance != null) || this._sqlTrackingQuery.TryGetWorkflow(this._instanceId, out this._sqlTrackingWorkflowInstance)) { this._sqlTrackingWorkflowInstance.Refresh(); foreach (UserTrackingRecord record in this._sqlTrackingWorkflowInstance.UserEvents) { if (record.UserDataKey == "StateActivity.StateChange") { string userData = record.UserData as string; if (userData == null) { throw new InvalidOperationException(SR.GetInvalidUserDataInStateChangeTrackingRecord()); } StateActivity state = StateMachineHelpers.FindStateByName(stateMachineWorkflow, record.QualifiedName); if (state == null) { throw new InvalidOperationException(SR.GetInvalidUserDataInStateChangeTrackingRecord()); } if (StateMachineHelpers.IsLeafState(state)) { stack.Push(userData); } } } } return(new ReadOnlyCollection <string>(stack.ToArray())); }
private StateActivity GetCurrentState() { foreach (WorkflowQueueInfo info in this.WorkflowInstance.GetWorkflowQueueData()) { if (info.QueueName.Equals("SetStateQueue")) { if (info.SubscribedActivityNames.Count == 0) { return(null); } return(StateMachineHelpers.FindStateByName(this.StateMachineWorkflow, info.SubscribedActivityNames[0])); } } return(null); }
public override ValidationErrorCollection Validate(ValidationManager manager, object obj) { ValidationErrorCollection validationErrors = new ValidationErrorCollection(base.Validate(manager, obj)); SetStateActivity setState = obj as SetStateActivity; if (setState == null) { throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(StateActivity).FullName), "obj"); } if (!SetStateContainment.Validate(setState, validationErrors)) { return(validationErrors); // could not find a valid parent } if (String.IsNullOrEmpty(setState.TargetStateName)) { validationErrors.Add(new ValidationError( SR.GetString(SR.Error_PropertyNotSet, SetStateActivity.TargetStateNamePropertyName), ErrorNumbers.Error_PropertyNotSet, false, SetStateActivity.TargetStateNamePropertyName)); } else { StateActivity enclosingState = StateMachineHelpers.FindEnclosingState(setState); Debug.Assert(enclosingState != null); // this should be caught by the SetStateContainment.Validate call above StateActivity rootState = StateMachineHelpers.GetRootState(enclosingState); StateActivity targetActivity = StateMachineHelpers.FindStateByName( rootState, setState.TargetStateName); StateActivity targetState = targetActivity as StateActivity; if (targetState == null) { validationErrors.Add(new ValidationError(SR.GetError_SetStateMustPointToAState(), ErrorNumbers.Error_SetStateMustPointToAState, false, SetStateActivity.TargetStateNamePropertyName)); } else { if (!StateMachineHelpers.IsLeafState(targetState)) { validationErrors.Add(new ValidationError(SR.GetError_SetStateMustPointToALeafNodeState(), ErrorNumbers.Error_SetStateMustPointToALeafNodeState, false, SetStateActivity.TargetStateNamePropertyName)); } } } return(validationErrors); }
private StateActivity GetCurrentState() { ReadOnlyCollection <WorkflowQueueInfo> workflowQueuedInfos = this.WorkflowInstance.GetWorkflowQueueData(); foreach (WorkflowQueueInfo queueInfo in workflowQueuedInfos) { if (queueInfo.QueueName.Equals(StateMachineWorkflowActivity.SetStateQueueName)) { if (queueInfo.SubscribedActivityNames.Count == 0) { return(null); } Debug.Assert(queueInfo.SubscribedActivityNames.Count == 1); StateMachineWorkflowActivity stateMachineWorkflow = this.StateMachineWorkflow; StateActivity currentState = StateMachineHelpers.FindStateByName(stateMachineWorkflow, queueInfo.SubscribedActivityNames[0]); return(currentState); } } return(null); }
private static void ValidateCompletedState(StateActivity state, ValidationErrorCollection validationErrors) { string completedStateName = StateMachineHelpers.GetCompletedStateName(state); if (!String.IsNullOrEmpty(completedStateName)) { StateActivity completedState = StateMachineHelpers.FindStateByName( state, completedStateName); if (completedState == null) { validationErrors.Add(new ValidationError( SR.GetError_CompletedStateMustPointToAState(), ErrorNumbers.Error_CompletedStateMustPointToAState, false, StateMachineWorkflowActivity.CompletedStateNamePropertyName)); } else { if (StateMachineHelpers.IsLeafState(completedState)) { if (completedState.EnabledActivities.Count > 0) { validationErrors.Add(new ValidationError( SR.GetString(SR.Error_CompletedStateCannotContainActivities), ErrorNumbers.Error_CompletedStateCannotContainActivities, false, StateMachineWorkflowActivity.CompletedStateNamePropertyName)); } } else { validationErrors.Add(new ValidationError( SR.GetError_CompletedStateMustPointToALeafNodeState(), ErrorNumbers.Error_CompletedStateMustPointToALeafNodeState, false, StateMachineWorkflowActivity.CompletedStateNamePropertyName)); } } } }
private static void ValidateCompletedState(StateActivity state, ValidationErrorCollection validationErrors) { string completedStateName = StateMachineHelpers.GetCompletedStateName(state); if (!string.IsNullOrEmpty(completedStateName)) { StateActivity activity = StateMachineHelpers.FindStateByName(state, completedStateName); if (activity == null) { validationErrors.Add(new ValidationError(SR.GetError_CompletedStateMustPointToAState(), 0x5f6, false, "CompletedStateName")); } else if (StateMachineHelpers.IsLeafState(activity)) { if (activity.EnabledActivities.Count > 0) { validationErrors.Add(new ValidationError(SR.GetString("Error_CompletedStateCannotContainActivities"), 0x5ff, false, "CompletedStateName")); } } else { validationErrors.Add(new ValidationError(SR.GetError_CompletedStateMustPointToALeafNodeState(), 0x5f8, false, "CompletedStateName")); } } }
private ReadOnlyCollection <string> GetStateHistory() { if (_sqlTrackingService == null) { _sqlTrackingService = _runtime.GetService <SqlTrackingService>(); if (_sqlTrackingService == null) { throw new InvalidOperationException(SR.GetSqlTrackingServiceRequired()); } } if (_sqlTrackingQuery == null) { _sqlTrackingQuery = new SqlTrackingQuery(_sqlTrackingService.ConnectionString); } StateMachineWorkflowActivity stateMachineWorkflow; Stack <string> stateHistory = new Stack <string>(); try { stateMachineWorkflow = this.StateMachineWorkflow; } catch (InvalidOperationException) { return(new ReadOnlyCollection <string>(stateHistory.ToArray())); } if (_sqlTrackingWorkflowInstance == null) { bool result = _sqlTrackingQuery.TryGetWorkflow(_instanceId, out _sqlTrackingWorkflowInstance); if (!result) { // Workflow has not started yet, so we just return an // empty collection return(new ReadOnlyCollection <string>(stateHistory.ToArray())); } } _sqlTrackingWorkflowInstance.Refresh(); IList <UserTrackingRecord> events = _sqlTrackingWorkflowInstance.UserEvents; foreach (UserTrackingRecord record in events) { if (record.UserDataKey != StateActivity.StateChangeTrackingDataKey) { continue; } string stateQualifiedName = record.UserData as string; if (stateQualifiedName == null) { throw new InvalidOperationException(SR.GetInvalidUserDataInStateChangeTrackingRecord()); } StateActivity state = StateMachineHelpers.FindStateByName(stateMachineWorkflow, record.QualifiedName); if (state == null) { throw new InvalidOperationException(SR.GetInvalidUserDataInStateChangeTrackingRecord()); } if (StateMachineHelpers.IsLeafState(state)) { stateHistory.Push(stateQualifiedName); } } ReadOnlyCollection <string> history = new ReadOnlyCollection <string>(stateHistory.ToArray()); return(history); }