public static OrderFromCartDraft DefaultOrderFromCartDraftWithShipmentState(OrderFromCartDraft draft, Cart cart, ShipmentState shipmentState)
{
var orderFromCartDraft = DefaultOrderFromCartDraft(draft, cart);
orderFromCartDraft.ShipmentState = shipmentState;
return(orderFromCartDraft);
}
public static OrderFromCartDraft DefaultOrderFromCartDraftWithPaymentState(OrderFromCartDraft draft, Cart cart, PaymentState paymentState)
{
var orderFromCartDraft = DefaultOrderFromCartDraft(draft, cart);
orderFromCartDraft.PaymentState = paymentState;
return(orderFromCartDraft);
}
public static OrderFromCartDraft DefaultOrderFromCartDraftWithNumber(OrderFromCartDraft draft, Cart cart, string orderNumber)
{
var orderFromCartDraft = DefaultOrderFromCartDraft(draft, cart);
orderFromCartDraft.OrderNumber = orderNumber;
return(orderFromCartDraft);
}
public static OrderFromCartDraft DefaultOrderFromCartDraftWithOrderState(OrderFromCartDraft draft, Cart cart, OrderState orderState)
{
var orderFromCartDraft = DefaultOrderFromCartDraft(draft, cart);
orderFromCartDraft.OrderState = orderState;
return(orderFromCartDraft);
}
public OrderFromCartDraft GetOrderFromCartDraft(bool withDefaultShippingCountry = true, bool withShippingMethod = false, bool withOrderNumber = true, bool withCustomer = true, bool withCustomLineItem = false, bool withItemShippingAddress = false, string customerEmail = null)
{
//Create A Cart
Cart cart = null;
if (withCustomLineItem)
{
cart = this.cartFixture.CreateCartWithCustomLineItem(
withDefaultShippingCountry: withDefaultShippingCountry,
withCustomer: withCustomer, withItemShippingAddress: withItemShippingAddress, customerEmail: customerEmail);
}
else
{
cart = this.cartFixture.CreateCartWithLineItem(withDefaultShippingCountry: withDefaultShippingCountry,
withShippingMethod: withShippingMethod, withCustomer: withCustomer,
withItemShippingAddress: withItemShippingAddress, customerEmail: customerEmail);
}
//Then Create Order from this Cart
OrderFromCartDraft orderFromCartDraft = new OrderFromCartDraft
{
Id = cart.Id,
Version = cart.Version
};
if (withOrderNumber)
{
orderFromCartDraft.OrderNumber = TestingUtility.RandomString(10);
}
return(orderFromCartDraft);
}
public Order CreateOrderFromCart(OrderFromCartDraft orderFromCartDraft)
{
IClient commerceToolsClient = this.GetService <IClient>();
Order order = commerceToolsClient.ExecuteAsync(new CreateCommand <Order>(orderFromCartDraft)).Result;
return(order);
}
public static OrderFromCartDraft DefaultOrderFromCartDraft(OrderFromCartDraft orderFromCartDraft, Cart cart)
{
var rand = TestingUtility.RandomInt();
orderFromCartDraft.Id = cart.Id;
orderFromCartDraft.Version = cart.Version;
orderFromCartDraft.OrderNumber = $"Order_{rand}";
return(orderFromCartDraft);
}
public static OrderFromCartDraft DefaultOrderFromCartDraft(OrderFromCartDraft orderFromCartDraft, Cart cart)
{
var rand = TestingUtility.RandomInt();
orderFromCartDraft.Cart = cart.ToKeyResourceIdentifier();
orderFromCartDraft.Version = cart.Version;
orderFromCartDraft.OrderNumber = $"Order_{rand}";
return(orderFromCartDraft);
}
//[Fact]
public void CreateOrderFromCart()
{
IClient commerceToolsClient = this.ordersFixture.GetService <IClient>();
OrderFromCartDraft orderFromCartDraft = this.ordersFixture.GetOrderFromCartDraft();
Order order = commerceToolsClient
.ExecuteAsync(new CreateCommand <Order>(orderFromCartDraft)).Result;
this.ordersFixture.OrdersToDelete.Add(order);
Assert.Equal(order.OrderNumber, orderFromCartDraft.OrderNumber);
}
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 OrderFromCartDraft GetOrderFromCartDraft()
{
//Create A Cart
Cart cart = this.cartFixture.CreateCart();
this.cartFixture.CartToDelete.Add(cart);
//Add at least one product to this cart
//Then Create Order from this Cart
OrderFromCartDraft orderFromCartDraft = new OrderFromCartDraft();
orderFromCartDraft.Id = cart.Id;
orderFromCartDraft.Version = cart.Version;
orderFromCartDraft.OrderNumber = this.RandomString(10);
return(orderFromCartDraft);
}
/// <summary>
/// Run Order 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];
string language = project.Languages[0];
/* CREATE ORDER
* ===================================================================================
* An order is created from an existing cart. To create an order from a cart, the
* cart cannot be empty and it must have a shipping address set.
*/
// Retrieve 2 products to add to a cart.
Response <ProductProjectionQueryResult> productProjectionQueryResponse = await client.ProductProjections().QueryProductProjectionsAsync(limit: 2);
List <ProductProjection> products = new List <ProductProjection>();
List <LineItemDraft> lineItemDrafts = new List <LineItemDraft>();
if (productProjectionQueryResponse.Success)
{
ProductProjectionQueryResult productProjectionQueryResult = productProjectionQueryResponse.Result;
Console.WriteLine("Retrieved {0} products.", productProjectionQueryResult.Results.Count);
foreach (ProductProjection product in productProjectionQueryResult.Results)
{
LineItemDraft lineItemDraft = new LineItemDraft(product.Id, product.MasterVariant.Id)
{
Quantity = 1
};
lineItemDrafts.Add(lineItemDraft);
}
}
else
{
Helper.WriteError <ProductProjectionQueryResult>(productProjectionQueryResponse);
}
// Create a shipping address.
Address shippingAddress = new Address();
shippingAddress.FirstName = "John";
shippingAddress.LastName = "Doe";
shippingAddress.StreetNumber = "123";
shippingAddress.StreetName = "Main St.";
shippingAddress.PostalCode = "11111";
shippingAddress.City = "City";
shippingAddress.Country = country;
// Create the cart.
Cart cart = null;
if (lineItemDrafts.Count > 0)
{
CartDraft cartDraft = new CartDraft(currency)
{
ShippingAddress = shippingAddress,
LineItems = lineItemDrafts
};
Response <Cart> cartResponse = await client.Carts().CreateCartAsync(cartDraft);
if (cartResponse.Success)
{
cart = cartResponse.Result;
Console.WriteLine("Created new cart with ID {0}.", cart.Id);
}
else
{
Helper.WriteError <Cart>(cartResponse);
}
}
// Create the order from the cart.
Response <Order> orderResponse = null;
Order order = null;
if (cart != null)
{
OrderFromCartDraft orderFromCartDraft = new OrderFromCartDraft(cart);
orderResponse = await client.Orders().CreateOrderFromCartAsync(orderFromCartDraft);
if (orderResponse.Success)
{
order = orderResponse.Result;
Console.WriteLine("Created new order with ID {0}.", order.Id);
foreach (LineItem lineItem in order.LineItems)
{
Console.WriteLine("Order has a line iten named '{0}' with an ID of {1}.", lineItem.Name[language], lineItem.Id);
}
}
else
{
Helper.WriteError <Order>(orderResponse);
}
}
/* GET ORDERS
* ===================================================================================
*/
// Get 3 most recent orders.
Response <OrderQueryResult> orderQueryResponse = await client.Orders().QueryOrdersAsync(sort: "createdAt desc", limit: 3);
List <Order> orders = new List <Order>();
if (orderQueryResponse.Success)
{
OrderQueryResult orderQueryResult = orderQueryResponse.Result;
orders = orderQueryResult.Results;
Console.WriteLine("Retrieved {0} orders.", orders.Count);
}
else
{
Helper.WriteError <OrderQueryResult>(orderQueryResponse);
}
// Get a single order by its ID.
if (orders.Count > 0)
{
string orderId = orders[0].Id;
orderResponse = await client.Orders().GetOrderByIdAsync(orderId);
if (orderResponse.Success)
{
order = orderResponse.Result;
Console.WriteLine("Retrieved order with ID {0}.", order.Id);
}
else
{
Helper.WriteError <Order>(orderResponse);
}
}
/* UPDATE AN ORDER
* ===================================================================================
* 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).
*/
if (order != null)
{
ChangeOrderStateAction changeOrderStateAction = new ChangeOrderStateAction(OrderState.Confirmed);
// Here is how you would make the setDescription request using a GenericAction object.
GenericAction setOrderNumberAction = new GenericAction("setOrderNumber");
setOrderNumberAction["orderNumber"] = "ABC123";
List <UpdateAction> actions = new List <UpdateAction>()
{
changeOrderStateAction, setOrderNumberAction
};
orderResponse = await client.Orders().UpdateOrderAsync(order, actions);
if (orderResponse.Success)
{
order = orderResponse.Result;
Console.WriteLine("Updated order with ID {0}.", order.Id);
Console.WriteLine("Order state: {0}", order.OrderState);
Console.WriteLine("Order number: {0}", order.OrderNumber);
}
else
{
Helper.WriteError <Order>(orderResponse);
}
}
/* DELETE AN ORDER
* ===================================================================================
* Delete API requests return a generic response, but some return the object that was
* deleted. The Orders delete request returns a generic response.
*/
if (order != null)
{
Response <JObject> deleteResponse = await client.Orders().DeleteOrderAsync(order);
if (deleteResponse.Success)
{
Console.WriteLine("Deleted order with ID {0}.", order.Id);
}
else
{
Helper.WriteError <JObject>(deleteResponse);
}
}
}
/// <summary>
/// Gets a test OrderFromCartDraft.
/// </summary>
/// <param name="cart">Cart</param>
/// <returns>OrderFromCartDraft</returns>
public static OrderFromCartDraft GetTestOrderFromCartDraft(Cart cart)
{
OrderFromCartDraft orderFromCartDraft = new OrderFromCartDraft(cart.Id, cart.Version);
return(orderFromCartDraft);
}
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);
}
