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))); }