internal static EventActivityBinder <ResponseState, T> ThenPublishActions <T>(this EventActivityBinder <ResponseState, T> binder, ResponseUpdateType responseUpdateType) where T : class, IResponseMessage
{
return(binder.ThenAsync(async context =>
{
//Retrieve the list of actions
IEnumerable <ResponseActionModel> actions = responseUpdateType == ResponseUpdateType.CloseResponse
? context.Data.Response.ActionPlan.CloseActions : context.Data.Response.ActionPlan.OpenActions;
var actionStatus = context.Data.ActionStatus;
actions = actions.Where(p =>
(actionStatus.HasFlag(ActionStatus.Error) && p.Status == ActionStatus.Error) ||
(actionStatus.HasFlag(ActionStatus.NotStarted) && p.Status == ActionStatus.NotStarted) ||
(actionStatus.HasFlag(ActionStatus.Skipped) && p.Status == ActionStatus.Skipped) ||
(actionStatus.HasFlag(ActionStatus.Success) && p.Status == ActionStatus.Success)
);
//If the response is not of type CloseResponse, we trigger the event cluster associated
if (responseUpdateType != ResponseUpdateType.CloseResponse)
{
await context.Publish(new ResponseTagExistingEventClustersRequestedEvent()
{
ResponseId = context.Data.Response.ResponseId,
ResponseGeolocation = context.Data.Response.Geolocation,
Radius = context.Data.Response.ActionPlan.PrimaryRadius
});
}
//If there is no action to update, we send the UI update immediately.
if (actions == null || actions.Count() == 0)
{
await context.Publish(new ResponseUIUpdateRequestedEvent()
{
ResponseId = context.Instance.CorrelationId,
ResponseUI = new ResponseUIModel()
{
UpdateType = context.Instance.ActionUpdateType.ToString(),
ResponseId = context.Instance.CorrelationId
}
});
return;
}
context.Instance.ActionCorrelationId = Guid.NewGuid();
context.Instance.ActionUpdateType = responseUpdateType;
context.Instance.ActionsTotal = actions.Count();
context.Instance.ActionsCompletedCount = 0;
await actions.TaskForEach(async action => {
await Console.Out.WriteLineAsync($"Response--{context.Instance.CorrelationId}: Start Action {action.ActionId} of type {action.ActionType}.");
await context.Publish(new ActionEvent()
{
ActionCorrelationId = context.Instance.ActionCorrelationId,
ActionId = action.ActionId,
ResponseId = context.Data.Response.ResponseId,
Action = action,
Geolocation = context.Data.Response.Geolocation,
PrimaryRadius = context.Data.Response.ActionPlan.PrimaryRadius,
SecondaryRadius = context.Data.Response.ActionPlan.SecondaryRadius
});
});
}));
}
public static EventActivityBinder <FutureState, T> SetFutureFaulted <T, TFault>(this EventActivityBinder <FutureState, T> binder,
AsyncEventMessageFactory <FutureState, T, TFault> messageFactory)
where T : class
where TFault : class
{
return(binder.ThenAsync(context => context.Instance.SetFault(context.CreateConsumeContext(), context.Instance.CorrelationId, messageFactory)));
}
public static EventActivityBinder <FutureState, Fault <T> > SetFault <T>(this EventActivityBinder <FutureState, Fault <T> > binder,
Func <ConsumeEventContext <FutureState, Fault <T> >, Guid> getResultId, AsyncEventMessageFactory <FutureState, Fault <T>, Fault <T> > messageFactory)
{
return(binder.ThenAsync(context =>
{
ConsumeEventContext <FutureState, Fault <T> > consumeContext = context.CreateConsumeContext();
var resultId = getResultId(consumeContext);
return context.Instance.SetFault(consumeContext, resultId, messageFactory);
}));
}
/// <summary>
/// Set the result associated with the identifier using the message factory
/// </summary>
/// <param name="binder"></param>
/// <param name="getResultId">Should return the result identifier</param>
/// <param name="messageFactory">Should return the result message</param>
/// <typeparam name="T">The event type</typeparam>
/// <typeparam name="TResult">The result type</typeparam>
/// <returns></returns>
public static EventActivityBinder <FutureState, T> SetResult <T, TResult>(this EventActivityBinder <FutureState, T> binder,
Func <FutureConsumeContext <T>, Guid> getResultId, AsyncFutureMessageFactory <T, TResult> messageFactory)
where T : class
where TResult : class
{
return(binder.ThenAsync(context =>
{
FutureConsumeContext <T> consumeContext = context.CreateFutureConsumeContext();
var resultId = getResultId(consumeContext);
return consumeContext.SetResult(resultId, messageFactory);
}));
}
/// <summary>
/// Set the result associated with the identifier using the message factory
/// </summary>
/// <param name="binder"></param>
/// <param name="getResultId">Should return the result identifier</param>
/// <param name="messageFactory">Should return the result message</param>
/// <typeparam name="T">The event type</typeparam>
/// <typeparam name="TResult">The result type</typeparam>
/// <returns></returns>
public static EventActivityBinder <FutureState, T> SetResult <T, TResult>(this EventActivityBinder <FutureState, T> binder,
Func <ConsumeEventContext <FutureState, T>, Guid> getResultId, EventMessageFactory <FutureState, T, TResult> messageFactory)
where T : class
where TResult : class
{
return(binder.ThenAsync(context =>
{
ConsumeEventContext <FutureState, T> consumeContext = context.CreateConsumeContext();
var resultId = getResultId(consumeContext);
return context.Instance.SetResult(consumeContext, resultId, x => Task.FromResult(messageFactory(x)));
}));
}
public static EventActivityBinder <TInstance, TData> ThenAsync <TInstance, TData>(
this EventActivityBinder <TInstance, TData> binder,
Func <TInstance, TData, Task> action) where TInstance : class
{
return(binder.ThenAsync(ctx => action(ctx.Instance, ctx.Data)));
}
