public ActionResult <ApplicationPoolEditablePropertiesDto> Edit(string name)
{
var applicationPoolDto =
QueryDispatcher.Dispatch(new GetEditableApplicationPoolProperties(name));
return(Ok(applicationPoolDto));
}
public virtual IActionResult Find([FromQuery] FilterQuery filterQuery)
{
var query = new FindQuery <TModel>(filterQuery);
var result = QueryDispatcher.Dispatch(query);
return(Ok(result));
}
public virtual IActionResult GetById([FromRoute] TIdentifier id)
{
var query = new GetQuery <TModel>(id);
var result = QueryDispatcher.Dispatch(query);
return(OkOrNotFound(result));
}
public IActionResult GetAllTrips()
{
var query = new GetAllTripsQuery();
var queryResult = QueryDispatcher.Execute <GetAllTripsQuery, GetAllTripsQueryResult>(query);
return(Ok(queryResult.Trips));
}
public async Task InsertQueryTestAsync()
{
var queryDispatcher =
new QueryDispatcher(
new QueryExecutor(
new CommandPreparer(),
new ConnectionFactory(ConnectionString.Default)));
var queries = new String[]
{
"DROP TABLE IF EXISTS insert_query_test;",
"CREATE TABLE insert_query_test (value TEXT NOT NULL);",
"INSERT INTO insert_query_test VALUES ('StraightSql');"
};
foreach (var query in queries)
{
await queryDispatcher.ExecuteAsync(new Query(query));
}
var countQuery = "SELECT COUNT(*) FROM insert_query_test;";
var count = await queryDispatcher.CountAsync(new Query(countQuery));
Assert.Equal(count, 1);
}
public ActionResult Get(string siteName, [FromQuery] string subString)
{
var query = new GetApplicationsContainedSubstring(siteName, subString);
var applicationsDto = QueryDispatcher.Dispatch(query);
return(Ok(applicationsDto));
}
public async Task EmptyListQueryTestAsync()
{
var queryDispatcher =
new QueryDispatcher(
new QueryExecutor(
new CommandPreparer(),
new ConnectionFactory(ConnectionString.Default)));
var setupQueries = new String[]
{
"DROP TABLE IF EXISTS empty_list_query_test;",
"CREATE TABLE empty_list_query_test (id INT NOT NULL, value TEXT NOT NULL);"
};
foreach (var setupQuery in setupQueries)
{
await queryDispatcher.ExecuteAsync(new Query(setupQuery));
}
var listQuery = "SELECT id, value FROM empty_list_query_test;";
var items = await queryDispatcher.ListAsync(new Query(listQuery), row =>
{
return(new
{
id = row.ReadInt32("id"),
value = row.ReadString("value")
});
});
Assert.NotNull(items);
Assert.Empty(items);
}
private void EnviarMail(String cuil, Boolean archivoGeneradoConExito, String nombreArchivo, String queryParams, String reportTitle)
{
EnviarMailQuery _enviarMailQuery = new EnviarMailQuery();
_enviarMailQuery.Cuil = cuil;
StringBuilder _mensaje = new StringBuilder();
if (archivoGeneradoConExito)
{
_enviarMailQuery.Link = FileUtil.GenerarLinkDeDescarga(nombreArchivo);
_mensaje.Append(GlobalVars.EmailMensaje);
}
else
{
_mensaje.Append("Se produjo un error inesperado al generar el reporte '")
.Append(nombreArchivo)
.Append("'. Por favor pongase en contacto con un administrador del sistema.")
.Append("\n")
.Append("Parámetros enviados: ")
.Append(queryParams);
}
_enviarMailQuery.Mensaje = _mensaje.ToString();
_enviarMailQuery.ReportTitle = reportTitle;
var _enviarMailQueryResult = QueryDispatcher.Dispatch <EnviarMailQuery, EnviarMailQueryResult>(_enviarMailQuery);
}
public virtual IActionResult Find(FindCriteria findCriteria)
{
var query = new FindQuery <TModel>(findCriteria);
var result = QueryDispatcher.Dispatch(query);
return(Ok(result));
}
public IActionResult GetAll()
{
var query = new GetAllLocationsQuery();
var queryResult = QueryDispatcher.Execute <GetAllLocationsQuery, GetAllLocationsQueryResult> (query);
return(Ok(queryResult.Locations));
}
public async Task DatabaseAbstractionTestAsync()
{
var queryDispatcher = new QueryDispatcher(new QueryExecutor(new CommandPreparer(), new ConnectionFactory(ConnectionString.Default)));
var readerCollection = new ReaderCollection(new[] { Reader.Create(new TestItemReader()) });
var database = new Database(queryDispatcher, readerCollection);
var setupQueries = new String[]
{
"DROP TABLE IF EXISTS database_abstraction_test;",
"CREATE TABLE database_abstraction_test (id INT NOT NULL, value TEXT NOT NULL);",
"INSERT INTO database_abstraction_test VALUES (1, 'James');",
"INSERT INTO database_abstraction_test VALUES (2, 'Madison');",
"INSERT INTO database_abstraction_test VALUES (3, 'University');"
};
foreach (var setupQuery in setupQueries)
{
await queryDispatcher.ExecuteAsync(new Query(setupQuery));
}
var item =
await database
.CreateQuery(@"
SELECT id, value
FROM database_abstraction_test
WHERE id = :id;" )
.SetParameter("id", 1)
.FirstAsync <TestItem>();
Assert.NotNull(item);
Assert.Equal(item.Id, 1);
Assert.Equal(item.Value, "James");
}
public IActionResult GetLeaguesByApiId([FromRoute] int leagueId)
{
var query = new GetLeagueByApiIdQuery(leagueId);
var result = QueryDispatcher.Retrive <GetLeagueByApiIdQueryResult, GetLeagueByApiIdQuery>(query);
return(Ok(result));
}
public async Task ShouldInvokeRegisteredQueryHandlerInContainerWhenDispatchedMultipleTimes()
{
var queryHandler = new TestQueryHandler(_outputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
container.Register <IQueryAsyncHandler <QuerySomethingWithNonReferenceTypeResult, int> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter);
const string data1 = "Test message 1.";
const string data2 = "Test message 2.";
const int data3 = 1;
var dispatcher = new QueryDispatcher(resolver);
var result1 = dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething(data1));
var result2 = dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething(data2));
var result3 = dispatcher.DispatchAsync <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(data3));
await Task.WhenAll(result1, result2, result3);
(await result1).Should().Be(data1);
(await result2).Should().Be(data2);
(await result3).Should().Be(data3);
}
public PersonalVerQueryResult Retrieve(PersonalVerQuery query)
{
QueryDispatcher _queryDispatcher = ServiceLocator.Current.GetInstance <QueryDispatcher>();
var queryResult = new PersonalVerQueryResult();
var querySession = _repositryLocalScheme.Session.CallFunction <PersonalVerDto>("PR_VER_DATOS_PERSONAL (?)")
.SetParameter(0, query.IdAsignacionPersonal);
//.SetParameter(1, query.IdSalita);
queryResult.PersonalVerDto = (PersonalVerDto)querySession.UniqueResult <PersonalVerDto>();
var querySession2 = _repositryLocalScheme.Session.CallFunction <PersonalHistorialDto>("PR_VER_HISTORIAL_PERSONAL (?)")
.SetParameter(0, query.IdPersonal);
queryResult.HistorialPersonal = (List <PersonalHistorialDto>)querySession2.List <PersonalHistorialDto>();
var querySession3 = _repositryLocalScheme.Session.CallFunction <PersonalRequisitosDto>("PR_OBTENER_REQ_PERSONAL (?)")
.SetParameter(0, query.IdPersonal);
queryResult.RequisitosPersonal = (List <PersonalRequisitosDto>)querySession3.List <PersonalRequisitosDto>();
var querySession4 = _repositryLocalScheme.Session.CallFunction <CursoDto>("PR_OBTENER_CURSOS_PERSONAL (?)")
.SetParameter(0, query.IdPersonal);
queryResult.CursosPersonal = (List <CursoDto>)querySession4.List <CursoDto>();
return(queryResult);
}
public async Task Should_Invoke_Registered_Query_Handler_In_Container_When_Dispatched_Multiple_Times()
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var container = new Container();
container.Register <IQueryAsyncHandler <QuerySomething, string> >(() => queryHandler, Lifestyle.Singleton);
container.Register <IQueryAsyncHandler <QuerySomethingWithNonReferenceTypeResult, int> >(() => queryHandler, Lifestyle.Singleton);
var containerAdapter = new SimpleInjectorContainerAdapter(container);
var resolver = new ContainerQueryAsyncHandlerResolver(containerAdapter);
const string data1 = "Test message 1.";
const string data2 = "Test message 2.";
const int data3 = 1;
var dispatcher = new QueryDispatcher(resolver);
var result1 = dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething(data1));
var result2 = dispatcher.DispatchAsync <QuerySomething, string>(new QuerySomething(data2));
var result3 = dispatcher.DispatchAsync <QuerySomethingWithNonReferenceTypeResult, int>(new QuerySomethingWithNonReferenceTypeResult(data3));
await Task.WhenAll(result1, result2, result3);
Assert.Equal(data1, await result1);
Assert.Equal(data2, await result2);
Assert.Equal(data3, await result3);
}
public Task Should_Throw_When_Cancelled()
{
return(Assert.ThrowsAnyAsync <OperationCanceledException>(async() =>
{
var queryHandler = new TestQueryHandler(_testOutputHelper);
var registration = new QueryHandlerRegistration();
registration.Register(() => (IQueryAsyncHandler <QuerySomethingWithDelay, string>)queryHandler);
var cts = new CancellationTokenSource();
var dispatcher = new QueryDispatcher(registration);
Task task = dispatcher.DispatchAsync <QuerySomethingWithDelay, string>(new QuerySomethingWithDelay("This will be cancelled", 3000), cts.Token);
cts.Cancel();
try
{
await task;
}
catch (Exception ex)
{
_testOutputHelper.WriteLine(ex.ToString());
throw;
}
}));
}
public void Start()
{
//Import
LoggingService.Info("Download Quotations ");
var stocks = QueryDispatcher.Execute(new StockAllQuery());
foreach (var stock in stocks)
{
var quotationsBefore = QueryDispatcher.Execute(new StockQuotationsCountByIdQuery(stock.Id));
var quotations = new QuotationServiceClient(QueryDispatcher, new StockQuoteExternalService(LoggingService)).Get(stock.Id).ToList();
if (!quotations.Any())
{
LoggingService.Info($"No quotations for stock {stock.Name} imported (Qty Before: {quotationsBefore})");
continue;
}
var cmd = new StockQuotationsAddOrChangeCommand(
stock.Id,
stock.OriginalVersion,
quotations);
CommandDispatcher.Execute(cmd);
//Statistics
var existentQuotations = QueryDispatcher.Execute(new StockQuotationsByIdQuery(stock.Id)).Count();
var diff = existentQuotations - quotationsBefore;
LoggingService.Info($"{diff} Quotation(s) for stock {stock.Name} imported (Qty After: {existentQuotations},Qty Before: {quotationsBefore})");
}
}
public OrderController(CommandDispatcher commandDispatcher,
QueryDispatcher queryDispatcher,
IResourceManager resourceManager,
Cart cartService) : base(commandDispatcher, queryDispatcher, resourceManager)
{
cart = cartService;
}
public async Task CountQueryTestAsync()
{
var queryDispatcher =
new QueryDispatcher(
new QueryExecutor(
new CommandPreparer(),
new ConnectionFactory(ConnectionString.Default)));
var arrangeQueries = new String[]
{
"DROP TABLE IF EXISTS count_query_test;",
"CREATE TABLE count_query_test (value TEXT NOT NULL);",
"INSERT INTO count_query_test VALUES ('Sigma');",
"INSERT INTO count_query_test VALUES ('Nu');",
"INSERT INTO count_query_test VALUES ('Iota');",
"INSERT INTO count_query_test VALUES ('Delta');",
"INSERT INTO count_query_test VALUES ('697');",
};
foreach (var arrangeQuery in arrangeQueries)
{
await queryDispatcher.ExecuteAsync(new Query(arrangeQuery));
}
var countQuery = "SELECT COUNT(*) FROM count_query_test;";
var count = await queryDispatcher.ExecuteScalarAsync <Int64>(new Query(countQuery));
Assert.Equal(count, 5);
}
public ApiServer()
{
_Context = new ApplicationContext();
_QueryDispatcher = new QueryDispatcher();
_CommandDispatcher = new CommandDispatcher();
_Log = LogManager.GetLogger(GetType().FullName);
}
public DatosAdminBeneficiarioQueryResult Retrieve(DatosAdminBeneficiarioQuery query)
{
var queryResult = new DatosAdminBeneficiarioQueryResult();
//Traigo los datos de la sala cuna
QueryDispatcher _queryDispatcher = ServiceLocator.Current.GetInstance <QueryDispatcher>();
SalaCunaByIdQuery querySala = new SalaCunaByIdQuery()
{
IdSalaCuna = query.SalaCunaId
};
SalaCunaByIdQueryResult resultadoSala = _queryDispatcher.Dispatch <SalaCunaByIdQuery, SalaCunaByIdQueryResult>(querySala);
queryResult.SalaCuna = resultadoSala.SalaCuna;
//Traigo las salitas de una sala
_queryDispatcher = ServiceLocator.Current.GetInstance <QueryDispatcher>();
SalitaCunaAdminBenQuery querySalitas = new SalitaCunaAdminBenQuery()
{
SalaCunaId = query.SalaCunaId,
SeleccionBaja = query.SeleccionBaja
};
SalitaCunaAdminBenQueryResult resultadoSalitas = _queryDispatcher.Dispatch <SalitaCunaAdminBenQuery, SalitaCunaAdminBenQueryResult>(querySalitas);
queryResult.SalitasCuna = resultadoSalitas.SalitasCunaDto;
return(queryResult);
}
public virtual IActionResult Count([FromQuery] SearchFilter searchFilter)
{
var query = new CountQuery <TModel>(searchFilter);
var result = QueryDispatcher.Dispatch(query);
return(Ok(result));
}
public IActionResult GetAllTeams()
{
var query = new GetAllTeamsQuery();
var result = QueryDispatcher.Retrive <GetAllTeamsQueryResult, GetAllTeamsQuery>(query);
return(Ok(result));
}
public ActionResult GetApplicationEditableProperties(string siteName, string applicationName)
{
var applicationDto =
QueryDispatcher.Dispatch(new GetEditableApplicationProperties(siteName, applicationName));
return(Ok(applicationDto));
}
public void Start()
{
//Get old transactions
var transactions = GetOpenPositions(Stocks);
var positions = QueryDispatcher.Execute(new OpenPositionsAllQuery());
foreach (var pos in positions)
{
var oldOpenTrans = transactions.Values.Where(t => t.Stock.Id == pos.ProductId).ToList();
if (!oldOpenTrans.Any())
{
LoggingService.Warn($"Unknown position of {pos.Shares}x{pos.PricePerShare}");
}
else if (pos.Shares != oldOpenTrans.Sum(t => t.Shares))
{
LoggingService.Warn($"Diffent amount of shares for {oldOpenTrans.FirstOrDefault().Stock.Name} {pos.Shares}x{pos.PricePerShare}");
}
else
{
LoggingService.Info($"Open position ok for {oldOpenTrans.FirstOrDefault().Stock.Name} ({pos.Shares}x{pos.PricePerShare}={pos.PositionSize})");
}
}
}
public QueryResult ExecuteQuery(QueryParameter parameter)
{
var commandDispatcher = new QueryDispatcher();
var parametro = commandDispatcher.Dispatch(parameter);
return(parametro);
}
public void InitTest()
{
new GuyWire().Wire();
_CommandDispatcher = ServiceLocator.Current.GetInstance <CommandDispatcher>();
_QueryDispatcher = ServiceLocator.Current.GetInstance <QueryDispatcher>();
}
public Module(
Func <ICommand, Task> dispatcher,
Func <IEvent[], Task> publish,
QueryDispatcher queryDispatcher)
: this(dispatcher, publish, queryDispatcher, events => Task.CompletedTask)
{
}
public async Task FirstQueryThrowsIfEmptyTestAsync()
{
var queryDispatcher =
new QueryDispatcher(
new QueryExecutor(
new CommandPreparer(),
new ConnectionFactory(ConnectionString.Default)));
var setupQueries = new String[]
{
"DROP TABLE IF EXISTS first_query_throws_if_empty_test;",
"CREATE TABLE first_query_throws_if_empty_test (id INT NOT NULL, value TEXT NOT NULL);"
};
foreach (var setupQuery in setupQueries)
{
await queryDispatcher.ExecuteAsync(new Query(setupQuery));
}
var listQuery = @"
SELECT id, value
FROM first_query_throws_if_empty_test;" ;
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await queryDispatcher.FirstAsync(new Query(listQuery), row =>
{
return(new
{
id = row.ReadInt32("id"),
value = row.ReadString("value")
});
});
});
}
private static IQueryDispatcher BuildQueryDispatcher(IServiceProvider serviceProvider, IQueryDispatcher queryDispatcher)
{
if (queryDispatcher == null)
{
queryDispatcher = new QueryDispatcher(serviceProvider);
}
var partManager = serviceProvider.GetRequiredService <ApplicationPartManager>();
var queryHandlerFeature = new QueryHandlerFeature();
partManager.PopulateFeature(queryHandlerFeature);
foreach (var type in queryHandlerFeature.QueryHandlers)
{
var queryHandlerInspector = new QueryHandlerInspector(type);
var queryHandlerDescriptors = queryHandlerInspector.GetQueryHandlerDescriptors();
foreach (var queryHandlerDescriptor in queryHandlerDescriptors)
{
var queryType = queryHandlerDescriptor.QueryType;
var queryHandlerProvider = Activator.CreateInstance(typeof(QueryHandlerProvider <>).MakeGenericType(queryType), type, queryHandlerDescriptor);
Task taskRegistration = queryDispatcher.RegisterAsync((dynamic)queryHandlerProvider); // TODO: The task is neither awaited nor stored.
}
}
return(queryDispatcher);
}
public void Dispatch()
{
var serviceLocator = Substitute.For<Griffin.Container.IServiceLocator>();
var handler = Substitute.For<IExecuteQuery<FakeQuery, string>>();
serviceLocator.Resolve(typeof(IExecuteQuery<FakeQuery, string>)).Returns(handler);
var dispatcher = new QueryDispatcher(serviceLocator);
dispatcher.Execute(new FakeQuery());
}
public void DispatchReal()
{
var handler = Substitute.For<IExecuteQuery<FakeQuery, string>>();
var registrar = new ContainerRegistrar();
registrar.RegisterInstance(handler);
var dispatcher = new QueryDispatcher(registrar.Build());
dispatcher.Execute(new FakeQuery());
}
