public async Task <IActionResult> Handle(string signalName, ExecuteSignalRequest request, CancellationToken cancellationToken = default)
{
var result = await _signaler.TriggerSignalAsync(signalName, request.Input, request.WorkflowInstanceId, request.CorrelationId, cancellationToken).ToList();
if (Response.HasStarted)
{
return(new EmptyResult());
}
return(Ok(new ExecuteSignalResponse(result.Select(x => new StartedWorkflow(x.WorkflowInstanceId, x.ActivityId)).ToList())));
}
public async Task <IActionResult> Handle(string token, CancellationToken cancellationToken)
{
if (!_tokenService.TryDecryptToken(token, out Signal signal))
{
return(NotFound());
}
await _signaler.TriggerSignalAsync(signal.Name, null, signal.WorkflowInstanceId, cancellationToken);
return(HttpContext.Response.HasStarted
? new EmptyResult()
: Accepted());
}
public async Task <IActionResult> Handle(string token, CancellationToken cancellationToken)
{
if (!_tokenService.TryDecryptToken(token, out SignalModel signal))
{
return(BadRequest());
}
var affectedWorkflows = await _signaler.TriggerSignalAsync(signal.Name, null, signal.WorkflowInstanceId, cancellationToken : cancellationToken).ToList();
await _mediator.Publish(new HttpTriggeredSignal(signal, affectedWorkflows), cancellationToken);
var response = HttpContext.Response;
return(response.HasStarted || response.StatusCode != (int)HttpStatusCode.OK
? new EmptyResult()
: Ok(affectedWorkflows));
}
protected override async ValueTask <IActivityExecutionResult> OnExecuteAsync(ActivityExecutionContext context)
{
// Persist the workflow before sending the signal. This fixes a use case where a responding workflow sends a response signal handled by this workflow in a separate branch for example.
await _workflowInstanceStore.SaveAsync(context.WorkflowInstance, context.CancellationToken);
// Trigger the signal synchronously. If we dispatched the signal instead, we don't have to explicitly save the workflow instance. For future reconsideration.
// Warning: Sending a signal directly instead of dispatching it can potentially cause a deadlock if another workflow sends a signal back to this workflow immediately.
switch (SendMode)
{
case SendSignalMode.Synchronously:
await _signaler.TriggerSignalAsync(Signal, Input, correlationId : CorrelationId, cancellationToken : context.CancellationToken);
break;
case SendSignalMode.Asynchronously:
default:
await _signaler.DispatchSignalAsync(Signal, Input, correlationId : CorrelationId, cancellationToken : context.CancellationToken);
break;
}
return(Done());
}
public async Task <IActionResult> Trigger(string signalName, string correlationId, CancellationToken cancellationToken)
{
await _signaler.TriggerSignalAsync(signalName, workflowInstanceId : correlationId, cancellationToken : cancellationToken);
return(Ok("Signal triggered :)"));
}
public async Task <IActionResult> StartFire(CancellationToken cancellationToken)
{
var startedWorkflows = await _signaler.TriggerSignalAsync("Fire", cancellationToken : cancellationToken);
return(Ok(startedWorkflows));
}
protected override async ValueTask <IActivityExecutionResult> OnExecuteAsync(ActivityExecutionContext context)
{
await _signaler.TriggerSignalAsync(Signal, Input, CorrelationId, context.CancellationToken);
return(Done());
}
