private static IWorkflowBuilder GetDefaultBuilder(RavenDBProvider provider)
{
var builder = new WorkflowBuilder<XElement>(provider,
new XmlWorkflowParser(),
provider
).WithDefaultCache();
return builder;
}
private static IWorkflowBuilder GetDefaultBuilder(string connectionString)
{
var generator = new OptimaJet.Workflow.DbPersistence.DbXmlWorkflowGenerator(connectionString);
var builder = new WorkflowBuilder<XElement>(generator,
new XmlWorkflowParser(),
new OptimaJet.Workflow.DbPersistence.DbSchemePersistenceProvider(connectionString)
).WithDefaultCache();
return builder;
}
private static IWorkflowBuilder GetDefaultBuilder()
{
var connectionString = ConfigurationManager.ConnectionStrings["WF.Sample.Business.Properties.Settings.WorkflowEngineConnectionString"].ConnectionString;
var generator = new DbXmlWorkflowGenerator(connectionString);
var builder = new WorkflowBuilder<XElement>(generator,
new XmlWorkflowParser(),
new DbSchemePersistenceProvider(connectionString)
).WithDefaultCache();
return builder;
}
public void Test_SetEventDataIsCalled()
{
WorkflowBuilder builder = new WorkflowBuilder();
DataReceivedEventReceiver eventReceiver = new DataReceivedEventReceiver();
builder.Add(eventReceiver);
var context = builder.Compile();
context.PublishEvent(new DataReceivedEventData() { Data = "data"});
context.Run();
Assert.That(eventReceiver.Data, Is.EqualTo("data"));
}
private WorkflowRuntime CreateRuntimeRavenDB()
{
var provider = new RavenDBProvider(new Raven.Client.Document.DocumentStore()
{
Url = Parameters.DBUrl,
DefaultDatabase = Parameters.Database
});
callbackProvider = new WorkflowCallbackProvider(Parameters, provider);
var builder = new WorkflowBuilder <XElement>(callbackProvider, new XmlWorkflowParser(), provider).WithDefaultCache();
return(new WorkflowRuntime(Parameters.RuntimeId)
.WithBuilder(builder)
.WithPersistenceProvider(provider));
}
private static async Task TryToRun(WorkflowBuilder workflowBuilder)
{
if (_numberOfExceptionsInLastTime++ >= HOW_MANY_EXCEPTIONS_IN_SHORT_TIME_TO_STOP_BOT)
{
throw new Exception("Too many restarts");
}
try
{
await workflowBuilder.Run();
}
catch (Exception e)
{
HandleException(e);
await Task.Delay(10000);
}
}
public ServerWorkflow()
{
this.DisplayName = "NTFE Workflow";
this.Body = new Flowchart();
this.CustomResult = new Variable <string>("CustomResult");
this.Variable1 = new Variable <string>("Variable1");
this.Body.StartNode = WorkflowBuilder.CreateServer(new ServerSetting(0, "节点1", "", "", null, null, false)
, "节点1"
, "test"
, null
, this.Variable1
, this.CustomResult
, null
, null);
}
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 static Workflow Build(string requiredRole)
{
var select = new StepBuilder <ISelectScheduleStep>();
var create = new StepBuilder <ICreateScheduleStep>();
var edit = new StepBuilder <IEditScheduleStep>();
var redirect = new StepBuilder <IRedirectSelectOrCreated>();
var delete = new StepBuilder <IDeleteScheduleStep>();
select
.Edge(x => x.Back).MapsTo(EdgeDone)
.Edge(x => x.Canceled).MapsTo(EdgeCanceled)
.Edge(x => x.Create).MapsTo(create)
.Edge(x => x.Edit).MapsTo(redirect)
.Edge(x => x.Delete).MapsTo(delete)
.Input(x => x.CanGoBack).Constant(false)
.SetUniqueWorkflowStepId(WorkflowIds.ScheduleWorkflow);
create
.Edge(x => x.Canceled).MapsTo(EdgeCanceled)
.Edge(x => x.Saved).MapsTo(redirect)
.Edge(x => x.Back).MapsTo(select);
redirect
.Edge(x => x.Next).MapsTo(edit)
.Edge(x => x.NotSet).MapsTo(select)
.Input(x => x.CreatedId).From(create).Output(x => x.Id)
.Input(x => x.SelectedId).From(select).Output(x => x.SingleSelectId);
edit
.Edge(x => x.Canceled).MapsTo(EdgeCanceled)
.Edge(x => x.Saved).MapsTo(edit)
.Edge(x => x.Back).MapsTo(select)
.Input(x => x.Id).From(redirect).Output(x => x.RedirectId);
delete
.Edge(x => x.Deleted).MapsTo(select)
.Input(x => x.Ids).From(select).Output(x => x.MultiSelectIds);
return(WorkflowBuilder.Create()
.WithId(WorkflowIds.ScheduleWorkflow)
.WithDefinition(nameof(WorkflowIds.ScheduleWorkflow))
.WithEdges(EdgeDone, EdgeCanceled, EdgeFailed)
.WithRequiredRole(requiredRole)
.StartWith(select));
}
public void Setup()
{
m_workflowBuilder = new WorkflowBuilder();
InitializeEventReceiver receiver = new InitializeEventReceiver();
m_simpleNode1 = new SimpleNode();
m_simpleNode2 = new SimpleNode();
m_simpleNode3 = new SimpleNode();
m_workflowBuilder.Add(receiver);
m_workflowBuilder.Add(m_simpleNode1);
m_workflowBuilder.Add(m_simpleNode2);
m_workflowBuilder.Add(m_simpleNode3);
m_workflowBuilder.Connect(receiver.Pin(x => x.Fired), m_simpleNode1);
m_workflowBuilder.Connect(m_simpleNode1.Pin(x => x.Next), m_simpleNode2);
m_workflowBuilder.Connect(m_simpleNode2.Pin(x => x.Next), m_simpleNode3);
m_debuggerMock = new Mock<IDebugger>();
}
private Client.ProcessType Parse(ProcessType processType)
{
var activity = this._workflowParser.Parse(WorkflowBuilder.GetCacheKey(processType)
, processType.Workflow.Serialized
, processType.ActivitySettings);
return(new Client.ProcessType()
{
CreateTime = processType.CreateTime,
Description = processType.Description,
Name = processType.Name,
Version = processType.Version,
IsCurrent = processType.IsCurrent,
Group = processType.Group,
ActivityNames = processType.ActivitySettings.Select(o => o.ActivityName).ToArray(),
DataFields = activity.Variables.Select(o => o.Name).ToArray()
});
}
void IWaitingResumptionHandle.Resume(WaitingResumption waitingResumption)
{
var r = waitingResumption as BookmarkResumption;
var persisted = this._processService.GetWorkflowInstance(r.Process).WorkflowInstance;
var instance = WorkflowBuilder.CreateInstance(r.Process, this._parser);
instance.Load(persisted);
//只能尝试恢复存在的书签
if (instance.GetBookmarks().Any(o => o.Name == r.BookmarkName))
{
instance.Update(r.Process.GetInputs());
instance.ResumeBookmark(r.BookmarkName, r.Value);
}
else
{
this._log.WarnFormat("没有在流程“{0}”#{1}中找到名为{2}的书签，取消本次恢复", r.Process.Title, r.Process.ID, r.BookmarkName);
}
}
public void ApplyChanges(WorkflowModel model, WorkflowReplacementModel?replacements)
{
var document = WorkflowBuilder.ParseDocument(model.DiagramXml);
var participants = document.Descendants(bpmn + "collaboration").Elements(bpmn + "participant").ToDictionaryEx(a => a.Attribute("id") !.Value);
var processElements = document.Descendants(bpmn + "process").ToDictionaryEx(a => a.Attribute("id") !.Value);
var diagramElements = document.Descendants(bpmndi + "BPMNPlane").Elements().ToDictionaryEx(a => a.Attribute("bpmnElement") !.Value, "bpmnElement");
if (participants.Count != processElements.Count)
{
throw new InvalidOperationException(WorkflowValidationMessage.ParticipantsAndProcessesAreNotSynchronized.NiceToString());
}
Locator locator = new Workflow.Locator(this, diagramElements, model, replacements);
var messageFlows = document.Descendants(bpmn + "collaboration").Elements(bpmn + "messageFlow").ToDictionaryEx(a => a.Attribute("id") !.Value);
var oldMessageFlows = this.messageFlows.ToDictionaryEx(a => a.bpmnElementId, "messageFlows");
Synchronizer.Synchronize(messageFlows, oldMessageFlows,
null,
(id, omf) =>
{
this.messageFlows.Remove(omf);
omf.Entity.Delete(WorkflowConnectionOperation.Delete);
},
(id, mf, omf) =>
{
omf.Entity.ApplyXml(mf, locator);
});
var oldPools = this.pools.Values.ToDictionaryEx(a => a.pool.bpmnElementId, "pools");
Synchronizer.Synchronize(participants, oldPools,
createNew: (id, pa) =>
{
var wp = new WorkflowPoolEntity {
Xml = new WorkflowXmlEmbedded(), Workflow = this.workflow
}.ApplyXml(pa, locator);
var pb = new PoolBuilder(wp, Enumerable.Empty <LaneBuilder>(), Enumerable.Empty <XmlEntity <WorkflowConnectionEntity> >());
this.pools.Add(wp.ToLite(), pb);
pb.ApplyChanges(processElements.GetOrThrow(pa.Attribute("processRef") !.Value), locator);
},
void IWaitingResumptionHandle.Resume(WaitingResumption waitingResumption)
{
var r = waitingResumption as SubProcessCompleteResumption;
var subProcess = r.SubProcess;
var parentProcess = r.Process;
//尝试从父流程中获取启动该子流程的节点实例信息
SubProcessActivityInstance sub = this._processService.GetSubProcessActivityInstances(parentProcess, subProcess);
if (sub == null)
{
throw new InvalidOperationException(string.Format("没有在父流程“{0}”#{1}中找到启动子流程“{2}”#{3}的子流程节点实例"
, parentProcess.Title
, parentProcess.ID
, subProcess.Title
, subProcess.ID));
}
//将子流程的流程变量传递给父流程
var dict = subProcess.GetDataFields();
foreach (string key in dict.Keys)
{
parentProcess.UpdateDataField(key, dict[key]);
}
//唤醒父流程
var persisted = this._processService.GetWorkflowInstance(parentProcess).WorkflowInstance;
var instance = WorkflowBuilder.CreateInstance(parentProcess, this._parser);
instance.Load(persisted);
instance.Update(parentProcess.GetInputs());
instance.ResumeBookmark(sub.ReferredBookmarkName, null);
//目前不允许在调度项中生成新的非延迟调度项，无法保证预期顺序，需要有类似核心的quack机制
////创建父流程唤醒调度项
//this._resumption.Add(new BookmarkResumption(parentProcess
// , sub.ActivityName
// , sub.ReferredBookmarkName
// , string.Empty));
//将子流程节点置为完成
sub.SetAsComplete();
this._processService.UpdateActivityInstance(sub);
}
public static string StoreWorkflowElements(WorkflowBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (builder.Workflow.Count > 0)
{
var stringBuilder = new StringBuilder();
using (var writer = XmlnsIndentedWriter.Create(stringBuilder, DefaultWriterSettings))
{
WorkflowBuilder.Serializer.Serialize(writer, builder);
}
return(stringBuilder.ToString());
}
return(string.Empty);
}
public void Setup()
{
m_workflowBuilder = new WorkflowBuilder();
m_initEvent = new InitializeEventReceiver();
m_executionNode = new MakeMessageNode();
m_concatFunction = new ConcatFunction();
m_getMessage1Function = new GetMessageFunction("Hello");
m_getMessage2Function = new GetMessageFunction("World");
m_workflowBuilder.Add(m_initEvent);
m_workflowBuilder.Add(m_concatFunction);
m_workflowBuilder.Add(m_getMessage1Function);
m_workflowBuilder.Add(m_getMessage2Function);
m_workflowBuilder.Add(m_executionNode);
m_workflowBuilder.Connect(m_concatFunction.Pin(x => x.First), m_getMessage1Function.Pin(x => x.Message));
m_workflowBuilder.Connect(m_concatFunction.Pin(x => x.Second), m_getMessage2Function.Pin(x => x.Message));
m_workflowBuilder.Connect(m_executionNode.Pin(x => x.Input), m_concatFunction.Pin(x => x.Output));
m_workflowBuilder.Connect(m_initEvent.Pin(x => x.Fired), m_executionNode);
}
void IWaitingResumptionHandle.Resume(WaitingResumption waitingResumption)
{
try
{
var r = waitingResumption as ErrorResumption;
//错误恢复使用粗粒度实现，不延续原有工作流实例树
var instance = WorkflowBuilder.CreateInstance(r.Process, this._parser);
instance.Update(r.Process.GetInputs());
instance.Run();
this._log.InfoFormat("尝试对流程{0}#{1}在FlowNodeIndex={2}处进行了错误恢复"
, r.Process.Title
, r.Process.ID
, r.ErrorNodeIndex);
}
catch (Exception e)
{
//由于ErrorResumption本身就是错误恢复调度，即使异常也不应抛出而导致其本身被记录成error
this._log.Error("错误重试时异常", e);
}
}
// This will load the the workflow and start the subscription to what ever elements we want.
private void LoadInputWorkflow(string filename)
{
using (var reader = XmlReader.Create(filename))
{
var serializer = new XmlSerializer(typeof(WorkflowBuilder));
workflowBuilder = (WorkflowBuilder)serializer.Deserialize(reader);
var workflow = workflowBuilder.Workflow.Build();
var observableFactory = Expression.Lambda <Func <IObservable <Tuple <IplImage, Point2f, Point2f, Point2f> > > >(workflow).Compile();
imgDetectedSubscription = observableFactory().Subscribe(x => updateImage(x.Item1));
CubesSubscription = observableFactory().Subscribe(x => updateCubesPositions(x.Item2, x.Item3, x.Item4));
workflowBuilderGraph = workflowBuilder.Workflow;
}
}
public static WorkflowRuntime InitWorkflowRuntime(IServiceProvider provider, IConfigurationRoot config)
{
var connectionString = config.GetConnectionString("Default");
var dbProvider = new MSSQLProvider(connectionString);
var builder = new WorkflowBuilder <XElement>(dbProvider, new XmlWorkflowParser(), dbProvider).WithDefaultCache();
Runtime = new WorkflowRuntime()
.WithBuilder(builder)
.WithPersistenceProvider(dbProvider)
.WithActionProvider(provider.GetService <IWorkflowActionProvider>())
.EnableCodeActions()
.SwitchAutoUpdateSchemeBeforeGetAvailableCommandsOn();
Runtime.ProcessStatusChanged += Runtime_ProcessStatusChanged;
Runtime.Start();
return(Runtime);
}
private WorkflowRuntime WorkflowRuntimeFactory()
{
//WorkflowRuntime.RegisterLicense("your license key text");
var dbProvider = new MSSQLProvider(_engineConfiguration.ConnectionString);
var builder = new WorkflowBuilder <XElement>(dbProvider, new XmlWorkflowParser(), dbProvider).WithDefaultCache();
var runtime = new WorkflowRuntime()
.WithBuilder(builder)
.WithPersistenceProvider(dbProvider)
.WithActionProvider(_actionService)
.WithBus(new NullBus())
.EnableCodeActions()
.SwitchAutoUpdateSchemeBeforeGetAvailableCommandsOn();
runtime.ProcessStatusChanged += Runtime_ProcessStatusChanged;
runtime.Start();
return(runtime);
}
public static Workflow Build(string requiredRole)
{
var selectQuery = new StepBuilder <ISelectSearchQueryStep>();
var createQuery = new StepBuilder <ICreateSearchQueryStep>();
var deleteQueries = new StepBuilder <IDeleteSearchQueryStep>();
var invokeWorkflow = new StepBuilder <IInvokeSearchQueryByIdWorkflowStep>();
selectQuery
.Edge(x => x.Back).MapsTo(EdgeDone)
.Edge(x => x.Canceled).MapsTo(EdgeCanceled)
.Edge(x => x.Create).MapsTo(createQuery)
.Edge(x => x.Edit).MapsTo(invokeWorkflow)
.Edge(x => x.Delete).MapsTo(deleteQueries)
.Input(x => x.CanGoBack).Constant(false)
.SetUniqueWorkflowStepId(WorkflowIds.SearchQueryWorkflow)
.UseGenericDashboardComponentConfiguration(WorkflowIds.SearchQueryWorkflow, "api/cea/searchqueries/count", DAL.WebApplication.CatchEmAll_SearchQueries.Key);
createQuery
.Edge(x => x.Canceled).MapsTo(EdgeCanceled)
.Edge(x => x.Saved).MapsTo(selectQuery)
.Edge(x => x.Back).MapsTo(selectQuery)
.UseDashboardComponentConfigurationFrom(selectQuery);
deleteQueries
.Edge(x => x.Deleted).MapsTo(selectQuery)
.Input(x => x.Ids).From(selectQuery).Output(x => x.MultiSelectIds);
invokeWorkflow
.Edge(x => x.Done).MapsTo(selectQuery)
.Edge(x => x.Canceled).MapsTo(EdgeCanceled)
.Edge(x => x.Failed).MapsTo(EdgeFailed)
.Input(x => x.QueryId).From(selectQuery).Output(x => x.SingleSelectId);
return(WorkflowBuilder.Create()
.WithId(WorkflowIds.SearchQueryWorkflow)
.WithDefinition(nameof(WorkflowIds.SearchQueryWorkflow))
.WithEdges(EdgeDone, EdgeCanceled, EdgeFailed)
.WithRequiredRole(requiredRole)
.StartWith(selectQuery));
}
private static void CreateRuntime()
{
if (_runtime == null)
{
lock (_sync)
{
if (_runtime == null)
{
var provider = DataServiceProvider.Get <IPersistenceProviderContainer>().Provider;
var builder = new WorkflowBuilder <XElement>(provider, new XmlWorkflowParser(), provider).WithDefaultCache();
_runtime = new WorkflowRuntime()
.WithBuilder(builder)
.WithActionProvider(new ActionProvider(DataServiceProvider))
.WithRuleProvider(new RuleProvider(DataServiceProvider))
.WithPersistenceProvider(provider)
.WithTimerManager(new TimerManager())
.WithBus(new NullBus())
.SwitchAutoUpdateSchemeBeforeGetAvailableCommandsOn()
.RegisterAssemblyForCodeActions(Assembly.GetExecutingAssembly())
.Start();
var plugin = new OptimaJet.Workflow.Core.Plugins.BasicPlugin();
//Settings for SendEmail actions
// plugin.Setting_Mailserver = "smtp.yourserver.com";
// plugin.Setting_MailserverPort = 25;
// plugin.Setting_MailserverFrom = "*****@*****.**";
// plugin.Setting_MailserverLogin = "******";
// plugin.Setting_MailserverPassword = "******";
// plugin.Setting_MailserverSsl = true;
plugin.UsersInRoleAsync = UsersInRoleAsync;
_runtime.WithPlugin(plugin);
_runtime.ProcessStatusChanged += _runtime_ProcessStatusChanged;
}
}
}
}
// This will load the the workflow and start the subscription to what ever elements we want.
private void LoadInputWorkflow(string filename)
{
using (var reader = XmlReader.Create(filename))
{
var serializer = new XmlSerializer(typeof(WorkflowBuilder));
workflowBuilder = (WorkflowBuilder)serializer.Deserialize(reader);
// If we wanted to get a value before we start we used something like this
// ThresholdObj.value = Convert.ToSingle(Utils.GetWorkflowProperty(workflowBuilder.Workflow, "ThresholdValue"));
var workflow = workflowBuilder.Workflow.Build();
var observableFactory = Expression.Lambda <Func <IObservable <IplImage> > >(workflow).Compile();
imgDetectedSubscription = observableFactory().Subscribe(x => updateImage(x));
workflowBuilderGraph = workflowBuilder.Workflow;
}
}
public async Task Test01()
{
var workflow = new ForkJoinWorkflow(Join.JoinMode.WaitAll);
var workflowBlueprint = WorkflowBuilder.Build(workflow);
var workflowResult = await WorkflowStarter.StartWorkflowAsync(workflowBlueprint);
var workflowInstance = workflowResult.WorkflowInstance !;
async Task <bool> GetActivityHasExecutedAsync(string name)
{
var activity = workflowBlueprint.Activities.First(x => x.Name == name);
var entry = await WorkflowExecutionLog.FindEntryAsync(new ActivityIdSpecification(activity.Id));
return(entry != null);
}
Task <bool> GetIsFinishedAsync() => GetActivityHasExecutedAsync("Finished");
Assert.Equal(WorkflowStatus.Suspended, workflowInstance.WorkflowStatus);
Assert.False(await GetIsFinishedAsync());
// Trigger signal 1.
workflowInstance = await TriggerSignalAsync(workflowBlueprint, workflowInstance, "Signal1");
Assert.Equal(WorkflowStatus.Suspended, workflowInstance.WorkflowStatus);
Assert.False(await GetIsFinishedAsync());
// Trigger signal 2.
workflowInstance = await TriggerSignalAsync(workflowBlueprint, workflowInstance, "Signal2");
Assert.Equal(WorkflowStatus.Suspended, workflowInstance.WorkflowStatus);
Assert.False(await GetIsFinishedAsync());
// Trigger signal 3.
workflowInstance = await TriggerSignalAsync(workflowBlueprint, workflowInstance, "Signal3");
Assert.Equal(WorkflowStatus.Finished, workflowInstance.WorkflowStatus);
Assert.True(await GetIsFinishedAsync());
}
private static WorkflowRuntime InitWorkflowRuntime()
{
try
{
var connectionString = ConnectionString;
var dbProvider = new MSSQLProvider(connectionString);
var builder = new WorkflowBuilder <XElement>(
dbProvider,
new OptimaJet.Workflow.Core.Parser.XmlWorkflowParser(),
dbProvider
).WithDefaultCache();
var runtime = new WorkflowRuntime()
.WithBuilder(builder)
.WithPersistenceProvider(dbProvider)
.WithBus(new NullBus())
//TODO If you have planned use Timers uncomment following line of code
//.WithTimerManager(new TimerManager())
.EnableCodeActions()
.SwitchAutoUpdateSchemeBeforeGetAvailableCommandsOn();
//events subscription
runtime.ProcessActivityChanged += (sender, args) => { };
runtime.ProcessStatusChanged += (sender, args) => { };
//TODO If you have planned to use Code Actions functionality that required references to external assemblies you have to register them here
//runtime.RegisterAssemblyForCodeActions(Assembly.GetAssembly(typeof(SomeTypeFromMyAssembly)));
//starts the WorkflowRuntime
//TODO If you have planned use Timers the best way to start WorkflowRuntime is somwhere outside of this function in Global.asax for example
runtime.Start();
return(runtime);
}
catch (Exception ex)
{
throw new Exception();
}
}
public void Build_GroupInspectBuilder_ReturnNestedVisualizerElement()
{
var workflowBuilder = new WorkflowBuilder();
var source = workflowBuilder.Workflow.Add(new UnitBuilder());
var group = workflowBuilder.Workflow.Add(new GroupWorkflowBuilder());
var groupBuilder = (GroupWorkflowBuilder)group.Value;
workflowBuilder.Workflow.AddEdge(source, group, new ExpressionBuilderArgument());
var input = groupBuilder.Workflow.Add(new WorkflowInputBuilder());
var combinator = groupBuilder.Workflow.Add(new UnitBuilder());
var output = groupBuilder.Workflow.Add(new WorkflowOutputBuilder());
groupBuilder.Workflow.AddEdge(input, combinator, new ExpressionBuilderArgument());
groupBuilder.Workflow.AddEdge(combinator, output, new ExpressionBuilderArgument());
var inspectable = workflowBuilder.Workflow.ToInspectableGraph();
var inspectGroup = (InspectBuilder)inspectable.ElementAt(1).Value;
var result = inspectable.Build();
var visualizerElement = ExpressionBuilder.GetVisualizerElement(inspectGroup);
Assert.AreEqual(combinator.Value, visualizerElement.Builder);
}
void RunInspector(params ExpressionBuilder[] builders)
{
var workflowBuilder = new WorkflowBuilder();
var previous = default(Node <ExpressionBuilder, ExpressionBuilderArgument>);
foreach (var builder in builders)
{
var inspector = new InspectBuilder(builder);
var node = workflowBuilder.Workflow.Add(inspector);
if (previous != null)
{
workflowBuilder.Workflow.AddEdge(previous, node, new ExpressionBuilderArgument());
}
previous = node;
}
var result = workflowBuilder.Workflow.BuildObservable();
var errors = workflowBuilder.Workflow.InspectErrorsEx();
using (var error = errors.Subscribe(ex => { throw ex; }))
using (var subscription = result.Subscribe())
{
}
}
public void FaultBookmark_SubProcess()
{
_process = this.CreateProcess(SequenceWorkflowParser.GetActivitySettings());
TestHelper.SetProcessId(_process, Guid.NewGuid());
var instance = WorkflowBuilder.CreateInstance(_process, new SequenceWorkflowParser());
//跳转到子流程-节点2
this.UpdateCurrentNode(instance, 2);
instance.Run();
Thread.Sleep(1000);
this.AssertWorkflowInstance(instance, 1, 0);
//此时有一个子流程节点实例
Assert.AreEqual(1, _subProcessCount);
var bookmark = instance.GetBookmarks()[0].Name;
//子流程结束后恢复子流程活动
instance.ResumeBookmark(bookmark, null);
Thread.Sleep(1000);
//发生了错误
this.AssertWorkflowInstance(instance, 1, 1);
//书签复用
Assert.AreEqual(bookmark, instance.GetBookmarks()[0].Name);
//错误重试，应从callback处恢复
instance.ResumeBookmark(bookmark, null);
Thread.Sleep(1000);
//始终只能有一个书签
this.AssertWorkflowInstance(instance, 1, 2);
//重试不能重新创建子流程节点实例
Assert.AreEqual(1, _subProcessCount);
//修复后重试
SequenceWorkflowParser.Second.FinishRule["error"] = "true";
instance.ResumeBookmark(bookmark, null);
Thread.Sleep(1000);
this.AssertWorkflowInstance(instance, 0, 2);
}
private static WorkflowRuntime InitWorkflowRuntime()
{
var connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
var dbProvider = new MSSQLProvider(connectionString);
var builder = new WorkflowBuilder <XElement>(
dbProvider,
new OptimaJet.Workflow.Core.Parser.XmlWorkflowParser(),
dbProvider
).WithDefaultCache();
var runtime = new WorkflowRuntime()
.WithBuilder(builder)
.WithPersistenceProvider(dbProvider)
.WithBus(new NullBus())
.EnableCodeActions()
.SwitchAutoUpdateSchemeBeforeGetAvailableCommandsOn();
runtime.ProcessActivityChanged += (sender, args) => { };
runtime.ProcessStatusChanged += (sender, args) => { };
runtime.Start();
return(runtime);
}
public static void AddWorkflow(this IServiceCollection services, IConfiguration configuration)
{
var connectionString = configuration[$"ConnectionStrings:DefaultConnection"];
if (string.IsNullOrEmpty(connectionString))
{
throw new Exception("Please init ConnectionString before calling the Runtime!");
}
//TODO If you have a license key, you have to register it here
//WorkflowRuntime.RegisterLicense("your license key text");
var dbProvider = new PostgreSQLProvider(connectionString);
var builder = new WorkflowBuilder <XElement>(
dbProvider,
new OptimaJet.Workflow.Core.Parser.XmlWorkflowParser(),
dbProvider
).WithDefaultCache();
var runtime = new WorkflowRuntime()
.WithBuilder(builder)
.WithPersistenceProvider(dbProvider)
.EnableCodeActions()
.SwitchAutoUpdateSchemeBeforeGetAvailableCommandsOn()
.WithActionProvider(new ActionProvider())
.AsSingleServer();
//events subscription
runtime.OnProcessActivityChanged += (sender, args) => { };
runtime.OnProcessStatusChangedAsync += (sender, args, token) => { return(ProcessStatusChanged(args, runtime)); };
//TODO If you have planned to use Code Actions functionality that required references to external assemblies you have to register them here
//runtime.RegisterAssemblyForCodeActions(Assembly.GetAssembly(typeof(SomeTypeFromMyAssembly)));
services.AddSingleton(s => runtime);
}
private WorkflowRuntime CreateRuntimePostgreSQL()
{
var provider = new OptimaJet.Workflow.PostgreSQL.PostgreSQLProvider(Parameters.ConnectionString);
callbackProvider = new WorkflowCallbackProvider(Parameters, provider);
var builder = new WorkflowBuilder<XElement>(callbackProvider, new XmlWorkflowParser(), provider).WithDefaultCache();
return new WorkflowRuntime(Parameters.RuntimeId)
.WithBuilder(builder)
.WithPersistenceProvider(provider);
}
//通过Flowchart节点和自定义活动列表解析NTFE-BPM活动树
private Taobao.Workflow.Activities.Statements.WorkflowActivity ParseWorkflowActivity(XElement root
, IList <ActivitySetting> activitySettings
, bool isCacheMetaData)
{
var activity = new WorkflowActivity();
var variableElements = root.Descendants("Variable").ToList();
//设置变量集合
this.SetVariablesForActivity(variableElements, activity);
var nodeDataElements = root.Descendants("NodeData")
.Where(o => o.Attribute("Category").Value != "Comment")
.ToList();
var linkDataElements = root.Descendants("LinkData").ToList();
var flowNodes = new Dictionary <string, FlowNodeInfo>(); //定义点集合
var temp = new List <string>();
foreach (var nodeDataElement in nodeDataElements)
{
var category = nodeDataElement.Attribute("Category").Value;
if (category == "HumanPar" || category == "ServerPar" || category == "ChildPar" || category == "Start")
{
continue;
}
var activityName = nodeDataElement.Attribute("Text").Value;
var key = nodeDataElement.Attribute("Key").Value;
if (temp.Contains(activityName))
{
throw new InvalidOperationException("流程中包括重复名称的节点，请检查！");
}
temp.Add(activityName);
var activitySetting = activitySettings.FirstOrDefault(o => o.ActivityName == activityName);
if (activitySetting == null)
{
throw new Exception(string.Format(@"解析出错，找不到名称为“{0}”的ActivitySetting", activityName));
}
Taobao.Activities.Statements.FlowStep flowStep = null;
if (activitySetting is HumanSetting)
{
var humanSetting = activitySetting as HumanSetting;
//创建人工节点
flowStep = WorkflowBuilder.CreateHuman(activitySetting
, activitySetting.ActivityName
, new GetUsers(humanSetting.ActionerRule.Scripts)
, activity.CustomActivityResult
, new Dictionary <string, Taobao.Activities.Statements.FlowNode>()
, null);
}
else if (activitySetting is ServerSetting)
{
var customSetting = activitySetting as CustomSetting;
var serverSetting = activitySetting as ServerSetting;
var resultTo = activity.Variables.ToList().FirstOrDefault(o => o.Name == serverSetting.ResultTo);
//创建人工节点
flowStep = WorkflowBuilder.CreateServer(activitySetting
, activitySetting.ActivityName
, serverSetting.Script
, customSetting.FinishRule.Scripts
, resultTo != null ? (Variable <string>)resultTo : null
, activity.CustomActivityResult
, new Dictionary <string, Taobao.Activities.Statements.FlowNode>()
, null);
}
else if (activitySetting is SubProcessSetting)
{
var customSetting = activitySetting as CustomSetting;
var subProcessSetting = activitySetting as SubProcessSetting;
//创建子流程节点
flowStep = WorkflowBuilder.CreateSubProcess(activitySetting
, activitySetting.ActivityName
, customSetting.FinishRule.Scripts
, activity.CustomActivityResult
, new Dictionary <string, Taobao.Activities.Statements.FlowNode>()
, null);
}
else if (activitySetting is ParallelSetting)
{
IList <Custom> customs = new List <Custom>();
//遍历customs
var customParElements = nodeDataElements.Where(o => o.Attribute("SubGraphKey") != null && o.Attribute("SubGraphKey").Value == key).ToList();
foreach (var customParElement in customParElements)
{
var customeCategory = customParElement.Attribute("Category").Value;
var customeActivityName = customParElement.Attribute("Text").Value;
if (temp.Contains(customeActivityName))
{
throw new InvalidOperationException("流程中包括重复名称的节点，请检查！");
}
temp.Add(customeActivityName);
var customActivitySetting = activitySettings.FirstOrDefault(o => o.ActivityName == customeActivityName);
if (customActivitySetting == null)
{
throw new Exception(string.Format(@"解析出错，找不到名称为“{0}”的ActivitySetting", customeActivityName));
}
if (customActivitySetting is HumanSetting)
{
var humanSetting = customActivitySetting as HumanSetting;
//创建并行容器中人工节点
var human = WorkflowBuilder.CreateHuman(customActivitySetting
, customActivitySetting.ActivityName
, new GetUsers(humanSetting.ActionerRule.Scripts)
, activity.CustomActivityResult);
customs.Add(human);
}
else if (customActivitySetting is ServerSetting)
{
var customSetting = customActivitySetting as CustomSetting;
var serverSetting = customActivitySetting as ServerSetting;
var resultTo = activity.Variables.ToList().FirstOrDefault(o => o.Name == serverSetting.ResultTo);
//创建并行容器中自动节点
var server = WorkflowBuilder.CreateServer(customActivitySetting
, customActivitySetting.ActivityName
, serverSetting.Script
, customSetting.FinishRule.Scripts
, resultTo != null ? (Variable <string>)resultTo : null
, activity.CustomActivityResult);
customs.Add(server);
}
else if (customActivitySetting is SubProcessSetting)
{
var customSetting = customActivitySetting as CustomSetting;
var subProcessSetting = customActivitySetting as SubProcessSetting;
//创建并行容器中子流程节点
var subprocess = WorkflowBuilder.CreateSubProcess(customActivitySetting
, customActivitySetting.ActivityName
, customSetting.FinishRule.Scripts
, activity.CustomActivityResult);
customs.Add(subprocess);
}
}
//创建并行容器节点
flowStep = WorkflowBuilder.CreateParallel(activitySetting
, activitySetting.ActivityName
, (activitySetting as ParallelSetting).CompletionCondition
, null
, customs.ToArray());
}
flowNodes.Add(key, new FlowNodeInfo()
{
FlowStep = flowStep
});
}
if (nodeDataElements.Count(o => o.Attribute("Category").Value == "Start") != 1)
{
throw new InvalidOperationException("不包括Start开始节点");
}
//创建流程节点
this.BuildFlowNode(flowNodes, linkDataElements);
var startLinkElement = linkDataElements.FirstOrDefault(o => o.Attribute("From").Value == "Start");
if (startLinkElement == null)
{
throw new InvalidOperationException("不包含Start到初始点连线");
}
activity.Body.StartNode = flowNodes[startLinkElement.Attribute("To").Value].FlowStep;
//初始化Flowchart节点的元素
if (isCacheMetaData)
{
CacheMetadata(activity.Body);
}
return(activity);
}
/**********************************************************************************************
* Mehtod 명 : GetDefaultBuilder
* 개 발 자 : 양영석
* 생 성 일 : 2014-02-18
* 용 도 : 사용할 Process를 가져온다.
* Input 값 : GetDefaultBuilder(Process명, Generator명)
* ProcessName - dbo.WorkflowScheme의 Code
* GeneratorSource - dbo.WorkflowProcessScheme의 ProcessName
* Ouput 값 : IWorkflowBuilder
**********************************************************************************************/
/// <summary>
/// GetDefaultBuilder : 사용할 Process를 가져온다
/// </summary>
/// <param name="ProcessName">dbo.WorkflowScheme.Code</param>
/// <param name="GeneratorSource">dbo.WorkflowProcessScheme.ProcessName</param>
/// <returns>IWorkflowBuilder</returns>
public static IWorkflowBuilder GetDefaultBuilder(string ProcessName, object GeneratorSource)
{
_ProcessName = ProcessName;
_GeneratorSource = GeneratorSource;
var connectionString = ConnStrHelper.getDbConnString();
var generator = new DbXmlWorkflowGenerator(connectionString).WithMapping(ProcessName, GeneratorSource);
var builder = new WorkflowBuilder<XElement>(generator, new XmlWorkflowParser(), new DbSchemePersistenceProvider(connectionString)).WithDefaultCache();
return builder;
}
private WorkflowRuntime CreateRuntimeMongoDB()
{
var provider = new OptimaJet.Workflow.MongoDB.MongoDBProvider(new MongoClient(Parameters.DBUrl).GetServer().GetDatabase(Parameters.Database));
callbackProvider = new WorkflowCallbackProvider(this.Parameters, provider);
var builder = new WorkflowBuilder<XElement>(callbackProvider, new XmlWorkflowParser(), provider).WithDefaultCache();
return new WorkflowRuntime(Parameters.RuntimeId)
.WithBuilder(builder)
.WithPersistenceProvider(provider);
}
public WorkflowBuilder GetWorkflowBuilder()
{
MongoConfiguration.Initialize();
return(WorkflowBuilder.Create(this._configuration.Token, this._context, typeof(WatchmanBot).Assembly)
.SetDefaultMiddlewares()
.AddOnReadyHandlers(builder =>
{
builder
.AddHandler(() => Task.Run(() => Log.Information("Bot started and logged in...")))
.AddFromIoC <ConfigurationService>(configurationService => configurationService.InitDefaultConfigurations)
.AddFromIoC <CustomCommandsLoader>(customCommandsLoader => customCommandsLoader.InitDefaultCustomCommands)
.AddFromIoC <HelpDataCollectorService, HelpDBGeneratorService>((dataCollector, helpService) => () =>
{
Task.Run(() => helpService.FillDatabase(dataCollector.GetCommandsInfo(typeof(WatchmanBot).Assembly)));
return Task.CompletedTask;
})
.AddFromIoC <ResponsesInitService>(responsesService => async() =>
{
await responsesService.InitNewResponsesFromResources();
})
.AddFromIoC <InitializationService, DiscordServersService>((initService, serversService) => () =>
{
var stopwatch = Stopwatch.StartNew();
// when bot was offline for less than 1 minutes, it doesn't make sense to init all servers
if (WorkflowBuilder.DisconnectedTimes.LastOrDefault() > DateTime.Now.AddMinutes(-1))
{
Log.Information("Bot was connected less than 1 minute ago");
return Task.CompletedTask;
}
var servers = serversService.GetDiscordServers().Result;
Task.WaitAll(servers.Select(async server =>
{
Log.Information("Initializing server: {server}", server.ToJson());
await initService.InitServer(server);
Log.Information("Done server: {server}", server.ToJson());
}).ToArray());
Log.Information(stopwatch.ElapsedMilliseconds.ToString());
return Task.CompletedTask;
})
.AddHandler(() => Task.Run(() => Log.Information("Bot has done every Ready tasks.")));
})
.AddOnUserJoinedHandlers(builder =>
{
builder
.AddFromIoC <WelcomeUserService>(x => x.WelcomeUser)
.AddFromIoC <MutingRejoinedUsersService>(x => x.MuteAgainIfNeeded);
})
.AddOnDiscordServerAddedBotHandlers(builder =>
{
builder
.AddFromIoC <InitializationService>(initService => async server => await initService.InitServer(server));
})
.AddOnWorkflowExceptionHandlers(builder =>
{
builder
.AddFromIoC <ExceptionHandlerService>(x => x.LogException)
.AddHandler(this.PrintDebugExceptionInfo, onlyOnDebug: true)
.AddHandler(this.PrintExceptionOnConsole);
})
.AddOnChannelCreatedHandlers(builder =>
{
builder
.AddFromIoC <MuteRoleInitService>(x => (_, server) => x.InitForServer(server));
}));
}
public static IWorkflowBuilder WithShemePersistenceProvider <TSchemeMedium>(this WorkflowBuilder <TSchemeMedium> bulder, ISchemePersistenceProvider <TSchemeMedium> schemePersistenceProvider) where TSchemeMedium : class
{
bulder.SchemePersistenceProvider = schemePersistenceProvider;
return(bulder);
}
public static IWorkflowBuilder WithParser <TSchemeMedium>(this WorkflowBuilder <TSchemeMedium> bulder, IWorkflowParser <TSchemeMedium> parser) where TSchemeMedium : class
{
bulder.Parser = parser;
return(bulder);
}
private WorkflowRuntime CreateRuntimeMSSQL()
{
var generator = new OptimaJet.Workflow.DbPersistence.DbXmlWorkflowGenerator(Parameters.ConnectionString);
callbackProvider = new WorkflowCallbackProvider(Parameters, generator);
var builder = new WorkflowBuilder<XElement>(callbackProvider,
new XmlWorkflowParser(),
new OptimaJet.Workflow.DbPersistence.DbSchemePersistenceProvider(Parameters.ConnectionString)
).WithDefaultCache();
return new WorkflowRuntime(Parameters.RuntimeId)
.WithBuilder(builder)
.WithPersistenceProvider(new OptimaJet.Workflow.DbPersistence.DbPersistenceProvider(Parameters.ConnectionString));
}
private static void CreateRuntime()
{
if (_runtime == null)
{
lock (_sync)
{
if (_runtime == null)
{
var loopPlugin = new LoopPlugin();
var filePlugin = new FilePlugin();
var approvalPlugin = new ApprovalPlugin();
#region ApprovalPlugin Settings
approvalPlugin.GetUserNamesByIds += GeUserNamesByIds;
// approvalPlugin.AutoApprovalHistory = true;
// approvalPlugin.NameParameterForComment = "Comment";
#endregion ApprovalPlugin Settings
var basicPlugin = new BasicPlugin();
#region BasicPlugin Settings
//Settings for SendEmail actions
// basicPlugin.Setting_Mailserver = "smtp.yourserver.com";
// basicPlugin.Setting_MailserverPort = 25;
// basicPlugin.Setting_MailserverFrom = "*****@*****.**";
// basicPlugin.Setting_MailserverLogin = "******";
// basicPlugin.Setting_MailserverPassword = "******";
// basicPlugin.Setting_MailserverSsl = true;
//not implemented
basicPlugin.ApproversInStageAsync += ApproversInStageAsync;
basicPlugin.UsersInRoleAsync += UsersInRoleAsync;
basicPlugin.CheckPredefinedActorAsync += CheckPredefinedActorAsync;
basicPlugin.GetPredefinedIdentitiesAsync += GetPredefinedIdentitiesAsync;
basicPlugin.UpdateDocumentStateAsync += UpdateDocumentStateAsync;
basicPlugin.WithActors(new List <string>()
{
"Manager", "Author"
});
#endregion BasicPlugin Settings
var provider = DataServiceProvider.Get <IPersistenceProviderContainer>().Provider;
var externalParametersProvider = new ExternalParametersProvider();
externalParametersProvider.GetDocument += GetDocument;
var builder = new WorkflowBuilder <XElement>(provider, new XmlWorkflowParser(), provider).WithDefaultCache();
_runtime = new WorkflowRuntime()
.WithBuilder(builder)
.WithActionProvider(new ActionProvider(DataServiceProvider))
.WithRuleProvider(new RuleProvider(DataServiceProvider))
.WithDesignerAutocompleteProvider(new AutoCompleteProvider())
.WithPersistenceProvider(provider)
.SwitchAutoUpdateSchemeBeforeGetAvailableCommandsOn()
.RegisterAssemblyForCodeActions(Assembly.GetExecutingAssembly())
.WithPlugins(null, basicPlugin, loopPlugin, filePlugin, approvalPlugin)
.WithExternalParametersProvider(externalParametersProvider)
.CodeActionsDebugOn()
.AsSingleServer() //.AsMultiServer()
// .WithConsoleAllLogger()
.Start();
}
}
}
}
public void Setup()
{
m_workflowBuilder = new WorkflowBuilder();
}
public static SocketDesignGraph Build()
{
ScanState scanState = new ScanState()
{
Name = ScanState.Identifier
};
RectifyState rectifyState = new RectifyState()
{
Name = RectifyState.Identifier
};
SocketDesignState socketState = new SocketDesignState()
{
Name = SocketDesignState.Identifier
};
SocketDesignGraph graph = new SocketDesignGraph();
WorkflowBuilder builder = new WorkflowBuilder(graph);
graph.AddState(scanState);
graph.AddState(rectifyState);
graph.AddState(socketState);
WorkflowTransition toRectify = graph.AddTransition(scanState, rectifyState);
toRectify.BeforeTransition.Add(() => {
OG.Context.TransformManager.SetActiveGizmoType(TransformManager.NoGizmoType);
OGActions.InitializeLegFromScan();
});
WorkflowTransition toSocket = graph.AddTransition(rectifyState, socketState);
toSocket.BeforeTransition.Add(() => {
OG.Context.TransformManager.SetActiveGizmoType(TransformManager.NoGizmoType);
});
WorkflowTransition backToRectify = graph.AddTransition(socketState, rectifyState);
backToRectify.BeforeTransition.Add(() => {
OG.Context.TransformManager.SetActiveGizmoType(TransformManager.NoGizmoType);
});
// scan tool states
var trimScanTool = builder.AddState(OGWorkflow.TrimScanState, OGActions.BeginTrimScanTool);
builder.AddTransition(scanState, trimScanTool, OGWorkflow.TrimScanStartT, OGActions.CanTrimScan, null, null);
builder.AddTransition(trimScanTool, scanState, OGWorkflow.TrimScanAcceptT, OGActions.CanAcceptTrimScanTool, OGActions.AcceptTrimScanTool, null);
builder.AddTransition(trimScanTool, scanState, OGWorkflow.TrimScanCancelT, null, OGActions.CancelTrimScanTool, null);
var alignScanTool = builder.AddState(OGWorkflow.AlignScanState, OGActions.BeginAlignScanTool);
builder.AddTransition(scanState, alignScanTool, OGWorkflow.AlignScanStartT, OGActions.CanAlignScan, null, null);
builder.AddTransition(alignScanTool, scanState, OGWorkflow.AlignScanAcceptT, OGActions.CanAcceptAlignScanTool, OGActions.AcceptAlignScanTool, null);
builder.AddTransition(alignScanTool, scanState, OGWorkflow.AlignScanCancelT, null, OGActions.CancelAlignScanTool, null);
// rectify tool states
var drawAreaTool = builder.AddState(OGWorkflow.DrawAreaState, OGActions.BeginDrawAreaTool);
builder.AddTransition(rectifyState, drawAreaTool, OGWorkflow.DrawAreaStartT, OGActions.CanDrawArea, null, null);
builder.AddTransition(drawAreaTool, rectifyState, OGWorkflow.DrawAreaExitT, null, OGActions.EndDrawAreaTool, null);
var deformRingTool = builder.AddState(OGWorkflow.AddDeformRingState, OGActions.BeginDeformRingTool);
builder.AddTransition(rectifyState, deformRingTool, OGWorkflow.AddDeformRingStartT, OGActions.CanAddDeformRing, null, null);
builder.AddTransition(deformRingTool, rectifyState, OGWorkflow.AddDeformRingAcceptT, OGActions.CanAcceptDeformRingTool, OGActions.AcceptDeformRingTool, null);
builder.AddTransition(deformRingTool, rectifyState, OGWorkflow.AddDeformRingCancelT, null, OGActions.CancelDeformRingTool, null);
var sculptAreaTool = builder.AddState(OGWorkflow.SculptAreaState, OGActions.BeginSculptCurveTool);
builder.AddTransition(rectifyState, sculptAreaTool, OGWorkflow.SculptAreaStartT, OGActions.CanSculptCurve, null, null);
builder.AddTransition(sculptAreaTool, rectifyState, OGWorkflow.SculptAreaExitT, null, OGActions.EndSculptCurveTool, null);
// socket tool states
var drawTrimlineTool = builder.AddState(OGWorkflow.DrawTrimlineState, OGActions.BeginDrawTrimLineTool);
builder.AddTransition(socketState, drawTrimlineTool, OGWorkflow.DrawTrimlineStartT, OGActions.CanDrawTrimLine, null, null);
builder.AddTransition(drawTrimlineTool, socketState, OGWorkflow.DrawTrimlineExitT, null, OGActions.EndDrawTrimLineTool, null);
var planeTrimlineTool = builder.AddState(OGWorkflow.PlaneTrimlineState, OGActions.BeginPlaneTrimLineTool);
builder.AddTransition(socketState, planeTrimlineTool, OGWorkflow.PlaneTrimlineStartT, OGActions.CanAddPlaneTrimLine, null, null);
builder.AddTransition(planeTrimlineTool, socketState, OGWorkflow.PlaneTrimlineAcceptT, OGActions.CanAcceptPlaneTrimLineTool, OGActions.AcceptPlaneTrimLineTool, null);
builder.AddTransition(planeTrimlineTool, socketState, OGWorkflow.PlaneTrimlineCancelT, null, OGActions.CancelPlaneTrimLineTool, null);
var sculptTrimlineTool = builder.AddState(OGWorkflow.SculptTrimlineState, OGActions.BeginSculptCurveTool);
builder.AddTransition(socketState, sculptTrimlineTool, OGWorkflow.SculptTrimlineStartT, OGActions.CanSculptCurve, null, null);
builder.AddTransition(sculptTrimlineTool, socketState, OGWorkflow.SculptTrimlineExitT, null, OGActions.EndSculptCurveTool, null);
graph.LogF = DebugUtil.Log; // print debug output
return(graph);
}
private WorkflowRuntime CreateRuntimeRavenDB()
{
var provider = new RavenDBProvider(new Raven.Client.Document.DocumentStore()
{
Url = Parameters.DBUrl,
DefaultDatabase = Parameters.Database
});
callbackProvider = new WorkflowCallbackProvider(Parameters, provider);
var builder = new WorkflowBuilder<XElement>(callbackProvider, new XmlWorkflowParser(), provider).WithDefaultCache();
return new WorkflowRuntime(Parameters.RuntimeId)
.WithBuilder(builder)
.WithPersistenceProvider(provider);
}
