public Task <TResult> ProcessAsync <TResult>(IAsyncQuery <TResult> query)
{
var handlerType = typeof(IAsyncQueryHandler <,>).MakeGenericType(query.GetType(), typeof(TResult));
var handler = (IAsyncQueryHandler <IAsyncQuery <TResult>, TResult>)_container.GetInstance(handlerType);
return(handler.HandleAsync((dynamic)query, CancellationToken.None));
}
public async Task <TResult> Send <TResult>(IAsyncQuery <TResult> query)
{
var queryType = query.GetType();
var validator = _validatorsFactory(queryType);
if (validator != null)
{
var validatorType = validator.GetType();
var actionPossible = (ActionPossible)validatorType.InvokeMember("Execute", BindingFlags.InvokeMethod, null, validator, new object[] { query });
if (actionPossible.IsImpossible)
{
_eventsBus.Publish(new ActionImposibleEvent(actionPossible.Errors));
return(default(TResult));
}
}
var handler = _asyncHandlersFactory(queryType, typeof(TResult));
var handlerType = handler.GetType();
return(await(Task <TResult>) handlerType.InvokeMember("Handle", BindingFlags.InvokeMethod, null, handler, new object[] { query }));
}
public async Task <TResult> Process <TResult>(IAsyncQuery <TResult> query)
{
var handlerType = typeof(IAsyncQueryHandler <,>).MakeGenericType(query.GetType(), typeof(TResult));
dynamic handler = _container.Resolve(handlerType);
return(await handler.HandleAsync((dynamic)query));
}
public Task <TResult> HandleAsync <TResult>(IAsyncQuery <TResult> query, CancellationToken cancellationToken)
{
var handlerType = typeof(IAsyncQueryHandler <,>).MakeGenericType(query.GetType(), typeof(TResult));
dynamic handler = _container.GetInstance(handlerType);
var result = (Task <TResult>)handler.HandleAsync((dynamic)query, (dynamic)cancellationToken);
return(result);
}
public AsyncQueryResultBuilder(IAsyncQuery <TResult> query, ViewDataDictionary viewData, TempDataDictionary tempData, ViewEngineCollection viewEngineCollection)
{
this.query = query;
this.viewData = viewData;
this.tempData = tempData;
this.viewEngineCollection = viewEngineCollection;
this.mapper = DependencyResolver.Current.GetService <IMapper>();
mediator = DependencyResolver.Current.GetService <IMediator>();
}
public async Task <TResult> RequestAsync <TResult>(IAsyncQuery <TResult> query)
{
var handlerType = typeof(IAsyncQueryHandler <,>).MakeGenericType(query.GetType(), typeof(TResult));
var handler = container.GetInstance(handlerType);
var result = await(Task <TResult>) handler.GetType().GetMethod("HandleAsync", new[] { query.GetType() }).Invoke(handler, new object[] { query });
return(result);
}
public async Task <TResult> ProcessAsync <TResult>(IAsyncQuery <TResult> query) where TResult : class
{
var handlerType = typeof(IAsyncQueryExecutor <,>).MakeGenericType(query.GetType(), typeof(TResult));
var executor = serviceProvider.GetService(handlerType);
if (executor == null)
{
throw new Exception(string.Format("Query executor not found for query type {0}", query.GetType().Name));
}
return(await(executor as dynamic).ExecuteAsync(query as dynamic));
}
/// <inheritdoc cref="IAsyncQueryMediary.QueryAsync{TContext,TResult}"/>
public virtual Task <TResult> QueryAsync <TContext, TResult>(IAsyncQuery <TContext, TResult> query, TContext context, CancellationToken cancellationToken = default)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(Decorator.Decorate(GetOperationName(query, nameof(query.Execute)), () => query.Execute(context, cancellationToken)));
}
public async Task <QueryExecutionResult <TResult> > ExecuteAsync <TSource, TResult>(
IAsyncQuery <TSource, TResult> query,
IQueryContext context
)
{
var source = _serviceProvider.GetService(typeof(TSource));
if (source is not null)
{
return(await query.ExecuteAsync((TSource)source, context));
}
return(default);
public virtual Task <TResult> QueryAsync <TContext, TResult>(IAsyncQuery <TContext, TResult> query, TContext context)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(Decorator.Decorate(query, () => query.ExecuteAsync(context)));
}
public async Task ProcessQuery_QueryIsNotCacheInfo_ShouldReturnCorrectValue(
[Frozen]Mock<IAsyncQueryBus> queryBus,
IAsyncQuery<object> query,
object expected,
CacheAsyncQueryBus sut)
{
//arrange
queryBus.Setup(q => q.ProcessQuery<IAsyncQuery<object>, object>(query)).ReturnsTask(expected);
//act
var actual = await sut.ProcessQuery<IAsyncQuery<object>, object>(query);
//assert
actual.Should().Be(expected);
}
public async Task ProcessQuery_QueryIsNotCacheInfo_ShouldReturnCorrectValue(
[Frozen] Mock <IAsyncQueryBus> queryBus,
IAsyncQuery <object> query,
object expected,
CacheAsyncQueryBus sut)
{
//arrange
queryBus.Setup(q => q.ProcessQuery <IAsyncQuery <object>, object>(query)).ReturnsTask(expected);
//act
var actual = await sut.ProcessQuery <IAsyncQuery <object>, object>(query);
//assert
actual.Should().Be(expected);
}
public void ProcessQuery_WhenQueryHandlerIsNotFound_ShouldThrow(
[Frozen]Mock<IAsyncQueryCommandHandlerFactory> asyncQueryHandlerFactory,
IAsyncQuery<string> query,
AsyncCommandQueryBus sut)
{
//arrange
asyncQueryHandlerFactory.Setup(a => a.Create<IAsyncQuery<string>, string>())
.Throws<InvalidOperationException>();
//act
Func<Task> action = async () => await sut.ProcessQuery<IAsyncQuery<string>, string>(query);
//assert
action.ShouldThrow<InvalidOperationException>();
}
public void ProcessQuery_WhenQueryHandlerIsNotFound_ShouldThrow(
[Frozen] Mock <IAsyncQueryCommandHandlerFactory> asyncQueryHandlerFactory,
IAsyncQuery <string> query,
AsyncCommandQueryBus sut)
{
//arrange
asyncQueryHandlerFactory.Setup(a => a.Create <IAsyncQuery <string>, string>())
.Throws <InvalidOperationException>();
//act
Func <Task> action = async() => await sut.ProcessQuery <IAsyncQuery <string>, string>(query);
//assert
action.ShouldThrow <InvalidOperationException>();
}
public async Task <T> QueryAsync <TSource, T>(IAsyncQuery <TSource, T> query)
{
var context = new QueryContext(_serviceProvider);
foreach (var executor in _asyncExecutors)
{
var queryExecutionResult = await executor.ExecuteAsync(query, context);
if (queryExecutionResult.Type == QueryExecutionResultType.Success)
{
return(queryExecutionResult.Result);
}
}
throw new NoMatchingQueryExecutorException();
}
public async Task ProcessQuery_ShouldReturnCorrectValue(
[Frozen]Mock<IAsyncQueryCommandHandlerFactory> asyncQueryHandlerFactory,
Mock<IAsyncQueryHandler<IAsyncQuery<string>, string>> queryHandler,
IAsyncQuery<string> query,
string expected,
AsyncCommandQueryBus sut)
{
//arrange
asyncQueryHandlerFactory.Setup(a => a.Create<IAsyncQuery<string>, string>()).Returns(queryHandler.Object);
queryHandler.Setup(q => q.Execute(query)).ReturnsTask(expected);
//act
var actual = await sut.ProcessQuery<IAsyncQuery<string>, string>(query);
//assert
actual.Should().Be(expected);
}
public async Task ProcessQuery_ShouldReturnCorrectValue(
[Frozen] Mock <IAsyncQueryCommandHandlerFactory> asyncQueryHandlerFactory,
Mock <IAsyncQueryHandler <IAsyncQuery <string>, string> > queryHandler,
IAsyncQuery <string> query,
string expected,
AsyncCommandQueryBus sut)
{
//arrange
asyncQueryHandlerFactory.Setup(a => a.Create <IAsyncQuery <string>, string>()).Returns(queryHandler.Object);
queryHandler.Setup(q => q.Execute(query)).ReturnsTask(expected);
//act
var actual = await sut.ProcessQuery <IAsyncQuery <string>, string>(query);
//assert
actual.Should().Be(expected);
}
/// <inheritdoc />
public async Task <TResult> DispatchAsync <TResult>(IAsyncQuery <TResult> query)
{
Guard.ArgumentNotNull(query, nameof(query));
// Retriever query handler.
Type genericType = typeof(IAsyncQueryHandler <,>);
Type[] typeArguments = { typeof(TResult), query.GetType() };
Type queryHandlerType = genericType.MakeGenericType(typeArguments);
var queryHandler = ServiceProvider.GetRequiredService(queryHandlerType);
// Invoke retrieve method.
MethodInfo retrieveMethod = queryHandlerType.GetMethod("RetrieveAsync");
var result = (Task <TResult>)retrieveMethod.Invoke(queryHandler, new object[] { query });
return(await result);
}
public async Task <T> QueryAsync <T>(IAsyncQuery <T> query, CancellationToken cancellationToken = default)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
await EnsureConnectionIsEstablishedAsync(cancellationToken);
if (_dbConnection == null)
{
throw new InvalidOperationException("No db connection established");
}
return(await query
.ExecuteQueryAsync(_dbConnection, null, cancellationToken)
.ConfigureAwait(false));
}
public async Task Resolve_ShouldReturnCorrectValue(
[Frozen] Mock <IHttpRequestSpecificationResolver> mockSpecResolver,
[Frozen] Mock <IHttpRequestBuilder> mockBuilder,
[Frozen] Mock <IHttpRequestSpecificationsTransformer> mockTransformer,
DefaultHttpRequestResolver sut,
Mock <IHttpRequestBuilderOptions> options,
IAsyncQuery <string> query,
IHttpRequestSpecification specs,
IHttpRequest expected
)
{
//arrange
mockSpecResolver.Setup(m => m.ResolveHttpRequestSpecification(query)).Returns(specs);
mockTransformer.Setup(m => m.TransformHttpSpecificationsToHttpBuilderOptions(specs, query))
.ReturnsTask(options.Object);
options.Setup(m => m.ToRequest(mockBuilder.Object)).Returns(expected);
//act
var actual = await sut.ResolveHttpRequest(query);
//assert
actual.Should().Be(expected);
}
public async Task Resolve_ShouldReturnCorrectValue(
[Frozen]Mock<IHttpRequestSpecificationResolver> mockSpecResolver,
[Frozen]Mock<IHttpRequestBuilder> mockBuilder,
[Frozen]Mock<IHttpRequestSpecificationsTransformer> mockTransformer,
DefaultHttpRequestResolver sut,
Mock<IHttpRequestBuilderOptions> options,
IAsyncQuery<string> query,
IHttpRequestSpecification specs,
IHttpRequest expected
)
{
//arrange
mockSpecResolver.Setup(m => m.ResolveHttpRequestSpecification(query)).Returns(specs);
mockTransformer.Setup(m => m.TransformHttpSpecificationsToHttpBuilderOptions(specs, query))
.ReturnsTask(options.Object);
options.Setup(m => m.ToRequest(mockBuilder.Object)).Returns(expected);
//act
var actual = await sut.ResolveHttpRequest(query);
//assert
actual.Should().Be(expected);
}
public Task <IList <TResponse> > ExecuteAsyncQuery <TResponse>(IAsyncQuery <TResponse> query)
{
return(_mediator.SendAsync(query));
}
public void Resolve_VerifyGuardClause(GuardClauseAssertion assertion, IAsyncQuery<string> query)
{
assertion.Verify<DefaultHttpRequestResolver>(d => d.ResolveHttpRequest(query));
}
public async Task <TResult> HandleAsync <TResult>(IAsyncQuery <TResult> query)
{
return(await GetProcessor(query).HandleAsync(query));
}
public async Task <QueryExecutionResult <TResult> > ExecuteAsync <TSource, TResult>(IAsyncQuery <TSource, TResult> query, IQueryContext context)
{
if (query is IAsyncQuery <TExecutorSource, TResult> typedQuery)
{
TResult result = await ExecuteAsync <TResult>(typedQuery, context);
return(result);
}
return(default);
public Task <TResponse> SendAsync <TResponse>(IAsyncQuery <TResponse> request)
{
var wrapper = GetWrapper <AsyncWrapperQueryHandler <TResponse>, TResponse>(request, typeof(IAsyncQueryHandler <,>), typeof(AsyncWrapperQueryHandler <,>));
return(wrapper.Handle(request));
}
public async Task <TResult> HandleAsync <TResult>(IAsyncQuery <TResult> query)
{
var rsp = await GetClientForQuery(query).Execute <IAsyncQuery <TResult>, TResult>(query, default);
return(rsp.Value);
}
public async Task <TResult> HandleAsync <TResult>(IAsyncQuery <TResult> query, CancellationToken cancellationToken)
{
var rsp = await GetClientForQuery(query).Execute <IAsyncQuery <TResult>, TResult>(query, cancellationToken);
return(rsp.Value);
}
public abstract Task <TResponse> Handle(IAsyncQuery <TResponse> message);
public void Resolve_VerifyGuardClause(GuardClauseAssertion assertion, IAsyncQuery <string> query)
{
assertion.Verify <DefaultHttpRequestResolver>(d => d.ResolveHttpRequest(query));
}
public Task <TResult> HandleAsync <TResult>(IAsyncQuery <TResult> query)
{
return(HandleAsync(query, CancellationToken.None));
}
public async Task <TResult> HandleAsync <TResult>(IAsyncQuery <TResult> query, CancellationToken cancellationToken)
{
return(await GetProcessor(query).HandleAsync(query, cancellationToken));
}
public virtual Task <TResult> QueryAsync <TContext, TResult>(IAsyncQuery <TContext, TResult> query)
{
return(Invoker.QueryAsync(query, GetContext <TContext>()));
}
public AsyncQueryCache(
IAsyncQuery <TIn, TOut> query,
IConcurrentDictionaryFactory <TIn, Task <TOut> > factory)
: base(query, factory)
{
}
public Task <T> QueryAsync <T>(IAsyncQuery <T> query, CancellationToken cancellationToken = default) => Retry.DoAsync(() => query.ExecuteAsync(_connection, _transaction, cancellationToken), _retryOptions);
