private void StopWorkflows()
{
logger.LogVerbose("Stopping configured workflows");
if (stoppedWorkflows.Count > 0)
{
throw new ValidationException("There are alredy stopped workflows, activate them first!");
}
List <WorkflowEntity> allWorkflows = processRepository.GetAllWorkflows().Where(p => p.WfType == WorkflowType.Definition && (p.WfCategory == WorkflowCategory.Workflow || p.WfCategory == WorkflowCategory.BusinessRule)).ToList();
if (workflows == null)
{
workflows = allWorkflows.Select(p => p.Name).ToList();
}
if (workflows != null && workflows.Count > 0)
{
foreach (var item in workflows)
{
WorkflowEntity wkflow = allWorkflows.FirstOrDefault(p => p.Name == item);
if (wkflow != null && wkflow.WfState == WorkflowState.Activated)
{
DeactivateWorkflow(wkflow);
}
else
{
logger.LogVerbose($"Workflows {item} does not exist or is already stopped");
}
}
}
}
public void CanCreateSaveUpdateAndComplete()
{
IWorkflowEntity toReturn = new WorkflowEntity();
_workflowPersister.Expect(p => p.CreateEmptyWorkflowEntity(Guid.Empty)).IgnoreArguments().Repeat.Times(1).Return(toReturn);
_workflowPersister.Expect(p => p.Load(Guid.Empty)).IgnoreArguments().Repeat.Times(2).Return(toReturn);
_workflowPersister.Expect(p => p.Save(toReturn));
_workflowPersister.Expect(p => p.Update(toReturn));
_workflowPersister.Expect(p => p.Complete(toReturn));
IStateMachineContext machineContext = _workflowService.Start(@"simplestatemachine.boo");
Assert.IsNotNull(machineContext);
Assert.IsTrue(machineContext.IsStarted);
Assert.AreEqual("Initial", machineContext.CurrentState.StateName);
// should trigger the Update
machineContext.HandleEvent(1);
Assert.AreEqual("First", machineContext.CurrentState.StateName);
// should trigger the Complete
machineContext.HandleEvent(3);
_workflowPersister.VerifyAllExpectations();
}
// Si la actividad devuelve un valor, se debe derivar de CodeActivity<TResult>
// y devolver el valor desde el método Execute.
protected override void Execute(CodeActivityContext context)
{
logger.Info("WorkflowInstanceId={0} Step2", context.WorkflowInstanceId);
WorkflowEntity dataEntry = context.GetValue(this.Entry);
List <ParkingEntity> dataEntryParking = context.GetValue(this.EntryParking);
for (int i = 0; i < dataEntryParking.Count; i++)
{
string jObject = @"{""payload"": ""{\""{0}\"": " +
@"\""" + dataEntry.IdPlaces[i] + @"\""" +
@"}"" , ""deviceId"": """ +
service +
@"""}";
logger.Info("Step2 jObject: {0}", jObject);
logger.Info("Step2 Mapper- init");
Mapper mapper = new Mapper();
var result = mapper.Execute(jObject, new Foursquare());
logger.Info("Step2 Mapper- final");
float rating = float.Parse(result.Response.Venue.Rating.ToString(new NumberFormatInfo()
{
NumberDecimalSeparator = "."
})) / float.Parse("2.0");
dataEntryParking.ElementAt(i).Ranking = rating;
logger.Info("Step2 google rating{0}", rating);
}
this.Out.Set(context, dataEntryParking);
}
public void SaveAndLoad()
{
var filePersister = new FilePersister(string.Empty);
WorkflowEntity workflowEntity = new WorkflowEntity
{
CurrentState = "CurrentState",
DomainContextId = Guid.NewGuid(),
DomainContextStatusProperty = "DomainContextStatusProperty",
DomainContextTypeDescription = "DomainContextTypeDescription",
MachineConfiguration = "MachineConfiguration",
WorkflowId = Guid.NewGuid()
};
filePersister.Save(workflowEntity);
var path = string.Format("{0}.xml", workflowEntity.WorkflowId);
Assert.That(File.Exists(path));
var workflowEntity1 = filePersister.Load(workflowEntity.WorkflowId);
Assert.AreEqual(workflowEntity1.CurrentState, workflowEntity.CurrentState);
Assert.AreEqual(workflowEntity1.DomainContextId, workflowEntity.DomainContextId);
Assert.AreEqual(workflowEntity1.DomainContextStatusProperty, workflowEntity.DomainContextStatusProperty);
Assert.AreEqual(workflowEntity1.DomainContextTypeDescription, workflowEntity.DomainContextTypeDescription);
Assert.AreEqual(workflowEntity1.MachineConfiguration, workflowEntity.MachineConfiguration);
Assert.AreEqual(workflowEntity1.WorkflowId, workflowEntity.WorkflowId);
Assert.AreEqual(workflowEntity1.WorkflowId, workflowEntity.WorkflowId);
File.Delete(path);
}
public void CanPersistAndRestore()
{
IWorkflowEntity toReturn = new WorkflowEntity();
_workflowPersister.Expect(p => p.CreateEmptyWorkflowEntity(Guid.Empty)).IgnoreArguments().Return(toReturn);
_workflowPersister.Expect(p => p.Save(new WorkflowEntity())).IgnoreArguments().Callback <IWorkflowEntity>(x =>
{
toReturn = x;
return(true);
});
IStateMachineContext machineContext = _workflowService.Start(@"testStateMachine.boo");
Assert.IsNotNull(machineContext);
Assert.IsTrue(machineContext.IsStarted);
Assert.IsNotNull(toReturn);
Assert.That(Guid.Empty == toReturn.WorkflowId, Is.Not.True);
Assert.AreEqual("Initial", machineContext.CurrentState.StateName);
Assert.AreNotEqual(Guid.Empty, machineContext.Id);
_workflowPersister.Expect(p => p.Load(new Guid())).IgnoreArguments().Return(toReturn);
IStateMachineContext restoredMachine = _workflowService.Load(machineContext.Id);
Assert.AreNotSame(restoredMachine, _workflowService);
Assert.IsTrue(restoredMachine.IsStarted);
Assert.AreEqual(machineContext.CurrentState.StateName, restoredMachine.CurrentState.StateName);
_workflowPersister.VerifyAllExpectations();
}
/// <summary>
/// 点击关闭设置按钮的监听
/// </summary>
public void OnClickCloseSetting()
{
entity = (WorkflowEntity)workModel.DataEntity;
entity.SwitchToTargetWorkflow = "MaininterfaceWorkflowLogic";
var logic = workModel.GetComponent <SettingWorkflowLogic>();
SettingWorkflowLogic settingWorkflowLogic = logic;
settingWorkflowLogic.Execute();
}
/// <summary>
/// 点击关闭设置按钮的监听
/// </summary>
public void OnClickCloseHelp()
{
entity = (WorkflowEntity)workModel.DataEntity;
entity.SwitchToTargetWorkflow = "MaininterfaceWorkflowLogic";
HelpWorkflowLogic helpWorkflow = workModel.GetComponent <HelpWorkflowLogic>();
helpWorkflow.Execute();
//helpUIEntity.isShow = !helpUIEntity.isShow;
}
public static int CreateOrUpdateWorkflow(
IWorkflowService workflowService,
WorkflowEntity workflowEntity)
{
return(workflowService.DbConnection
.Query <int>(CommandBuilder.CreateOrUpdateWorkflow(workflowEntity),
workflowEntity)
.FirstOrDefault());
}
public void SetFullWorkflowElement(WorkflowEntity workflow, XElement element)
{
var model = (WorkflowReplacementModel?)this.customResolutionModel.TryGetCN(Guid.Parse(element.Attribute("Guid") !.Value));
var wie = new WorkflowImportExport(workflow)
{
ReplacementModel = model
};
wie.FromXml(element, this);
}
public void CanCreateUsingWorkflowServiceTest()
{
IWorkflowEntity toReturn = new WorkflowEntity();
_workflowPersister.Expect(p => p.CreateEmptyWorkflowEntity(Guid.Empty)).IgnoreArguments().Return(toReturn);
IStateMachineContext machineContext = _workflowService.Start(@"testStateMachine.boo");
Assert.IsNotNull(machineContext);
Assert.IsTrue(machineContext.IsStarted);
_workflowPersister.VerifyAllExpectations();
}
public WorkflowBuilder(WorkflowEntity wf)
{
using (HeavyProfiler.Log("WorkflowBuilder"))
using (new EntityCache())
{
this.workflow = wf;
List <WorkflowConnectionEntity> connections;
List <WorkflowEventEntity> events;
List <WorkflowActivityEntity> activities;
List <WorkflowGatewayEntity> gateways;
List <WorkflowLaneEntity> lanes;
List <WorkflowPoolEntity> poolEntities;
if (wf.IsNew)
{
connections = new List <WorkflowConnectionEntity>();
events = new List <WorkflowEventEntity>();
activities = new List <WorkflowActivityEntity>();
gateways = new List <WorkflowGatewayEntity>();
lanes = new List <WorkflowLaneEntity>();
poolEntities = new List <WorkflowPoolEntity>();
}
else
{
connections = wf.WorkflowConnections().ToList();
events = wf.WorkflowEvents().ToList();
activities = wf.WorkflowActivities().ToList();
gateways = wf.WorkflowGateways().ToList();
lanes = wf.WorkflowPools().SelectMany(a => a.WorkflowLanes()).ToList();
poolEntities = wf.WorkflowPools().ToList();
}
var xmlConnections = connections.Select(a => new XmlEntity <WorkflowConnectionEntity>(a)).ToList();
var nodes = events.Cast <IWorkflowNodeEntity>().Concat(activities).Concat(gateways).ToList();
this.pools = (from pool in poolEntities
let laneBuilders = (from lane in lanes
where lane.Pool.Is(pool)
select new LaneBuilder(lane,
activities.Where(a => a.Lane.Is(lane)),
events.Where(a => a.Lane.Is(lane)),
gateways.Where(a => a.Lane.Is(lane)),
xmlConnections.Where(c => c.Entity.From.Lane.Is(lane) || c.Entity.To.Lane.Is(lane))))
let sequenceFlows = xmlConnections.Where(c => c.Entity.From.Lane.Pool.Is(pool) && c.Entity.To.Lane.Pool.Is(pool))
select new PoolBuilder(pool, laneBuilders, sequenceFlows))
.ToDictionary(a => a.pool.Entity.ToLite());
this.messageFlows = xmlConnections.Where(c => !c.Entity.From.Lane.Pool.Is(c.Entity.To.Lane.Pool)).ToList();
}
}
public static PreviewResult PreviewChanges(WorkflowEntity workflow, WorkflowModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var document = XDocument.Parse(model.DiagramXml);
var wb = new WorkflowBuilder(workflow);
return(wb.PreviewChanges(document, model));
}
/// <summary>
/// Creates a new Workflow Designer instance (VB) with Intellisense
/// </summary>
/// <param name="sourceFile">Workflow FileName</param>
public static void NewInstanceVB(string sourceFile = _defaultWorkflow)
{
_expressionEditorServiceVB = new VbExpressionEditorService();
_wfDesigner = new WorkflowDesigner();
Hashtable hashTable = new Hashtable
{
{ WorkflowDesignerColors.DesignerViewShellBarControlBackgroundColorKey, SystemColors.HighlightBrush },
{ WorkflowDesignerColors.DesignerViewShellBarColorGradientBeginKey, SystemColors.HighlightBrush },
{ WorkflowDesignerColors.DesignerViewShellBarColorGradientEndKey, SystemColors.HighlightBrush },
};
_wfDesigner.PropertyInspectorFontAndColorData = System.Xaml.XamlServices.Save(hashTable);
_wfDesigner.Context.Services.GetService <DesignerConfigurationService>().TargetFrameworkName = new System.Runtime.Versioning.FrameworkName(".NETFramework", new Version(4, 5));
_wfDesigner.Context.Services.GetService <DesignerConfigurationService>().LoadingFromUntrustedSourceEnabled = true;
_wfDesigner.Context.Services.GetService <DesignerConfigurationService>().AutoConnectEnabled = true;
_wfDesigner.Context.Services.GetService <DesignerConfigurationService>().RubberBandSelectionEnabled = true;
_wfDesigner.Context.Services.Publish <IExpressionEditorService>(_expressionEditorServiceVB);
//associates all of the basic activities with their designers
new DesignerMetadata().Register();
//load Workflow Xaml
_wfDesigner.Load(sourceFile);
SelectHelper._wfDesigner = _wfDesigner;
if (!SelectHelper.WorkflowDictionary.ContainsKey(sourceFile))
{
SelectHelper.WorkflowDictionary.Add(sourceFile, _wfDesigner);
}
else
{
SelectHelper.WorkflowDictionary[sourceFile] = _wfDesigner;
}
if (!SelectHelper.RuntimeApplicationHelperDictionary.ContainsKey(sourceFile))
{
SelectHelper.RuntimeApplicationHelperDictionary.Add(sourceFile, new RuntimeApplicationHelper());
}
WorkflowEntity workflowEntity = new WorkflowEntity();
if (!SelectHelper.WorkflowEntityDictionary.ContainsKey(sourceFile))
{
SelectHelper.WorkflowEntityDictionary.Add(sourceFile, workflowEntity);
}
else
{
SelectHelper.WorkflowEntityDictionary[sourceFile] = workflowEntity;
}
}
public void SubmitForm(WorkflowEntity itemsEntity, string keyValue)
{
if (!string.IsNullOrEmpty(keyValue))
{
itemsEntity.Modify(keyValue);
service.Update(itemsEntity);
}
else
{
itemsEntity.Create();
service.Insert(itemsEntity);
}
}
private void DeactivateWorkflow(WorkflowEntity wkflow)
{
try
{
processRepository.DeActivateWorkflow(wkflow.Id);
stoppedWorkflows.Add(wkflow.Id);
logger.LogVerbose($"Workflows {wkflow.Name} has been stopped");
}
catch (Exception ex)
{
logger.LogWarning($"Cannot stop workflow {wkflow.Name} error {ex.Message} ");
}
}
public void CanPersistAndRestoreDomainContextWithStatusProperty()
{
var user = new User();
user.StatusChanged += user_StatusChanged;
_domainContextRepository.Expect(x => x.GetId(user)).Return(user.Id);
_domainContextRepository.Expect(x => x.GetTypeDescription(user)).Return("SimpleStateMachine.User");
_domainContextRepository.Expect(x => x.Save(user));
_domainContextRepository.Expect(x => x.Load("SimpleStateMachine.User", user.Id)).Return(new User());
IWorkflowEntity toReturn = new WorkflowEntity();
_workflowPersister.Expect(p => p.CreateEmptyWorkflowEntity(Guid.Empty)).IgnoreArguments().Return(toReturn);
_workflowPersister.Expect(p => p.Save(new WorkflowEntity())).IgnoreArguments().Callback <IWorkflowEntity>(x =>
{
toReturn = x;
return(true);
});
IStateMachineContext machineContext = _workflowService.Start(@"testStateMachine.boo", user, "CurrentStatus");
Assert.IsNotNull(machineContext);
Assert.IsTrue(machineContext.IsStarted);
Assert.AreEqual(user.CurrentStatus, machineContext.CurrentState.StateIdentifier);
Assert.AreEqual(1, _userStateChangedCount);
_workflowPersister.Expect(p => p.Load(new Guid())).IgnoreArguments().Return(toReturn);
IStateMachineContext restoredMachine = _workflowService.Load(machineContext.Id);
Assert.IsAssignableFrom(typeof(ReflectiveDomainContextWrapper), restoredMachine.DomainContext);
var contextWrapper = (ReflectiveDomainContextWrapper)restoredMachine.DomainContext;
Assert.IsAssignableFrom(typeof(User), contextWrapper.DomainContext);
// should be the newly loaded user.
Assert.AreNotEqual(contextWrapper.DomainContext, user);
Assert.AreNotEqual(((User)contextWrapper.DomainContext).Id, user.Id);
// state changed should not have been called!
// is it up to the domain context repository to restore the state of the domain context.
Assert.AreEqual(1, _userStateChangedCount);
_domainContextRepository.VerifyAllExpectations();
_workflowPersister.VerifyAllExpectations();
}
public WorkflowImportExport(WorkflowEntity wf)
{
using (HeavyProfiler.Log("WorkflowBuilder"))
using (new EntityCache())
{
this.workflow = wf;
this.connections = wf.IsNew ? new Dictionary <string, WorkflowConnectionEntity>() : wf.WorkflowConnections().ToDictionaryEx(a => a.BpmnElementId);
this.events = wf.IsNew ? new Dictionary <string, WorkflowEventEntity>() : wf.WorkflowEvents().ToDictionaryEx(a => a.BpmnElementId);
this.activities = wf.IsNew ? new Dictionary <string, WorkflowActivityEntity>() : wf.WorkflowActivities().ToDictionaryEx(a => a.BpmnElementId);
this.gateways = wf.IsNew ? new Dictionary <string, WorkflowGatewayEntity>() : wf.WorkflowGateways().ToDictionaryEx(a => a.BpmnElementId);
this.lanes = wf.IsNew ? new Dictionary <string, WorkflowLaneEntity>() : wf.WorkflowPools().SelectMany(a => a.WorkflowLanes()).ToDictionaryEx(a => a.BpmnElementId);
this.pools = wf.IsNew ? new Dictionary <string, WorkflowPoolEntity>() : wf.WorkflowPools().ToDictionaryEx(a => a.BpmnElementId);
}
}
/// <summary>
/// 初始化工作流
/// </summary>
public void Start()
{
workModel = FindObjectOfType <WorkflowDataModel>();
entity = (WorkflowEntity)workModel.DataEntity;
entity.SwitchToTargetWorkflow = "MaininterfaceWorkflowLogic";
var model1 = objSetting.GetComponent <DataModelBehaviour>();
setEntity = (SetUIEntity)model1.DataEntity;
var model2 = objHelp.GetComponent <DataModelBehaviour>();
helpUIEntity = (HelpUIEntity)model2.DataEntity;
var trans = GameObject.Find("Context");
var model3 = trans.GetComponent <DataModelBehaviour>();
showTextEntity = (ShowTextEntity)model3.DataEntity;
}
internal void Clone(WorkflowEntity wf, Dictionary <IWorkflowNodeEntity, IWorkflowNodeEntity> nodes)
{
var oldPool = this.pool.Entity;
var newPool = new WorkflowPoolEntity
{
Workflow = wf,
Name = oldPool.Name,
BpmnElementId = oldPool.BpmnElementId,
Xml = oldPool.Xml,
}.Save();
foreach (var lb in this.lanes.Values)
{
lb.Clone(newPool, nodes);
}
}
public WorkflowBuilder(WorkflowEntity wf)
{
using (HeavyProfiler.Log("WorkflowBuilder"))
using (new EntityCache())
{
this.workflow = wf;
List <WorkflowConnectionEntity> connections;
List <WorkflowEventEntity> events;
List <WorkflowActivityEntity> activities;
List <WorkflowGatewayEntity> gateways;
if (wf.IsNew)
{
connections = new List <WorkflowConnectionEntity>();
events = new List <WorkflowEventEntity>();
activities = new List <WorkflowActivityEntity>();
gateways = new List <WorkflowGatewayEntity>();
}
else
{
connections = wf.WorkflowConnections().ToList();
events = wf.WorkflowEvents().ToList();
activities = wf.WorkflowActivities().ToList();
gateways = wf.WorkflowGateways().ToList();
}
var xmlConnections = connections.Select(a => new XmlEntity <WorkflowConnectionEntity>(a)).ToList();
var nodes = events.Cast <IWorkflowNodeEntity>().Concat(activities).Concat(gateways).ToList();
this.pools = (from n in nodes
group n by n.Lane into grLane
select new LaneBuilder(grLane.Key,
grLane.OfType <WorkflowActivityEntity>(),
grLane.OfType <WorkflowEventEntity>(),
grLane.OfType <WorkflowGatewayEntity>(),
xmlConnections.Where(c => c.Entity.From.Lane.Is(grLane.Key) || c.Entity.To.Lane.Is(grLane.Key))) into lb
group lb by lb.lane.Entity.Pool into grPool
select new PoolBuilder(grPool.Key, grPool, xmlConnections.Where(c => c.Entity.From.Lane.Pool.Is(grPool.Key) && c.Entity.To.Lane.Pool.Is(grPool.Key))))
.ToDictionary(pb => pb.pool.Entity.ToLite());
this.messageFlows = xmlConnections.Where(c => !c.Entity.From.Lane.Pool.Is(c.Entity.To.Lane.Pool)).ToList();
}
}
public static string CreateOrUpdateWorkflow(WorkflowEntity workflowEntity)
{
return($@"
INSERT INTO `workflows` (
`current_state`,
`uuid`,
`workflow_name`,
`date_created`,
`date_modified`,
`is_active`)
VALUES (@{nameof(workflowEntity.CurrentState)},
@{nameof(workflowEntity.Uuid)},
@{nameof(workflowEntity.WorkflowName)},
utc_timestamp(3),
utc_timestamp(3),
@{nameof(workflowEntity.IsActive)})
ON DUPLICATE KEY UPDATE `current_state` = @{nameof(workflowEntity.CurrentState)},
`date_modified` = utc_timestamp(3);");
}
private void InitialiseWorkflow(string workflowName)
{
if (workflowName is null)
{
throw new NullReferenceException("The workflow specified is null");
}
var workflow = new WorkflowEntity
{
CurrentState = StateManager.GlobalState.Initialise,
Uuid = Guid.NewGuid(),
IsActive = true,
WorkflowName = workflowName,
DateCreated = DateTime.UtcNow
};
StateflowDbContext
.Commands
.CreateOrUpdateWorkflow(this, workflow);
}
public void CanPersistAndRestoreDomainContext()
{
var user = new User();
user.StatusChanged += user_StatusChanged;
_domainContextRepository.Expect(x => x.GetId(user)).Return(user.Id);
_domainContextRepository.Expect(x => x.GetTypeDescription(user)).Return("SimpleStateMachine.User");
_domainContextRepository.Expect(x => x.Save(user));
_domainContextRepository.Expect(x => x.Load("SimpleStateMachine.User", user.Id)).Return(new User());
IWorkflowEntity toReturn = new WorkflowEntity();
_workflowPersister.Expect(p => p.CreateEmptyWorkflowEntity(Guid.Empty)).IgnoreArguments().Return(toReturn);
_workflowPersister.Expect(p => p.Save(new WorkflowEntity())).IgnoreArguments().Callback <IWorkflowEntity>(x =>
{
toReturn = x;
return(true);
});
IStateMachineContext machineContext = _workflowService.Start(@"testStateMachine.boo", user);
Assert.IsNotNull(machineContext);
Assert.IsTrue(machineContext.IsStarted);
_workflowPersister.Expect(p => p.Load(new Guid())).IgnoreArguments().Return(toReturn);
IStateMachineContext restoredMachine = _workflowService.Load(machineContext.Id);
Assert.IsAssignableFrom(typeof(User), restoredMachine.DomainContext);
// should be the newly loaded user.
Assert.AreNotEqual(restoredMachine.DomainContext, user);
Assert.AreNotEqual(((User)restoredMachine.DomainContext).Id, user.Id);
// should have never been called
Assert.AreEqual(0, _userStateChangedCount);
_domainContextRepository.VerifyAllExpectations();
_workflowPersister.VerifyAllExpectations();
}
// Si la actividad devuelve un valor, se debe derivar de CodeActivity<TResult>
// y devolver el valor desde el método Execute.
protected override void Execute(CodeActivityContext context)
{
logger.Info("WorkflowInstanceId={0} Step3", context.WorkflowInstanceId);
WorkflowEntity dataEntry = context.GetValue(this.Entry);
List <ParkingEntity> dataEntryParking = context.GetValue(this.EntryParking);
for (int i = 0; i < dataEntryParking.Count; i++)
{
string jObject = @"{""payload"": ""{\""{0}\"": " +
dataEntry.LatitudeOrigins[i].ToString(new NumberFormatInfo()
{
NumberDecimalSeparator = "."
}) +
@",\""{1}\"":" +
dataEntry.LongitudeOrigins[i].ToString(new NumberFormatInfo()
{
NumberDecimalSeparator = "."
}) +
@"}"" , ""deviceId"": """ +
service +
@"""}";
logger.Info("Step3 jObject: {0}", jObject);
logger.Info("Step3 Mapper- init");
Mapper mapper = new Mapper();
var result = mapper.Execute(jObject, new Openweathermap());
logger.Info("Step3 Mapper- final");
float temp = float.Parse(result.Main.Temp.ToString(new NumberFormatInfo()
{
NumberDecimalSeparator = "."
}));
dataEntryParking.ElementAt(i).Temperature = temp;
logger.Info("Step3 temp{0}", temp);
}
this.Out.Set(context, dataEntryParking);
this.OutFinal.Set(context, dataEntryParking.ToArray());
}
public static void ApplyDocument(WorkflowEntity workflow, WorkflowModel model, WorkflowReplacementModel replacements)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var wb = new WorkflowBuilder(workflow);
if (workflow.IsNew)
{
workflow.Save();
}
wb.ApplyChanges(model, replacements);
wb.ValidateGraph();
workflow.FullDiagramXml = new WorkflowXmlEmbedded {
DiagramXml = wb.GetXDocument().ToString()
};
workflow.Save();
}
public void IdOfContextMatchesIdOfLoadedMachineTest()
{
IWorkflowEntity toReturn = new WorkflowEntity();
_workflowPersister.Expect(p => p.CreateEmptyWorkflowEntity(Guid.Empty)).IgnoreArguments().Return(toReturn);
_workflowPersister.Expect(p => p.Save(new WorkflowEntity())).IgnoreArguments().Callback <IWorkflowEntity>(x =>
{
toReturn = x;
return(true);
});
IStateMachineContext machineContext = _workflowService.Start(@"testStateMachine.boo");
Assert.IsNotNull(machineContext);
Assert.IsTrue(machineContext.IsStarted);
_workflowPersister.Expect(p => p.Load(new Guid())).IgnoreArguments().Return(toReturn);
IStateMachineContext restoredMachine = _workflowService.Load(machineContext.Id);
Assert.AreEqual(restoredMachine.Id, machineContext.Id);
}
public XElement GetFullWorkflowElement(WorkflowEntity workflow)
{
var wie = new WorkflowImportExport(workflow);
return(wie.ToXml(this));
}
public static IEnumerable <WorkflowConnectionEntity> WorkflowConnectionsFromCache(this WorkflowEntity e)
{
return(GetWorkflowNodeGraph(e.ToLite()).NextGraph.EdgesWithValue.SelectMany(edge => edge.Value));
}
public static IQueryable <WorkflowConnectionEntity> WorkflowConnections(this WorkflowEntity e)
{
return(WorkflowConnectionsExpression.Evaluate(e));
}
public static IEnumerable <WorkflowGatewayEntity> WorkflowGatewaysFromCache(this WorkflowEntity e)
{
return(GetWorkflowNodeGraph(e.ToLite()).NextGraph.OfType <WorkflowGatewayEntity>());
}
