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);
}
