public void Build(IWorkflowBuilder <RoleData> builder)
        {
            var branch1 = builder
                          .CreateBranch()
                          .StartWith <DoSomething>()
                          .Input(step => step.Message, data => "Starting 1")
                          .Then <RoleStep>()
                          .Input(step => step.Role, data => data.Role)
                          .Output(data => data.Role, step => step.Role)
                          .If(data => data.Role == Role.Student)
                          .Do(then => then
                              .StartWith <StudentStep>())
                          .If(data => data.Role == Role.Teacher)
                          .Do(then => then
                              .StartWith <TeacherStep>());

            var branch2 = builder
                          .CreateBranch()
                          .StartWith <DoSomething>()
                          .Input(step => step.Message, data => "Starting 2")
                          .If(data => data.Role == Role.Student)
                          .Do(then => then
                              .StartWith <StudentStep>())
                          .If(data => data.Role == Role.Teacher)
                          .Do(then => then
                              .StartWith <TeacherStep>());

            builder
            .StartWith <DoSomething>()
            .Input(step => step.Message, data => "branch")
            .Decide(data => data.branchId)
            .Branch(1, branch1)
            .Branch(2, branch2);
        }
Beispiel #2
0
        public void Build(IWorkflowBuilder <WfData> builder)
        {
            var branch1 = builder.CreateBranch()
                          .StartWith <CustomMessage>()
                          .Input(step => step.Message, data => "hi from 1")
                          .Then <CustomMessage>()
                          .Input(step => step.Message, data => "bye from 1");

            var branch2 = builder.CreateBranch()
                          .StartWith <CustomMessage>()
                          .Input(step => step.Message, data => "hi from 2")
                          .Then <CustomMessage>()
                          .Input(step => step.Message, data => "bye from 2");


            builder
            .StartWith <HelloWorld>()
            .Then((context) =>
            {
                Console.WriteLine("------1");
                Task.Delay(TimeSpan.FromSeconds(20)).Wait();
                Console.WriteLine("------2");
                return(ExecutionResult.Next());
            })
            .Decide(data => data.Value1)
            .Branch((data, outcome) => data.Value1 == "one", branch1)
            .Branch((data, outcome) => data.Value1 == "two", branch2);
        }
Beispiel #3
0
        public void Build(IWorkflowBuilder <MyData> builder)
        {
            //builder
            //    .StartWith<AddNumbers>()
            //    .Then<GoodbyeWorld>();

            //builder
            //.StartWith<AddNumbers>()
            //    .Input(step => step.Input1, data => data.Value1)
            //    .Input(step => step.Input2, data => data.Value2)
            //    .Output(data => data.Value3, step => step.Output)
            //.Then<CustomMessage>()
            //    .Name("Print custom message")
            //    .Input(step => step.Message, data => "The answer is " + data.Value3.ToString());

            var branch1 = builder.CreateBranch()
                          .StartWith <AddNumbers>()
                          .Input(step => step.Input1, data => data.Value1)
                          .Input(step => step.Input2, data => data.Value2)
                          .Output(data => data.Value3, step => step.Output);

            var branch2 = builder.CreateBranch()

                          .StartWith <CustomMessage>()
                          .Input(cust => cust.Message, data => data.Value3.ToString());

            builder
            .StartWith <HelloWorld>()
            .Decide(data => data.Value3)
            .Branch(1, branch1)
            .Branch(2, branch2);
        }
Beispiel #4
0
 public void Build(IWorkflowBuilder <EquirectangularWorkflowData> builder)
 {
     builder
     .Initialise()
     .RegisterImages()
     .InitialiseProgressBar(data => data.Activities.Count)
     .If(data => data.Activities.Any())
     .Do(branch => branch
         .ForEach(data => data.Activities, _ => false)
         .Do(activityStep => activityStep
             .SetWorkflowActivity()
             .CalculateVisibleRange()
             .CalculateGlobalOffset()
             .ForEach(data => data.Activity !.Registrations, _ => false)    // Single registration
             .Do(registration => registration
                 .SetWorkflowRegistration()
                 .ShouldWriteSingle()
                 .Branch(true, builder
                         .CreateBranch()
                         .LoadImageSingle()
                         .NormaliseImage()
                         .ToEquirectangular()
                         .StitchImages()
                         .GetCropBounds()
                         .RenderUnderlay()
                         .ColourCorrect()
                         .CropImage()
                         .SaveImage()
                         )
                 )
             )
         )
     .LogCompletion();
 }
Beispiel #5
0
 public void Build(IWorkflowBuilder <GeostationaryWorkflowData> builder)
 {
     builder
     .Initialise()
     .CreateActivity()
     .InitialiseProgressBar(data => data.Activity !.Registrations.Count + 1)
     .If(data => data.Activity !.Registrations.Any())
     .Do(branch => branch
         .ForEach(data => data.Activity !.Registrations, _ => false)
         .Do(registration => registration
             .SetWorkflowRegistration()
             .ShouldWriteSingle()
             .Branch(true, builder.CreateBranch()
                     .LoadImageSingle()
                     .NormaliseImage()
                     .EqualiseOverlayHistogram()
                     .RenderOverlay()
                     .RenderUnderlay()
                     .ComposeOverlay()
                     .ColourCorrect()
                     .ApplyHaze()
                     .SaveImage()
                     )
             )
         )
     .LogCompletion();
 }
        public void Build(IWorkflowBuilder <MyNameClass> builder)
        {
            var branch1 = builder.CreateBranch()
                          .StartWith(context => { Console.WriteLine("输入小于3个字符"); ExecutionResult.Next(); });
            var branch2 = builder.CreateBranch()
                          .StartWith(context => { Console.WriteLine("输入大于等于3个字符"); ExecutionResult.Next(); });

            builder
            .StartWith(context => ExecutionResult.Next())
            .Activity("activity-1", (data) => data.MyName)
            .Output(data => data.MyName, step => step.Result)
            .Decide(data => data.MyName.Length)
            .Branch((data, outcome) => data.MyName.Length < 3, branch1)
            .Branch((data, outcome) => data.MyName.Length >= 3, branch2)
            .Then <GoodbyeWithName>()
            .Input(step => step.Name, data => data.MyName);
        }
Beispiel #7
0
            public void Build(IWorkflowBuilder <MyDataClass> builder)
            {
                var addBranch = builder.CreateBranch()
                                .StartWith <AddNumbers>()
                                .Input(step => step.Input1, data => data.Value1)
                                .Input(step => step.Input2, data => data.Value2)
                                .Output(data => data.Value3, step => step.Output);

                var subtractBranch = builder.CreateBranch()
                                     .StartWith <SubtractNumbers>()
                                     .Input(step => step.Input1, data => data.Value1)
                                     .Input(step => step.Input2, data => data.Value2)
                                     .Output(data => data.Value3, step => step.Output);

                builder
                .StartWith <Decide>()
                .Input(step => step.Expression, data => data.Op)
                .Branch("+", addBranch)
                .Branch("-", subtractBranch);
            }
Beispiel #8
0
        public void Build(IWorkflowBuilder <WfData> builder)
        {
            var branch1 = builder.CreateBranch()
                          .StartWith <CustomMessage>()
                          .Input(step => step.Message, data => "hi from 1")
                          .Then <CustomMessage>()
                          .Input(step => step.Message, data => "bye from 1");

            var branch2 = builder.CreateBranch()
                          .StartWith <CustomMessage>()
                          .Input(step => step.Message, data => "hi from 2")
                          .Then <CustomMessage>()
                          .Input(step => step.Message, data => "bye from 2");


            builder
            .StartWith <HelloWorld>()
            .Decide(data => data.Value1)
            .Branch((data, outcome) => data.Value1 == "one", branch1)
            .Branch((data, outcome) => data.Value1 == "two", branch2);
        }
Beispiel #9
0
        public void Build(IWorkflowBuilder <MyData> builder)
        {
            var branch1 = builder.CreateBranch()
                          .StartWith <PrintMessage>()
                          .Input(step => step.Message, data => "hi from 1")
                          .Then <PrintMessage>()
                          .Input(step => step.Message, data => "bye from 1");

            var branch2 = builder.CreateBranch()
                          .StartWith <PrintMessage>()
                          .Input(step => step.Message, data => "hi from 2")
                          .Then <PrintMessage>()
                          .Input(step => step.Message, data => "bye from 2");


            builder
            .StartWith <SayHello>()
            .Decide(data => data.Value)
            .Branch(1, branch1)
            .Branch(2, branch2);
        }
        public void Build(IWorkflowBuilder <MyData> builder)
        {
            var branch1 = builder.CreateBranch()
                          .StartWith <PrintMessage>()
                          .Input(step => step.Message, data => "hi from 1")
                          .Input(step => step.id, data => data.id)
                          .Then <PrintMessage>()
                          .Input(step => step.Message, data => "bye from 1");

            var branch2 = builder.CreateBranch()
                          .StartWith <PrintMessage>()
                          .Input((step, data) => { step.id = data.id; step.Message = "hi from 2"; });

            //.Then<PrintMessage>()
            //    .Input(step => step.Message, data => "bye from 2");


            builder
            .StartWith(x => { Console.WriteLine("start w2"); return(ExecutionResult.Next()); })
            .Decide(data => 2)
            .Branch(1, branch1)
            .Branch(2, branch2);
        }
Beispiel #11
0
        public void Build(IWorkflowBuilder <Item> builder)
        {
            Log.Information("[Workflow] Build: {Id}", Id);

            // Workflow branch executes DropShip items
            var dropshipBranch = builder.CreateBranch()
                                 .StartWith <NotifyApprovers>()
                                 .OnError(WorkflowErrorHandling.Retry, TimeSpan.FromMinutes(10))
                                 .WaitFor("ApprovePCT", (data, context) => context.Workflow.Id, data => DateTime.Now)
                                 .Then <PricingAutoAssign>()
                                 .Input(step => step.CalcPrice, data => data.Price)
                                 .Input(step => step.item, data => data)
                                 .Output(data => data.Price, step => step.CalcPrice)
                                 .Then <CustomMessage>()
                                 .Input(step => step.Message, data => "The vendor from the event is " + data.Vendor);

            // Workflow branch executes RSC items
            var rscBranch = builder.CreateBranch()
                            .StartWith <MerchantApproval>()
                            .Then(context => Log.Logger.Information("---------- Start Merchant Approval Task ------------"))
                            .UserTask("MerchantApprove", data => "username")
                            // (Value, Label)
                            .WithOption("Approve", "Merchant-Approved").Do(then => then
                                                                           .StartWith(context => Log.Logger.Information("You approved"))
                                                                           )
                            .WithOption("Denied", "Merchant-Denied").Do(then => then
                                                                        .StartWith(context => Log.Logger.Information("You did not approve"))
                                                                        )
                            .Then <CustomMessage>()
                            .Input(step => step.Message, data => "-----Complete Merchant Approval Step ------")

                            //.WaitFor("MerchantApprove", (data, context) => context.Workflow.Id, data => DateTime.Now)
                            //.If(data => data.isDSCert(false)).Do(then => then
                            // .StartWith(<CheckVendorDSCert>())
                            // .If(data.CertFlag.boolean(false)).Do(then => then
                            // .StartWith(<RejectWorkflow>()
                            // .EndWorkflow()
                            //.If(data => data.isDSCert(true)).Do(then => then
                            //    .StartWith(<RemoveRSCSelections>())
                            // .Attach(dropshipBranch);

                            .Parallel()
                            .Do(then =>
                                then.StartWith <HazmatApproval>()
                                .Input(step => step.Message, data => "Item 1.1")
                                .If(data => data.HazardousFlag.Equals("Y")).Do(then => then
                                                                               .WaitFor("HazmatApproval", (data, context) => context.Workflow.Id, data => DateTime.Now))
                                .Then <CustomMessage>()
                                .Input(step => step.Message, data => "-----Complete HazmatApproval Approval Step ------"))
                            .Do(then =>
                                then.StartWith <ComplianceApproval>()
                                .Input(step => step.Message, data => "Item 2.1")
                                .WaitFor("ComplianceApproval", (data, context) => context.Workflow.Id, data => DateTime.Now)
                                .Then <CustomMessage>()
                                .Input(step => step.Message, data => "-----Complete ComplianceApproval Approval Step ------"))
                            .Join()
                            .Then <PricingAutoAssign>()
                            .Input(step => step.CalcPrice, data => data.Price)
                            .Input(step => step.item, data => data)
                            .Output(data => data.Price, step => step.CalcPrice);

            builder
            .StartWith <NewItem>()
            // Associate the WorkflowID with the item in workflow database
            .Input(step => step.item, data => data)
            // This will set the item data in the workflow process so we can refer to it later.
            .Output(data => data.WorkflowId, step => step.item.WorkflowId)


            .Decide(data => data.ArticleSourceFlag)
            .Branch((data, outcome) => data.ArticleSourceFlag == "A", dropshipBranch)
            .Branch((data, outcome) => data.ArticleSourceFlag == "B", rscBranch)
            .Branch((data, outcome) => data.ArticleSourceFlag == "D", rscBranch);
        }