public Task HandleAsync(SeatsReserved evnt)
{
return(TryTransactionAsync(async(connection, transaction) =>
{
var effectedRows = await connection.UpdateAsync(new
{
Version = evnt.Version,
EventSequence = evnt.Sequence
}, new
{
Id = evnt.AggregateRootId,
Version = evnt.Version - 1
}, ConfigSettings.ConferenceTable, transaction);
if (effectedRows == 1)
{
var tasks = new List <Task>();
//插入预定记录
foreach (var reservationItem in evnt.ReservationItems)
{
tasks.Add(connection.InsertAsync(new
{
ConferenceId = evnt.AggregateRootId,
ReservationId = evnt.ReservationId,
SeatTypeId = reservationItem.SeatTypeId,
Quantity = reservationItem.Quantity
}, ConfigSettings.ReservationItemsTable, transaction));
}
//更新位置的可用数量
foreach (var seatAvailableQuantity in evnt.SeatAvailableQuantities)
{
tasks.Add(connection.UpdateAsync(new
{
AvailableQuantity = seatAvailableQuantity.AvailableQuantity
}, new
{
ConferenceId = evnt.AggregateRootId,
Id = seatAvailableQuantity.SeatTypeId
}, ConfigSettings.SeatTypeTable, transaction));
}
await Task.WhenAll(tasks);
}
}));
}
public when_reservation_confirmation_is_received_for_non_current_correlation_id()
{
var makeReservationCommand = sut.Commands.Select(e => e.Body).OfType <MakeSeatReservation>().Single();
var seatsReserved = new SeatsReserved {
SourceId = conferenceId, ReservationId = makeReservationCommand.ReservationId, ReservationDetails = new SeatQuantity[0]
};
try {
sut.Handle(new Envelope <SeatsReserved>(seatsReserved)
{
CorrelationId = Guid.NewGuid().ToString()
});
} catch (InvalidOperationException e) {
exception = e;
}
}
private void OnSeatsReserved(SeatsReserved e)
{
var details = e.ReservationDetails.ToList();
if (details.Count > 0)
{
pendingReservations[e.ReservationId] = details;
}
else
{
pendingReservations.Remove(e.ReservationId);
}
foreach (var seat in e.AvailableSeatsChanged)
{
remainingSeats[seat.SeatType] = remainingSeats[seat.SeatType] + seat.Quantity;
}
}
public void Setup()
{
this._sut = new RegistrationProcessManager();
this._orderId = Guid.NewGuid();
this._conferenceId = Guid.NewGuid();
var seatType = Guid.NewGuid();
this._sut.Handle(
new OrderPlaced {
SourceId = this._orderId,
ConferenceId = this._conferenceId,
Seats = new[] { new SeatQuantity(Guid.NewGuid(), 2) },
ReservationAutoExpiration = DateTime.UtcNow.Add(TimeSpan.FromMinutes(22))
});
var makeReservationCommand = this._sut.Commands.Select(e => e.Body).OfType <MakeSeatReservation>().Single();
this._reservationId = makeReservationCommand.ReservationId;
this._sut.Handle(
new Envelope <SeatsReserved>(
new SeatsReserved {
SourceId = this._conferenceId,
ReservationId = makeReservationCommand.ReservationId,
ReservationDetails = new[] { new SeatQuantity(seatType, 2) }
})
{
CorrelationId = makeReservationCommand.Id.ToString()
});
var makeReservationCommand1 = _sut.Commands.Select(e => e.Body).OfType <MakeSeatReservation>().Single();
var seatsReserved = new SeatsReserved {
SourceId = this._conferenceId, ReservationId = makeReservationCommand.ReservationId, ReservationDetails = new SeatQuantity[0]
};
this._initialCommandCount = this._sut.Commands.Count();
_sut.Handle(new Envelope <SeatsReserved>(seatsReserved)
{
CorrelationId = makeReservationCommand1.Id.ToString()
});
}
public void MakeReservation(Guid reservationId, IEnumerable <SeatQuantity> wantedSeats)
{
var wantedList = wantedSeats.ToList();
if (wantedList.Any(x => !this._remainingSeats.ContainsKey(x.SeatType)))
{
throw new ArgumentOutOfRangeException("wantedSeats");
}
var difference = new Dictionary <Guid, SeatDifference>();
foreach (var seatQuantity in wantedList)
{
var item = GetOrAdd(difference, seatQuantity.SeatType);
item.Wanted = seatQuantity.Quantity;
item.Remaining = this._remainingSeats[seatQuantity.SeatType];
}
List <SeatQuantity> existing;
if (this._pendingReservations.TryGetValue(reservationId, out existing))
{
foreach (var seatQuantity in existing)
{
GetOrAdd(difference, seatQuantity.SeatType).Existing = seatQuantity.Quantity;
}
}
var reservation = new SeatsReserved()
{
ReservationId = reservationId,
ReservationDetails =
difference.Select(x => new SeatQuantity(x.Key, x.Value.Actual)).Where(x => x.Quantity != 0).ToList(),
AvailableSeatsChanged =
difference.Select(x => new SeatQuantity(x.Key, -x.Value.DeltaSinceLast)).Where(x => x.Quantity != 0)
.ToList()
};
this.Update(reservation);
}
public void Handle(SeatsReserved @event)
{
UpdateAvailableQuantity(@event, @event.AvailableSeatsChanged);
}
/// <summary>
/// Handle the event.
/// </summary>
/// <param name="event">The <see cref="IEvent"/> to handle.</param>
public Task HandleAsync(SeatsReserved @event)
{
MakePayment makePayment = new MakePayment();
return(this.EventContext.Request.Processor.ProcessAsync(makePayment));
}
