public async Task <WorkflowDefinitionVersion> PublishAsync(
WorkflowDefinitionVersion workflowDefinition,
CancellationToken cancellationToken)
{
var definition = mapper.Map <WorkflowDefinitionVersion>(workflowDefinition);
var publishedDefinition = await store.GetByIdAsync(
definition.DefinitionId,
VersionOptions.Published,
cancellationToken);
if (publishedDefinition != null)
{
publishedDefinition.IsPublished = false;
publishedDefinition.IsLatest = false;
await store.UpdateAsync(publishedDefinition, cancellationToken);
}
if (definition.IsPublished)
{
definition.Id = idGenerator.Generate();
definition.Version++;
}
else
{
definition.IsPublished = true;
}
definition.IsLatest = true;
definition = Initialize(definition);
await store.SaveAsync(definition, cancellationToken);
return(definition);
}
public async Task <WorkflowDefinitionVersion> SaveDraftAsync(
WorkflowDefinitionVersion workflowDefinition,
CancellationToken cancellationToken)
{
var draft = mapper.Map <WorkflowDefinitionVersion>(workflowDefinition);
var latestVersion = await store.GetByIdAsync(
workflowDefinition.DefinitionId,
VersionOptions.Latest,
cancellationToken);
if (latestVersion != null && latestVersion.IsPublished && latestVersion.IsLatest)
{
latestVersion.IsLatest = false;
draft.Id = idGenerator.Generate();
draft.Version++;
await store.UpdateAsync(latestVersion, cancellationToken);
}
draft.IsLatest = true;
draft.IsPublished = false;
draft = Initialize(draft);
await store.SaveAsync(draft, cancellationToken);
return(draft);
}
/// <summary>
/// 创建工作流
/// </summary>
/// <param name="definition"></param>
/// <param name="input"></param>
/// <param name="workflowInstance"></param>
/// <param name="correlationId"></param>
/// <returns></returns>
public Workflow CreateWorkflow(
WorkflowDefinitionVersion definition,
Variables input = default,
WorkflowInstance workflowInstance = default,
string correlationId = default)
{
if (definition.IsDisabled)//工作流定义已经禁用
{
throw new InvalidOperationException("Cannot instantiate disabled workflow definitions.");
}
var activities = CreateActivities(definition.Activities).ToList(); //创建节点
var connections = CreateConnections(definition.Connections, activities); //创建连线
var id = idGenerator.Generate(); //生成Id
var workflow = new Workflow(
id,
definition,
clock.GetCurrentInstant(),
activities,
connections,
input,
correlationId);
if (workflowInstance != default)
{
workflow.Initialize(workflowInstance);
}
return(workflow);
}
private static async Task Main(string[] args)
{
// Setup a service collection.
var services = new ServiceCollection()
.AddElsa()
.AddConsoleActivities()
.BuildServiceProvider();
// Define a workflow as data so we can store it somewhere (file, database, etc.).
var workflowDefinition = new WorkflowDefinitionVersion
{
Activities = new[]
{
new ActivityDefinition <WriteLine>("activity-1", new { TextExpression = new LiteralExpression("Hello world!") }),
new ActivityDefinition <WriteLine>("activity-2", new { TextExpression = new LiteralExpression("Goodbye cruel world...") })
},
Connections = new []
{
new ConnectionDefinition("activity-1", "activity-2", OutcomeNames.Done),
}
};
// Run the workflow.
var invoker = services.GetService <IWorkflowInvoker>();
await invoker.StartAsync(workflowDefinition);
Console.ReadLine();
}
public async Task AddAsync(WorkflowDefinitionVersion definition, CancellationToken cancellationToken = default)
{
var document = mapper.Map <WorkflowDefinitionVersionDocument>(definition);
session.Save(document);
await session.CommitAsync();
}
public async Task AddAsync(WorkflowDefinitionVersion definition, CancellationToken cancellationToken = default)
{
var document = Map(definition);
await dbContext.WorkflowDefinitionVersions.AddAsync(document, cancellationToken);
await dbContext.SaveChangesAsync(cancellationToken);
}
public async Task <AWFDefinitionCreateResponse> CreateDefinitionAsync(WorkflowDefinitionEditModel model, CancellationToken cancellationToken)
{
var workflow = new WorkflowDefinitionVersion();
var postedWorkflow = _serializer.Deserialize <WorkflowModel>(model.Json, JsonTokenFormatter.FormatName);
workflow.Activities = postedWorkflow.Activities
.Select(x => new ActivityDefinition(x.Id, x.Type, x.State, x.Left, x.Top))
.ToList();
workflow.Connections = postedWorkflow.Connections.Select(
x => new ConnectionDefinition(x.SourceActivityId, x.DestinationActivityId, x.Outcome)).ToList();
workflow.Description = model.Description;
workflow.Name = model.Name;
workflow.IsDisabled = model.IsDisabled;
workflow.IsSingleton = model.IsSingleton;
var publish = model.SubmitAction == "publish";
if (publish)
{
workflow = await _publisher.PublishAsync(workflow, cancellationToken);
}
else
{
workflow = await _publisher.SaveDraftAsync(workflow, cancellationToken);
}
return(_mapper.Map <AWFDefinitionCreateResponse>(workflow));
}
private Activity GetWorkflowDefinition(WorkflowServiceParameter param)
{
var wfDefVersionRepository = WorkflowServiceEngine.Instance.WorkflowContainerManager.Resolve <IRepository <WorkflowDefinitionVersion> >();
var wfDefVersion = new WorkflowDefinitionVersion();
string xaml = "";
//if starting workflow
if (param.WorkflowDefinitionId == 0)
{
//get the latest version of the default wf def
wfDefVersion = wfDefVersionRepository.GetAll()
.Where(w => w.WorkflowDefinition.EntityType == param.EntityType && w.WorkflowDefinition.IsDefault == true)
.OrderByDescending(w => w.WorkflowVersion)
.First();
param.WorkflowDefinitionId = wfDefVersion.WorkflowDefinitionId.Value;
}
else if (param.WorkflowVersion == 0)
{
//get the latest version of the specified wf def
wfDefVersion = wfDefVersionRepository.GetAll()
.Where(w => w.WorkflowDefinition.EntityType == param.EntityType && w.WorkflowDefinition.Id == param.WorkflowDefinitionId)
.OrderByDescending(w => w.WorkflowVersion)
.First();
}
else
{
//get the specified version of the specified wf def
wfDefVersion = wfDefVersionRepository.GetAll()
.Where(w => w.WorkflowDefinition.EntityType == param.EntityType && w.WorkflowDefinition.Id == param.WorkflowDefinitionId &&
w.WorkflowVersion == param.WorkflowVersion)
.OrderByDescending(w => w.WorkflowVersion)
.First();
}
xaml = wfDefVersion.WorkflowXamlFileContent;
string _byteOrderMarkUtf8 = Encoding.UTF8.GetString(Encoding.UTF8.GetPreamble());
if (xaml.StartsWith(_byteOrderMarkUtf8))
{
var lastIndexOfUtf8 = _byteOrderMarkUtf8.Length - 1;
xaml = xaml.Remove(0, lastIndexOfUtf8);
}
//Load workflow definition from xaml
ActivityXamlServicesSettings settings = new ActivityXamlServicesSettings
{
CompileExpressions = true
};
XamlXmlReaderSettings xamlReaderSettings = new XamlXmlReaderSettings {
LocalAssembly = typeof(ReceiptWorkflow).Assembly
};
var stream = new MemoryStream(Encoding.UTF8.GetBytes(xaml));
XamlReader xamlReader = new XamlXmlReader(stream, xamlReaderSettings);
var activity = ActivityXamlServices.Load(xamlReader, settings);
return(activity);
}
public async Task <WorkflowDefinitionVersion> UpdateAsync(WorkflowDefinitionVersion definition, CancellationToken cancellationToken = default)
{
var updatedDefinition = await decoratedStore.UpdateAsync(definition, cancellationToken);
await PublishUpdateEventAsync(cancellationToken);
return(updatedDefinition);
}
public async Task <WorkflowDefinitionVersion> AddAsync(WorkflowDefinitionVersion definition, CancellationToken cancellationToken = default)
{
var result = await decoratedStore.AddAsync(definition, cancellationToken);
await PublishUpdateEventAsync(cancellationToken);
return(result);
}
public async Task <WorkflowDefinitionVersion> UpdateAsync(WorkflowDefinitionVersion definition, CancellationToken cancellationToken = default)
{
var document = Map(definition);
var client = storage.Client;
await client.UpsertDocumentWithRetriesAsync(storage.CollectionUri, document, cancellationToken : cancellationToken);
return(Map(document));
}
public async Task <WorkflowDefinitionVersion> SaveAsync(WorkflowDefinitionVersion definition, CancellationToken cancellationToken = default)
{
var document = Map(definition);
var client = await GetDocumentClient();
await client.UpsertDocumentWithRetriesAsync(GetCollectionUri(), document, cancellationToken : cancellationToken);
return(definition);
}
public async Task <WorkflowDefinitionVersion> AddAsync(WorkflowDefinitionVersion definition, CancellationToken cancellationToken = default)
{
var entity = Map(definition);
await dbContext.WorkflowDefinitionVersions.AddAsync(entity, cancellationToken);
await dbContext.SaveChangesAsync(cancellationToken);
return(Map(entity));
}
public async Task <WorkflowDefinitionVersion> UpdateAsync(WorkflowDefinitionVersion definition, CancellationToken cancellationToken)
{
var existingDefinition = await GetByIdAsync(definition.Id, VersionOptions.SpecificVersion(definition.Version), cancellationToken);
var index = definitions.IndexOf(existingDefinition);
definitions[index] = definition;
return(definition);
}
public async Task AddAsync(WorkflowDefinitionVersion definition, CancellationToken cancellationToken = default)
{
var existingDefinition = await GetByIdAsync(definition.Id, VersionOptions.SpecificVersion(definition.Version), cancellationToken);
if (existingDefinition != null)
{
throw new ArgumentException($"A workflow definition with ID '{definition.Id}' and version '{definition.Version}' already exists.");
}
definitions.Add(definition);
}
public async Task <WorkflowDefinitionVersion> AddAsync(
WorkflowDefinitionVersion definition,
CancellationToken cancellationToken = default)
{
var dest = Map(definition);
var entity = await _workflowDefinitionVersionService.Add(dest);
var result = Map(entity);
return(result);
}
public async Task <WorkflowDefinitionVersion> SaveAsync(
WorkflowDefinitionVersion definition,
CancellationToken cancellationToken = default)
{
var exisitingEntity = await _workflowDefinitionVersionService.GetByVersionId(definition.Id);
if (exisitingEntity == null)
{
return(await AddAsync(definition, cancellationToken));
}
return(await UpdateAsync(definition, cancellationToken));
}
public async Task <WorkflowDefinitionVersion> UpdateAsync(WorkflowDefinitionVersion definition,
CancellationToken cancellationToken)
{
await workflowDefinitionCollection.ReplaceOneAsync(
x => x.Id == definition.Id && x.Version == definition.Version,
definition,
new UpdateOptions { IsUpsert = false },
cancellationToken
);
return(definition);
}
public Task <WorkflowExecutionContext> StartAsync(
WorkflowDefinitionVersion workflowDefinition,
Variables input = default,
IEnumerable <string> startActivityIds = default,
string correlationId = default,
CancellationToken cancellationToken = default)
{
var workflow = workflowFactory.CreateWorkflow(workflowDefinition, input, correlationId: correlationId);
var startActivities = workflow.Activities.Find(startActivityIds);
return(ExecuteAsync(workflow, false, startActivities, cancellationToken));
}
public async Task <WorkflowDefinitionVersion> UpdateAsync(
WorkflowDefinitionVersion definition,
CancellationToken cancellationToken)
{
var document = await dbContext.WorkflowDefinitionVersions.FindAsync(definition.Id);
document = mapper.Map(definition, document);
dbContext.WorkflowDefinitionVersions.Update(document);
await dbContext.SaveChangesAsync(cancellationToken);
return(Map(document));
}
public WorkflowInstanceDetailsModel(
WorkflowInstance workflowInstance,
WorkflowDefinitionVersion workflowDefinition,
WorkflowModel workflowModel,
IEnumerable <ActivityDescriptor> activityDefinitions,
string returnUrl)
{
WorkflowInstance = workflowInstance;
WorkflowDefinition = workflowDefinition;
WorkflowModel = workflowModel;
ActivityDefinitions = activityDefinitions.ToArray();
ReturnUrl = returnUrl;
}
public static IEnumerable <ActivityDefinition> GetStartActivities(this WorkflowDefinitionVersion workflow)
{
var destinationActivityIds =
workflow.Connections.Select(x => x.DestinationActivityId).Distinct().ToLookup(x => x);
var query =
from activity in workflow.Activities
where !destinationActivityIds.Contains(activity.Id)
select activity;
var activities = query.ToArray();
return(activities.Any() ? activities : workflow.Activities.Take(1));
}
public async Task <WorkflowDefinitionVersion> SaveAsync(
WorkflowDefinitionVersion definition,
CancellationToken cancellationToken = default)
{
var document = Map(definition);
await dbContext.WorkflowDefinitionVersions.Upsert(document)
.On(x => new { x.Id })
.RunAsync(cancellationToken);
await dbContext.SaveChangesAsync(cancellationToken);
return(definition);
}
public async Task <WorkflowDefinitionVersion> SaveAsync(WorkflowDefinitionVersion definition, CancellationToken cancellationToken = default)
{
var existingDefinition = await GetByIdAsync(definition.Id, VersionOptions.SpecificVersion(definition.Version), cancellationToken);
if (existingDefinition == null)
{
await AddAsync(definition, cancellationToken);
}
else
{
await UpdateAsync(definition, cancellationToken);
}
return(definition);
}
public async Task <WorkflowDefinitionVersion> SaveAsync(WorkflowDefinitionVersion definition, CancellationToken cancellationToken = default)
{
var existingEntity =
await dbContext
.WorkflowDefinitionVersions
.Include(x => x.Activities)
.Include(x => x.Connections)
.FirstOrDefaultAsync(x => x.VersionId == definition.Id, cancellationToken);
if (existingEntity == null)
{
return(await AddAsync(definition, cancellationToken));
}
return(await UpdateAsync(definition, cancellationToken));
}
public WorkflowDefinitionVersion New()
{
var definition = new WorkflowDefinitionVersion
{
Id = idGenerator.Generate(),
DefinitionId = idGenerator.Generate(),
Name = "New Workflow",
Version = 1,
IsLatest = true,
IsPublished = false,
IsSingleton = false,
IsDisabled = false
};
return(definition);
}
private async Task <WorkflowDefinitionListItemModel> CreateWorkflowDefinitionListItemModelAsync(
WorkflowDefinitionVersion workflowDefinition,
CancellationToken cancellationToken)
{
var instances = await workflowInstanceStore
.ListByDefinitionAsync(workflowDefinition.DefinitionId, cancellationToken)
.ToListAsync();
return(new WorkflowDefinitionListItemModel
{
WorkflowDefinition = workflowDefinition,
AbortedCount = instances.Count(x => x.Status == WorkflowStatus.Aborted),
FaultedCount = instances.Count(x => x.Status == WorkflowStatus.Faulted),
FinishedCount = instances.Count(x => x.Status == WorkflowStatus.Finished),
ExecutingCount = instances.Count(x => x.Status == WorkflowStatus.Executing),
});
}
public Workflow(
string id,
WorkflowDefinitionVersion definition,
Instant createdAt,
IEnumerable <IActivity> activities,
IEnumerable <Connection> connections,
Variables input = default,
string correlationId = default) : this()
{
Id = id;
Definition = definition;
CreatedAt = createdAt;
CorrelationId = correlationId;
Activities = activities.ToList();
Connections = connections.ToList();
Input = new Variables(input ?? Variables.Empty);
}
public async Task <WorkflowDefinitionVersion> UpdateAsync(
WorkflowDefinitionVersion definition,
CancellationToken cancellationToken)
{
var query = session
.Query <WorkflowDefinitionVersionDocument, WorkflowDefinitionIndex>()
.Where(x => x.WorkflowDefinitionId == definition.DefinitionId)
.WithVersion(VersionOptions.SpecificVersion(definition.Version));
var document = await query.FirstOrDefaultAsync();
document = mapper.Map(definition, document);
session.Save(document);
await session.CommitAsync();
return(mapper.Map <WorkflowDefinitionVersion>(document));
}
private async Task <IActionResult> SaveAsync(
WorkflowDefinitionEditModel model,
WorkflowDefinitionVersion workflow,
CancellationToken cancellationToken)
{
var postedWorkflow = serializer.Deserialize <WorkflowModel>(model.Json, JsonTokenFormatter.FormatName);
workflow.Activities = postedWorkflow.Activities
.Select(x => new ActivityDefinition(x.Id, x.Type, x.State, x.Left, x.Top))
.ToList();
workflow.Connections = postedWorkflow.Connections.Select(
x => new ConnectionDefinition(x.SourceActivityId, x.DestinationActivityId, x.Outcome)).ToList();
workflow.Description = model.Description;
workflow.Name = model.Name;
workflow.IsDisabled = model.IsDisabled;
workflow.IsSingleton = model.IsSingleton;
workflow.UserId = "";
var a = (((System.Security.Claims.ClaimsIdentity)HttpContext.User.Identity).Claims);
if (HttpContext.User.Identity != null && a.Count() > 0)
{
var w = a.ToList();
var e = w[0];
workflow.UserId = e.Value;
}
var publish = model.SubmitAction == "publish";
if (publish)
{
workflow = await publisher.PublishAsync(workflow, cancellationToken);
notifier.Notify("Workflow successfully published.", NotificationType.Success);
}
else
{
workflow = await publisher.SaveDraftAsync(workflow, cancellationToken);
notifier.Notify("Workflow successfully saved as a draft.", NotificationType.Success);
}
return(RedirectToRoute("EditWorkflowDefinition", new { id = workflow.DefinitionId }));
}
