public virtual async Task <IHttpActionResult> UpdateCart(UpdateCartRequest updateCartRequest)
{
if (updateCartRequest == null)
{
return(BadRequest("updateCartRequest is required"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var getCartParam = new GetCartParam
{
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo,
CustomerId = ComposerContext.CustomerId,
CartName = CartConfiguration.ShoppingCartName,
BaseUrl = RequestUtils.GetBaseUrl(Request).ToString(),
};
var updateCheckoutCartParam = new UpdateCheckoutCartParam
{
GetCartParam = getCartParam,
CurrentStep = updateCartRequest.CurrentStep.GetValueOrDefault(),
IsGuest = ComposerContext.IsGuest,
UpdateValues = updateCartRequest.UpdatedCart
};
var updateCartResultViewModel = await CheckoutService.UpdateCheckoutCartAsync(updateCheckoutCartParam);
return(Ok(updateCartResultViewModel));
}
public async Task WHEN_Passing_Valid_Paramaters_SHould_Update_LastCheckoutStep()
{
//Arrange
var cart = CreateBasicCart();
cart.Shipments = new List <Shipment>
{
new Shipment
{
LineItems = new List <LineItem>
{
new LineItem()
}
}
};
var service = CreateCheckoutService(cart);
// Act
var param = new UpdateCheckoutCartParam
{
GetCartParam = CreateGetCartParam(),
UpdateValues = new Dictionary <string, string>(),
CurrentStep = 2,
IsGuest = GetRandom.Boolean()
};
var processedCart = await service.UpdateCheckoutCartAsync(param);
//Assert
processedCart.Should().NotBeNull();
processedCart.Cart.OrderSummary.CheckoutRedirectAction.LastCheckoutStep.ShouldBeEquivalentTo(3);
}
public async Task WHEN_CustomMethod_Registered_AND_Passing_Valid_Parameters_SHOULD_Update_GuestCustomerInfo()
{
//Arrange
var cart = CreateBasicCart();
cart.Customer.Email = GetRandom.Email();
var service = CreateCheckoutService(cart);
var updatedCustomer = new CustomerSummaryViewModel
{
Email = GetRandom.Email()
};
// Act
var param = new UpdateCheckoutCartParam
{
GetCartParam = CreateGetCartParam(),
UpdateValues = CreateUpdateOperation("GuestCustomerInfo", updatedCustomer),
CurrentStep = GetRandom.Int(),
IsGuest = GetRandom.Boolean()
};
var processedCart = await service.UpdateCheckoutCartAsync(param);
//Assert
processedCart.Should().NotBeNull();
processedCart.Cart.Customer.Email.ShouldBeEquivalentTo(updatedCustomer.Email);
}
public virtual async Task <IHttpActionResult> UpdateCart(UpdateCartRequest updateCartRequest)
{
if (updateCartRequest == null)
{
return(BadRequest("updateCartRequest is required"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var getCartUrlParam = new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
};
var checkoutStepInfos = CartUrlProvider.GetCheckoutStepPageInfos(getCartUrlParam);
var nextStepUrl = CartUrlProvider.GetCheckoutStepUrl(new GetCheckoutStepUrlParam
{
CultureInfo = ComposerContext.CultureInfo,
StepNumber = updateCartRequest.CurrentStep.GetValueOrDefault() + 1
});
var getCartParam = new GetCartParam
{
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo,
CustomerId = ComposerContext.CustomerId,
CartName = CartConfiguration.ShoppingCartName,
BaseUrl = RequestUtils.GetBaseUrl(Request).ToString(),
};
var updateCheckoutCartParam = new UpdateCheckoutCartParam
{
GetCartParam = getCartParam,
CurrentStep = updateCartRequest.CurrentStep.GetValueOrDefault(),
IsGuest = ComposerContext.IsGuest,
UpdateValues = updateCartRequest.UpdatedCart
};
var homepageUrl = GetHomepageUrl();
var updateCartResultViewModel = await CheckoutService.UpdateCheckoutCartAsync(updateCheckoutCartParam);
SetHomepageUrl(updateCartResultViewModel.Cart, homepageUrl);
SetEditCartUrl(updateCartResultViewModel.Cart);
if (updateCartResultViewModel.Cart.OrderSummary != null)
{
updateCartResultViewModel.Cart.OrderSummary.CheckoutStepUrls = checkoutStepInfos.Values.Select(x => x.Url).ToList();
}
if (!updateCartResultViewModel.HasErrors)
{
updateCartResultViewModel.NextStepUrl = nextStepUrl;
}
return(Ok(updateCartResultViewModel));
}
public void WHEN_Passing_Null_GetCartParam_Parameter_SHOULD_Throw_Exception()
{
//Arrange
var service = _container.CreateInstance <CheckoutService>();
var param = new UpdateCheckoutCartParam
{
GetCartParam = null,
CurrentStep = GetRandom.Int(),
UpdateValues = new Dictionary <string, string>(),
IsGuest = GetRandom.Boolean()
};
// Act and Assert
Assert.ThrowsAsync <ArgumentException>(() => service.UpdateCheckoutCartAsync(param));
}
public async Task WHEN_Passing_Valid_Parameters_SHOULD_Update_BillingAddress_With_ShippingAddress()
{
//Arrange
var shippingAddress = new Address
{
City = "Paris",
FirstName = GetRandom.String(32),
LastName = GetRandom.String(32),
Line1 = GetRandom.String(32),
Line2 = GetRandom.String(32),
RegionCode = GetRandom.String(32),
CountryCode = GetRandom.String(32),
PhoneNumber = GetRandom.String(32)
};
var cart = CreateBasicCart();
cart.Shipments.First().Address = shippingAddress;
var service = CreateCheckoutService(cart);
var updatedBillingAddress = new BillingAddressViewModel
{
UseShippingAddress = true,
};
// Act
var param = new UpdateCheckoutCartParam
{
GetCartParam = CreateGetCartParam(),
UpdateValues = CreateUpdateOperation("BillingAddress", updatedBillingAddress),
CurrentStep = GetRandom.Int(),
IsGuest = GetRandom.Boolean()
};
var processedCart = await service.UpdateCheckoutCartAsync(param);
//Assert
processedCart.Should().NotBeNull();
processedCart.Cart.Payment.BillingAddress.City.Should().Be("Paris");
processedCart.Cart.Payment.BillingAddress.FirstName.ShouldBeEquivalentTo(shippingAddress.FirstName);
processedCart.Cart.Payment.BillingAddress.LastName.ShouldBeEquivalentTo(shippingAddress.LastName);
processedCart.Cart.Payment.BillingAddress.Line1.ShouldBeEquivalentTo(shippingAddress.Line1);
processedCart.Cart.Payment.BillingAddress.Line2.ShouldBeEquivalentTo(shippingAddress.Line2);
processedCart.Cart.Payment.BillingAddress.RegionCode.ShouldBeEquivalentTo(shippingAddress.RegionCode);
processedCart.Cart.Payment.BillingAddress.CountryCode.ShouldBeEquivalentTo(shippingAddress.CountryCode);
processedCart.Cart.Payment.BillingAddress.PhoneNumber.ShouldBeEquivalentTo(shippingAddress.PhoneNumber);
}
public async Task WHEN_Passing_RegisteredCustomer_Valid_Parameters_SHOULD_Update_ShippingAddress()
{
//Arrange
var cart = CreateBasicCart();
cart.Shipments.First().Address = new Address()
{
City = GetRandom.String(10),
PostalCode = GetRandom.String(6),
Id = Guid.NewGuid()
};
var service = CreateCheckoutService(cart);
var updatedAddress = new RegisteredShippingAddressViewModel
{
ShippingAddressId = Guid.NewGuid()
};
var address = await _container.Get <IAddressRepository>().GetAddressByIdAsync(updatedAddress.ShippingAddressId);
// Act
var param = new UpdateCheckoutCartParam
{
GetCartParam = CreateGetCartParam(),
UpdateValues = CreateUpdateOperation("ShippingAddressRegistered", updatedAddress),
CurrentStep = GetRandom.Int(),
IsGuest = GetRandom.Boolean()
};
var processedCart = await service.UpdateCheckoutCartAsync(param);
//Assert
processedCart.Cart.Should().NotBeNull();
processedCart.Cart.ShippingAddress.AddressBookId.ShouldBeEquivalentTo(updatedAddress.ShippingAddressId);
processedCart.Cart.ShippingAddress.AddressName.ShouldBeEquivalentTo(address.AddressName);
processedCart.Cart.ShippingAddress.City.ShouldBeEquivalentTo(address.City);
processedCart.Cart.ShippingAddress.CountryCode.ShouldBeEquivalentTo(address.CountryCode);
processedCart.Cart.ShippingAddress.FirstName.ShouldBeEquivalentTo(address.FirstName);
processedCart.Cart.ShippingAddress.LastName.ShouldBeEquivalentTo(address.LastName);
processedCart.Cart.ShippingAddress.Line1.ShouldBeEquivalentTo(address.Line1);
processedCart.Cart.ShippingAddress.Line2.ShouldBeEquivalentTo(address.Line2);
processedCart.Cart.ShippingAddress.PhoneNumber.ShouldBeEquivalentTo(address.PhoneNumber);
processedCart.Cart.ShippingAddress.PostalCode.ShouldBeEquivalentTo(address.PostalCode);
processedCart.Cart.ShippingAddress.RegionCode.ShouldBeEquivalentTo(address.RegionCode);
}
public async Task WHEN_Passing_Valid_Parameters_SHOULD_Update_ShippingMethod()
{
//Arrange
var updatedShippingMethod = new ShippingMethodViewModel
{
Name = GetRandom.String(32),
ShippingProviderId = Guid.NewGuid(),
Cost = GetRandom.PositiveInt(100).ToString(),
};
var mock = new Mock <IFulfillmentMethodRepository>();
mock.Setup(repo => repo.GetCalculatedFulfillmentMethods(It.IsAny <GetShippingMethodsParam>()))
.ReturnsAsync(new List <FulfillmentMethod>
{
new FulfillmentMethod(),
new FulfillmentMethod
{
Name = updatedShippingMethod.Name,
ShippingProviderId = updatedShippingMethod.ShippingProviderId
}
});
_container.Use(mock);
var cart = CreateBasicCart();
var service = CreateCheckoutService(cart);
// Act
var param = new UpdateCheckoutCartParam
{
GetCartParam = CreateGetCartParam(),
UpdateValues = CreateUpdateOperation("ShippingMethod", updatedShippingMethod),
CurrentStep = GetRandom.Int(),
IsGuest = GetRandom.Boolean()
};
var processedCart = await service.UpdateCheckoutCartAsync(param);
//Assert
processedCart.Cart.Should().NotBeNull();
processedCart.Cart.ShippingMethod.Name.Should().BeEquivalentTo(updatedShippingMethod.Name);
processedCart.Cart.ShippingMethod.ShippingProviderId.ShouldBeEquivalentTo(updatedShippingMethod.ShippingProviderId);
}
public async Task WHEN_Passing_Valid_Parameters_And_Having_Custom_Field_SHOULD_Update_GuestCustomerInfo()
{
//Arrange
var cart = CreateBasicCart();
cart.Customer.Email = GetRandom.Email();
var service = CreateCheckoutService(cart);
service.RegisterCartUpdateOperation <CustomerSummaryViewModel>("GuestCustomerInfo", UpdateCustomerWithCustomFieldInBag, GetRandom.PositiveInt(100));
var updatedCustomer = new FakeCustomerViewModelWithCustomField
{
Email = "test2",
CustomField = "test3"
};
var jsonViewModel = JsonConvert.SerializeObject(updatedCustomer);
var operations = new Dictionary <string, string> {
{ "GuestCustomerInfo", jsonViewModel }
};
// Act
var param = new UpdateCheckoutCartParam
{
GetCartParam = CreateGetCartParam(),
UpdateValues = operations,
CurrentStep = GetRandom.Int(),
IsGuest = GetRandom.Boolean()
};
var processedCart = await service.UpdateCheckoutCartAsync(param);
//Assert
processedCart.Should().NotBeNull();
processedCart.Cart.Customer.Email.ShouldBeEquivalentTo("test2-test3");
}
/// <summary>
/// Update a Cart during the checkout process.
/// </summary>
/// <param name="param">UpdateCheckoutCartParam</param>
public virtual async Task <UpdateCartResultViewModel> UpdateCheckoutCartAsync(UpdateCheckoutCartParam param)
{
if (param == null)
{
throw new ArgumentNullException("param");
}
if (param.GetCartParam == null)
{
throw new ArgumentException("param");
}
if (param.UpdateValues == null)
{
throw new ArgumentException("UpdateValues");
}
var cart = await CartRepository.GetCartAsync(param.GetCartParam).ConfigureAwait(false);
if (cart == null)
{
throw new InvalidOperationException("No cart found");
}
SetCustomerType(param.IsGuest, cart);
UpdateStepInfo(cart, param.CurrentStep + 1);
var operationsToExecute = GetOperationsToExecute(param.UpdateValues);
foreach (var operation in operationsToExecute)
{
await operation.Invoke(cart);
}
var updatedCart = await CartRepository.UpdateCartAsync(UpdateCartParamFactory.Build(cart)).ConfigureAwait(false);
var createCartViewModelParam = new CreateCartViewModelParam
{
Cart = updatedCart,
CultureInfo = param.GetCartParam.CultureInfo,
BaseUrl = param.GetCartParam.BaseUrl
};
var cartViewModel = await CreateCartViewModelAsync(createCartViewModelParam).ConfigureAwait(false);
var updateCartResultViewModel = new UpdateCartResultViewModel
{
HasErrors = updatedCart.Messages != null && updatedCart.Messages.Any(m => m.Severity == ExecutionMessageSeverity.Error || m.Severity == ExecutionMessageSeverity.Failure),
Cart = cartViewModel
};
return(updateCartResultViewModel);
}
