public WorkflowValidationException(long _workflowRunId, Workflow wf, WfActivity activity, IEnumerable <string> messages) : base("") { ValidationMessages = messages.ToList(); Workflow = wf; Activity = activity; }
/// <summary> /// Create a transition between the given activity instances for the provided exit point /// </summary> public static void AddTransition(Workflow wf, WfActivity from, WfActivity to, ExitPoint exitPoint) { // remove any existing var toRemove = from.ForwardTransitions.FirstOrDefault(t => t.FromExitPoint.Id == exitPoint.Id); if (toRemove != null) { from.ForwardTransitions.Remove(toRemove); var asTerm = toRemove.As <Termination>(); if (asTerm != null) { wf.Terminations.Remove(asTerm); } var asTrans = toRemove.As <Transition>(); if (asTrans != null) { wf.Transitions.Remove(asTrans); } toRemove.Delete(); } var trans = new Transition() { Name = exitPoint.Name, FromActivity = @from, ToActivity = to, FromExitPoint = exitPoint }; from.ForwardTransitions.Add(trans.As <TransitionStart>()); wf.Transitions.Add(trans); }
/// <summary> /// The default exit point for an activity /// </summary> public static ExitPoint GetDefaultExitPoint(this WfActivity activity) { ExitPoint result = null; var ioe = activity.As <EntityWithArgsAndExits>(); if (ioe != null) { result = ioe.ExitPoints.FirstOrDefault(ep => ep.IsDefaultExitPoint ?? false); } if (result == null) { var aType = activity.IsOfType.FirstOrDefault(t => t.Is <ActivityType>()); if (aType != null) { result = aType.Cast <ActivityType>().ExitPoints.FirstOrDefault(ep => ep.IsDefaultExitPoint ?? false); } } if (result == null) { throw new ApplicationException(string.Format("Unable to find the default exit point for {0}({1})", activity.Name ?? "[Unnamed]", activity.Id)); } return(result); }
/// <summary> /// Generate a parameter name that is unique to the workflow. Use the argument name if possible, otherwise append a number. /// </summary> private static string GeneratetUniqueNameForExpressionParameter(Workflow wf, WfActivity activity, ActivityArgument argument) { if (argument.Name == null) { throw new ArgumentException("Argument missing name"); } var composedName = activity.Is <Workflow>() ? argument.Name : string.Format("{0}_{1}", (activity.Name ?? string.Empty), argument.Name); if (!wf.ExpressionParameters.Any(expPar => expPar.Name == composedName)) { return(composedName); } var count = 0; string proposedName; do { count++; proposedName = String.Format("{0}{1}", composedName, count); }while (wf.ExpressionParameters.Any(expPar => expPar.Name == proposedName)); return(proposedName); }
public static Workflow AddUpdateExpressionToArgument(this Workflow wf, WfActivity activity, ActivityArgument arg, string expressionString, bool isTemplate) { if (isTemplate) { expressionString = ConvertTemplateToExpressionString(expressionString); } if (expressionString == null) { throw new ArgumentNullException("expressionString"); } var exp = activity.ExpressionMap.FirstOrDefault(x => x.ArgumentToPopulate?.Id == arg.Id); if (exp == null) { var newExp = new WfExpression() { ExpressionString = expressionString, ArgumentToPopulate = arg, ExpressionInActivity = activity, IsTemplateString = false }; activity.ExpressionMap.Add(newExp.As <WfExpression>()); } else { var wrExp = exp.AsWritable <WfExpression>(); wrExp.ExpressionString = expressionString; wrExp.Save(); } return(wf); }
/// <summary> /// Create a transition between the given activity instances for the named exit point /// </summary> public static void AddTermination(Workflow wf, WfActivity from, string fromExitPointName = null, string wfExitPointName = null) { ExitPoint fromExitPoint = fromExitPointName == null? @from.GetDefaultExitPoint() : GetNamedExitPoint(@from, fromExitPointName); ExitPoint wfExitPoint = null; if (wfExitPointName == null) { wfExitPoint = wf.GetDefaultExitPoint(); if (wfExitPoint == null) { wf.AddDefaultExitPoint(); wfExitPoint = wf.GetDefaultExitPoint(); } } else { wfExitPoint = GetNamedExitPoint(wf.As <WfActivity>(), wfExitPointName); } if (fromExitPoint == null) { throw new ArgumentException("From activity missing named exit point."); } if (wfExitPoint == null) { throw new ArgumentException("Workflow missing named exit point."); } AddTermination(wf, @from, fromExitPoint, wfExitPoint); }
public static Workflow AddUpdateEntityExpression(this Workflow wf, WfActivity activity, ActivityArgument arg, EntityRef entityRef) { var exp = activity.ExpressionMap.FirstOrDefault(x => x.ArgumentToPopulate?.Id == arg.Id); var r = Entity.Get(entityRef).As <Resource>(); var expName = r.Id.ToString(); if (!string.IsNullOrEmpty(r.Name)) { expName = r.Name; } if (exp == null) { exp = new WfExpression { ArgumentToPopulate = arg, ExpressionInActivity = activity, ExpressionString = string.Format("[{0}]", expName) }; exp.WfExpressionKnownEntities.Add(new NamedReference { Name = expName, ReferencedEntity = r }); activity.ExpressionMap.Add(exp); } else { var wrExp = exp.AsWritable <WfExpression>(); wrExp.ExpressionString = string.Format("[{0}]", expName); wrExp.WfExpressionKnownEntities.Clear(); wrExp.WfExpressionKnownEntities.Add(new NamedReference { Name = expName, ReferencedEntity = r }); wrExp.Save(); } return(wf); }
void MarkRunSuspended(IRunState runState, WfActivity currentActivity) { Debug.Assert(currentActivity != null); using (new SecurityBypassContext()) { runState.PendingActivity = currentActivity; runState.RunStatus = WorkflowRunState_Enumeration.WorkflowRunSuspended; } }
public static Workflow AddEntityExpressionToInputArgument(this Workflow wf, WfActivity activity, string argumentName, EntityRef entityRef) { var destination = activity.GetInputArgument(argumentName); if (destination == null) { throw new ArgumentException(); } return(AddEntityExpression(wf, activity, destination, entityRef)); }
public static Workflow AddUpdateExpressionToArgument(this Workflow wf, WfActivity activity, string argumentName, string expressionString, bool isTemplate = false) { var destination = activity.GetInputArgument(argumentName); if (destination == null) { throw new ArgumentException(); } return(AddUpdateExpressionToArgument(wf, activity, destination, expressionString, isTemplate)); }
public static Workflow AddExpressionToActivityArgument(this Workflow wf, WfActivity activity, string argumentName, string expressionString, bool isTemplate = false) { var destination = activity.GetInputArgument(argumentName); if (destination == null) { throw new ArgumentException(String.Format("No matching argument name for activity. Activity='{0}' Argument='{1}'", activity.Name ?? "<unnamed>", argumentName ?? "<unnamed>")); } return(AddExpressionToArgument(wf, activity, destination, expressionString, isTemplate)); }
private async Task GetRoleUsers(List <WfActivitySelectModel> model, WfActivity act) { var users = await UserRoleSvc.GetUserListByRoleIds(act.roleIds); if (users != null && users.Count > 0) { model.Add(new WfActivitySelectModel() { Activity = act, UserList = users }); } }
/// <summary> /// Run the next step in the workflow by scheduling the activity. This call in turn will schedule other activities. /// </summary> private void ScheduleNextStep(IRunState context, WfActivity childActivity) { var nextWindowsActivity = context.Metadata.CachedInstances[childActivity.Id]; // ensure all child's input expressions are updated var inputExpressions = nextWindowsActivity.GetInputArgumentsExpressions(context, childActivity); var resolvedExpressions = ResolveExpressions(context, inputExpressions); var inputs = CreateInputDictionaryForNextStep(context, childActivity, resolvedExpressions); context.WorkflowInvoker.ScheduleActivity(context, nextWindowsActivity, inputs, NextStepCompletionCallback, NextStepPausedCallback); }
///// <summary> ///// Update all the output arguments ///// </summary> //void UpdateWfOutputs(IRunState context, Dictionary<WfExpression, object> resolvedExpressions) //{ // UpdateWorkflowArguments(context, resolvedExpressions); //} /// <summary> /// Create an input dictionary using the applicable values in the ArgumentValueStore /// </summary> ActivityInputs CreateInputDictionaryForNextStep(IRunState context, WfActivity nextActivity, Dictionary <WfExpression, object> evaluatedExpressions) { var result = new ActivityInputs(); // add expressions foreach (var kvp in evaluatedExpressions) { var arg = kvp.Key.ArgumentToPopulate; result.Add(arg, kvp.Value); } return(result); }
public Transition GetTransitionForExitPoint(WfActivity activity, EntityRef exitPointRef) { Transition result; if (_transitionCache.TryGetValue(new Tuple <long, long>(activity.Id, exitPointRef.Id), out result)) { return(result); } else { return(null); } }
public static Workflow AddEntityExpression(this Workflow wf, WfActivity activity, ActivityArgument arg, EntityRef entityRef) { var r = Entity.Get(entityRef).As <Resource>(); var exp = new WfExpression { ArgumentToPopulate = arg, ExpressionInActivity = activity, ExpressionString = string.Format("[{0}]", r.Id.ToString()) }; exp.WfExpressionKnownEntities.Add(new NamedReference { Name = r.Id.ToString(), ReferencedEntity = r }); activity.ExpressionMap.Add(exp); return(wf); }
private WfActivityInstance CreateActivityInstance(WfProcess process, WfProcessInstance processInstance, WfActivity activity, WfActivityState state, long assignToUserId, string assignToUserName) { return(CreateActivityInstance(process, processInstance, activity, state, $"[{assignToUserId}]", assignToUserName)); }
/// <summary> /// Create a windows activity instance for the given model activity /// </summary> /// <param name="nextActivity"></param> /// <param name="workflowRunId">The ID of the workflow run to record information against. 0 indicates there is no run.</param> /// <returns></returns> public static ActivityImplementationBase CreateWindowsActivity(this WfActivity nextActivity) { if ((nextActivity as IEntityInternal).IsTemporaryId) { throw new ArgumentException(string.Format("The activity '{0}':{1} has not been saved. All activities must be saved before being used.", nextActivity.Name, nextActivity.Id)); } var result = ActivityHelper.GetBackingClassInstanceForWfActivity(nextActivity); result.Initialize(nextActivity); return(result); }
public WfExpression GetPopulatedBy(WfActivity activity, ActivityArgument argument) { WfExpression result; var key = new Tuple <long, long>(activity.Id, argument.Id); if (_populatedByCache.TryGetValue(key, out result)) { return(result); } else { return(null); } }
/// <summary> /// Create a transition between the given activity instances for the provided exit point /// </summary> public static void AddTransition(Workflow wf, WfActivity from, WfActivity to, string exitPointName) { var exitPoint = GetNamedExitPoint(@from, exitPointName); if (exitPoint == null) { throw new ArgumentException(String.Format("Attempted to create a transition from a non-existent exit point. '{0}'", exitPointName)); } var trans = new Transition() { Name = exitPointName, FromActivity = @from, ToActivity = to, FromExitPoint = exitPoint }; wf.Transitions.Add(trans); }
public WfArgumentInstance GetArgInstance(ActivityArgument targetArg, WfActivity activity) { WfArgumentInstance targetArgInst = null; var key = new Tuple <long, long>(activity.Id, targetArg.Id); if (_argInstCache.TryGetValue(key, out targetArgInst)) { return(targetArgInst); } targetArgInst = targetArg.GetArgInstance(activity); _argInstCache.Add(key, targetArgInst); return(targetArgInst); }
/// <summary> /// Add an expression parameter, return the parameters substitution name /// </summary> /// <param name="wf"></param> /// <param name="from"></param> /// <param name="argument"></param> /// <returns></returns> public static string CreateArgumentInstance(Workflow wf, WfActivity from, ActivityArgument argument) { var uniqueName = GeneratetUniqueNameForExpressionParameter(wf, from, argument); var sourceInstance = new WfArgumentInstance { Name = uniqueName, ArgumentInstanceActivity = @from, ArgumentInstanceArgument = argument }; if (@from.IsReadOnly) { @from = @from.AsWritable <WfActivity>(); } @from.ArgumentInstanceFromActivity.Add(sourceInstance); wf.ExpressionParameters.Add(sourceInstance); return(uniqueName); }
public static IEnumerable <ActivityArgument> GetInputArguments(this WfActivity activity) { // for a workflow the input arguments are on the instance, for an activity they are on the type var typeArguments = activity.IsOfType.Select(t => t.As <ActivityType>()).First(t => t != null).InputArguments; var entityWithArgsAndExits = activity.As <EntityWithArgsAndExits>(); if (entityWithArgsAndExits != null) { return(entityWithArgsAndExits.InputArguments.Union(typeArguments)); } else { return(typeArguments); // note that his code assumes the first type is an activity type } }
public static void AddFirstActivityWithMapping(Workflow workflow, WfActivity firstActivity, IDictionary <string, string> newArgumentMappings) { workflow.FirstActivity = firstActivity; workflow.ContainedActivities.Add(firstActivity); if (newArgumentMappings != null) { foreach (var entry in newArgumentMappings) { var source = workflow.As <WfActivity>().GetInputArgument(entry.Key); var subName = CreateArgumentInstance(workflow, firstActivity, source); AddExpressionToActivityArgument(workflow, firstActivity, entry.Value, String.Format("[{0}]", subName), false); } } }
public static IEnumerable <ActivityArgument> GetOutputArguments(this WfActivity activity) { IEnumerable <ActivityArgument> result; // get the type defined arguments var type = activity.IsOfType.Select(t => t.As <ActivityType>()).First(t => t != null); result = type.OutputArguments; // get the instance defined arguments var entityWithArgsAndExits = activity.As <EntityWithArgsAndExits>(); if (entityWithArgsAndExits != null) { result = result.Union(entityWithArgsAndExits.OutputArguments); } return(result); }
/// <summary> /// Create a transition between the given activity instances for the provided exit point and field mappings /// </summary> public static void AddTransitionWithMapping(Workflow wf, WfActivity from, WfActivity to, ExitPoint exitPoint, IDictionary <string, string> argumentMappings) { var trans = new Transition() { FromActivity = @from, ToActivity = to, FromExitPoint = exitPoint }; wf.Transitions.Add(trans); if (argumentMappings != null) { foreach (var entry in argumentMappings) { //AddExpressionToActivityArgument(wf, to, entry.Value, entry.Key); AddExpressionToMapArguments(wf, @from, to, entry.Key, entry.Value); } } }
public static void SetActivityArgumentToResource(Workflow wf, WfActivity activity, string argumentName, Resource resource) { var arg = activity.GetInputArgument(argumentName); if (arg == null) { throw new ArgumentException(String.Format("No matching argument name for activity. Activity='{0}' Argument='{1}'", activity.Name ?? "<unnamed>", argumentName ?? "<unnamed>")); } var exp = new WfExpression { ArgumentToPopulate = arg, ExpressionInActivity = activity, ExpressionString = null }; exp.WfExpressionKnownEntities.Add(new NamedReference() { Name = "E1", ReferencedEntity = resource }); activity.ExpressionMap.Add(exp); // BUG: needed to work around an issue saving relationships }
public static ExitPoint GetNamedExitPoint(this WfActivity activity, string name) { ExitPoint result = null; var actAsDyn = activity.As <EntityWithArgsAndExits>(); if (actAsDyn != null) { result = actAsDyn.ExitPoints.FirstOrDefault(ep => ep.Name == name); } if (result != null) { return(result); } else { return(activity.IsOfType.Select(t => t.As <EntityWithArgsAndExits>()).First(t => t != null).ExitPoints.FirstOrDefault(ep => ep.Name == name)); } }
///// <summary> ///// The default time before an activity timeouts ///// </summary> //public static TimeSpan DefaultActivityTimeout { get { return new TimeSpan(0, 1, 0); } } //TODO: move into system configuration ///// <summary> ///// The default number of times a workflow will execute directly contained activities. ///// </summary> //public static int DefaultWorkflowMaxActivityExecutes { get { return 1000; } } //TODO: move into system configuration /// <summary> /// The default exit point for an activity /// </summary> public static IEnumerable <ExitPoint> GetExitPoints(this WfActivity activity) { IEnumerable <ExitPoint> result = new List <ExitPoint>(); var ioe = activity.As <EntityWithArgsAndExits>(); if (ioe != null) { result = ioe.ExitPoints.ToList(); } var aType = activity.IsOfType.FirstOrDefault(t => t.Is <ActivityType>()); if (aType != null) { result = result.Union(aType.Cast <ActivityType>().ExitPoints.ToList()); } return(result); }
/// <summary> /// 创建节点实例 /// </summary> /// <param name="process"></param> /// <param name="processInstance"></param> /// <param name="activity"></param> /// <returns></returns> private WfActivityInstance CreateActivityInstance(WfProcess process, WfProcessInstance processInstance, WfActivity activity, WfActivityState state, string assignToUserId, string assignToUserName) { return(new WfActivityInstance() { ActivityGuid = activity.key, ActivityName = activity.text, ActivityState = state, ActivityType = activity.activityType, CommonStatus = CommonStatus.Enabled, ProcessId = process.Id, ProcessInstanceId = processInstance.Id, ProcessName = process.Name, AssignToUserIds = assignToUserId, AssignToUserNames = assignToUserName }); }