public async Task HandleAsync(IReadOnlyCollection <IDomainEvent> domainEvents, CancellationToken cancellationToken)
{
var domainEvent = domainEvents.Single();
switch (domainEvent.EventType.FullName)
{
case "Invoice.Core.DomainModel.InvoiceCreatedEvent":
{
// Initiate process for this invoice
var id = domainEvent.GetIdentity();
var invoiceId = Guid.Parse(id.Value.Replace("invoice-", ""));
await _assignmentService.CreateAssignment(new CreateAssignmentCommand(AssignmentId.New, invoiceId));
break;
}
case "Invoice.Core.DomainModel.InvoiceSentEvent":
{
var id = domainEvent.GetIdentity();
var invoiceId = Guid.Parse(id.Value.Replace("invoice-", ""));
var assignment = await _queryProcessor.ProcessAsync(new GetAssignmentByInvoiceIdQuery(invoiceId), CancellationToken.None);
await _assignmentService.SetWaitingForPayment(new SetWaitingForPaymentCommand(AssignmentId.With(assignment.AssignmentId), assignment.InvoiceId));
await _paymentService.SetWaitingForPayment(new WaitingForPaymentRequest()
{
InvoiceId = invoiceId
});
var assignmentInvoice = await _queryProcessor.ProcessAsync(new GetAssignmentInvoiceQuery(invoiceId), CancellationToken.None);
if (assignmentInvoice.PayInAdvance)
{
await _payoutService.PayEmployee(new PayEmployeeRequest { InvoiceId = invoiceId });
}
break;
}
case "Payment.Core.DomainModel.PaymentReceivedEvent":
{
dynamic paymentReceived = domainEvent.GetAggregateEvent();
Guid invoiceId = paymentReceived.InvoiceId;
var assignmentInvoice = await _queryProcessor.ProcessAsync(new GetAssignmentInvoiceQuery(invoiceId), CancellationToken.None);
if (!assignmentInvoice.PayInAdvance)
{
await _payoutService.PayEmployee(new PayEmployeeRequest { InvoiceId = invoiceId });
}
break;
}
case "Payment.Core.DomainModel.PaymentDueEvent":
{
dynamic paymentDue = domainEvent.GetAggregateEvent();
Guid invoiceId = paymentDue.InvoiceId;
await _invoiceService.SendReminder(invoiceId);
break;
}
case "Payout.Core.DomainModel.EmployeePaidEvent":
{
// close assignment
dynamic employeePaid = domainEvent.GetAggregateEvent();
Guid invoiceId = employeePaid.InvoiceId;
var assignment = await _queryProcessor.ProcessAsync(new GetAssignmentByInvoiceIdQuery(invoiceId), CancellationToken.None);
await _assignmentService.CloseAssignment(new CloseAssignmentCommand(AssignmentId.With(assignment.AssignmentId)));
break;
}
}
}
/// <summary>
/// Process a query.
/// </summary>
/// <typeparam name="TResult">The type of result</typeparam>
/// <param name="queryProcessor">The query processor</param>
/// <param name="queryName">The name of the query</param>
/// <param name="json">The JSON representation of the query</param>
/// <returns>The result of the query</returns>
public static async Task <TResult> ProcessAsync <TResult>(this IQueryProcessor queryProcessor, string queryName, string json)
{
return(await queryProcessor.ProcessAsync <TResult>(queryName, JObject.Parse(json)));
}
public async Task <CustomerDto[]> GetCustomers()
{
var customers = await _queryProcessor.ProcessAsync(new GetAllCustomersQuery(), CancellationToken.None).ConfigureAwait(false);
return(customers);
}
public async Task <ICollection <Item> > GetItem([FromQuery] int listId)
{
return(await queryProcessor.ProcessAsync(new GetItemsFromListQuery { ListId = listId }));
}
public async Task <CapacityDto> GetByDate(DateTime byDate) => await _queryProcessor.ProcessAsync(new GetCapacityByDate(byDate), CancellationToken.None);
public Task <IEnumerable <VkUserModel> > Search([FromQuery] SearchUserQuery query)
{
return(_queryProcessor.ProcessAsync(query));
}
public override async Task <ITestAggregateReadModel> GetTestAggregateReadModelAsync(IIdentity id)
{
return(await _queryProcessor.ProcessAsync(new ReadModelByIdQuery <InMemoryTestAggregateReadModel>(id.Value), CancellationToken.None).ConfigureAwait(false));
}
public async Task <IActionResult> Get(Guid id, CancellationToken ct)
{
var x = await _queryExecutor.ProcessAsync(new ReadModelByIdQuery <EmployeeReadModel>(EmployeeId.With(id)), ct);
return(Ok(x));
}
public async Task <ICollection <List> > GetAllLists()
{
return(await queryProcessor.ProcessAsync(new GetListsQuery()));
}
public async Task <IEnumerable <PaymentDto> > GetAll()
{
return(await _queryProcessor.ProcessAsync(new GetAllPaymentsQuery(), CancellationToken.None));
}
/// <inheritdoc />
public Task <TResult> GetResultAsync <TQuery, TResult>(TQuery query) where TQuery : IQuery
{
return(_queryProcessor.ProcessAsync <TQuery, TResult>(query));
}
public Task <IEnumerable <ProjectListDTO> > Get()
{
return(queryProcessor.ProcessAsync <ProjectQueryHandler, AllProjectQuery, IEnumerable <ProjectListDTO> >(new AllProjectQuery()));
}
public Task <IEnumerable <TeamListDTO> > Get()
{
return(queryProcessor.ProcessAsync <TeamQueryHandler, AllTeamQuery, IEnumerable <TeamListDTO> >(new AllTeamQuery()));
}
public static Task <TResult> ProcessAsync <TResult>(
this IQueryProcessor queryProcessor,
IQuery <TResult> query)
{
return(queryProcessor.ProcessAsync(query, CancellationToken.None));
}
public async Task <BookingResource> GetBooking(string bookingId)
{
var booking = await _queryProcessor.ProcessAsync(new BookingIdQuery(bookingId), CancellationToken.None);
return(new BookingResource(Url, booking));
}
public async Task <VehicleEntity> GetVehicleByIdAsync(VehicleId id, CancellationToken ctx)
{
var result = await _queryProcessor.ProcessAsync(new ReadModelByIdQuery <VehicleReadModel>(id), ctx);
return(result?.ToVehicle());
}
public async Task <AssignmentDto[]> GetAll()
{
var a = await _queryProcessor.ProcessAsync(new GetAllAssignmentsQuery(), CancellationToken.None);
return(a);
}
/// <inheritdoc />
public Task <TResult> GetResultAsync <TResult>(IQuery <TResult> query)
{
return(_queryProcessor.ProcessAsync(query));
}
public async Task <IEnumerable <PayoutDto> > GetAll()
{
return(await _queryProcessor.ProcessAsync(new GetAllPayoutQuery(), CancellationToken.None).ConfigureAwait(false));
}
public void ProcessAsync_ThrowsException_WhenQueryIsNull()
{
_getSomething = null;
Assert.ThrowsAsync <ArgumentNullException>(async() => await _sut.ProcessAsync <GetSomething, Something>(_getSomething));
}
public async Task <ActionResult> Index(GetAccountIndex query)
{
var accountIndex = await _queryProcessor.ProcessAsync(query);
return(View(accountIndex));
}
public Task <IEnumerable <TaskStateListDTO> > GetStates()
{
return(queryProcessor.ProcessAsync <TaskQueryHandler, AllStateQuery, IEnumerable <TaskStateListDTO> >(new AllStateQuery()));
}
public async Task <ActionResult <ExampleReadModel> > GetExample(string id)
{
var readModel = await _queryProcessor.ProcessAsync(new ReadModelByIdQuery <ExampleReadModel>(id), CancellationToken.None);
return(Ok(readModel));
}
public async Task <object> Handle(string queryName, string content)
{
return(await _queryProcessor.ProcessAsync <object>(queryName, JObject.Parse(content)));
}
private async Task <object> Handle(string queryName, string content)
{
return(await _queryProcessor.ProcessAsync <object>(queryName, content));
}
