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