public static Guid AddWorkflowDefinition(this Web web, WorkflowDefinition definition, bool publish = true)
{
var servicesManager = new WorkflowServicesManager(web.Context, web);
var deploymentService = servicesManager.GetWorkflowDeploymentService();
WorkflowDefinition def = new WorkflowDefinition(web.Context);
def.AssociationUrl = definition.AssociationUrl;
def.Description = definition.Description;
def.DisplayName = definition.DisplayName;
def.DraftVersion = definition.DraftVersion;
def.FormField = definition.FormField;
def.Id = definition.Id != Guid.Empty ? definition.Id : Guid.NewGuid();
foreach (var prop in definition.Properties)
{
def.SetProperty(prop.Key,prop.Value);
}
def.RequiresAssociationForm = definition.RequiresAssociationForm;
def.RequiresInitiationForm = definition.RequiresInitiationForm;
def.RestrictToScope = definition.RestrictToScope;
def.RestrictToType = definition.RestrictToType;
def.Xaml = definition.Xaml;
var result = deploymentService.SaveDefinition(def);
web.Context.ExecuteQueryRetry();
if (publish)
{
deploymentService.PublishDefinition(result.Value);
web.Context.ExecuteQueryRetry();
}
return result.Value;
}
public OpenWindow(WorkflowDefinition[] wds)
{
InitializeComponent();
dataGrid.ItemsSource = null;
dataGrid.ItemsSource = wds;
dataGrid.DoubleClick += new EventHandler<EventArgs>(dataGrid_DoubleClick);
}
void dataGrid_DoubleClick(object sender, EventArgs e)
{
if (dataGrid.SelectedItem != null)
{
selectWorkflowDefinition = (WorkflowDefinition)dataGrid.SelectedItem;
this.DialogResult = true;
}
}
/// <summary>
/// Adds a workflow subscription to a list
/// </summary>
/// <param name="list"></param>
/// <param name="workflowDefinition">The workflow definition. <seealso>
/// <cref>WorkflowExtensions.GetWorkflowDefinition</cref>
/// </seealso>
/// </param>
/// <param name="subscriptionName">The name of the workflow subscription to create</param>
/// <param name="startManually">if True the workflow can be started manually</param>
/// <param name="startOnCreate">if True the workflow will be started on item creation</param>
/// <param name="startOnChange">if True the workflow will be started on item change</param>
/// <param name="historyListName">the name of the history list. If not available it will be created</param>
/// <param name="taskListName">the name of the task list. If not available it will be created</param>
/// <param name="associationValues"></param>
/// <returns>Guid of the workflow subscription</returns>
public static Guid AddWorkflowSubscription(this List list, WorkflowDefinition workflowDefinition, string subscriptionName, bool startManually, bool startOnCreate, bool startOnChange, string historyListName, string taskListName, Dictionary<string, string> associationValues = null)
{
// parameter validation
subscriptionName.ValidateNotNullOrEmpty("subscriptionName");
historyListName.ValidateNotNullOrEmpty("historyListName");
taskListName.ValidateNotNullOrEmpty("taskListName");
var historyList = list.ParentWeb.GetListByTitle(historyListName);
if (historyList == null)
{
historyList = list.ParentWeb.CreateList(ListTemplateType.WorkflowHistory, historyListName, false);
}
var taskList = list.ParentWeb.GetListByTitle(taskListName);
if (taskList == null)
{
taskList = list.ParentWeb.CreateList(ListTemplateType.Tasks, taskListName, false);
}
var sub = new WorkflowSubscription(list.Context);
sub.DefinitionId = workflowDefinition.Id;
sub.Enabled = true;
sub.Name = subscriptionName;
var eventTypes = new List<string>();
if (startManually) eventTypes.Add("WorkflowStart");
if (startOnCreate) eventTypes.Add("ItemAdded");
if (startOnChange) eventTypes.Add("ItemUpdated");
sub.EventTypes = eventTypes;
sub.SetProperty("HistoryListId", historyList.Id.ToString());
sub.SetProperty("TaskListId", taskList.Id.ToString());
if (associationValues != null)
{
foreach (var key in associationValues.Keys)
{
sub.SetProperty(key, associationValues[key]);
}
}
var servicesManager = new WorkflowServicesManager(list.Context, list.ParentWeb);
var subscriptionService = servicesManager.GetWorkflowSubscriptionService();
var subscriptionResult = subscriptionService.PublishSubscriptionForList(sub, list.Id);
list.Context.ExecuteQueryRetry();
return subscriptionResult.Value;
}
private bool HasCurrentActivityBeforeActivity(WorkflowActivityInput input, WorkflowDefinition definition,
IWorkflowActivityBase activity, List<WorkflowTransition> checkedTransitions)
{
var inboundTransitions = definition.GetInboundTransitions(activity);
if (inboundTransitions.Any(t => input.Instance.CurrentActivityIds.Contains(t.From)))
return true;
checkedTransitions.AddRange(inboundTransitions);
foreach (var transition in inboundTransitions)
{
if (HasCurrentActivityBeforeActivity(input, definition, definition.GetActivityById(transition.From), checkedTransitions))
return true;
}
return false;
}
public Guid SaveDefinitionAndPublish(string name, string translatedWorkflows)
{
var definition = new WorkflowDefinition(ClientContext)
{
DisplayName = name,
Xaml = translatedWorkflows
};
var deploymentService = workflowServicesManager.GetWorkflowDeploymentService();
var result = deploymentService.SaveDefinition(definition);
ClientContext.ExecuteQuery();
deploymentService.PublishDefinition(result.Value);
ClientContext.ExecuteQuery();
return result.Value;
}
private bool HasCurrentActivityBeforeActivity(WorkflowActivityInput input, WorkflowDefinition definition,
IWorkflowActivityBase activity, List <WorkflowTransition> checkedTransitions)
{
var inboundTransitions = definition.GetInboundTransitions(activity);
if (inboundTransitions.Any(t => input.Instance.CurrentActivityIds.Contains(t.From)))
{
return(true);
}
checkedTransitions.AddRange(inboundTransitions);
foreach (var transition in inboundTransitions)
{
if (HasCurrentActivityBeforeActivity(input, definition, definition.GetActivityById(transition.From), checkedTransitions))
{
return(true);
}
}
return(false);
}
public ExecutionPointer BuildChildPointer(WorkflowDefinition def, ExecutionPointer pointer, int childDefinitionId, object branch)
{
var childPointerId = GenerateId();
var childScope = new Stack <string>(pointer.Scope);
childScope.Push(pointer.Id);
pointer.Children.Add(childPointerId);
return(new ExecutionPointer()
{
Id = childPointerId,
PredecessorId = pointer.Id,
StepId = childDefinitionId,
Active = true,
ContextItem = branch,
Status = PointerStatus.Pending,
StepName = def.Steps.First(x => x.Id == childDefinitionId).Name,
EventUserId = pointer.EventUserId,
Scope = childScope
});
}
public void should_sleep_pointer()
{
//arrange
var persistenceData = new object();
var definition = new WorkflowDefinition();
var pointer = new ExecutionPointer()
{
Id = "1", Active = true, StepId = 0, Status = PointerStatus.Running
};
var step = A.Fake <WorkflowStep>();
var workflowResult = new WorkflowExecutorResult();
var instance = GivenWorkflow(pointer);
var result = ExecutionResult.Sleep(TimeSpan.FromMinutes(5), persistenceData);
//act
Subject.ProcessExecutionResult(instance, definition, pointer, step, result, workflowResult);
//assert
pointer.Status.Should().Be(PointerStatus.Sleeping);
pointer.SleepUntil.Should().NotBeNull();
}
/// <summary>
/// Initializes a new <see cref="AuthenticationDefinitionValidator"/>
/// </summary>
/// <param name="workflow">The <see cref="WorkflowDefinition"/> the <see cref="AuthenticationDefinition"/>s to validate belong to</param>
public AuthenticationDefinitionValidator(WorkflowDefinition workflow)
{
this.Workflow = workflow;
this.RuleFor(a => a.Name)
.NotEmpty()
.WithErrorCode($"{nameof(AuthenticationDefinition)}.{nameof(AuthenticationDefinition.Name)}");
this.RuleFor(a => a.Properties)
.NotNull()
.WithErrorCode($"{nameof(AuthenticationDefinition)}.{nameof(AuthenticationDefinition.Properties)}");
this.RuleFor(a => a.Properties)
.Must(BeOfExpectedType)
.WithErrorCode($"{nameof(AuthenticationDefinition)}.{nameof(AuthenticationDefinition.Properties)}")
.When(a => a.Properties != null);
this.RuleFor(a => a.Properties)
.SetInheritanceValidator(v =>
{
v.Add(new BasicAuthenticationPropertiesValidator());
v.Add(new BearerAuthenticationPropertiesValidator());
v.Add(new OAuth2AuthenticationPropertiesValidator());
});
}
/// <summary>
/// Create a workflow
/// </summary>
/// <param name="workflowOid">Workflow Oid</param>
/// <param name="parentWorkflowOid">Parent workflow oid</param>
/// <param name="workflowCode">Workflow Code</param>
/// <param name="domain">Workflow domain</param>
/// <param name="properties">Workflow list of properties</param>
public void CreateWorkflow(Guid workflowOid, Guid parentWorkflowOid, string workflowCode, string domain, IEnumerable <PropertyInfo> properties)
{
using (var uofw = new FlowTasksUnitOfWork())
{
var wfc = uofw.WorkflowCodes.First(c => c.Code == workflowCode);
var status = WorkflowStatusType.InProgress.ToString();
var wfs = uofw.WorkflowStatuses.First(s => s.Status == status);
WorkflowDefinition parentWfd = null;
if (parentWorkflowOid != Guid.Empty)
{
parentWfd = uofw.WorkflowDefinitions.First(w => w.WorkflowOid == parentWorkflowOid);
}
if (string.IsNullOrWhiteSpace(domain))
{
domain = Defaults.CommonWorkGroup;
}
var wfd = new WorkflowDefinition
{
WorkflowOid = workflowOid,
Domain = domain,
WorkflowCode = wfc,
StartedOn = DateTime.Now,
WorkflowStatus = wfs,
WorkflowParentDefinition = parentWfd
};
uofw.WorkflowDefinitions.Insert(wfd);
// Add "default" properties based on the specified domain
AddProperties(uofw, domain, wfc, wfd, properties);
uofw.Commit();
}
_tracer.Trace(workflowOid, ActionTrace.WorkflowCreated, workflowCode,
Properties.Resources.WF_STARTED, TraceEventType.Activity);
}
public async Task <WorkflowDefinition> Update(WorkflowDefinition WorkflowDefinition)
{
if (!await WorkflowDefinitionValidator.Update(WorkflowDefinition))
{
return(WorkflowDefinition);
}
try
{
var oldData = await UOW.WorkflowDefinitionRepository.Get(WorkflowDefinition.Id);
InitParameter(WorkflowDefinition);
WorkflowDefinition.ModifierId = CurrentContext.UserId;
await UOW.Begin();
await UOW.WorkflowDefinitionRepository.Update(WorkflowDefinition);
await UOW.Commit();
var newData = await UOW.WorkflowDefinitionRepository.Get(WorkflowDefinition.Id);
await Logging.CreateAuditLog(newData, oldData, nameof(WorkflowDefinitionService));
return(newData);
}
catch (Exception ex)
{
await UOW.Rollback();
await Logging.CreateSystemLog(ex.InnerException, nameof(WorkflowDefinitionService));
if (ex.InnerException == null)
{
throw new MessageException(ex);
}
else
{
throw new MessageException(ex.InnerException);
}
}
}
// TODO: Use this
private static WorkflowDefinition Given_a_workflow_with_invalid_fork_and_join()
{
var workflow = new WorkflowDefinition();
workflow.Activities = new List <IWorkflowActivityBase>
{
new ForkActivity {
Id = "1"
},
new MockActivity {
Id = "2"
},
new MockActivity {
Id = "3"
},
new JoinActivity {
Id = "4"
},
};
workflow.StartActivity = workflow.Activities.First();
workflow.Transitions = new List <WorkflowTransition>
{
new WorkflowTransition {
From = "1", To = "2"
},
new WorkflowTransition {
From = "1", To = "3"
},
new WorkflowTransition {
From = "2", To = "3"
},
new WorkflowTransition {
From = "2", To = "4"
},
new WorkflowTransition {
From = "3", To = "4"
},
};
return(workflow);
}
public async Task<IWorkflowBlueprint> CreateWorkflowBlueprintAsync(WorkflowDefinition workflowDefinition, CancellationToken cancellationToken)
{
var manyActivityBlueprints = await Task.WhenAll(workflowDefinition.Activities.Select(async x => await CreateBlueprintsAsync(x, cancellationToken)));
var activityBlueprints = manyActivityBlueprints.SelectMany(x => x).Distinct().ToDictionary(x => x.Id);
var compositeActivityBlueprints = activityBlueprints.Values.Where(x => x is ICompositeActivityBlueprint).Cast<ICompositeActivityBlueprint>().ToList();
var connections = compositeActivityBlueprints.SelectMany(x => x.Connections).Distinct().ToList();
var propertyProviders = compositeActivityBlueprints.SelectMany(x => x.ActivityPropertyProviders).ToList();
connections.AddRange(workflowDefinition.Connections.Select(x => ResolveConnection(x, activityBlueprints)).Where(x => x != null).Select(x => x!));
propertyProviders.AddRange(await CreatePropertyProviders(workflowDefinition, cancellationToken));
var workflowBlueprint = new WorkflowBlueprint(
workflowDefinition.DefinitionId,
workflowDefinition.Version,
workflowDefinition.VersionId,
workflowDefinition.TenantId,
workflowDefinition.IsSingleton,
workflowDefinition.Name,
workflowDefinition.DisplayName,
workflowDefinition.Description,
workflowDefinition.IsLatest,
workflowDefinition.IsPublished,
workflowDefinition.Tag,
workflowDefinition.Channel,
workflowDefinition.Variables,
workflowDefinition.CustomAttributes,
workflowDefinition.ContextOptions,
workflowDefinition.PersistenceBehavior,
workflowDefinition.DeleteCompletedInstances,
activityBlueprints.Values,
connections,
new ActivityPropertyProviders(propertyProviders.ToDictionary(x => x.Key, x => x.Value))
);
// For those composite activities that do not have a parent, assign the workflow to be their parent.
foreach (var compositeActivityBlueprint in compositeActivityBlueprints.Where(x => x.Parent == null))
((CompositeActivityBlueprint) compositeActivityBlueprint).Parent = workflowBlueprint;
return workflowBlueprint;
}
public String GetWorkflowProcessXmlProcessIdOrVersion(String processID, int version)
{
// return TestProcessContentXml;
if (version <= 0)
{
WorkflowDefinition wd = RuntimeContextFactory.getRuntimeContext().PersistenceService.FindTheLatestVersionOfWorkflowDefinitionByProcessId(processID);
if (wd != null)
{
return(wd.ProcessContent);
}
}
else
{
WorkflowDefinition wd = RuntimeContextFactory.getRuntimeContext().PersistenceService.FindWorkflowDefinitionByProcessIdAndVersionNumber(processID, version);
if (wd != null)
{
return(wd.ProcessContent);
}
}
return("");
}
public void Validate_EventReference_ResultEventNotSet_ShouldFail()
{
//arrange
var workflow = WorkflowDefinition.Create("fake", "fake", "fake")
.StartsWith("fake", flow => flow.Callback())
.End()
.Build();
var eventRef = new EventReference()
{
TriggerEvent = "fake"
};
//act
var result = new EventReferenceValidator(workflow).Validate(eventRef);
//assert
result.Should()
.NotBeNull();
result.Errors.Should()
.NotBeNullOrEmpty()
.And.Contain(e => e.PropertyName == nameof(EventReference.ResultEvent));
}
public void Validate_FunctionReference_FunctionNotFound_ShouldFail()
{
//arrange
var workflow = WorkflowDefinition.Create("fake", "fake", "fake")
.StartsWith("fake", flow => flow.Callback())
.End()
.Build();
var functionRef = new FunctionReference()
{
RefName = "fake"
};
//act
var result = new FunctionReferenceValidator(workflow).Validate(functionRef);
//assert
result.Should()
.NotBeNull();
result.Errors.Should()
.NotBeNullOrEmpty()
.And.Contain(e => e.PropertyName == nameof(FunctionReference.RefName));
}
public void ProcessCancellations(WorkflowInstance workflow, WorkflowDefinition workflowDef, WorkflowExecutorResult executionResult)
{
foreach (var step in workflowDef.Steps.Where(x => x.CancelCondition != null))
{
var func = step.CancelCondition.Compile();
var cancel = false;
try
{
cancel = (bool)(func.DynamicInvoke(workflow.Data));
}
catch (Exception ex)
{
_logger.LogError(default(EventId), ex, ex.Message);
}
if (cancel)
{
var toCancel = workflow.ExecutionPointers.Where(x => x.StepId == step.Id && x.Status != PointerStatus.Complete && x.Status != PointerStatus.Cancelled).ToList();
foreach (var ptr in toCancel)
{
if (step.ProceedOnCancel)
{
_executionResultProcessor.ProcessExecutionResult(workflow, workflowDef, ptr, step, ExecutionResult.Next(), executionResult);
}
ptr.EndTime = _dateTimeProvider.UtcNow;
ptr.Active = false;
ptr.Status = PointerStatus.Cancelled;
foreach (var descendent in workflow.ExecutionPointers.FindByScope(ptr.Id).Where(x => x.Status != PointerStatus.Complete && x.Status != PointerStatus.Cancelled))
{
descendent.EndTime = _dateTimeProvider.UtcNow;
descendent.Active = false;
descendent.Status = PointerStatus.Cancelled;
}
}
}
}
}
/// <summary>
/// Initializes a new <see cref="AuthenticationDefinitionValidator"/>
/// </summary>
/// <param name="workflow">The <see cref="WorkflowDefinition"/> the <see cref="AuthenticationDefinition"/>s to validate belong to</param>
public AuthenticationDefinitionValidator(WorkflowDefinition workflow)
{
this.Workflow = workflow;
this.RuleFor(a => a.Name)
.NotEmpty()
.WithErrorCode($"{nameof(AuthenticationDefinition)}.{nameof(AuthenticationDefinition.Name)}");
this.RuleFor(a => a.Properties)
.NotNull()
.WithErrorCode($"{nameof(AuthenticationDefinition)}.{nameof(AuthenticationDefinition.Properties)}");
this.RuleFor(a => a.Properties)
.Must(BeOfExpectedType)
.WithErrorCode($"{nameof(AuthenticationDefinition)}.{nameof(AuthenticationDefinition.Properties)}")
.WithMessage((auth, properties) => $"The specified properties object cannot be discriminated against the expected type for scheme '{auth.Scheme}'")
.When(a => a.Properties != null);
this.RuleFor(a => a.Properties)
.SetInheritanceValidator(v =>
{
v.Add(new BasicAuthenticationPropertiesValidator());
v.Add(new BearerAuthenticationPropertiesValidator());
v.Add(new OAuth2AuthenticationPropertiesValidator());
});
}
public WorkflowMiddlewareRunnerTests(ITestOutputHelper output)
{
Out = output;
Middleware = new List <IWorkflowMiddleware>();
Workflow = new WorkflowInstance();
Definition = new WorkflowDefinition();
TopLevelErrorHandler = A.Fake <IWorkflowMiddlewareErrorHandler>();
DefLevelErrorHandler = A.Fake <IDefLevelErrorHandler>();
ServiceProvider = new ServiceCollection()
.AddTransient(_ => TopLevelErrorHandler)
.AddTransient(_ => DefLevelErrorHandler)
.BuildServiceProvider();
A
.CallTo(HandleMethodFor(TopLevelErrorHandler))
.Returns(Task.CompletedTask);
A
.CallTo(HandleMethodFor(DefLevelErrorHandler))
.Returns(Task.CompletedTask);
Runner = new WorkflowMiddlewareRunner(Middleware, ServiceProvider);
}
/// <inheritdoc/>
public async Task <IGraphViewModel> BuildGraph(WorkflowDefinition definition)
{
var isEmpty = definition.States == null || !definition.States.Any();
var graph = new GraphViewModel();
//graph.RegisterBehavior(new DragAndDropNodeBehavior(graph, this.jSRuntime));
var startNode = this.BuildStartNode(!isEmpty);
var endNode = this.BuildEndNode();
await graph.AddElementAsync(startNode);
if (!isEmpty)
{
var startState = definition.GetStartState();
await this.BuildStateNodes(definition, graph, startState, endNode, startNode);
}
else
{
await this.BuildEdgeBetween(graph, startNode, endNode);
}
await graph.AddElementAsync(endNode);
return(await Task.FromResult(graph));
}
public WorkflowDefinition_WorkflowDefinitionDTO(WorkflowDefinition WorkflowDefinition)
{
this.Id = WorkflowDefinition.Id;
this.Code = WorkflowDefinition.Code;
this.Name = WorkflowDefinition.Name;
this.CreatorId = WorkflowDefinition.CreatorId;
this.ModifierId = WorkflowDefinition.ModifierId;
this.WorkflowTypeId = WorkflowDefinition.WorkflowTypeId;
this.StartDate = WorkflowDefinition.StartDate;
this.EndDate = WorkflowDefinition.EndDate;
this.StatusId = WorkflowDefinition.StatusId;
this.CreatedAt = WorkflowDefinition.CreatedAt;
this.UpdatedAt = WorkflowDefinition.UpdatedAt;
this.Creator = WorkflowDefinition.Creator == null ? null : new WorkflowDefinition_AppUserDTO(WorkflowDefinition.Creator);
this.Modifier = WorkflowDefinition.Modifier == null ? null : new WorkflowDefinition_AppUserDTO(WorkflowDefinition.Modifier);
this.Status = WorkflowDefinition.Status == null ? null : new WorkflowDefinition_StatusDTO(WorkflowDefinition.Status);
this.WorkflowType = WorkflowDefinition.WorkflowType == null ? null : new WorkflowDefinition_WorkflowTypeDTO(WorkflowDefinition.WorkflowType);
this.WorkflowDirections = WorkflowDefinition.WorkflowDirections?.Select(x => new WorkflowDefinition_WorkflowDirectionDTO(x)).ToList();
this.WorkflowParameters = WorkflowDefinition.WorkflowParameters?.Select(x => new WorkflowDefinition_WorkflowParameterDTO(x)).ToList();
this.WorkflowSteps = WorkflowDefinition.WorkflowSteps?.Select(x => new WorkflowDefinition_WorkflowStepDTO(x)).ToList();
this.Errors = WorkflowDefinition.Errors;
}
public static byte[] GetWorkflowDefinitionGraphic(Guid tenantId, int workflowType)
{
WorkflowDefinition definition = WorkflowLogic.GetWorkflowDefinition(tenantId, workflowType);
ServiceContainer serviceContainer = new ServiceContainer();
DesignerSerializationManager serializationManager = new DesignerSerializationManager(serviceContainer);
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
TypeProvider typeProvider = new TypeProvider((IServiceProvider)serializationManager);
typeProvider.AddAssembly(System.Reflection.Assembly.Load("Crab.Workflow"));
serviceContainer.AddService(typeof(ITypeProvider), typeProvider);
Activity rootActivity = null;
using (serializationManager.CreateSession())
{
TextReader reader1 = new StringReader(definition.Xoml);
using (XmlReader reader = XmlReader.Create(reader1))
{
rootActivity = (Activity)serializer.Deserialize((IDesignerSerializationManager)serializationManager, reader);
}
}
return(Viewer.GetWorkflowImageBinary(rootActivity, null));
}
/// <summary>
/// Initializes a new <see cref="EventStateTriggerDefinitionValidator"/>
/// </summary>
/// <param name="workflow">The <see cref="WorkflowDefinition"/> the <see cref="EventStateTriggerDefinition"/> to validate belongs to</param>
/// <param name="eventState">The <see cref="EventStateDefinition"/> the <see cref="EventStateTriggerDefinition"/> to validate belongs to</param>
public EventStateTriggerDefinitionValidator(WorkflowDefinition workflow, EventStateDefinition eventState)
{
this.Workflow = workflow;
this.EventState = eventState;
this.RuleForEach(t => t.Actions)
.SetValidator(new ActionDefinitionValidator(this.Workflow))
.When(t => t.Actions != null && t.Actions.Any())
.WithErrorCode($"{nameof(EventStateTriggerDefinition)}.{nameof(EventStateTriggerDefinition.Actions)}");
this.RuleFor(t => t.Events)
.NotEmpty()
.WithErrorCode($"{nameof(EventStateTriggerDefinition)}.{nameof(EventStateTriggerDefinition.Events)}");
this.RuleForEach(t => t.Events)
.Must(ReferenceExistingEvent)
.When(t => t.Events != null && t.Events.Any())
.WithErrorCode($"{nameof(EventStateTriggerDefinition)}.{nameof(EventStateTriggerDefinition.Events)}")
.WithMessage(eventRef => $"Failed to find an event with name '{eventRef}'");
this.RuleForEach(t => t.Events)
.Must(BeConsumed)
.When(t => t.Events != null && t.Events.Any())
.WithErrorCode($"{nameof(EventStateTriggerDefinition)}.{nameof(EventStateTriggerDefinition.Events)}")
.WithMessage(eventRef => $"The event with name '{eventRef}' must be of kind '{EnumHelper.Stringify(EventKind.Consumed)}' to be used in an event state trigger");
}
private WorkflowDefinition Convert(DefinitionSourceV1 source)
{
var dataType = typeof(object);
if (!string.IsNullOrEmpty(source.DataType))
{
dataType = FindType(source.DataType);
}
var result = new WorkflowDefinition
{
Id = source.Id,
Version = source.Version,
Steps = ConvertSteps(source.Steps, dataType),
DefaultErrorBehavior = source.DefaultErrorBehavior,
DefaultErrorRetryInterval = source.DefaultErrorRetryInterval,
Description = source.Description,
DataType = dataType
};
return(result);
}
public void should_subscribe_to_event()
{
//arrange
var definition = new WorkflowDefinition();
var pointer = new ExecutionPointer {
Id = "1", Active = true, StepId = 0, Status = PointerStatus.Running
};
var step = A.Fake <WorkflowStep>();
var workflowResult = new WorkflowExecutorResult();
var instance = GivenWorkflow(pointer);
var result = ExecutionResult.WaitForEvent("Event", "Key", DateTime.Now);
//act
Subject.ProcessExecutionResult(instance, definition, pointer, step, result, workflowResult);
//assert
pointer.Status.Should().Be(PointerStatus.WaitingForEvent);
pointer.Active.Should().BeFalse();
pointer.EventName.Should().Be("Event");
pointer.EventKey.Should().Be("Key");
workflowResult.Subscriptions.Should().Contain(x => x.StepId == pointer.StepId && x.EventName == "Event" && x.EventKey == "Key");
}
/// <inheritdoc/>
public override bool IsValid(ValidationContext <WorkflowDefinition> context, IEnumerable <FunctionDefinition> value)
{
WorkflowDefinition workflow = context.InstanceToValidate;
int index = 0;
IValidator <FunctionDefinition> validator = new FunctionDefinitionValidator(workflow);
foreach (FunctionDefinition function in value)
{
ValidationResult validationResult = validator.Validate(function);
if (validationResult.IsValid)
{
index++;
continue;
}
foreach (var failure in validationResult.Errors)
{
context.AddFailure(failure);
}
return(false);
}
return(true);
}
private async Task UpdateParameters(Guid RequestId, WorkflowDefinition WorkflowDefinition, Dictionary <string, string> Parameters)
{
// khởi tạo các parameter cho workflow
List <RequestWorkflowParameterMapping> RequestWorkflowParameterMappings = new List <RequestWorkflowParameterMapping>();
foreach (WorkflowParameter WorkflowParameter in WorkflowDefinition.WorkflowParameters)
{
RequestWorkflowParameterMapping RequestWorkflowParameterMapping = new RequestWorkflowParameterMapping();
RequestWorkflowParameterMappings.Add(RequestWorkflowParameterMapping);
RequestWorkflowParameterMapping.RequestId = RequestId;
RequestWorkflowParameterMapping.WorkflowParameterId = WorkflowParameter.Id;
RequestWorkflowParameterMapping.Value = null;
foreach (var pair in Parameters)
{
if (WorkflowParameter.Name == pair.Key)
{
RequestWorkflowParameterMapping.Value = pair.Value;
}
}
}
await UOW.RequestWorkflowParameterMappingRepository.BulkMerge(RequestId, RequestWorkflowParameterMappings);
}
public void Validate_Action_NoFunctionNorEvent_ShouldFail()
{
//arrange
var workflow = WorkflowDefinition.Create("fake", "fake", "fake")
.StartsWith("fake", flow => flow.Callback())
.End()
.Build();
var action = new ActionDefinition();
//act
var result = new ActionDefinitionValidator(workflow).Validate(action);
//assert
result.Should()
.NotBeNull();
result.Errors.Should()
.NotBeNullOrEmpty()
.And.HaveCount(3)
.And.Contain(e => e.PropertyName == nameof(ActionDefinition.Event))
.And.Contain(e => e.PropertyName == nameof(ActionDefinition.Function))
.And.Contain(e => e.PropertyName == nameof(ActionDefinition.Subflow));
}
public static string sample_SFSystemCalculator(HttpContext context)
{
WorkflowDefinition workflowDefinition = new WorkflowDefinition()
{
Correlation = new WorkflowCorrelation()
{
CorrelationId = Guid.NewGuid()
},
Workflow = WorkflowDefinitions.workflow_SFSystemCalculator(),
};
var response = manager.StartWorkflow <SFSystemCalculatorStartRequest, SFSystemCalculatorStartResponse>(workflowDefinition, null, "Start");
StringBuilder sb = new StringBuilder();
if (response != null && response.Started)
{
sb.Append("<script>");
sb.Append("function setOpt(op){document.getElementById('op').value = op.value;}");
sb.Append("</script>");
sb.Append($"Workflow SFSystemCalculator partito</br></br>");
sb.Append("<form action='/step' method='post'>");
sb.Append($"<input type='hidden' name='correlationid' value='{workflowDefinition.Correlation.CorrelationId}' />");
sb.Append("<input type='hidden' name='step' value='step_SFSystemCalculator_continue' />");
sb.Append("<input type='hidden' name='op' id='op'/>");
sb.Append("<div>");
sb.Append("<div><input type='text' name='number' value='0'/></div>");
sb.Append("<div><input onclick='setOpt(this);' type='submit' value='+' style='width:30px;' /> <input onclick='setOpt(this);' type='submit' value='-' style='width:30px;'/></div>");
sb.Append("<div><input onclick='setOpt(this);' type='submit' value='*' style='width:30px;' /> <input onclick='setOpt(this);' type='submit' value=':' style='width:30px;'/></div>");
sb.Append("</div>");
sb.Append("</form>");
}
return(sb.ToString());
}
public void should_advance_workflow()
{
//arrange
var definition = new WorkflowDefinition();
var pointer1 = new ExecutionPointer()
{
Id = "1", Active = true, StepId = 0, Status = PointerStatus.Running
};
var pointer2 = new ExecutionPointer()
{
Id = "2"
};
var outcome = new StepOutcome()
{
NextStep = 1
};
var step = A.Fake <WorkflowStep>();
var workflowResult = new WorkflowExecutorResult();
var instance = GivenWorkflow(pointer1);
var result = ExecutionResult.Next();
A.CallTo(() => step.Outcomes).Returns(new List <StepOutcome>()
{
outcome
});
A.CallTo(() => PointerFactory.BuildNextPointer(definition, pointer1, outcome)).Returns(pointer2);
//act
Subject.ProcessExecutionResult(instance, definition, pointer1, step, result, workflowResult);
//assert
pointer1.Active.Should().BeFalse();
pointer1.Status.Should().Be(PointerStatus.Complete);
pointer1.EndTime.Should().NotBeNull();
A.CallTo(() => PointerFactory.BuildNextPointer(definition, pointer1, outcome)).MustHaveHappened();
instance.ExecutionPointers.Should().Contain(pointer2);
}
public void UpdateWorkflowDefinitionXAML(PSHWorkflowDefinition WFDefinition)
{
using (var clientContext = new ClientContext(_PWAUrl))
{
var workflowServicesManager = new WorkflowServicesManager(clientContext, clientContext.Web);
// connect to the deployment service
var workflowDeploymentService = workflowServicesManager.GetWorkflowDeploymentService();
//Get all the definitions from the Deployment Service, or get a specific definition using the GetDefinition method.
WorkflowDefinitionCollection wfDefinitions = workflowDeploymentService.EnumerateDefinitions(false);
clientContext.Load(wfDefinitions, wfDefs => wfDefs.Where(wfd => wfd.Id == WFDefinition.WFDefinitionId));
clientContext.ExecuteQuery();
WorkflowDefinition wfDefinition = wfDefinitions.First();
wfDefinition.DisplayName = WFDefinition.WFName;
wfDefinition.Xaml = WFDefinition.WFDefinitionXAML;
ClientResult <Guid> wfDefId = workflowDeploymentService.SaveDefinition(wfDefinition);
workflowDeploymentService.PublishDefinition(wfDefinition.Id);
clientContext.ExecuteQuery();
}
}
public async Task <bool> Create(WorkflowDefinition WorkflowDefinition)
{
WorkflowDefinitionDAO WorkflowDefinitionDAO = new WorkflowDefinitionDAO();
WorkflowDefinitionDAO.Id = WorkflowDefinition.Id;
WorkflowDefinitionDAO.Name = WorkflowDefinition.Name;
WorkflowDefinitionDAO.Code = WorkflowDefinition.Code;
WorkflowDefinitionDAO.CreatorId = WorkflowDefinition.CreatorId;
WorkflowDefinitionDAO.ModifierId = WorkflowDefinition.ModifierId;
WorkflowDefinitionDAO.WorkflowTypeId = WorkflowDefinition.WorkflowTypeId;
WorkflowDefinitionDAO.StartDate = WorkflowDefinition.StartDate;
WorkflowDefinitionDAO.EndDate = WorkflowDefinition.EndDate;
WorkflowDefinitionDAO.StatusId = WorkflowDefinition.StatusId;
WorkflowDefinitionDAO.CreatedAt = StaticParams.DateTimeNow;
WorkflowDefinitionDAO.UpdatedAt = StaticParams.DateTimeNow;
DataContext.WorkflowDefinition.Add(WorkflowDefinitionDAO);
await DataContext.SaveChangesAsync();
WorkflowDefinition.Id = WorkflowDefinitionDAO.Id;
await SaveReference(WorkflowDefinition);
return(true);
}
public static string step_SFSystemCalculator_end(HttpContext context)
{
WorkflowDefinition workflowDefinition = new WorkflowDefinition()
{
Workflow = WorkflowDefinitions.workflow_SFSystemCalculator(),
Correlation = new WorkflowCorrelation()
{
CorrelationId = Guid.Parse(context.Request.Form["correlationid"])
},
};
var request = new SFSystemCalculatorEndRequest();
var response = manager.ContinueWorkflow <SFSystemCalculatorEndRequest, SFSystemCalculatorEndResponse>(workflowDefinition, request, "end");
StringBuilder sb = new StringBuilder();
if (response != null)
{
sb.Append($"Il risultato e': { response.Result}");
}
return(sb.ToString());
}
public async Task <WorkflowDefinition> SaveDraftAsync(WorkflowDefinition workflowDefinition, CancellationToken cancellationToken = default)
{
var draft = workflowDefinition;
var latestVersion = await _workflowDefinitionStore.FindByDefinitionIdAsync(
workflowDefinition.DefinitionId,
VersionOptions.Latest,
cancellationToken);
if (latestVersion != null && latestVersion.IsPublished && latestVersion.IsLatest)
{
latestVersion.IsLatest = false;
await _workflowDefinitionStore.SaveAsync(latestVersion, cancellationToken);
}
draft.IsLatest = true;
draft.IsPublished = false;
draft = Initialize(draft);
await _workflowDefinitionStore.SaveAsync(draft, cancellationToken);
return(draft);
}
public static WorkflowDefinition GetWorkflowDefinition(Guid tenantId, int workflowType)
{
Database db = DatabaseFactory.CreateDatabase(Constants.Database.TenantMetadata);
using (DbCommand command = db.GetStoredProcCommand("crab_GetWorkflowDefinition"))
{
db.AddInParameter(command, "TenantId", DbType.Guid, tenantId);
db.AddInParameter(command, "WorkflowType", DbType.Int32, workflowType);
using (IDataReader reader = db.ExecuteReader(command))
{
if (reader.Read())
{
WorkflowDefinition definition = new WorkflowDefinition();
definition.Id = (Guid)reader["Id"];
definition.WorkflowType = (int)reader["WorkflowType"];
definition.Xoml = (string)reader["Xoml"];
definition.Rules = (string)reader["Rules"];
return(definition);
}
}
}
return(null);
}
public WorkflowDefinitionPipeBind(WorkflowDefinition def)
{
_def = def;
}
public WorkflowDefinitionPipeBind()
{
_def = null;
_id = Guid.Empty;
_name = string.Empty;
}
private void DeployWorkflowDefinition(WebModelHost host,
Web web,
SP2013WorkflowDefinition workflowDefinitionModel)
{
var clientContext = web.Context;
var workflowServiceManager = new WorkflowServicesManager(clientContext, web);
var workflowDeploymentService = workflowServiceManager.GetWorkflowDeploymentService();
var publishedWorkflows = workflowDeploymentService.EnumerateDefinitions(false);
clientContext.Load(publishedWorkflows, c => c.Include(
w => w.DisplayName,
w => w.Id,
w => w.Published
));
clientContext.ExecuteQuery();
var currentWorkflowDefinition = publishedWorkflows.FirstOrDefault(w => w.DisplayName == workflowDefinitionModel.DisplayName);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentWorkflowDefinition,
ObjectType = typeof(WorkflowDefinition),
ObjectDefinition = workflowDefinitionModel,
ModelHost = host
});
if (currentWorkflowDefinition == null)
{
var workflowDefinition = new WorkflowDefinition(clientContext)
{
Xaml = workflowDefinitionModel.Xaml,
DisplayName = workflowDefinitionModel.DisplayName
};
clientContext.Load(workflowDefinition);
workflowDeploymentService.SaveDefinition(workflowDefinition);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = workflowDefinition,
ObjectType = typeof(WorkflowDefinition),
ObjectDefinition = workflowDefinitionModel,
ModelHost = host
});
workflowDeploymentService.PublishDefinition(workflowDefinition.Id);
clientContext.ExecuteQuery();
}
else
{
if (workflowDefinitionModel.Override)
{
currentWorkflowDefinition.Xaml = workflowDefinitionModel.Xaml;
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentWorkflowDefinition,
ObjectType = typeof(WorkflowDefinition),
ObjectDefinition = workflowDefinitionModel,
ModelHost = host
});
workflowDeploymentService.SaveDefinition(currentWorkflowDefinition);
workflowDeploymentService.PublishDefinition(currentWorkflowDefinition.Id);
clientContext.ExecuteQuery();
}
else
{
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentWorkflowDefinition,
ObjectType = typeof(WorkflowDefinition),
ObjectDefinition = workflowDefinitionModel,
ModelHost = host
});
workflowDeploymentService.PublishDefinition(currentWorkflowDefinition.Id);
clientContext.ExecuteQuery();
}
}
}
private void DeployWorkflowDefinition(object host, SPWeb web, SP2013WorkflowDefinition workflowDefinitionModel)
{
var workflowServiceManager = new WorkflowServicesManager(web);
var workflowDeploymentService = workflowServiceManager.GetWorkflowDeploymentService();
var publishedWorkflows = workflowDeploymentService.EnumerateDefinitions(false);
var currentWorkflowDefinition = publishedWorkflows.FirstOrDefault(w => w.DisplayName == workflowDefinitionModel.DisplayName);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentWorkflowDefinition,
ObjectType = typeof(WorkflowDefinition),
ObjectDefinition = workflowDefinitionModel,
ModelHost = host
});
if (currentWorkflowDefinition == null)
{
var workflowDefinition = new WorkflowDefinition()
{
Xaml = workflowDefinitionModel.Xaml,
DisplayName = workflowDefinitionModel.DisplayName
};
workflowDeploymentService.SaveDefinition(workflowDefinition);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = workflowDefinition,
ObjectType = typeof(WorkflowDefinition),
ObjectDefinition = workflowDefinitionModel,
ModelHost = host
});
workflowDeploymentService.PublishDefinition(workflowDefinition.Id);
}
else
{
if (workflowDefinitionModel.Override)
{
currentWorkflowDefinition.Xaml = workflowDefinitionModel.Xaml;
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentWorkflowDefinition,
ObjectType = typeof(WorkflowDefinition),
ObjectDefinition = workflowDefinitionModel,
ModelHost = host
});
workflowDeploymentService.SaveDefinition(currentWorkflowDefinition);
workflowDeploymentService.PublishDefinition(currentWorkflowDefinition.Id);
}
else
{
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentWorkflowDefinition,
ObjectType = typeof(WorkflowDefinition),
ObjectDefinition = workflowDefinitionModel,
ModelHost = host
});
workflowDeploymentService.PublishDefinition(currentWorkflowDefinition.Id);
}
}
}
/// <summary>Called when the previous activity has been executed.
/// The method may be called multiple times when there are multiple incoming transitions. </summary>
/// <param name="input">The input. </param>
/// <param name="definition">The workflow definition. </param>
/// <returns>True when the activity should be automatically and immediately executed (with no args). </returns>
internal override Task<bool> PrepareAsync(WorkflowActivityInput input, WorkflowDefinition definition)
{
var immediatelyExecute = !HasCurrentActivityBeforeActivity(input, definition, this, new List<WorkflowTransition>());
return Task.FromResult(immediatelyExecute);
}
protected void ProcessFile(FileInfo xamlFile)
{
// Load and validate XAML.
var workflowServicesManager = new WorkflowServicesManager(_clientContext, _clientContext.Web);
var workflowDeploymentService = workflowServicesManager.GetWorkflowDeploymentService();
var xaml = File.ReadAllText(xamlFile.FullName);
var validationResult = workflowDeploymentService.ValidateActivity(xaml);
_clientContext.ExecuteQuery();
if (!string.IsNullOrEmpty(validationResult.Value))
{
throw new PSSnapInException(string.Format("XAML validation failed: {0}.", validationResult.Value));
}
var workflowDefinition = workflowDeploymentService.GetDefinition(new Guid(Id));
_clientContext.Load(workflowDefinition, w => w);
_clientContext.ExecuteQuery();
// Create new definition if not exists.
if (workflowDefinition.ServerObjectIsNull == true)
{
workflowDefinition = new WorkflowDefinition(_clientContext);
}
// Determine list name before setting other values (requires a round-trip to server)
workflowDefinition.RestrictToScope = RestrictToScope ?? GetRestrictToScopeFromListName();
workflowDefinition.AssociationUrl = AssociationUrl;
workflowDefinition.Description = Description;
workflowDefinition.DisplayName = DisplayName;
workflowDefinition.DraftVersion = DraftVersion;
workflowDefinition.FormField = FormField;
workflowDefinition.Id = new Guid(Id);
workflowDefinition.InitiationUrl = InitiationUrl;
workflowDefinition.RequiresAssociationForm = RequiresAssociationForm;
workflowDefinition.RequiresInitiationForm = RequiresInitiationForm;
workflowDefinition.RestrictToType = RestrictToType;
workflowDefinition.Xaml = xaml;
// Save changes.
workflowDeploymentService.SaveDefinition(workflowDefinition);
_clientContext.ExecuteQuery();
WriteObject("Workflow definition saved.");
// Publish the workflow.
if (Publish)
{
workflowDeploymentService.PublishDefinition(workflowDefinition.Id);
_clientContext.ExecuteQuery();
WriteObject("Workflow definition published.");
}
}
private void OKButton_Click(object sender, RoutedEventArgs e)
{
if (dataGrid.SelectedItem == null)
{
MessageBox.Show("请选择需要打开的流程！");
return;
}
selectWorkflowDefinition = (WorkflowDefinition)dataGrid.SelectedItem;
this.DialogResult = true;
}
protected virtual void MapProperties(WorkflowDefinition workflow, SP2013WorkflowDefinition definition)
{
if (!string.IsNullOrEmpty(definition.RestrictToType))
workflow.RestrictToType = definition.RestrictToType;
if (!string.IsNullOrEmpty(definition.RestrictToScope))
workflow.RestrictToScope = definition.RestrictToScope;
foreach (var prop in definition.Properties)
workflow.SetProperty(prop.Name, prop.Value);
}
private void DeployWorkflowDefinition(object host, SPWeb web, SP2013WorkflowDefinition workflowDefinitionModel)
{
var workflowServiceManager = new WorkflowServicesManager(web);
var workflowDeploymentService = workflowServiceManager.GetWorkflowDeploymentService();
var currentWorkflowDefinition = GetCurrentWorkflowDefinition(web, workflowDefinitionModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentWorkflowDefinition,
ObjectType = typeof(WorkflowDefinition),
ObjectDefinition = workflowDefinitionModel,
ModelHost = host
});
if (currentWorkflowDefinition == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new SP2013 workflow definition");
var workflowDefinition = new WorkflowDefinition()
{
Xaml = workflowDefinitionModel.Xaml,
DisplayName = workflowDefinitionModel.DisplayName
};
MapProperties(workflowDefinition, workflowDefinitionModel);
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Calling SaveDefinition()");
var wfId = workflowDeploymentService.SaveDefinition(workflowDefinition);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = workflowDefinition,
ObjectType = typeof(WorkflowDefinition),
ObjectDefinition = workflowDefinitionModel,
ModelHost = host
});
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Calling PublishDefinition()");
workflowDeploymentService.PublishDefinition(wfId);
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing SP2013 workflow definition");
if (workflowDefinitionModel.Override)
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Override = true. Overriding workflow definition");
currentWorkflowDefinition.Xaml = workflowDefinitionModel.Xaml;
MapProperties(currentWorkflowDefinition, workflowDefinitionModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentWorkflowDefinition,
ObjectType = typeof(WorkflowDefinition),
ObjectDefinition = workflowDefinitionModel,
ModelHost = host
});
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Calling SaveDefinition()");
var wfId = workflowDeploymentService.SaveDefinition(currentWorkflowDefinition);
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Calling PublishDefinition()");
workflowDeploymentService.PublishDefinition(wfId);
}
else
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Override = false. Skipping workflow definition");
MapProperties(currentWorkflowDefinition, workflowDefinitionModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentWorkflowDefinition,
ObjectType = typeof(WorkflowDefinition),
ObjectDefinition = workflowDefinitionModel,
ModelHost = host
});
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Calling PublishDefinition()");
workflowDeploymentService.PublishDefinition(currentWorkflowDefinition.Id);
}
}
}
