public Task HandleAsync(
IDomainEvent <ThingyAggregate, ThingyId, ThingySagaExceptionRequestedEvent> domainEvent,
ISagaContext sagaContext,
CancellationToken cancellationToken)
{
throw new Exception("Exception thrown (as requested by ThingySagaExceptionRequestedEvent)");
}
public Task HandleAsync(OrderApproved message, ISagaContext context)
{
_logger.LogInformation($"Completed a saga for order: {Data.OrderId}, customer: {Data.CustomerId}," +
$"parcels: {string.Join(", ", Data.ParcelIds)}");
return(CompleteAsync());
}
public Task HandleAsync(Message2 message, ISagaContext context)
{
Data.IsMessage2 = true;
Console.WriteLine("M2 reached!");
Reject();
return(Task.CompletedTask);
}
public Task HandleAsync(IDomainEvent <Room, Room.RoomId, RoomOccupied> domainEvent,
ISagaContext sagaContext, CancellationToken cancellationToken)
{
Publish(new AssignRoom(_reservationId, domainEvent.AggregateIdentity));
return(Task.FromResult(0));
}
public Task HandleAsync(SynchronizationDataMergedEvent @event, ISagaContext sagaContext)
{
logger.LogInformation($"{nameof(@event)} ({sagaContext.CorrelationId}) {this.GetType()}");
// send email notification command
return(Task.CompletedTask);
}
public Task CompensateAsync(Message2 message, ISagaContext context)
{
Console.BackgroundColor = ConsoleColor.Blue;
Console.WriteLine($"COMPANSATE M2 with message: {message.Text}");
return(Task.CompletedTask);
}
public override SagaId ResolveId(object message, ISagaContext context)
{
return(message switch
{
Message m => m.SagaId.ToString(),
_ => base.ResolveId(message, context),
});
public Task HandleAsync(IDomainEvent <Reservation, ReservationId, RoomAssigned> domainEvent,
ISagaContext sagaContext, CancellationToken cancellationToken)
{
Complete();
return(Task.FromResult(0));
}
public Task HandleAsync(Message1 message, ISagaContext context)
{
Data.IsMessage1 = true;
Console.WriteLine("M1 reached!");
CompleteSaga();
return(Task.CompletedTask);
}
public Task HandleAsync(
IDomainEvent <SagaTestAggregate, SagaTestAggregateId, SagaTestEventC> domainEvent,
ISagaContext sagaContext,
CancellationToken cancellationToken)
{
return(Task.FromResult(0));
}
private async Task ProcessAsync <TMessage>(TMessage message, ISagaAction <TMessage> action,
Func <TMessage, ISagaContext, Task> onCompleted, Func <TMessage, ISagaContext, Task> onRejected,
ISagaContext context = null) where TMessage : class
{
context = context ?? SagaContext.Empty;
var saga = (ISaga)action;
var sagaType = saga.GetType();
var id = saga.ResolveId(message, context);
var dataType = saga.GetSagaDataType();
await Semaphore.WaitAsync();
try
{
var state = await _repository.ReadAsync(id, sagaType).ConfigureAwait(false);
if (state is null)
{
if (!(action is ISagaStartAction <TMessage>))
{
return;
}
state = CreateSagaState(id, sagaType, dataType);
}
else if (state.State == SagaStates.Rejected)
{
return;
}
InitializeSaga(saga, id, state);
try
{
await action.HandleAsync(message, context);
}
catch (Exception e)
{
context.SagaContextError = new SagaContextError(e);
saga.Reject();
}
await UpdateSagaAsync(message, saga, state);
}
finally
{
Semaphore.Release();
}
if (saga.State is SagaStates.Rejected)
{
await onRejected(message, context);
await CompensateAsync(saga, sagaType, context);
}
else if (saga.State is SagaStates.Completed)
{
await onCompleted(message, context);
}
}
public async Task HandleAsync(OrderCreated message, ISagaContext context)
{
var tasks = Data.ParcelIds.Select(id =>
_publisher.SendAsync(new AddParcelToOrder(Data.OrderId, id, Data.CustomerId),
_accessor.CorrelationContext));
await Task.WhenAll(tasks);
}
public Task HandleAsync(
IDomainEvent <SagaTestAggregate, SagaTestAggregateId, SagaTestEventB> domainEvent,
ISagaContext sagaContext,
CancellationToken cancellationToken)
{
Publish(new SagaTestCCommand(domainEvent.AggregateIdentity));
return(Task.FromResult(0));
}
public async Task HandleAsync(SynchronizationAcceptedEvent @event, ISagaContext sagaContext)
{
logger.LogInformation($"{nameof(@event)} ({sagaContext.CorrelationId}) {this.GetType()}");
await busPublisher.SendAsync(
new MergeSynchronizationDataCommand(),
CorrelationContext.Create(sagaContext.CorrelationId));
}
public override SagaId ResolveId(object message, ISagaContext context)
{
switch (message)
{
case SignedIn m: return(SagaId.NewSagaId());
default: return(base.ResolveId(message, context));
}
}
public async Task HandleAsync(MakeOrder message, ISagaContext context)
{
_logger.LogInformation($"Started a saga for order: {message.OrderId}, customer: {message.CustomerId}," +
$"parcels: {message.ParcelId}");
Data.ParcelIds.Add(message.ParcelId);
Data.OrderId = message.OrderId;
Data.CustomerId = message.CustomerId;
await _publisher.SendAsync(new CreateOrder(Data.OrderId, message.CustomerId), _accessor.CorrelationContext);
}
public Task HandleAsync(IDomainEvent <Reservation, ReservationId, RoomOccupyRequested> domainEvent,
ISagaContext sagaContext, CancellationToken cancellationToken)
{
Publish(new OccupyRoom(
domainEvent.AggregateEvent.RoomId,
_reservationId,
new Range(domainEvent.AggregateEvent.Arrival, domainEvent.AggregateEvent.Departure)));
return(Task.FromResult(0));
}
public Task HandleAsync(
IDomainEvent <KontoAggregate, KontoId, Abgebucht> domainEvent,
ISagaContext sagaContext,
CancellationToken cancellationToken)
{
this.Emit(new BezahlungAbgeschlossen());
this.Publish(new BezahlungAbschliessenCommand(this.Id));
this.Complete();
return(Task.CompletedTask);
}
public async Task HandleAsync(
IDomainEvent <BankStatementAggregate, BankStatementId, BankStatementTextMatched3Event> domainEvent,
ISagaContext sagaContext, CancellationToken cancellationToken)
{
if (State != SagaState.Running)
{
throw DomainError.With("Saga must be running!");
}
Emit(new BankStatementSagaTextMatchedEvent());
await Task.CompletedTask;
}
/// <summary>
/// Завершает обработку саги.
/// </summary>
/// <param name="sagaContext">Завершаемая сага.</param>
public void FinilizeSaga(ISagaContext <TS, TK> sagaContext)
{
if (sagaContext.Completed)
{
this.SagaRepository.Remove(sagaContext);
}
else
{
this.SagaRepository.Store(sagaContext);
}
}
public Task HandleAsync(
IDomainEvent <KontoAggregate, KontoId, KontoEroeffnet> domainEvent,
ISagaContext sagaContext,
CancellationToken cancellationToken)
{
var kontoId = domainEvent.AggregateIdentity;
this.Emit(new KontoZugeordnet(kontoId));
this.PublishAbbuchenCommand(kontoId, this.state.Beschreibung, this.state.Betrag);
return(Task.CompletedTask);
}
public override Guid ResolveId(object message, ISagaContext context)
{
switch (message)
{
case CustomerCreated cc: return(cc.Id);
case OrderCreated cc: return(cc.CustomerId);
default: return(base.ResolveId(message, context));
}
}
public async Task HandleAsync(TourRegistrationClosed message, ISagaContext context)
{
await _busPublisher.SendAsync(
new GenerateTeams(
message.TourId,
message.LeagueId,
message.PlayersInTeam,
message.TeamsInTour,
message.Pid,
message.GenerateTeamsStrategy),
CorrelationContext.Empty);
}
private async Task CompensateAsync(ISaga saga, Type sagaType, ISagaContext context)
{
var sagaLogs = await _log.ReadAsync(saga.Id, sagaType);
sagaLogs.OrderByDescending(l => l.CreatedAt)
.Select(l => l.Message)
.ToList()
.ForEach(async message =>
{
await((Task)saga.InvokeGeneric(nameof(ISagaAction <object> .CompensateAsync), message, context))
.ConfigureAwait(false);
});
}
public Task HandleAsync(
IDomainEvent <ThingyAggregate, ThingyId, ThingySagaStartRequestedEvent> domainEvent,
ISagaContext sagaContext,
CancellationToken cancellationToken)
{
// This check is redundant! We do it to verify EventFlow works correctly
if (State != SagaState.New)
{
throw DomainError.With("Saga must be new!");
}
Emit(new ThingySagaStartedEvent(domainEvent.AggregateIdentity));
return(Task.FromResult(0));
}
public Task HandleAsync(
IDomainEvent <Reservation, ReservationId, ReservationCreated> domainEvent,
ISagaContext sagaContext,
CancellationToken cancellationToken)
{
Emit(new StartedReservationSaga(domainEvent.AggregateIdentity));
Publish(new OccupyAnyAvailableRoom(
domainEvent.AggregateIdentity,
domainEvent.AggregateEvent.CheckInTime,
domainEvent.AggregateEvent.CheckOutTime));
return(Task.FromResult(0));
}
public Task HandleAsync(
IDomainEvent <ExampleAggregate, ExampleId, ResetEvent> domainEvent,
ISagaContext sagaContext,
CancellationToken cancellationToken)
{
// This check is redundant! We do it to verify EventFlow works correctly
if (State != SagaState.Running)
{
throw DomainError.With("Saga must be running!");
}
Emit(new ExampleSagaCompletedEvent());
return(Task.FromResult(0));
}
private void CheckStateCompletion(ISagaContext <TState, TKey> context, TKey key, TState state)
{
if (context.IsAborted)
{
_repository.RemoveState(key);
return;
}
if (context.IsCompleted)
{
_repository.RemoveState(key);
OnComplete?.Invoke(MessageBus, state);
return;
}
_repository.SaveExisting(key, context);
}
public async Task HandleAsync(
IDomainEvent <PatientAggregate, PatientId, CancerPatientWithHeadAndNeckTopygraphyIsRegistered> @event,
ISagaContext sagaContext, CancellationToken cancellationToken)
{
this.Emit(new ConsultationSchedulingIsStartedEvent(@event.AggregateIdentity,
@event.AggregateEvent.RegistrationDate));
var doctors = await _queryProcessor.ProcessAsync(DoctorQueriesFactory.GetAllOncologists, cancellationToken).ConfigureAwait(false);
var machines = await _queryProcessor.ProcessAsync(TreatmentMachineQueriesFactory.GetWithAdvanceCapability, cancellationToken).ConfigureAwait(false);
var machineIds = machines.Select(x => x.Id);
var rooms = await _queryProcessor.ProcessAsync(TreatmentRoomQueriesFactory.RoomsEquippedWithAnyOfTheseMachines(machineIds), cancellationToken).ConfigureAwait(false);
await HandleReservation(rooms, doctors).ConfigureAwait(false);
}
public async Task CompensateAsync(OrderCreated message, ISagaContext context)
{
var diff = DateTime.UtcNow.Subtract(Data.CustomerCreatedAt);
if (diff.TotalHours <= CreationHoursLimit)
{
await _busPublisher.SendAsync(new CreateOrderDiscount(
message.Id, message.CustomerId, 10), CorrelationContext.Empty);
Complete();
}
else
{
Reject();
}
}
