public IStepBuilder <TData, ActionStepBody> Then(Action <IStepExecutionContext> body)
{
var newStep = new WorkflowStep <ActionStepBody>();
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, ActionStepBody>(WorkflowBuilder, newStep);
stepBuilder.Input(x => x.Body, x => body);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public ActionResult CriarWorkflowStep([FromBody] WorkflowStep inputs)
{
try
{
_serv.CriarWorkflowStep(inputs);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest($"Ocorreu um erro ao criar um novo WorkflowStep: {ex.Message}"));
}
}
public ActionResult EditarWorkflowStep([FromBody] WorkflowStep inputs)
{
try
{
_serv.EditarWorkflowStep(inputs);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest($"Ocorreu um erro ao editar o WorkflowStep {inputs.IdWorkflowStep}: {ex.Message}"));
}
}
private void Given1StepWorkflow(WorkflowStep step1, string id, int version)
{
A.CallTo(() => Registry.GetDefinition(id, version)).Returns(new WorkflowDefinition()
{
Id = id,
Version = version,
DataType = typeof(object),
Steps = new List <WorkflowStep>()
{
step1
}
});
}
public static WorkflowStepDto?FromWorkflowStep(WorkflowStep step)
{
if (step == null)
{
return(null);
}
return(SimpleMapper.Map(step, new WorkflowStepDto
{
Transitions = step.Transitions.ToDictionary(
y => y.Key,
y => WorkflowTransitionDto.FromWorkflowTransition(y.Value) !)
}));
public IStepBuilder <TData, TStepBody> CompensateWithSequence(Action <IWorkflowBuilder <TData> > builder)
{
var newStep = new WorkflowStep <Sequence>();
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, Sequence>(WorkflowBuilder, newStep);
Step.CompensationStepId = newStep.Id;
builder.Invoke(WorkflowBuilder);
stepBuilder.Step.Children.Add(stepBuilder.Step.Id + 1); //TODO: make more elegant
return(this);
}
public bool IsExistWorkflowOrderNo(WorkflowStep workFlow)
{
if (workFlow.IsActive)
{
var result = this.context.workFlowSteps
.Where(w => w.OrderNo.Equals(workFlow.OrderNo) &&
w.IsActive && !w.Id.Equals(workFlow.Id))
.FirstOrDefault();
return(result != null);
}
return(false);
}
public WorkflowStep_WorkflowStepDTO(WorkflowStep WorkflowStep)
{
this.Id = WorkflowStep.Id;
this.WorkflowDefinitionId = WorkflowStep.WorkflowDefinitionId;
this.Code = WorkflowStep.Code;
this.Name = WorkflowStep.Name;
this.RoleId = WorkflowStep.RoleId;
this.SubjectMailForReject = WorkflowStep.SubjectMailForReject;
this.BodyMailForReject = WorkflowStep.BodyMailForReject;
this.Role = WorkflowStep.Role == null ? null : new WorkflowStep_RoleDTO(WorkflowStep.Role);
this.WorkflowDefinition = WorkflowStep.WorkflowDefinition == null ? null : new WorkflowStep_WorkflowDefinitionDTO(WorkflowStep.WorkflowDefinition);
this.WorkflowParameters = WorkflowStep.WorkflowParameters?.Select(p => new WorkflowStep_WorkflowParameterDTO(p)).ToList();
this.Errors = WorkflowStep.Errors;
}
private void GetCurrentStep()
{
BasePage p = ((BasePage)this.Page);
if (workflow == null)
{
workflow = GetWorkflow();
}
EntityIDValue = p.GetEntityIDValue(p.Screen, Me.EntityID, Me.EntityInputType);
step = workflowService.GetProvider(workflow).GetCurrentWorkflowStep(workflow, EntityIDValue);
}
public void should_map_outputs()
{
//arrange
Expression <Func <IStepWithProperties, int> > p1 = x => x.Property1;
Expression <Func <DataClass, IStepExecutionContext, int> > v1 = (x, context) => x.Value1;
var step1Body = A.Fake <IStepWithProperties>();
A.CallTo(() => step1Body.Property1).Returns(7);
A.CallTo(() => step1Body.RunAsync(A <IStepExecutionContext> .Ignored)).Returns(ExecutionResult.Next());
WorkflowStep step1 = BuildFakeStep(step1Body, new List <DataMapping>(), new List <DataMapping>()
{
new DataMapping()
{
Source = p1,
Target = v1
}
}
);
Given1StepWorkflow(step1, "Workflow", 1);
var data = new DataClass()
{
Value1 = 5
};
var instance = new WorkflowInstance
{
WorkflowDefinitionId = "Workflow",
Version = 1,
Status = WorkflowStatus.Runnable,
NextExecution = 0,
Id = "001",
Data = data,
ExecutionPointers = new List <ExecutionPointer>()
{
new ExecutionPointer()
{
Active = true, StepId = 0
}
}
};
//act
Subject.Execute(instance);
//assert
data.Value1.Should().Be(7);
}
public IParallelStepBuilder <TData, Sequence> Parallel()
{
var newStep = new WorkflowStep <Sequence>();
var newBuilder = new StepBuilder <TData, Sequence>(WorkflowBuilder, newStep);
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new ParallelStepBuilder <TData, Sequence>(WorkflowBuilder, newBuilder, newBuilder);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public GettingLoanFlow(WorkflowStep <GettingLoanSteps> initialState, List <IFlowParameter> flowParameters) : base(
initialState, flowParameters)
{
this.Configure(StartStep)
.OnEntry(() => { })
.Permit(WorkFlowActions.Next, WorkflowSteps.Single(a => a.Step == GettingLoanSteps.PrimitiveCheck));
this.Configure(WorkflowSteps.Single(a => a.Step == GettingLoanSteps.PrimitiveCheck))
.OnEntry(() => { })
.Permit(WorkFlowActions.Next, WorkflowSteps.Single(a => a.Step == GettingLoanSteps.PreparingDocuments));
this.Configure(WorkflowSteps.Single(a => a.Step == GettingLoanSteps.PreparingDocuments))
.OnEntry(() => { })
.Permit(WorkFlowActions.Next, WorkflowSteps.Single(a => a.Step == GettingLoanSteps.Payment));
}
private void AttachInputs(StepSourceV1 source, Type dataType, Type stepType, WorkflowStep step)
{
foreach (var input in source.Inputs)
{
var dataParameter = Expression.Parameter(dataType, "data");
var contextParameter = Expression.Parameter(typeof(IStepExecutionContext), "context");
var sourceExpr = DynamicExpressionParser.ParseLambda(new [] { dataParameter, contextParameter }, typeof(object), input.Value);
var stepParameter = Expression.Parameter(stepType, "step");
var targetProperty = Expression.Property(stepParameter, input.Key);
var targetExpr = Expression.Lambda(targetProperty, stepParameter);
step.Inputs.Add(new MemberMapParameter(sourceExpr, targetExpr));
}
}
public async Task <ActionResult <WorkflowStep_WorkflowStepDTO> > Get([FromBody] WorkflowStep_WorkflowStepDTO WorkflowStep_WorkflowStepDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
if (!await HasPermission(WorkflowStep_WorkflowStepDTO.Id))
{
return(Forbid());
}
WorkflowStep WorkflowStep = await WorkflowStepService.Get(WorkflowStep_WorkflowStepDTO.Id);
return(new WorkflowStep_WorkflowStepDTO(WorkflowStep));
}
internal static void Enrich(WorkflowStep workflowStep)
{
var activity = Activity.Current;
if (activity != null)
{
var stepName = string.IsNullOrEmpty(workflowStep.Name)
? "inline"
: workflowStep.Name;
activity.DisplayName += $" step {stepName}";
activity.SetTag("workflow.step.id", workflowStep.Id);
activity.SetTag("workflow.step.name", workflowStep.Name);
activity.SetTag("workflow.step.type", workflowStep.BodyType.Name);
}
}
public IContainerStepBuilder <TData, Schedule, TStepBody> Schedule(Expression <Func <TData, TimeSpan> > time)
{
var newStep = new WorkflowStep <Schedule>();
Expression <Func <Schedule, TimeSpan> > inputExpr = (x => x.Interval);
newStep.Inputs.Add(new MemberMapParameter(time, inputExpr));
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new ReturnStepBuilder <TData, Schedule, TStepBody>(WorkflowBuilder, newStep, this);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public IStepBuilder <TData, Delay> Delay(Expression <Func <TData, TimeSpan> > period)
{
var newStep = new WorkflowStep <Delay>();
Expression <Func <Delay, TimeSpan> > inputExpr = (x => x.Period);
newStep.Inputs.Add(new MemberMapParameter(period, inputExpr));
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, Delay>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
private void AttachOutputs(Step source, Type dataType, Type stepType, WorkflowStep step)
{
foreach (var output in source.Outputs)
{
Action <IStepBody, object> acn = (pStep, pData) =>
{
object resolvedValue = _scriptHost.EvaluateExpression(output.Value, new Dictionary <string, object>()
{
["step"] = pStep,
["data"] = pData
});
(pData as IDictionary <string, object>)[output.Key] = resolvedValue;
};
step.Outputs.Add(new ActionParameter <IStepBody, object>(acn));
}
}
private async Task <bool> ValidateRole(WorkflowStep WorkflowStep)
{
RoleFilter RoleFilter = new RoleFilter
{
Id = new IdFilter {
Equal = WorkflowStep.RoleId
}
};
var count = await UOW.RoleRepository.Count(RoleFilter);
if (count == 0)
{
WorkflowStep.AddError(nameof(WorkflowStepValidator), nameof(WorkflowStep.Role), ErrorCode.RoleNotExisted);
}
return(WorkflowStep.IsValidated);
}
public IUserTaskReturnBuilder <TData> WithOption(string value, string label)
{
var newStep = new WorkflowStep <When>();
Expression <Func <When, object> > inputExpr = (x => x.ExpectedOutcome);
Expression <Func <TData, string> > valueExpr = (x => value);
var mapping = new MemberMapParameter(valueExpr, inputExpr);
newStep.Inputs.Add(mapping);
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new UserTaskReturnBuilder <TData>(WorkflowBuilder, newStep, this);
Step.Children.Add(newStep.Id);
_wrapper.Options[label] = value;
return(stepBuilder);
}
public IStepBuilder <TData, Decide> Decide(Expression <Func <TData, object> > expression)
{
var newStep = new WorkflowStep <Decide>();
Expression <Func <Decide, object> > inputExpr = (x => x.Expression);
newStep.Inputs.Add(new MemberMapParameter(expression, inputExpr));
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, Decide>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public IContainerStepBuilder <TData, If, If> If(Expression <Func <TData, bool> > condition)
{
var newStep = new WorkflowStep <If>();
Expression <Func <If, bool> > inputExpr = (x => x.Condition);
newStep.Inputs.Add(new MemberMapParameter(condition, inputExpr));
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, If>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public IContainerStepBuilder <TData, Foreach, Foreach> ForEach(Expression <Func <TData, IEnumerable> > collection)
{
var newStep = new WorkflowStep <Foreach>();
Expression <Func <Foreach, IEnumerable> > inputExpr = (x => x.Collection);
newStep.Inputs.Add(new MemberMapParameter(collection, inputExpr));
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, Foreach>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
private async Task <bool> ValidateWorkflowStepInUsed(WorkflowStep WorkflowStep)
{
RequestWorkflowStepMappingFilter RequestWorkflowStepMappingFilter = new RequestWorkflowStepMappingFilter
{
WorkflowStepId = new IdFilter {
Equal = WorkflowStep.Id
}
};
var count = await UOW.RequestWorkflowStepMappingRepository.Count(RequestWorkflowStepMappingFilter);
if (count != 0)
{
WorkflowStep.AddError(nameof(WorkflowStepValidator), nameof(WorkflowStep.Id), ErrorCode.WorkflowStepInUsed);
}
return(WorkflowStep.IsValidated);
}
private void ProcessOutputs(WorkflowInstance workflow, WorkflowStep step, IStepBody body)
{
foreach (var output in step.Outputs)
{
var member = (output.Target.Body as MemberExpression);
if (member != null) // to resolve a field or property
{
var list = new List <String>()
{
"system.int64", "system.int32", "system.string", "system.boolean"
};
var resolvedValue = output.Source.Compile().DynamicInvoke(body);
Type resolvedValueType = resolvedValue.GetType();
var type = resolvedValueType.FullName.ToLower();
if (!list.Contains(type))
{
var data = workflow.Data;
var value = resolvedValue.GetType().GetProperty(member.Member.Name).GetValue(resolvedValue, null);
data.GetType().GetProperty(member.Member.Name).SetValue(data, value);
}
else if (list.Contains(type))
{
var data = workflow.Data;
data.GetType().GetProperty(member.Member.Name).SetValue(data, resolvedValue);
}
}
if (member == null) // to resolve an object
{
var resolvedValue = output.Source.Compile().DynamicInvoke(body);
var data = workflow.Data;
Type dataType = data.GetType();
foreach (PropertyInfo propertyInfo in dataType.GetProperties())
{
var value = resolvedValue.GetType().GetProperty(propertyInfo.Name).GetValue(resolvedValue, null);
data.GetType().GetProperty(propertyInfo.Name).SetValue(data, value);
}
}
}
}
public IStepBuilder <TData, TStepBody> CompensateWith <TStep>(Action <IStepBuilder <TData, TStep> > stepSetup = null) where TStep : IStepBody
{
WorkflowStep <TStep> newStep = new WorkflowStep <TStep>();
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, TStep>(WorkflowBuilder, newStep);
if (stepSetup != null)
{
stepSetup.Invoke(stepBuilder);
}
newStep.Name = newStep.Name ?? typeof(TStep).Name;
Step.CompensationStepId = newStep.Id;
return(this);
}
public void Test_Graph_Run_Ok()
{
DBController db = DBController.Create(connectionString);
Workflow wf = db.WorkflowMetadataGet("Test100");
WorkflowGraph wfg = WorkflowGraph.Create(wf, db);
wfg.Start();
BlockingCollection <string> step_set = new BlockingCollection <string>();
Task t1 = Task.Factory.StartNew(() =>
{
WorkflowStep step = null;
while (wfg.TryTake(out step, TimeSpan.FromMinutes(5)))
{
wfg.SetNodeExecutionResult(step.Key, WfResult.Started);
Thread.Sleep(1000);
step_set.Add(step.Key);
}
step_set.CompleteAdding();
Console.WriteLine(String.Format("Finishing Step Submitting thread"));
});
Task t2 = Task.Factory.StartNew(() =>
{
string Key = String.Empty;
while (step_set.TryTake(out Key, -1))
{
Console.WriteLine(String.Format("Processing step {0}", Key));
wfg.SetNodeExecutionResult(Key, WfResult.Succeeded);
//wfg.SetNodeExecutionResult(Key, WfResult.Failed);
}
Console.WriteLine(String.Format("Finishing Step Processing thread"));
});
Task.WaitAll(t1, t2);
WfResult wr = wfg.WorkflowRunStatus;
WfResult wc = wfg.WorkflowCompleteStatus;
Console.WriteLine(String.Format("Run status {0}", wr.StatusCode.ToString()));
Console.WriteLine(String.Format("Complete status {0}", wc.StatusCode.ToString()));
Assert.IsTrue(wr.StatusCode == WfStatus.Succeeded);
}
public void should_map_outputs()
{
//arrange
var param = A.Fake <IStepParameter>();
var step1Body = A.Fake <IStepWithProperties>();
A.CallTo(() => step1Body.Property1).Returns(7);
A.CallTo(() => step1Body.RunAsync(A <IStepExecutionContext> .Ignored)).Returns(ExecutionResult.Next());
WorkflowStep step1 = BuildFakeStep(step1Body, new List <IStepParameter>(), new List <IStepParameter>()
{
param
}
);
Given1StepWorkflow(step1, "Workflow", 1);
var data = new DataClass()
{
Value1 = 5
};
var instance = new WorkflowInstance
{
WorkflowDefinitionId = "Workflow",
Version = 1,
Status = WorkflowStatus.Runnable,
NextExecution = 0,
Id = "001",
Data = data,
ExecutionPointers = new ExecutionPointerCollection(new List <ExecutionPointer>()
{
new ExecutionPointer()
{
Id = "1", Active = true, StepId = 0
}
})
};
//act
Subject.Execute(instance);
//assert
A.CallTo(() => param.AssignOutput(data, step1Body, A <IStepExecutionContext> .Ignored))
.MustHaveHappened();
}
private void ProcessInputs(WorkflowInstance workflow, WorkflowStep step, IStepBody body, IStepExecutionContext context)
{
//TODO: Move to own class
foreach (var input in step.Inputs)
{
var member = (input.Target.Body as MemberExpression);
if (member == null)
{
UnaryExpression ubody = (UnaryExpression)input.Target.Body;
member = ubody.Operand as MemberExpression;
}
object resolvedValue = null;
switch (input.Source.Parameters.Count)
{
case 1:
resolvedValue = input.Source.Compile().DynamicInvoke(workflow.Data);
break;
case 2:
resolvedValue = input.Source.Compile().DynamicInvoke(workflow.Data, context);
break;
default:
throw new ArgumentException();
}
var property = step.BodyType.GetProperty(member.Member.Name);
var propertyType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;
if (CanChangeType(resolvedValue, propertyType))
{
var safeValue = (resolvedValue == null) ? null : Convert.ChangeType(resolvedValue, propertyType);
property.SetValue(body, safeValue);
}
else
{
property.SetValue(body, resolvedValue);
}
}
}
public static WorkflowStepDto FromWorkflowStep(WorkflowStep step)
{
var response = SimpleMapper.Map(step, new WorkflowStepDto
{
Transitions = step.Transitions.ToDictionary(
y => y.Key,
y => WorkflowTransitionDto.FromWorkflowTransition(y.Value))
});
if (step.NoUpdate != null)
{
response.NoUpdate = true;
response.NoUpdateExpression = step.NoUpdate.Expression;
response.NoUpdateRoles = step.NoUpdate.Roles?.ToArray();
}
return(response);
}
public override void UpdatedState(WorkflowStep step)
{
if (step.State != step.NextWorkflowStep.State)
switch (step.WithWorkflowAction)
{
case WorkflowActions.Approve:
Invoice.InvoiceState.ApproveInvoice(Invoice);
break;
case WorkflowActions.Reject:
Invoice.InvoiceState.RejectInvoice(Invoice);
break;
case WorkflowActions.Cancel:
Invoice.InvoiceState.CancelInvoice(Invoice);
break;
}
}
public StateStepConfigurationMetadata(IEnumerable<DocumentType> documentTypes, WorkflowStep workflowStep)
{
DocumentTypes = documentTypes;
WorkflowStep = workflowStep;
}
public StateStepConfigurationMetadataAttribute(DocumentType[] documentTypes, WorkflowStep workflowStep)
{
DocumentTypes = documentTypes;
WorkflowStep = workflowStep;
}
private CatalogUploadViewModel GetCatalogViewModel(WorkflowStep<CatalogUploadState> nextStep, CatalogUploadState state)
{
var vm = new CatalogUploadViewModel();
vm.PageTitle = nextStep.StepName;
vm.NavigationLocation = new string[] { "Admin" };
vm.CatalogUploadState = state;
vm.StepView = nextStep.StepView;
vm.StepActionName = nextStep.StepButton;// "Next Step";
vm.MyCatalogs = Account.User(false).MyAdminCatalogs().OrderBy(c => c.CatalogName).ToList();
vm.MyPricingPlan = Account.User().PricingPlan;
vm.MyUserBalances = Account.User().MyBalances();
// vm.DefaultSongBalance = vm.PricingPlans.Where(p => p.IsEnabled == true).Min(p => p.NumberOfSongs);
vm.MinUploadFiles = 1;
return vm;
}
