public async Task ShouldCreateOrderFromCartAndDeleteOrderAsync()
{
CartDraft cartDraft = Helper.GetTestCartDraft(_project, _testCustomers[0].Id);
Response <Cart> cartResponse = await _client.Carts().CreateCartAsync(cartDraft);
Assert.IsTrue(cartResponse.Success);
Cart cart = cartResponse.Result;
Assert.NotNull(cart.Id);
int quantity = 3;
AddLineItemAction addLineItemAction = new AddLineItemAction(_testProduct.Id, _testProduct.MasterData.Current.MasterVariant.Id);
addLineItemAction.Quantity = quantity;
cartResponse = await _client.Carts().UpdateCartAsync(cart, addLineItemAction);
Assert.IsTrue(cartResponse.Success);
cart = cartResponse.Result;
Assert.NotNull(cart.Id);
Assert.NotNull(cart.LineItems);
Assert.AreEqual(cart.LineItems.Count, 1);
Assert.AreEqual(cart.LineItems[0].ProductId, _testProduct.Id);
Assert.AreEqual(cart.LineItems[0].Variant.Id, _testProduct.MasterData.Current.MasterVariant.Id);
Assert.AreEqual(cart.LineItems[0].Quantity, quantity);
OrderFromCartDraft orderFromCartDraft = Helper.GetTestOrderFromCartDraft(cart);
Response <Order> orderResponse = await _client.Orders().CreateOrderFromCartAsync(orderFromCartDraft);
Assert.IsTrue(orderResponse.Success);
Order order = orderResponse.Result;
Assert.NotNull(order.Id);
// To get the new version number.
cartResponse = await _client.Carts().GetCartByIdAsync(cart.Id);
Assert.IsTrue(cartResponse.Success);
cart = cartResponse.Result;
string deletedOrderId = order.Id;
Response <JObject> response = await _client.Orders().DeleteOrderAsync(order);
Assert.IsTrue(response.Success);
orderResponse = await _client.Orders().GetOrderByIdAsync(deletedOrderId);
Assert.IsFalse(orderResponse.Success);
await _client.Carts().DeleteCartAsync(cart);
}
public async Task ShouldAddChangeAndRemoveLineItemAsync()
{
int quantity = 2;
int newQuantity = 3;
AddLineItemAction addLineItemAction =
new AddLineItemAction(_testProduct.Id, _testProduct.MasterData.Current.MasterVariant.Id);
addLineItemAction.Quantity = quantity;
Response <Cart> response = await _client.Carts().UpdateCartAsync(_testCarts[0], addLineItemAction);
Assert.True(response.Success);
_testCarts[0] = response.Result;
Assert.NotNull(_testCarts[0].Id);
Assert.NotNull(_testCarts[0].LineItems);
Assert.Equal(_testCarts[0].LineItems.Count, 1);
Assert.Equal(_testCarts[0].LineItems[0].ProductId, _testProduct.Id);
Assert.Equal(_testCarts[0].LineItems[0].Variant.Id, _testProduct.MasterData.Current.MasterVariant.Id);
Assert.Equal(_testCarts[0].LineItems[0].Quantity, quantity);
ChangeLineItemQuantityAction changeLineItemQuantityAction =
new ChangeLineItemQuantityAction(_testCarts[0].LineItems[0].Id, newQuantity);
response = await _client.Carts().UpdateCartAsync(_testCarts[0], changeLineItemQuantityAction);
Assert.True(response.Success);
_testCarts[0] = response.Result;
Assert.NotNull(_testCarts[0].Id);
Assert.NotNull(_testCarts[0].LineItems);
Assert.Equal(_testCarts[0].LineItems.Count, 1);
Assert.Equal(_testCarts[0].LineItems[0].Quantity, newQuantity);
RemoveLineItemAction removeLineItemAction = new RemoveLineItemAction(_testCarts[0].LineItems[0].Id);
response = await _client.Carts().UpdateCartAsync(_testCarts[0], removeLineItemAction);
Assert.True(response.Success);
_testCarts[0] = response.Result;
Assert.NotNull(_testCarts[0].Id);
Assert.NotNull(_testCarts[0].LineItems);
Assert.Equal(_testCarts[0].LineItems.Count, 0);
}
public async Task ShouldAddChangeAndRemoveLineItemAsync()
{
int quantity = 2;
int newQuantity = 3;
for (int i = 4; i < _testCarts.Count; i++)
{
var cart = _testCarts[i];
AddLineItemAction addLineItemAction = new AddLineItemAction(_testProduct.Id, _testProduct.MasterData.Current.MasterVariant.Id);
addLineItemAction.Quantity = quantity;
if (cart.TaxMode != null && cart.TaxMode == TaxMode.External)
{
addLineItemAction.ExternalTaxRate = new ExternalTaxRateDraft("TestTaxRate", _project.Countries[0])
{
Amount = 0.1m
};
addLineItemAction.ExternalPrice = new Money()
{
CentAmount = 5, CurrencyCode = _project.Currencies[0]
};
}
Response <Cart> response = await _client.Carts().UpdateCartAsync(cart, addLineItemAction);
Assert.IsTrue(response.Success);
cart = response.Result;
Assert.NotNull(cart.Id);
Assert.NotNull(cart.LineItems, "LineItems are null");
Assert.AreEqual(cart.LineItems.Count, 1);
Assert.AreEqual(cart.LineItems[0].ProductId, _testProduct.Id);
Assert.AreEqual(cart.LineItems[0].Variant.Id, _testProduct.MasterData.Current.MasterVariant.Id);
Assert.AreEqual(cart.LineItems[0].Quantity, quantity);
Assert.NotNull(cart.LineItems[0].TaxRate, "TaxRate is null");
if (cart.TaxMode != null && cart.TaxMode == TaxMode.External)
{
Assert.AreEqual(cart.LineItems[0].TaxRate.Name, addLineItemAction.ExternalTaxRate.Name);
Assert.AreEqual(cart.LineItems[0].TaxRate.Country, addLineItemAction.ExternalTaxRate.Country);
Assert.AreEqual(cart.LineItems[0].TaxRate.Amount, addLineItemAction.ExternalTaxRate.Amount);
Assert.AreEqual(cart.LineItems[0].Price.Value.CentAmount, addLineItemAction.ExternalPrice.CentAmount);
Assert.AreEqual(cart.LineItems[0].Price.Value.CurrencyCode, addLineItemAction.ExternalPrice.CurrencyCode);
}
ChangeLineItemQuantityAction changeLineItemQuantityAction =
new ChangeLineItemQuantityAction(cart.LineItems[0].Id, newQuantity);
if (cart.TaxMode != null && cart.TaxMode == TaxMode.External)
{
changeLineItemQuantityAction.ExternalPrice = new Money()
{
CentAmount = 10, CurrencyCode = _project.Currencies[0]
};
}
response = await _client.Carts().UpdateCartAsync(cart, changeLineItemQuantityAction);
Assert.IsTrue(response.Success, string.Format("TaxMode: {0}", cart.TaxMode));
Console.Error.WriteLine(string.Format("CartManagerTest - Information Only - CartId: {0} TaxMode: {1}", cart.Id, cart.TaxMode));
cart = response.Result;
Assert.NotNull(cart.Id);
Assert.NotNull(cart.LineItems);
Assert.AreEqual(cart.LineItems.Count, 1);
Assert.AreEqual(cart.LineItems[0].Quantity, newQuantity);
RemoveLineItemAction removeLineItemAction = new RemoveLineItemAction(cart.LineItems[0].Id);
response = await _client.Carts().UpdateCartAsync(cart, removeLineItemAction);
Assert.IsTrue(response.Success);
cart = response.Result;
Assert.NotNull(cart.Id);
Assert.NotNull(cart.LineItems);
Assert.AreEqual(cart.LineItems.Count, 0);
}
}
public void Init()
{
_client = new Client(Helper.GetConfiguration());
Task <Response <Project.Project> > projectTask = _client.Project().GetProjectAsync();
projectTask.Wait();
Assert.IsTrue(projectTask.Result.Success);
_project = projectTask.Result.Result;
_testCustomers = new List <Customer>();
for (int i = 0; i < 5; i++)
{
CustomerDraft customerDraft = Helper.GetTestCustomerDraft();
Task <Response <CustomerCreatedMessage> > customerTask = _client.Customers().CreateCustomerAsync(customerDraft);
customerTask.Wait();
Assert.IsTrue(customerTask.Result.Success);
CustomerCreatedMessage customerCreatedMessage = customerTask.Result.Result;
Assert.NotNull(customerCreatedMessage.Customer);
Assert.NotNull(customerCreatedMessage.Customer.Id);
_testCustomers.Add(customerCreatedMessage.Customer);
}
_testCarts = new List <Cart>();
Task <Response <Cart> > cartTask;
for (int i = 0; i < 5; i++)
{
CartDraft cartDraft = Helper.GetTestCartDraft(_project, _testCustomers[i].Id);
cartTask = _client.Carts().CreateCartAsync(cartDraft);
cartTask.Wait();
Assert.IsTrue(cartTask.Result.Success);
Cart cart = cartTask.Result.Result;
Assert.NotNull(cart.Id);
_testCarts.Add(cart);
}
ProductTypeDraft productTypeDraft = Helper.GetTestProductTypeDraft();
Task <Response <ProductType> > productTypeTask = _client.ProductTypes().CreateProductTypeAsync(productTypeDraft);
productTypeTask.Wait();
Assert.IsTrue(productTypeTask.Result.Success);
_testProductType = productTypeTask.Result.Result;
Assert.NotNull(_testProductType.Id);
TaxCategoryDraft taxCategoryDraft = Helper.GetTestTaxCategoryDraft(_project);
Task <Response <TaxCategory> > taxCategoryTask = _client.TaxCategories().CreateTaxCategoryAsync(taxCategoryDraft);
taxCategoryTask.Wait();
Assert.IsTrue(taxCategoryTask.Result.Success);
_testTaxCategory = taxCategoryTask.Result.Result;
Assert.NotNull(_testTaxCategory.Id);
Task <Response <ZoneQueryResult> > zoneQueryResultTask = _client.Zones().QueryZonesAsync();
zoneQueryResultTask.Wait();
if (zoneQueryResultTask.Result.Success && zoneQueryResultTask.Result.Result.Results.Count > 0)
{
_testZone = zoneQueryResultTask.Result.Result.Results[0];
_createdTestZone = false;
}
else
{
ZoneDraft zoneDraft = Helper.GetTestZoneDraft();
Task <Response <Zone> > zoneTask = _client.Zones().CreateZoneAsync(zoneDraft);
zoneTask.Wait();
Assert.IsTrue(zoneTask.Result.Success);
_testZone = zoneTask.Result.Result;
_createdTestZone = true;
}
Assert.NotNull(_testZone.Id);
ShippingMethodDraft shippingMethodDraft = Helper.GetTestShippingMethodDraft(_project, _testTaxCategory, _testZone);
Task <Response <ShippingMethod> > shippingMethodTask = _client.ShippingMethods().CreateShippingMethodAsync(shippingMethodDraft);
shippingMethodTask.Wait();
Assert.IsTrue(shippingMethodTask.Result.Success);
_testShippingMethod = shippingMethodTask.Result.Result;
Assert.NotNull(_testShippingMethod.Id);
ProductDraft productDraft = Helper.GetTestProductDraft(_project, _testProductType.Id, _testTaxCategory.Id);
Task <Response <Product> > productTask = _client.Products().CreateProductAsync(productDraft);
productTask.Wait();
Assert.IsTrue(productTask.Result.Success);
_testProduct = productTask.Result.Result;
Assert.NotNull(_testProduct.Id);
int quantity = 1;
AddLineItemAction addLineItemAction = new AddLineItemAction(_testProduct.Id, _testProduct.MasterData.Current.MasterVariant.Id);
addLineItemAction.Quantity = quantity;
cartTask = _client.Carts().UpdateCartAsync(_testCarts[0], addLineItemAction);
cartTask.Wait();
Assert.IsTrue(cartTask.Result.Success);
_testCarts[0] = cartTask.Result.Result;
Assert.NotNull(_testCarts[0].Id);
Assert.NotNull(_testCarts[0].LineItems);
Assert.AreEqual(_testCarts[0].LineItems.Count, 1);
Assert.AreEqual(_testCarts[0].LineItems[0].ProductId, _testProduct.Id);
Assert.AreEqual(_testCarts[0].LineItems[0].Variant.Id, _testProduct.MasterData.Current.MasterVariant.Id);
Assert.AreEqual(_testCarts[0].LineItems[0].Quantity, quantity);
OrderFromCartDraft orderFromCartDraft = Helper.GetTestOrderFromCartDraft(_testCarts[0]);
Task <Response <Order> > orderTask = _client.Orders().CreateOrderFromCartAsync(orderFromCartDraft);
orderTask.Wait();
Assert.IsTrue(orderTask.Result.Success);
_testOrder = orderTask.Result.Result;
Assert.NotNull(_testOrder.Id);
cartTask = _client.Carts().GetCartByIdAsync(_testCarts[0].Id);
cartTask.Wait();
Assert.IsTrue(cartTask.Result.Success);
_testCarts[0] = cartTask.Result.Result;
Assert.NotNull(_testCarts[0].Id);
}
/// <summary>
/// Run Cart example code.
/// </summary>
/// <param name="client">Client</param>
/// <param name="project">Project</param>
public async static Task Run(Client client, Project.Project project)
{
string currency = project.Currencies[0];
string country = project.Countries[0];
/* CREATE CART
* ===================================================================================
*/
CartDraft cartDraft = new CartDraft(currency);
Response <Cart> cartResponse = await client.Carts().CreateCartAsync(cartDraft);
Cart cart = null;
if (cartResponse.Success)
{
cart = cartResponse.Result;
Console.WriteLine("Created new cart with ID {0}.", cart.Id);
}
else
{
Helper.WriteError <Cart>(cartResponse);
}
/* GET CARTS
* ===================================================================================
*/
Response <CartQueryResult> cartQueryResponse = await client.Carts().QueryCartsAsync();
List <Cart> carts = new List <Cart>();
if (cartQueryResponse.Success)
{
CartQueryResult cartQueryResult = cartQueryResponse.Result;
carts = cartQueryResult.Results;
Console.WriteLine("Retrieved {0} carts.", carts.Count);
}
else
{
Helper.WriteError <CartQueryResult>(cartQueryResponse);
}
// Get a single cart by its ID.
string cartId = carts[0].Id;
cartResponse = await client.Carts().GetCartByIdAsync(cartId);
if (cartResponse.Success)
{
cart = cartResponse.Result;
Console.WriteLine("Retrieved cart with ID {0}.", cart.Id);
}
else
{
Helper.WriteError <Cart>(cartResponse);
}
/* UPDATE A CART
* ===================================================================================
* Each change is made using its own update action object which maps to an update
* action call in the API. The list of update action objects are sent to the API using
* a single request. If there is an update action in the API that has not yet been
* implemented in the SDK, you can use the GenericAction class to make any request you
* want (as long as it is a valid update action supported by the API).
*/
SetCountryAction setCountryAction = new SetCountryAction();
setCountryAction.Country = country;
// Here is how you would make the setCustomerEmail request using a GenericAction object.
GenericAction setCustomerEmailAction = new GenericAction("setCustomerEmail");
setCustomerEmailAction["email"] = "*****@*****.**";
//List<UpdateAction> actions = new List<UpdateAction>() { setCountryAction, setCustomerEmailAction };
List <UpdateAction> actions = new List <UpdateAction>()
{
setCustomerEmailAction
};
cartResponse = await client.Carts().UpdateCartAsync(cart, actions);
if (cartResponse.Success)
{
cart = cartResponse.Result;
Console.WriteLine("Updated cart with ID {0}.", cart.Id);
Console.WriteLine("Cart country: {0}", cart.Country);
Console.WriteLine("Cart customer email: {0}", cart.CustomerEmail);
}
else
{
Helper.WriteError <Cart>(cartResponse);
}
/* ADDING, CHANGING AND REMOVING LINE ITEMS
* ===================================================================================
* Making line item requests is done using update actions.
*/
// Find a product to add to the cart as a line item.
Response <ProductQueryResult> productQueryResponse = await client.Products().QueryProductsAsync();
Product product = null;
if (productQueryResponse.Success)
{
ProductQueryResult productQueryResult = productQueryResponse.Result;
product = productQueryResult.Results[0];
Console.WriteLine("Retrieved product with ID {0}.", product.Id);
}
else
{
Helper.WriteError <ProductQueryResult>(productQueryResponse);
}
// Add the line item to a cart.
AddLineItemAction addLineItemAction = new AddLineItemAction(product.Id, product.MasterData.Current.MasterVariant.Id);
addLineItemAction.Quantity = 1;
Console.WriteLine("addLineItemAction.Action: {0}", addLineItemAction.Action);
Console.WriteLine("addLineItemAction.ProductId: {0}", addLineItemAction.ProductId);
Console.WriteLine("addLineItemAction.VariantId: {0}", addLineItemAction.VariantId);
Console.WriteLine("addLineItemAction.Quantity: {0}", addLineItemAction.Quantity);
Console.WriteLine("cart.Id: {0}", cart.Id);
Console.WriteLine("cart.Version: {0}", cart.Version);
cartResponse = await client.Carts().UpdateCartAsync(cart, addLineItemAction);
if (cartResponse.Success)
{
cart = cartResponse.Result;
Console.WriteLine("Added line item to cart with ID {0}.", cart.Id);
Console.WriteLine("Line item product ID: {0}.", cart.LineItems[0].ProductId);
Console.WriteLine("Line item quantity: {0}.", cart.LineItems[0].Quantity);
}
else
{
Helper.WriteError <Cart>(cartResponse);
}
// Use another update action to change the quantity of the line item in the cart to 2.
if (cart.LineItems.Count > 0)
{
ChangeLineItemQuantityAction changeLineItemQuantityAction = new ChangeLineItemQuantityAction(cart.LineItems[0].Id, 2);
cartResponse = await client.Carts().UpdateCartAsync(cart, changeLineItemQuantityAction);
if (cartResponse.Success)
{
cart = cartResponse.Result;
Console.WriteLine("Changed line item quanity in cart with ID {0}.", cart.Id);
Console.WriteLine("Line item product ID: {0}.", cart.LineItems[0].ProductId);
Console.WriteLine("Line item quantity: {0}.", cart.LineItems[0].Quantity);
}
else
{
Helper.WriteError <Cart>(cartResponse);
}
}
// Finally, remove the line item from the cart.
if (cart.LineItems.Count > 0)
{
RemoveLineItemAction removeLineItemAction = new RemoveLineItemAction(cart.LineItems[0].Id);
cartResponse = await client.Carts().UpdateCartAsync(cart, removeLineItemAction);
if (cartResponse.Success)
{
cart = cartResponse.Result;
Console.WriteLine("Removed line item from cart with ID {0}.", cart.Id);
Console.WriteLine("Line items in cart: {0}.", cart.LineItems.Count);
}
else
{
Helper.WriteError <Cart>(cartResponse);
}
}
/* DELETE A CART
* ===================================================================================
* Delete API requests return a generic response, but some return the object that was
* deleted. The Carts delete request returns the full representation.
*/
cartResponse = await client.Carts().DeleteCartAsync(cart);
if (cartResponse.Success)
{
cart = cartResponse.Result;
Console.WriteLine("Deleted cart with ID {0}.", cart.Id);
}
else
{
Helper.WriteError <Cart>(cartResponse);
}
}
