public async Task UpdateSingleField_WithDeltaUpdateStrategy_Success()
{
var initialAddressInstance = new AddressAggregate
{
HouseNumber = "40",
Street = "Grove Street",
Town = "Manchester",
Postcode = "M1 1AA"
};
var initialUnitOfWork = new AddressUnitOfWork(Database, CollectionName);
initialUnitOfWork.Addresses.Add(initialAddressInstance);
await initialUnitOfWork.CommitAsync();
var outerUpdateUnitOfWork = new AddressUnitOfWork(Database, CollectionName);
var innerUpdateUnitOfWork = new AddressUnitOfWork(Database, CollectionName);
var outerUpdateInstance =
await outerUpdateUnitOfWork.Addresses.QuerySingleAsync(a => a.Id == initialAddressInstance.Id);
var innerUpdateInstance =
await outerUpdateUnitOfWork.Addresses.QuerySingleAsync(a => a.Id == initialAddressInstance.Id);
innerUpdateInstance.HouseNumber = "30";
await innerUpdateUnitOfWork.CommitAsync();
outerUpdateInstance.Street = "Wood Avenue";
await outerUpdateUnitOfWork.CommitAsync();
var result = await initialUnitOfWork.Addresses.QuerySingleAsync(a => a.Id == initialAddressInstance.Id);
Assert.AreEqual("30", result.HouseNumber);
Assert.AreEqual("Wood Avenue", result.Street);
}
private int UpdateAddress()
{
address address;
var addressAggregate = new AddressAggregate()
{
Address1 = customer.Address1,
Address2 = customer.Address2,
PostalCode = customer.PostalCode,
CountryName = customer.Country,
CityName = customer.City,
Phone = customer.Phone
};
try
{
address = addressService.FindByAddressAndPostalCode(addressAggregate.Address1, addressAggregate.Address2, addressAggregate.PostalCode);
addressAggregate.CityId = address.cityId;
addressAggregate.AddressId = address.addressId;
addressService.UpdateAddress(addressAggregate);
}
catch (NotFoundException e)
{
addressService.addNewAddress(addressAggregate);
address = addressService.FindByAddressAndPostalCode(addressAggregate.Address1, addressAggregate.Address2, addressAggregate.PostalCode);
}
return(address.addressId);
}
protected virtual void Add(Person person)
{
var aggregate = new PersonAggregate(person);
var nameAggregate = new NameAggregate(person.Name, person.Id);
var addressAggregate = new AddressAggregate(person.Address, person.Id);
context.Set <PersonAggregate>().Add(aggregate);
context.Set <NameAggregate>().Add(nameAggregate);
context.Set <AddressAggregate>().Add(addressAggregate);
}
private void ValidateAddressAggregate(AddressAggregate addressAggregate)
{
if (String.IsNullOrEmpty(addressAggregate.CityName))
{
throw new InvalidInputException("Must include city value");
}
if (String.IsNullOrEmpty(addressAggregate.CountryName))
{
throw new InvalidInputException("Must include country value");
}
if (String.IsNullOrEmpty(addressAggregate.Address1))
{
throw new InvalidInputException("Must include address value");
}
if (String.IsNullOrEmpty(addressAggregate.PostalCode))
{
throw new InvalidInputException("Must include postal code value");
}
if (String.IsNullOrEmpty(addressAggregate.Phone))
{
throw new InvalidInputException("Must include phone number value");
}
}
public void UpdateAddress(AddressAggregate addressAggregate)
{
var countryId = GetUpdatedCountryId(addressAggregate.CountryName);
var cityId = GetUpdatedCityId(addressAggregate.CityId, addressAggregate.CityName, countryId);
var existingAddress = FindByAddressAndPostalCode(addressAggregate.Address1, addressAggregate.Address2, addressAggregate.PostalCode);
var address = new address()
{
cityId = cityId,
address1 = addressAggregate.Address1,
address2 = addressAggregate.Address2,
addressId = addressAggregate.AddressId,
phone = addressAggregate.Phone,
postalCode = addressAggregate.PostalCode,
createdBy = existingAddress.createdBy,
createDate = existingAddress.createDate,
lastUpdate = DateTime.Now.ToUniversalTime(),
lastUpdateBy = _authRepository.Username
};
_repository.Update(address, address.addressId);
}
public async Task <OrderEntity> CreateOrderAsync(string buyerEmail, int deliveryMethodId, string basketId, AddressAggregate shippingAddress)
{
// get basket from the repo
var basket = await _basketRepo.GetBasketAsync(basketId);
// get items from product repo
var items = new List <OrderItemEntity>();
foreach (var item in basket.Items)
{
var productItem = await _unitOfWork.Repository <ProductEntity>().GetByIdAsync(item.Id);
var itemOrdered = new ProductItemOrdered(productItem.Name, productItem.Id, productItem.PictureUrl);
var orderItem = new OrderItemEntity(itemOrdered, productItem.Price, item.Quantity);
items.Add(orderItem);
}
// get delivery method from the repo
var deliveryMethod = await _unitOfWork.Repository <DeliveryMethodEntity>().GetByIdAsync(deliveryMethodId);
// calculate subtotal
var subTotal = items.Sum(a => a.Price * a.Quantity);
// check to see if order is exists
var spec = new OrderByPaymentIntentIdSpecification(basket.PaymentIntentId);
var existingOrder = await _unitOfWork.Repository <OrderEntity>().GetEntityWithSpec(spec);
if (existingOrder != null)
{
_unitOfWork.Repository <OrderEntity>().Delete(existingOrder);
await _paymentService.CreateOrUpdatePaymentIntent(basket.PaymentIntentId);
}
// create order
var order = new OrderEntity(items, buyerEmail, deliveryMethod, shippingAddress, subTotal, basket.PaymentIntentId);
_unitOfWork.Repository <OrderEntity>().Add(order);
// save to db
var result = await _unitOfWork.Complete();
// return order
if (result <= 0)
{
return(null);
}
return(order);
}
private static async Task UpdateOrInsertAggregateAsync(IDbConnection sqlCon, IDbTransaction trans, AddressAggregate addAgg, bool isInsert)
{
await sqlCon.ExecuteAsync(isInsert?AddressAggregateInsertSql : AddressAggregateUpdateSql, new
{
addAgg.AddressId,
addAgg.LastBlockHeight,
addAgg.Balance,
addAgg.ReceivedAmount,
addAgg.ReceivedCount,
addAgg.SentAmount,
addAgg.SentCount,
UpdatedOn = DateTime.Now
}, trans);
}
public void addNewAddress(AddressAggregate addressAggregate)
{
ValidateAddressAggregate(addressAggregate);
var username = _authRepository.Username;
try
{
var existingAddress = FindByAddressAndPostalCode(addressAggregate.Address1, addressAggregate.Address2, addressAggregate.PostalCode);
//Already exists
throw new DataIntegrityViolationException("Address already exists");
}
catch (NotFoundException e)
{
try
{
var country = countryService.findByName(addressAggregate.CountryName);
addressAggregate.CountryId = country.countryId;
}
catch (NotFoundException ex)
{
countryService.add(new country()
{
country1 = addressAggregate.CountryName,
lastUpdate = DateTime.Now.ToUniversalTime(),
createdBy = username,
lastUpdateBy = username,
createDate = DateTime.Now.ToUniversalTime()
});
var country = countryService.findByName(addressAggregate.CountryName);
addressAggregate.CountryId = country.countryId;
}
try
{
var city = cityService.findByNameAndCountryId(addressAggregate.CityName, addressAggregate.CountryId);
addressAggregate.CityId = city.cityId;
}
catch (NotFoundException ex)
{
cityService.add(new city()
{
countryId = addressAggregate.CountryId,
city1 = addressAggregate.CityName,
lastUpdateBy = username,
createdBy = username,
createDate = DateTime.Now.ToUniversalTime(),
lastUpdate = DateTime.Now.ToUniversalTime()
});
var city = cityService.findByNameAndCountryId(addressAggregate.CityName, addressAggregate.CountryId);
addressAggregate.CityId = city.cityId;
}
_repository.Add(new address()
{
cityId = addressAggregate.CityId,
address1 = addressAggregate.Address1,
address2 = addressAggregate.Address2,
createDate = DateTime.Now.ToUniversalTime(),
lastUpdate = DateTime.Now.ToUniversalTime(),
createdBy = username,
lastUpdateBy = username,
phone = addressAggregate.Phone,
postalCode = addressAggregate.PostalCode
});
}
}
