public void UpdateCartDiscountByIdChangeName()
{
IClient commerceToolsClient = this.cartDiscountFixture.GetService <IClient>();
CartDiscount cartDiscount = this.cartDiscountFixture.CreateCartDiscount();
string name = this.cartDiscountFixture.RandomString(10);
List <UpdateAction <CartDiscount> > updateActions = new List <UpdateAction <CartDiscount> >();
ChangeNameUpdateAction changeNameUpdateAction = new ChangeNameUpdateAction()
{
Name = new LocalizedString()
{
{ "en", name }
}
};
updateActions.Add(changeNameUpdateAction);
CartDiscount retrievedCartDiscount = commerceToolsClient
.ExecuteAsync(new UpdateByIdCommand <CartDiscount>(new Guid(cartDiscount.Id), cartDiscount.Version,
updateActions))
.Result;
this.cartDiscountFixture.CartDiscountsToDelete.Add(retrievedCartDiscount);
Assert.Equal(name, retrievedCartDiscount.Name["en"]);
}
public CartDiscount CreateCartDiscount(CartDiscountDraft cartDiscountDraft)
{
IClient commerceToolsClient = this.GetService <IClient>();
CartDiscount cartDiscount = commerceToolsClient.ExecuteAsync(new CreateCommand <CartDiscount>(cartDiscountDraft)).Result;
return(cartDiscount);
}
public void UpdateCartDiscountByIdSetDescription()
{
IClient commerceToolsClient = this.cartDiscountFixture.GetService <IClient>();
CartDiscount cartDiscount = this.cartDiscountFixture.CreateCartDiscount();
string newDescription = this.cartDiscountFixture.RandomString(20);
List <UpdateAction <CartDiscount> > updateActions = new List <UpdateAction <CartDiscount> >();
SetDescriptionUpdateAction setDescriptionUpdateAction = new SetDescriptionUpdateAction()
{
Description = new LocalizedString()
{
{ "en", newDescription }
}
};
updateActions.Add(setDescriptionUpdateAction);
CartDiscount retrievedCartDiscount = commerceToolsClient
.ExecuteAsync(new UpdateByIdCommand <CartDiscount>(new Guid(cartDiscount.Id), cartDiscount.Version,
updateActions))
.Result;
this.cartDiscountFixture.CartDiscountsToDelete.Add(retrievedCartDiscount);
Assert.Equal(newDescription, retrievedCartDiscount.Description["en"]);
}
public DiscountCodeDraft GetDiscountCodeDraft()
{
DiscountCodeDraft discountCodeDraft = new DiscountCodeDraft()
{
Code = this.RandomString(15),
Name = new LocalizedString()
{
{ "en", this.RandomString(10) }
},
Description = new LocalizedString()
{
{ "en", this.RandomString(20) }
},
IsActive = true,
CartPredicate = "1 = 1", //for all carts
ValidFrom = DateTime.Today,
ValidUntil = DateTime.Today.AddMonths(1), // valid one month
MaxApplicationsPerCustomer = 2
};
CartDiscount cartDiscount = this.CreateCartDiscount();
discountCodeDraft.CartDiscounts = new List <Reference <CartDiscount> >()
{
new Reference <CartDiscount>()
{
Id = cartDiscount.Id,
}
};
return(discountCodeDraft);
}
public void UpdateCartDiscountByIdChangeTarget()
{
IClient commerceToolsClient = this.cartDiscountFixture.GetService <IClient>();
CartDiscount cartDiscount = this.cartDiscountFixture.CreateCartDiscount();
//creating new cart discount value
var newCartDiscountTarget = new LineItemsCartDiscountTarget()
{
Predicate = " 1 <> 1"
};
List <UpdateAction <CartDiscount> > updateActions = new List <UpdateAction <CartDiscount> >();
ChangeTargetUpdateAction changeTargetUpdateAction = new ChangeTargetUpdateAction()
{
Target = newCartDiscountTarget
};
updateActions.Add(changeTargetUpdateAction);
CartDiscount retrievedCartDiscount = commerceToolsClient
.ExecuteAsync(new UpdateByIdCommand <CartDiscount>(new Guid(cartDiscount.Id),
cartDiscount.Version, updateActions))
.Result;
var cartDiscountTarget = (LineItemsCartDiscountTarget)cartDiscount.Target;
this.cartDiscountFixture.CartDiscountsToDelete.Add(retrievedCartDiscount);
Assert.NotEqual(cartDiscount.Version, retrievedCartDiscount.Version);
Assert.NotEqual(cartDiscountTarget.Predicate, newCartDiscountTarget.Predicate);
}
public static async Task <DiscountCodeDraft> GetDiscountCodeDraft(Project.Project project, Client client)
{
var name = new LocalizedString();
var description = new LocalizedString();
foreach (string language in project.Languages)
{
string randomPostfix = Helper.GetRandomString(10);
name.SetValue(language, string.Concat("test-discount-code-name", language, " ", randomPostfix));
description.SetValue(language, string.Concat("test-discount-code-description", language, "-", randomPostfix));
}
CartDiscount cartDiscount = await Helper.CreateTestCartDiscount(project, client, true);
var references = new List <Reference>
{
new Reference {
Id = cartDiscount.Id, ReferenceType = ReferenceType.CartDiscount
}
};
var discountCodeDraft = new DiscountCodeDraft(Helper.GetRandomString(10), references, GetRandomBoolean())
{
Description = description,
Name = name,
MaxApplications = Helper.GetRandomNumber(100, 1000),
MaxApplicationsPerCustomer = Helper.GetRandomNumber(100, 1000)
};
return(discountCodeDraft);
}
private CartDiscount CreateCartDiscount()
{
CartDiscount cartDiscount = this.cartDiscountsFixture.CreateCartDiscount(requireDiscountCode: true);
this.cartDiscountsFixture.CartDiscountsToDelete.Add(cartDiscount);
return(cartDiscount);
}
public async Task ShouldApplyDiscountOnCartWithCustomLineItemsAsync()
{
// Arrange
CartDiscount cartDiscount = await Helper.CreateCartDiscountForCustomLineItems(this._project, this._client);
CartDraft cartDraft = Helper.GetTestCartDraftWithCustomLineItems(_project);
// Act
Response <Cart> response = await _client.Carts().CreateCartAsync(cartDraft);
// Assert
response.Result.CustomLineItems.Count.Should().Be(1);
var customLineItem = response.Result.CustomLineItems.First();
customLineItem.DiscountedPricePerQuantity.Count.Should().BeGreaterThan(0);
var discountedLineItemPrice = customLineItem.DiscountedPricePerQuantity.First();
discountedLineItemPrice.DiscountedPrice.Value.CentAmount.Should().BeGreaterThan(1);
discountedLineItemPrice.DiscountedPrice.Value.CurrencyCode.Should().Be("EUR");
Assert.NotNull(discountedLineItemPrice);
Assert.NotNull(discountedLineItemPrice.DiscountedPrice);
Assert.NotNull(discountedLineItemPrice.DiscountedPrice.Value);
Assert.NotNull(discountedLineItemPrice.DiscountedPrice.Value);
Assert.IsFalse(string.IsNullOrEmpty(discountedLineItemPrice.DiscountedPrice.Value.CurrencyCode));
// Cleanup
await this._client.CartDiscounts().DeleteCartDiscountAsync(cartDiscount.Id, 1);
await this._client.Carts().DeleteCartAsync(response.Result);
}
public void UpdateCartDiscountByIdChangeValue()
{
IClient commerceToolsClient = this.cartDiscountFixture.GetService <IClient>();
CartDiscount cartDiscount = this.cartDiscountFixture.CreateCartDiscount();
//creating new cart discount value
var newCartDiscountValue = this.cartDiscountFixture.GetCartDiscountValueAsAbsolute();
List <UpdateAction <CartDiscount> > updateActions = new List <UpdateAction <CartDiscount> >();
ChangeValueUpdateAction changeValueUpdateAction = new ChangeValueUpdateAction()
{
Value = newCartDiscountValue
};
updateActions.Add(changeValueUpdateAction);
CartDiscount retrievedCartDiscount = commerceToolsClient
.ExecuteAsync(new UpdateByIdCommand <CartDiscount>(new Guid(cartDiscount.Id),
cartDiscount.Version, updateActions))
.Result;
this.cartDiscountFixture.CartDiscountsToDelete.Add(retrievedCartDiscount);
var cardDiscountAmount = ((AbsoluteCartDiscountValue)cartDiscount.Value).Money[0].CentAmount;
var retrievedCartDiscountAmount =
((AbsoluteCartDiscountValue)retrievedCartDiscount.Value).Money[0].CentAmount;
Assert.NotEqual(cartDiscount.Version, retrievedCartDiscount.Version);
Assert.NotEqual(cardDiscountAmount, retrievedCartDiscountAmount);
}
public void CalculateDiscount()
{
var percent = 50;
var cd = new CartDiscount(percent);
Assert.Equal(percent, cd.PercentValue);
Assert.Equal(50.0, cd.Make(100.0));
}
public void DiscountForEmptyCart()
{
var cart = CommonInstansesCreator.GetCart();
var discount = new CartDiscount(cart, 50);
Assert.Equal(0, discount.GetCost());
}
private void AddToDictionary(Guid key, CartDiscount value)
{
if (!removedDiscount.ContainsKey(key))
{
removedDiscount.Add(key, new List <CartDiscount>());
}
removedDiscount[key].Add(value);
}
public void AddCartDiscountTest()
{
var cart = new Cart();
var discount = new CartDiscount(10);
cart.AddDiscount(discount);
Assert.Equal(1, cart.CurrentState.CartDiscounts.Count);
Assert.Equal(discount, cart.CurrentState.CartDiscounts.First());
}
public void CreateCartDiscount()
{
IClient commerceToolsClient = this.cartDiscountFixture.GetService <IClient>();
CartDiscountDraft cartDiscountDraft = this.cartDiscountFixture.GetCartDiscountDraft();
CartDiscount cartDiscount = commerceToolsClient
.ExecuteAsync(new CreateCommand <CartDiscount>(cartDiscountDraft)).Result;
this.cartDiscountFixture.CartDiscountsToDelete.Add(cartDiscount);
Assert.Equal(cartDiscountDraft.Name["en"], cartDiscount.Name["en"]);
}
public void GetCartDiscountById()
{
IClient commerceToolsClient = this.cartDiscountFixture.GetService <IClient>();
CartDiscount cartDiscount = this.cartDiscountFixture.CreateCartDiscount();
this.cartDiscountFixture.CartDiscountsToDelete.Add(cartDiscount);
CartDiscount retrievedCartDiscount = commerceToolsClient
.ExecuteAsync(new GetByIdCommand <CartDiscount>(new Guid(cartDiscount.Id))).Result;
Assert.Equal(cartDiscount.Id, retrievedCartDiscount.Id);
}
public async Task ShouldGetCartDiscountByIdAsync()
{
Response <CartDiscount> response = await _client.CartDiscounts().GetCartDiscountByIdAsync(_testCartDiscount.Id);
Assert.IsTrue(response.Success);
CartDiscount cartDiscount = response.Result;
Assert.NotNull(cartDiscount.Id);
Assert.AreEqual(cartDiscount.Id, _testCartDiscount.Id);
}
public void Dispose()
{
IClient commerceToolsClient = this.GetService <IClient>();
this.CartDiscountsToDelete.Reverse();
foreach (CartDiscount cartDiscount in this.CartDiscountsToDelete)
{
CartDiscount deletedType = commerceToolsClient
.ExecuteAsync(new DeleteByIdCommand <CartDiscount>(new Guid(cartDiscount.Id),
cartDiscount.Version)).Result;
}
}
public void AddShoppingCartDiscount(ShoppingCart cart, Discount discount)
{
var cart_discount = new CartDiscount {
DiscountId = discount.Id,
ShoppingCartId = cart.Id,
Discount = discount,
ShoppingCart = cart
};
_context.ShoppingCartDiscounts.Add(cart_discount);
Save();
}
public void DiscountWorks()
{
var cart = CommonInstansesCreator.GetCart();
var productRepository = CommonInstansesCreator.GetProductRepo();
var product = productRepository.FirstOrDefault();
cart.AddProduct(new CartItem {
Count = 2, Product = product
});
var discount = new CartDiscount(cart, 50);
Assert.Equal(product.Cost, discount.GetCost());
}
public async void DeleteCartDiscountById()
{
IClient commerceToolsClient = this.cartDiscountFixture.GetService <IClient>();
CartDiscount cartDiscount = this.cartDiscountFixture.CreateCartDiscount();
CartDiscount retrievedCartDiscount = commerceToolsClient
.ExecuteAsync(
new DeleteByIdCommand <CartDiscount>(new Guid(cartDiscount.Id), cartDiscount.Version))
.Result;
NotFoundException exception = await Assert.ThrowsAsync <NotFoundException>(() =>
commerceToolsClient.ExecuteAsync(
new GetByIdCommand <CartDiscount>(new Guid(retrievedCartDiscount.Id))));
Assert.Equal(404, exception.StatusCode);
}
public void QueryCartDiscounts()
{
IClient commerceToolsClient = this.cartDiscountFixture.GetService <IClient>();
CartDiscount cartDiscount = this.cartDiscountFixture.CreateCartDiscount();
this.cartDiscountFixture.CartDiscountsToDelete.Add(cartDiscount);
QueryPredicate <CartDiscount> queryPredicate =
new QueryPredicate <CartDiscount>(cd => cd.Id == cartDiscount.Id.valueOf());
QueryCommand <CartDiscount> queryCommand = new QueryCommand <CartDiscount>();
queryCommand.SetWhere(queryPredicate);
PagedQueryResult <CartDiscount> returnedSet = commerceToolsClient.ExecuteAsync(queryCommand).Result;
Assert.Contains(returnedSet.Results, cd => cd.Id == cartDiscount.Id);
}
public void CalculateTotalWithProductsAndDiscounts()
{
var state = new CartState(new Cart());
var product = TestProducts.Cars.First();
const int count = 2;
state.Products.Add(product, count);
var cartDiscount = new CartDiscount(50);
var productDiscount = new ProductDiscount(product, 50);
state.CartDiscounts.Add(cartDiscount);
state.ProductDiscounts.Add(product, productDiscount);
Assert.Equal(product.Price * count / 4, state.Total);
}
public void UpdateCartDiscountByIdChangeSortOrder()
{
IClient commerceToolsClient = this.cartDiscountFixture.GetService <IClient>();
CartDiscount cartDiscount = this.cartDiscountFixture.CreateCartDiscount();
List <UpdateAction <CartDiscount> > updateActions = new List <UpdateAction <CartDiscount> >();
ChangeSortOrderUpdateAction changeSortOrderUpdateAction = new ChangeSortOrderUpdateAction()
{
SortOrder = this.cartDiscountFixture.RandomSortOrder()
};
updateActions.Add(changeSortOrderUpdateAction);
CartDiscount retrievedCartDiscount = commerceToolsClient
.ExecuteAsync(new UpdateByIdCommand <CartDiscount>(new Guid(cartDiscount.Id), cartDiscount.Version,
updateActions))
.Result;
this.cartDiscountFixture.CartDiscountsToDelete.Add(retrievedCartDiscount);
Assert.NotEqual(retrievedCartDiscount.SortOrder, cartDiscount.SortOrder);
}
public void UpdateCartDiscountByIdSetValidUntil()
{
IClient commerceToolsClient = this.cartDiscountFixture.GetService <IClient>();
CartDiscount cartDiscount = this.cartDiscountFixture.CreateCartDiscount();
List <UpdateAction <CartDiscount> > updateActions = new List <UpdateAction <CartDiscount> >();
SetValidUntilUpdateAction setValidUntilUpdateAction = new SetValidUntilUpdateAction()
{
ValidUntil = DateTime.Today.AddDays(1)
};
updateActions.Add(setValidUntilUpdateAction);
CartDiscount retrievedCartDiscount = commerceToolsClient
.ExecuteAsync(new UpdateByIdCommand <CartDiscount>(new Guid(cartDiscount.Id), cartDiscount.Version,
updateActions))
.Result;
this.cartDiscountFixture.CartDiscountsToDelete.Add(retrievedCartDiscount);
Assert.NotEqual(retrievedCartDiscount.ValidUntil, cartDiscount.ValidUntil);
}
public void UpdateCartDiscountByIdChangeStackingMode()
{
IClient commerceToolsClient = this.cartDiscountFixture.GetService <IClient>();
CartDiscount cartDiscount = this.cartDiscountFixture.CreateCartDiscount();
List <UpdateAction <CartDiscount> > updateActions = new List <UpdateAction <CartDiscount> >();
ChangeStackingModeUpdateAction changeStackingModeUpdateAction = new ChangeStackingModeUpdateAction()
{
StackingMode = StackingMode.StopAfterThisDiscount
};
updateActions.Add(changeStackingModeUpdateAction);
CartDiscount retrievedCartDiscount = commerceToolsClient
.ExecuteAsync(new UpdateByIdCommand <CartDiscount>(new Guid(cartDiscount.Id), cartDiscount.Version,
updateActions))
.Result;
this.cartDiscountFixture.CartDiscountsToDelete.Add(retrievedCartDiscount);
Assert.NotEqual(retrievedCartDiscount.StackingMode, cartDiscount.StackingMode);
}
public JsonResult ApplyDiscountCode(string discountCode)
{
var result = new DiscountMessage();
try
{
discountCode = discountCode.ToUpper();
var discount = storeDB.Discounts.SingleOrDefault(d => d.Code.ToUpper() == discountCode);
if (discount == null)
{
result.Error = string.Format("Discount code {0} does not exist", discountCode);
}
else
{
result.Description = discount.Description;
var localCart = ShoppingCart.GetCart(this.HttpContext);
var disc = localCart.Discounts.Where(d => d.CartId == localCart.ShoppingCartId && d.DiscountCode == discount.Code).FirstOrDefault();
if (disc == null)
{
disc = new CartDiscount {
DiscountCode = discount.Code, CartId = localCart.ShoppingCartId, Description = discount.Description
};
storeDB.CartDiscounts.Add(disc);
storeDB.SaveChanges();
}
GetCartTotals(result, localCart);
result.Code = discountCode;
disc = localCart.Discounts.Where(d => d.CartId == localCart.ShoppingCartId && d.DiscountCode == discount.Code).FirstOrDefault();
result.Amount = disc.Amount;
}
}
catch (Exception e)
{
result.Error = e.Message;
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public void Init()
{
_client = Helper.GetClient();
Task <Response <Project.Project> > projectTask = _client.Project().GetProjectAsync();
projectTask.Wait();
Assert.IsTrue(projectTask.Result.Success);
_project = projectTask.Result.Result;
Assert.IsTrue(_project.Languages.Count > 0);
Assert.IsTrue(_project.Currencies.Count > 0);
Task <CartDiscount> cartDiscountTask =
Helper.CreateTestCartDiscount(this._project, this._client);
cartDiscountTask.Wait();
Assert.IsNotNull(cartDiscountTask.Result);
_testCartDiscount = cartDiscountTask.Result;
Assert.NotNull(_testCartDiscount);
Assert.NotNull(_testCartDiscount.Id);
}
public void AddDiscount(CartDiscount discount)
{
CurrentState.CartDiscounts.Add(discount);
}
private async Task AddOrderDiscounts(Order order, CartDiscount discount)
{
try
{
var entity = new data.OrderDiscount()
{
OrderId = order.OrderId,
DiscountId = discount.DiscountId,
Discount = discount.Discount,
Quantity = discount.Quantity
};
// Set the order total of the shopping cart
_db.OrderDiscounts.Add(entity);
await _db.SaveChangesAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
