public FactoryRequestEndpoint(RequestAddressProvider <TCommand> addressProvider, PendingIdProvider <TRequest> pendingIdProvider,
AsyncFutureMessageFactory <TCommand, TRequest> factory)
{
_addressProvider = addressProvider;
_pendingIdProvider = pendingIdProvider;
_factory = factory;
}
public void SetCompletedUsingFactory(AsyncFutureMessageFactory <TInput, TResult> factoryMethod)
{
if (factoryMethod == null)
{
throw new ArgumentNullException(nameof(factoryMethod));
}
_result.Factory = factoryMethod;
}
public void Create(AsyncFutureMessageFactory <TInput, TFault> factory)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
_fault.Factory = factory;
}
public void SetFaultedUsingFactory(AsyncFutureMessageFactory <TInput, TFault> factoryMethod)
{
if (factoryMethod == null)
{
throw new ArgumentNullException(nameof(factoryMethod));
}
_fault.SetFaultedUsingFactory(factoryMethod);
}
public static EventActivityBinder <FutureState> SetVariable <TData, TValue>(this EventActivityBinder <FutureState> binder, string key,
AsyncFutureMessageFactory <TValue> valueFactory)
where TData : class
where TValue : class
{
return(binder.Add(new AsyncActivity <FutureState>(context =>
{
var futureContext = context.CreateFutureConsumeContext();
return futureContext.SetVariable(key, valueFactory);
})));
}
public void SetCompletedUsingFactory(AsyncFutureMessageFactory <TResponse, TResult> factoryMethod)
{
GetResultConfigurator().SetCompletedUsingFactory(factoryMethod);
}
public static async Task <TResult> SetResult <TResult>(this FutureConsumeContext context, Guid id, AsyncFutureMessageFactory <TResult> factory)
where TResult : class
{
if (!context.Instance.Completed.HasValue)
{
SetCompleted(context, id);
}
var result = await factory(context).ConfigureAwait(false);
context.Instance.Results[id] = new FutureMessage <TResult>(result);
return(result);
}
public FactoryCommandEndpoint(DestinationAddressProvider <FutureState> destinationAddressProvider, AsyncFutureMessageFactory <TRequest, TCommand> factory)
{
_destinationAddressProvider = destinationAddressProvider;
_factory = factory;
}
public FactoryResultEndpoint(AsyncFutureMessageFactory <TResult, TResponse> factory)
{
_factory = factory;
}
public static async Task <TValue> SetVariable <TValue>(this FutureConsumeContext context, string key, AsyncFutureMessageFactory <TValue> factory)
where TValue : class
{
var value = await factory(context).ConfigureAwait(false);
context.Instance.Variables[key] = value;
return(value);
}
public void SetFaultedUsingFactory(AsyncFutureMessageFactory <TInput, TFault> value)
{
_endpoint = new FactoryFaultEndpoint <TInput, TFault>(value);
}
/// <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);
}));
}
public void UsingRequestFactory(AsyncFutureMessageFactory <TInput, TRequest> factoryMethod)
{
_requestEndpoint = new FactoryRequestEndpoint <TInput, TRequest>(_addressProvider, PendingRequestIdProvider, factoryMethod);
}
public FactoryFaultEndpoint(AsyncFutureMessageFactory <TResult, TFault> factory)
{
_factory = factory;
}
