public async Task <IEnumerable <CollectedWorkflow> > DispatchUserActionsAsync(TriggerUserAction taskAction, CancellationToken cancellationToken = default)
{
var bookmark = new UserTaskBookmark(taskAction.Action);
var query = new WorkflowsQuery(nameof(Activities.UserTask), bookmark, taskAction.CorrelationId, taskAction.WorkflowInstanceId);
return(await _workflowLaunchpad.CollectAndDispatchWorkflowsAsync(query, new WorkflowInput(taskAction.Action), cancellationToken : cancellationToken));
}
private async Task TriggerWorkflowsAsync(ServiceBusMessage message, CancellationToken cancellationToken)
{
var correlationId = message.CorrelationId;
var model = new MessageModel
{
Body = message.Body.ToArray(),
CorrelationId = message.CorrelationId,
ContentType = message.ContentType,
Label = message.Subject,
To = message.To,
MessageId = message.MessageId,
PartitionKey = message.PartitionKey,
ViaPartitionKey = message.TransactionPartitionKey,
ReplyTo = message.ReplyTo,
SessionId = message.SessionId,
TimeToLive = message.TimeToLive,
ReplyToSessionId = message.ReplyToSessionId,
ScheduledEnqueueTimeUtc = message.ScheduledEnqueueTime.UtcDateTime,
UserProperties = new Dictionary <string, object>(message.ApplicationProperties),
};
var bookmark = new MessageReceivedBookmark(QueueOrTopic, Subscription);
var launchContext = new WorkflowsQuery(ActivityType, bookmark, correlationId);
using var scope = _serviceScopeFactory.CreateScope();
var workflowLaunchpad = scope.ServiceProvider.GetRequiredService <IWorkflowLaunchpad>();
await workflowLaunchpad.CollectAndDispatchWorkflowsAsync(launchContext, new WorkflowInput(model), cancellationToken);
}
public async Task <IActionResult> Handle(TriggerWorkflowsRequestModel request, CancellationToken cancellationToken = default)
{
var tenantId = await _tenantAccessor.GetTenantIdAsync(cancellationToken);
var context = new WorkflowsQuery(request.ActivityType, request.Bookmark, request.CorrelationId, request.WorkflowInstanceId, request.ContextId, tenantId);
ICollection <TriggeredWorkflowModel> triggeredWorkflows;
if (request.Dispatch)
{
var result = await _workflowLaunchpad.CollectAndDispatchWorkflowsAsync(context, new WorkflowInput(request.Input), cancellationToken).ToList();
triggeredWorkflows = result.Select(x => new TriggeredWorkflowModel(x.WorkflowInstanceId, x.ActivityId)).ToList();
}
else
{
var result = await _workflowLaunchpad.CollectAndExecuteWorkflowsAsync(context, new WorkflowInput(request.Input), cancellationToken).ToList();
triggeredWorkflows = result.Select(x => new TriggeredWorkflowModel(x.WorkflowInstanceId, x.ActivityId)).ToList();
}
if (Response.HasStarted)
{
return(new EmptyResult());
}
return(Ok(new TriggerWorkflowsResponseModel(triggeredWorkflows)));
}
private async Task TriggerWorkflowsAsync(Message message, CancellationToken cancellationToken)
{
var correlationId = message.CorrelationId;
var model = new MessageModel
{
Body = message.Body,
CorrelationId = message.CorrelationId,
ContentType = message.ContentType,
Label = message.Label,
To = message.To,
MessageId = message.MessageId,
PartitionKey = message.PartitionKey,
ViaPartitionKey = message.ViaPartitionKey,
ReplyTo = message.ReplyTo,
SessionId = message.SessionId,
ExpiresAtUtc = message.ExpiresAtUtc,
TimeToLive = message.TimeToLive,
ReplyToSessionId = message.ReplyToSessionId,
ScheduledEnqueueTimeUtc = message.ScheduledEnqueueTimeUtc,
UserProperties = new Dictionary <string, object>(message.UserProperties),
};
var bookmark = CreateBookmark(message);
var launchContext = new WorkflowsQuery(ActivityType, bookmark, correlationId);
await _workflowLaunchpad.UseServiceAsync(service => service.CollectAndDispatchWorkflowsAsync(launchContext, new WorkflowInput(model), cancellationToken));
}
public async Task Consume(ConsumeContext <T> context)
{
var message = context.Message;
var correlationId = default(Guid?);
foreach (var item in CorrelationIdSelectors)
{
if (item.TryGetCorrelationId(message, out correlationId))
{
break;
}
}
var bookmark = new MessageReceivedBookmark
{
MessageType = message.GetType().Name
};
var workflowQuery = new WorkflowsQuery(
nameof(ReceiveMassTransitMessage),
bookmark,
correlationId.ToString()
);
var workflowInput = new WorkflowInput {
Input = message
};
await _workflowLaunchpad.CollectAndExecuteWorkflowsAsync(workflowQuery, workflowInput, context.CancellationToken);
}
private async Task TriggerWorkflowsAsync(MqttApplicationMessage message, CancellationToken cancellationToken)
{
var bookmark = CreateBookmark(_receiverClient.Options);
var launchContext = new WorkflowsQuery(ActivityType, bookmark);
await _workflowLaunchpad.UseServiceAsync(service => service.CollectAndDispatchWorkflowsAsync(launchContext, new WorkflowInput(message), cancellationToken));
}
private async Task TriggerWorkflowsAsync(MqttApplicationMessage message, CancellationToken cancellationToken)
{
var bookmark = CreateBookmark(_receiverClient.Options);
var launchContext = new WorkflowsQuery(ActivityType, bookmark);
using var scope = _serviceScopeFactory.CreateScope();
var workflowLaunchpad = scope.ServiceProvider.GetRequiredService <IWorkflowLaunchpad>();
await workflowLaunchpad.CollectAndDispatchWorkflowsAsync(launchContext, new WorkflowInput(message), cancellationToken);
}
private async Task TriggerWorkflowsAsync(TransportMessage message, CancellationToken cancellationToken)
{
//avoid handler being triggered earlier than workflow is suspended
await Task.Delay(_delay, cancellationToken);
var config = _client.Configuration;
var bookmark = new MessageReceivedBookmark(config.ExchangeName, config.RoutingKey, config.ConnectionString, config.Headers);
var launchContext = new WorkflowsQuery(ActivityType, bookmark);
await _workflowLaunchpad.UseServiceAsync(service => service.CollectAndDispatchWorkflowsAsync(launchContext, new WorkflowInput(message), cancellationToken));
}
private async Task TriggerWorkflowsAsync(TransportMessage message, CancellationToken cancellationToken)
{
//avoid handler being triggered earlier than workflow is suspended
await Task.Delay(_delay, cancellationToken);
var config = _client.Configuration;
var bookmark = new MessageReceivedBookmark(config.ExchangeName, config.RoutingKey, config.ConnectionString, config.Headers);
var launchContext = new WorkflowsQuery(ActivityType, bookmark);
using var scope = _scopeFactory.CreateScope();
var workflowLaunchpad = scope.ServiceProvider.GetRequiredService <IWorkflowLaunchpad>();
await workflowLaunchpad.CollectAndDispatchWorkflowsAsync(launchContext, new WorkflowInput(message), cancellationToken);
}
public async Task <IEnumerable <CollectedWorkflow> > FindWorkflowsAsync(WorkflowsQuery query, CancellationToken cancellationToken = default)
{
var correlationId = query.CorrelationId;
if (!string.IsNullOrWhiteSpace(correlationId))
{
return(await CollectResumableOrStartableCorrelatedWorkflowsAsync(query, cancellationToken));
}
if (!string.IsNullOrWhiteSpace(query.WorkflowInstanceId))
{
return(await CollectSpecificWorkflowInstanceAsync(query, cancellationToken));
}
return(await CollectResumableAndStartableWorkflowsAsync(query, cancellationToken));
}
public async Task Handle(TelnyxWebhookReceived notification, CancellationToken cancellationToken)
{
var webhook = notification.Webhook;
var eventType = webhook.Data.EventType;
var payload = webhook.Data.Payload;
var activityType = _webhookFilterService.GetActivityTypeName(payload);
if (activityType == null)
{
_logger.LogWarning("The received event '{EventType}' is an unsupported event", webhook.Data.EventType);
return;
}
var correlationId = payload.GetCorrelationId();
var bookmark = new NotificationBookmark(eventType);
var context = new WorkflowsQuery(activityType, bookmark, correlationId);
await _workflowLaunchpad.CollectAndDispatchWorkflowsAsync(context, new WorkflowInput(webhook), cancellationToken).ToList();
}
public async Task Handle(TelnyxWebhookReceived notification, CancellationToken cancellationToken)
{
var webhook = notification.Webhook;
if (webhook.Data.Payload is not CallInitiatedPayload payload)
{
return;
}
var correlationId = GetCorrelationId(payload);
var toBookmark = new FilteredCallInitiatedToBookmark(payload.To);
var toQuery = new WorkflowsQuery(nameof(FilteredCallInitiated), toBookmark, correlationId);
var fromBookmark = new FilteredCallInitiatedToBookmark(payload.From);
var fromQuery = new WorkflowsQuery(nameof(FilteredCallInitiated), fromBookmark, correlationId);
await _workflowLaunchpad.CollectAndDispatchWorkflowsAsync(toQuery, new WorkflowInput(webhook), cancellationToken);
await _workflowLaunchpad.CollectAndDispatchWorkflowsAsync(fromQuery, new WorkflowInput(webhook), cancellationToken);
}
public async Task <IEnumerable <StartableWorkflow> > FindStartableWorkflowsAsync(WorkflowsQuery query, CancellationToken cancellationToken = default)
{
var correlationId = query.CorrelationId ?? Guid.NewGuid().ToString("N");
var updatedContext = query with {
CorrelationId = correlationId
};
await using var lockHandle = await AcquireLockAsync(correlationId, cancellationToken);
var startableWorkflowDefinitions = await CollectStartableWorkflowsInternalAsync(updatedContext, cancellationToken);
return(await InstantiateStartableWorkflows(startableWorkflowDefinitions, cancellationToken).ToList());
}
public async Task <IEnumerable <CollectedWorkflow> > CollectAndDispatchWorkflowsAsync(WorkflowsQuery query, WorkflowInput?input = default, CancellationToken cancellationToken = default)
{
var pendingWorkflows = await FindWorkflowsAsync(query, cancellationToken).ToList();
await DispatchPendingWorkflowsAsync(pendingWorkflows, input, cancellationToken);
return(pendingWorkflows);
}
public async Task <IEnumerable <CollectedWorkflow> > CollectResumableAndStartableWorkflowsAsync(WorkflowsQuery query, CancellationToken cancellationToken)
{
var bookmarkResultsQuery = query.Bookmark != null ? await _bookmarkFinder.FindBookmarksAsync(query.ActivityType, query.Bookmark, query.CorrelationId, query.TenantId, cancellationToken) : default;
var bookmarkResults = bookmarkResultsQuery?.ToList() ?? new List <BookmarkFinderResult>();
var triggeredPendingWorkflows = bookmarkResults.Select(x => new CollectedWorkflow(x.WorkflowInstanceId, x.ActivityId)).ToList();
var startableWorkflows = await FindStartableWorkflowsAsync(query, cancellationToken);
var pendingWorkflows = triggeredPendingWorkflows.Concat(startableWorkflows.Select(x => new CollectedWorkflow(x.WorkflowInstance.Id, x.ActivityId))).Distinct().ToList();
return(pendingWorkflows);
}
private async Task <IEnumerable <StartableWorkflow> > CollectStartableWorkflowsInternalAsync(WorkflowsQuery query, CancellationToken cancellationToken = default)
{
_logger.LogDebug("Triggering workflows using {ActivityType}", query.ActivityType);
var filter = query.Bookmark;
var triggers = filter != null ? (await _triggerFinder.FindTriggersAsync(query.ActivityType, filter, query.TenantId, cancellationToken)).ToList() : new List <TriggerFinderResult>();
var startableWorkflows = new List <StartableWorkflow>();
foreach (var trigger in triggers)
{
var workflowBlueprint = trigger.WorkflowBlueprint;
var startableWorkflow = await CollectStartableWorkflowInternalAsync(workflowBlueprint, trigger.ActivityId, query.CorrelationId !, query.ContextId, query.TenantId, cancellationToken);
if (startableWorkflow != null)
{
startableWorkflows.Add(startableWorkflow);
}
}
return(startableWorkflows);
}
private async Task <IEnumerable <CollectedWorkflow> > CollectSpecificWorkflowInstanceAsync(WorkflowsQuery query, CancellationToken cancellationToken)
{
var bookmarkResultsQuery = query.Bookmark != null ? await _bookmarkFinder.FindBookmarksAsync(query.ActivityType, query.Bookmark, query.CorrelationId, query.TenantId, cancellationToken) : default;
bookmarkResultsQuery = bookmarkResultsQuery?.Where(x => x.WorkflowInstanceId == query.WorkflowInstanceId);
var bookmarkResults = bookmarkResultsQuery?.ToList() ?? new List <BookmarkFinderResult>();
var pendingWorkflows = bookmarkResults.Select(x => new CollectedWorkflow(x.WorkflowInstanceId, x.ActivityId)).ToList();
return(pendingWorkflows);
}
public async Task <IEnumerable <CollectedWorkflow> > CollectAndExecuteWorkflowsAsync(WorkflowsQuery query, WorkflowInput?input = default, CancellationToken cancellationToken = default)
{
var pendingWorkflows = await FindWorkflowsAsync(query, cancellationToken).ToList();
await ExecutePendingWorkflowsAsync(pendingWorkflows, input, cancellationToken);
return(pendingWorkflows.Select(x => new CollectedWorkflow(x.WorkflowInstanceId, x.ActivityId)));
}
private async Task <IEnumerable <CollectedWorkflow> > CollectResumableOrStartableCorrelatedWorkflowsAsync(WorkflowsQuery query, CancellationToken cancellationToken)
{
var correlationId = query.CorrelationId !;
await using var handle = await AcquireLockAsync(correlationId, cancellationToken);
var correlatedWorkflowInstanceCount = !string.IsNullOrWhiteSpace(correlationId)
? await _workflowInstanceStore.CountAsync(new CorrelationIdSpecification <WorkflowInstance>(correlationId).And(new WorkflowUnfinishedStatusSpecification()), cancellationToken)
: 0;
_logger.LogDebug("Found {CorrelatedWorkflowCount} workflows with correlation ID {CorrelationId}", correlatedWorkflowInstanceCount, correlationId);
if (correlatedWorkflowInstanceCount > 0)
{
var bookmarkResults = query.Bookmark != null
? await _bookmarkFinder.FindBookmarksAsync(query.ActivityType, query.Bookmark, correlationId, query.TenantId, cancellationToken).ToList()
: new List <BookmarkFinderResult>();
_logger.LogDebug("Found {BookmarkCount} bookmarks for activity type {ActivityType}", bookmarkResults.Count, query.ActivityType);
return(bookmarkResults.Select(x => new CollectedWorkflow(x.WorkflowInstanceId, x.ActivityId)).ToList());
}
var startableWorkflows = await CollectStartableWorkflowsInternalAsync(query, cancellationToken);
return(startableWorkflows.Select(x => new CollectedWorkflow(x.WorkflowInstance.Id, x.ActivityId)).ToList());
}
