public void PersistSingleExecution()
        {
            var builder = new WorkflowDefinitionBuilder();

            var workflowDefinition = builder
                .WithIdentifier("testWorkflowDefinition")
                .AddNode()
                    .WithName("start")
                    .WithOperation<TestOperation>()
                    .IsStartNode()
                    .AddTransition()
                        .WithName("transition")
                        .To("end")
                    .BuildTransition()
                .BuildNode()
                .AddNode()
                    .WithName("end")
                    .IsEndNode()
                .BuildNode()
                .BuildWorkflow<TestData>();

            var instance =
                new WorkflowEngineBuilder().ConfigureServiceLocator()
                                           .ImportModule(new SqlPersistenceTestModule(SessionFactory))
                                           .Build()
                                           .StartNewInstance(workflowDefinition, new TestData());

            using (var session = SessionFactory.OpenSession())
                Assert.That(session.QueryOver<WorkflowDefinitionModel>().Where(d => d.Identifier == workflowDefinition.Identifier).SingleOrDefault(), Is.Not.Null);

            Assert.False(instance.IsFinished);
        }
        public void PersistNestedWorkflow()
        {
            var builder = new WorkflowDefinitionBuilder();

            var workflowDefinition = builder
                .WithIdentifier("testWorkflowDefinition")
                .AddNode()
                    .WithName("start")
                    .WithOperation<TestOperation>()
                    .IsStartNode()
                    .AddTransition()
                        .WithName("transition")
                        .To("nested")
                    .BuildTransition()
                .BuildNode()
                .AddNode()
                    .WithName("nested")
                    .AddTransition()
                        .WithName("nestedToEnd")
                        .To("end")
                    .BuildTransition()
                .BuildSubWorkflow(new WorkflowDefinitionBuilder()
                    .WithIdentifier("subWorkflowDefinition")
                    .AddNode()
                        .IsStartNode()
                        .IsEndNode()
                        .WithName("subWorkflowNode")
                        .WithOperation<TestOperation>()
                    .BuildNode()
                    .AsDefinitionBuilder())
                .AddNode()
                    .WithName("end")
                    .IsEndNode()
                .BuildNode()
                .BuildWorkflow();

            var instance =
                new WorkflowEngineBuilder().ConfigureServiceLocator()
                                           .ImportModule(new Neo4jPersistenceTestModule(GraphClient))
                                           .Build()
                                           .StartNewInstance(workflowDefinition);


        }
        private WorkflowDefinitionBuilder BuildWorkflowDefinition(WorkflowDefinitionBuilder builder, WorkflowDefinitionModel model)
        {
            builder.WithIdentifier(model.Identifier);
            foreach (var node in model.Nodes)
            {
                NodeBuilder nodeBuilder = builder.AddNode()
                                                 .WithName(node.Identifier);

                if (node.OperationType != null)
                {
                    nodeBuilder.WithOperation(Type.GetType(node.OperationType));
                }

                if (node.IsInitialNode)
                {
                    nodeBuilder.IsStartNode();
                }

                if (node.IsEndNode)
                {
                    nodeBuilder.IsEndNode();
                }

                foreach (var transition in node.OutgoingTransitions)
                {
                    TransitionBuilder transitionBuilder = nodeBuilder.AddTransition()
                        .WithName(transition.Identifier)
                        .To(transition.Destination);

                    if (transition.IsDefault)
                    {
                        transitionBuilder.IsDefault();
                    }

                    transitionBuilder.BuildTransition();
                }

                BuildNode(builder, nodeBuilder, (dynamic) node);
            }

            return builder;
        }