public async Task UpsertAsync(AccountCardDetails cardDetails, CancellationToken ct = default(CancellationToken))
{
//if it exists
var existingDetails = await GetAsync(cardDetails.AccountId, ct);
if (existingDetails != null)
{
//TODO: Compare byte[] versions
AggregateLock aggregateLock = null;
try
{
//lock it
aggregateLock = await LockAsync(cardDetails.AccountId.ToString(), "SYS", ct);
//update it
await UpdateAsync(cardDetails, aggregateLock, ct);
}
finally
{
if (aggregateLock != null)
{
await aggregateLock.ReleaseAsync();
}
}
}
else
{
//add it
await AddAsync(cardDetails, ct);
}
}
public async Task HandleAsync(UpsertAccountEvent @event, CancellationToken cancellationToken = new CancellationToken())
{
using (var uow = new CardDetailsContext(_options))
{
var billingAddress = @event.Addresses.FirstOrDefault(addr => addr.AddressType == "Billing");
if (billingAddress == null)
{
throw new ArgumentException("Must have a billing address", "@event");
}
var repository = new AccountCardDetailsRepositoryAsync(new EFUnitOfWork(uow));
var cardDetails = new AccountCardDetails(
accountId: Guid.Parse(@event.AccountId),
name: @event.Name.FirstName + " " + @event.Name.LastName,
cardNumber: @event.CardDetails.CardNumber,
cardSecurityCode: @event.CardDetails.CardSecurityCode,
firstLineOfAddress: billingAddress.FistLineOfAddress,
zipCode: billingAddress.ZipCode
);
cardDetails.Version = @event.Version;
await repository.UpsertAsync(cardDetails);
}
}
public async Task When_adding_card_details()
{
using (var uow = new CardDetailsContext(_options))
{
//arrange
var cardDetails = new AccountCardDetails(
Guid.NewGuid(),
"Jack TOrrance",
"4104231121998973",
"517",
"3 Kennebunkport Avenue",
"OH");
var repository = new AccountCardDetailsRepositoryAsync(new EFUnitOfWork(uow));
//act
await repository.AddAsync(cardDetails);
var savedRecord = await repository.GetAsync(cardDetails.AccountId);
//assert
Assert.That(savedRecord.AccountId, Is.EqualTo(cardDetails.AccountId));
Assert.That(savedRecord.Name, Is.EqualTo(cardDetails.Name));
Assert.That(savedRecord.CardNumber, Is.EqualTo(cardDetails.CardNumber));
Assert.That(savedRecord.CardSecurityCode, Is.EqualTo(cardDetails.CardSecurityCode));
Assert.That(savedRecord.FirstLineOfAddress, Is.EqualTo(cardDetails.FirstLineOfAddress));
Assert.That(savedRecord.ZipCode, Is.EqualTo(cardDetails.ZipCode));
}
}
public async Task When_updating_an_account()
{
using (var uow = new CardDetailsContext(_options))
{
//arrange
var cardDetails = new AccountCardDetails(
accountId: Guid.NewGuid(),
name: "Jack Torrance",
cardNumber: "4104231121998973",
cardSecurityCode: "517",
firstLineOfAddress: "Overlook Hotel",
zipCode: "40125"
);
var repository = new AccountCardDetailsRepositoryAsync(new EFUnitOfWork(uow));
await repository.AddAsync(cardDetails);
var @event = new UpsertAccountEvent()
{
AccountId = cardDetails.AccountId.ToString(),
Name = new Name {
FirstName = "Charles", LastName = "Grady"
},
Addresses = new List <Address>
{
new Address
{
FistLineOfAddress = "Overlook Hotel",
AddressType = "Billing",
State = "CO",
ZipCode = "80517"
}
},
ContactDetails = new ContactDetails
{
Email = "*****@*****.**", TelephoneNumber = "666-6666"
},
CardDetails = new CardDetails {
CardNumber = "4172097052597788", CardSecurityCode = "459"
},
Version = new byte[] { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 }
};
var handler = new UpsertAccountEventHandler(_options);
//act
await handler.HandleAsync(@event);
var accountCardDetails = await repository.GetAsync(Guid.Parse(@event.AccountId));
//assert
Assert.That(accountCardDetails.AccountId, Is.EqualTo(Guid.Parse(@event.AccountId)));
Assert.That(accountCardDetails.Name, Is.EqualTo(@event.Name.FirstName + " " + @event.Name.LastName));
var sourceAddress = @event.Addresses.First(addr => addr.AddressType == "Billing");
Assert.That(accountCardDetails.FirstLineOfAddress, Is.EqualTo(sourceAddress.FistLineOfAddress));
Assert.That(accountCardDetails.ZipCode, Is.EqualTo(sourceAddress.ZipCode));
}
}
private void TakePayment(AccountCardDetails cardDetails)
{
//TODO: We are just logging here, over calling a payment provider, which is what you would really want to do
_logger.Log(LogLevel.Information,
"Payment request for account with CC {0} and CVC {1}",
cardDetails.CardNumber,
cardDetails.CardSecurityCode);
}
public async Task UpsertAsync(AccountCardDetails cardDetails, CancellationToken ct = default(CancellationToken))
{
//if it exists
var existingDetails = await GetAsync(cardDetails.AccountId, ct);
if (existingDetails != null)
{
AggregateLock aggregateLock = null;
try
{
//lock it
aggregateLock = await LockAsync(cardDetails.AccountId.ToString(), "SYS", ct);
//TODO: We should really check for later timestamp before updating
//TODO: If the lock returned the card details we might be able to avoid this
var toChange = await GetAsync(cardDetails.AccountId, ct);
toChange.Name = cardDetails.Name;
toChange.Version = cardDetails.Version;
toChange.CardNumber = cardDetails.CardNumber;
toChange.ZipCode = cardDetails.ZipCode;
toChange.CardSecurityCode = cardDetails.CardSecurityCode;
toChange.FirstLineOfAddress = cardDetails.FirstLineOfAddress;
//update it
await UpdateAsync(ct);
}
finally
{
if (aggregateLock != null)
{
await aggregateLock.ReleaseAsync();
}
}
}
else
{
//add it
await AddAsync(cardDetails, ct);
}
}
public async Task AddAsync(AccountCardDetails cardDetails, CancellationToken ct = default(CancellationToken))
{
await _unitOfWork.AddAsync(cardDetails, ct);
}
private async Task UpdateAsync(AccountCardDetails cardDetails, AggregateLock aggregateLock, CancellationToken ct = default(CancellationToken))
{
await _unitOfWork.AddAsync(cardDetails, ct);
}
/// <summary>
/// Save the item
/// </summary>
/// <param name="account">The account to save</param>
/// <param name="ct">Cancel the operataion</param>
public async Task UpdateAsync(AccountCardDetails account, CancellationToken ct = default(CancellationToken))
{
await _context.SaveChangesAsync(ct);
}
/// <summary>
/// Save the item
/// </summary>
/// <param name="account">The account to save</param>
/// <param name="ct">Cancel the operataion</param>
public async Task AddAsync(AccountCardDetails account, CancellationToken ct = default(CancellationToken))
{
_context.Accounts.Add(account);
await _context.SaveChangesAsync(ct);
}