public void Can_validate_discount_dateRange()
{
var discount = new Discount
{
DiscountType = DiscountType.AssignedToSkus,
Name = "Discount 2",
UsePercentage = false,
DiscountPercentage = 0,
DiscountAmount = 5,
StartDateUtc = DateTime.UtcNow.AddDays(-1),
EndDateUtc = DateTime.UtcNow.AddDays(1),
RequiresCouponCode = false,
DiscountLimitation = DiscountLimitationType.Unlimited,
};
var customer = new Customer
{
CustomerGuid = Guid.NewGuid(),
AdminComment = "",
Active = true,
Deleted = false,
CreatedOnUtc = new DateTime(2010, 01, 01),
LastActivityDateUtc = new DateTime(2010, 01, 02)
};
var result1 = _discountService.IsDiscountValid(discount, customer);
result1.ShouldEqual(true);
discount.StartDateUtc = DateTime.UtcNow.AddDays(1);
var result2 = _discountService.IsDiscountValid(discount, customer);
result2.ShouldEqual(false);
}
public void Can_save_and_load_discount()
{
var discount = new Discount
{
DiscountType = DiscountType.AssignedToCategories,
Name = "Discount 1",
UsePercentage = true,
DiscountPercentage = 1.1M,
DiscountAmount = 2.1M,
StartDateUtc = new DateTime(2010, 01, 01),
EndDateUtc = new DateTime(2010, 01, 02),
RequiresCouponCode = true,
CouponCode = "SecretCode",
DiscountLimitation = DiscountLimitationType.Unlimited,
LimitationTimes = 3,
};
var fromDb = SaveAndLoadEntity(discount);
fromDb.ShouldNotBeNull();
fromDb.DiscountType.ShouldEqual(DiscountType.AssignedToCategories);
fromDb.Name.ShouldEqual("Discount 1");
fromDb.UsePercentage.ShouldEqual(true);
fromDb.DiscountPercentage.ShouldEqual(1.1M);
fromDb.DiscountAmount.ShouldEqual(2.1M);
fromDb.StartDateUtc.ShouldEqual(new DateTime(2010, 01, 01));
fromDb.EndDateUtc.ShouldEqual(new DateTime(2010, 01, 02));
fromDb.RequiresCouponCode.ShouldEqual(true);
fromDb.CouponCode.ShouldEqual("SecretCode");
fromDb.DiscountLimitation.ShouldEqual(DiscountLimitationType.Unlimited);
fromDb.LimitationTimes.ShouldEqual(3);
}
public void Can_calculate_discount_amount_fixed()
{
var discount = new Discount()
{
UsePercentage = false,
DiscountAmount = 10
};
discount.GetDiscountAmount(100).ShouldEqual(10);
discount.DiscountAmount = 20;
discount.GetDiscountAmount(200).ShouldEqual(20);
}
public void Can_calculate_discount_amount_percentage()
{
var discount = new Discount()
{
UsePercentage = true,
DiscountPercentage = 30
};
discount.GetDiscountAmount(100).ShouldEqual(30);
discount.DiscountPercentage = 60;
discount.GetDiscountAmount(200).ShouldEqual(120);
}
public static bool ContainsDiscount(this IList<Discount> discounts,
Discount discount)
{
if (discounts == null)
throw new ArgumentNullException("discounts");
if (discount == null)
throw new ArgumentNullException("discount");
foreach (var dis1 in discounts)
if (discount.Id == dis1.Id)
return true;
return false;
}
public void Can_save_and_load_discount_with_appliedCategories()
{
var discount = new Discount
{
Name = "Discount 1",
DiscountType = DiscountType.AssignedToCategories,
UsePercentage = true,
DiscountPercentage = 1,
DiscountAmount = 2,
StartDateUtc = new DateTime(2010, 01, 01),
EndDateUtc = new DateTime(2010, 01, 02),
RequiresCouponCode = true,
CouponCode = "SecretCode",
DiscountLimitation = DiscountLimitationType.Unlimited,
LimitationTimes = 3
};
discount.AppliedToCategories.Add(GetTestCategory());
var fromDb = SaveAndLoadEntity(discount);
fromDb.ShouldNotBeNull();
fromDb.AppliedToCategories.ShouldNotBeNull();
(fromDb.AppliedToCategories.Count == 1).ShouldBeTrue();
fromDb.AppliedToCategories.First().Name.ShouldEqual("Books");
}
/// <summary>
/// Gets discount amount
/// </summary>
/// <param name="productVariant">Product variant</param>
/// <param name="customer">The customer</param>
/// <param name="additionalCharge">Additional charge</param>
/// <param name="appliedDiscount">Applied discount</param>
/// <returns>Discount amount</returns>
public virtual decimal GetDiscountAmount(ProductVariant productVariant,
Customer customer,
decimal additionalCharge,
out Discount appliedDiscount)
{
return GetDiscountAmount(productVariant, customer, additionalCharge, 1, out appliedDiscount);
}
protected void PrepareDiscountModel(DiscountModel model, Discount discount)
{
if (model == null)
throw new ArgumentNullException("model");
model.PrimaryStoreCurrencyCode = _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId).CurrencyCode;
model.AvailableDiscountRequirementRules.Add(new SelectListItem() { Text = _localizationService.GetResource("Admin.Promotions.Discounts.Requirements.DiscountRequirementType.Select"), Value = "" });
var discountRules = _discountService.LoadAllDiscountRequirementRules();
foreach (var discountRule in discountRules)
model.AvailableDiscountRequirementRules.Add(new SelectListItem() { Text = discountRule.PluginDescriptor.FriendlyName, Value = discountRule.PluginDescriptor.SystemName });
if (discount != null)
{
//applied to categories
foreach (var category in discount.AppliedToCategories)
{
if (category != null && !category.Deleted)
{
model.AppliedToCategoryModels.Add(new DiscountModel.AppliedToCategoryModel()
{
CategoryId = category.Id,
Name = category.Name
});
}
}
//applied to product variants
foreach (var pv in discount.AppliedToProductVariants)
{
if (pv != null && !pv.Deleted)
{
var appliedToProductVariantModel = new DiscountModel.AppliedToProductVariantModel()
{
ProductVariantId = pv.Id,
FullProductName = pv.FullProductName
};
model.AppliedToProductVariantModels.Add(appliedToProductVariantModel);
}
}
//requirements
foreach (var dr in discount.DiscountRequirements.OrderBy(dr=>dr.Id))
{
var drr = _discountService.LoadDiscountRequirementRuleBySystemName(dr.DiscountRequirementRuleSystemName);
if (drr != null)
{
model.DiscountRequirementMetaInfos.Add(new DiscountModel.DiscountRequirementMetaInfo()
{
DiscountRequirementId = dr.Id,
RuleName = drr.PluginDescriptor.FriendlyName,
ConfigurationUrl = GetRequirementUrlInternal(drr, discount, dr.Id)
});
}
}
}
}
protected string GetRequirementUrlInternal(IDiscountRequirementRule discountRequirementRule, Discount discount, int? discountRequirementId)
{
if (discountRequirementRule == null)
throw new ArgumentNullException("discountRequirementRule");
if (discount == null)
throw new ArgumentNullException("discount");
string url = string.Format("{0}{1}", _webHelper.GetStoreLocation(), discountRequirementRule.GetConfigurationUrl(discount.Id, discountRequirementId));
return url;
}
public void Can_get_shopping_cart_subTotal_discount_including_tax()
{
//customer
Customer customer = new Customer();
//shopping cart
var productVariant1 = new ProductVariant
{
Id = 1,
Name = "Product variant name 1",
Price = 12.34M,
CustomerEntersPrice = false,
Published = true,
Product = new Product()
{
Id = 1,
Name = "Product name 1",
Published = true
}
};
var sci1 = new ShoppingCartItem()
{
ProductVariant = productVariant1,
ProductVariantId = productVariant1.Id,
Quantity = 2,
};
var productVariant2 = new ProductVariant
{
Id = 2,
Name = "Product variant name 2",
Price = 21.57M,
CustomerEntersPrice = false,
Published = true,
Product = new Product()
{
Id = 2,
Name = "Product name 2",
Published = true
}
};
var sci2 = new ShoppingCartItem()
{
ProductVariant = productVariant2,
ProductVariantId = productVariant2.Id,
Quantity = 3
};
var cart = new List<ShoppingCartItem>() { sci1, sci2 };
cart.ForEach(sci => sci.Customer = customer);
cart.ForEach(sci => sci.CustomerId = customer.Id);
//discounts
var discount1 = new Discount()
{
Id = 1,
Name = "Discount 1",
DiscountType = DiscountType.AssignedToOrderSubTotal,
DiscountAmount = 3,
DiscountLimitation = DiscountLimitationType.Unlimited,
};
_discountService.Expect(ds => ds.IsDiscountValid(discount1, customer)).Return(true);
_discountService.Expect(ds => ds.GetAllDiscounts(DiscountType.AssignedToOrderSubTotal)).Return(new List<Discount>() { discount1 });
_discountService.Expect(ds => ds.GetAllDiscounts(DiscountType.AssignedToCategories)).Return(new List<Discount>());
decimal discountAmount;
Discount appliedDiscount;
decimal subTotalWithoutDiscount;
decimal subTotalWithDiscount;
SortedDictionary<decimal, decimal> taxRates;
_orderTotalCalcService.GetShoppingCartSubTotal(cart, true,
out discountAmount, out appliedDiscount,
out subTotalWithoutDiscount, out subTotalWithDiscount, out taxRates);
//TODO strange. Why does the commented test fail? discountAmount.ShouldEqual(3.3);
//discountAmount.ShouldEqual(3.3);
appliedDiscount.ShouldNotBeNull();
appliedDiscount.Name.ShouldEqual("Discount 1");
subTotalWithoutDiscount.ShouldEqual(98.329);
subTotalWithDiscount.ShouldEqual(95.029);
taxRates.Count.ShouldEqual(1);
taxRates.ContainsKey(10).ShouldBeTrue();
taxRates[10].ShouldEqual(8.639);
}
public void Ensure_discount_is_not_applied_to_products_with_prices_entered_by_customer()
{
var productVariant = new ProductVariant
{
Id = 1,
Name = "Product variant name 1",
Price = 12.34M,
CustomerEntersPrice = true,
Published = true,
Product = new Product()
{
Id = 1,
Name = "Product name 1",
Published = true
}
};
//customer
Customer customer = null;
//discounts
var discount1 = new Discount()
{
Id = 1,
Name = "Discount 1",
DiscountType = DiscountType.AssignedToSkus,
DiscountAmount = 3,
DiscountLimitation = DiscountLimitationType.Unlimited
};
discount1.AppliedToProductVariants.Add(productVariant);
productVariant.AppliedDiscounts.Add(discount1);
_discountService.Expect(ds => ds.IsDiscountValid(discount1, customer)).Return(true);
Discount appliedDiscount;
_priceCalcService.GetDiscountAmount(productVariant, customer, 0, 1, out appliedDiscount).ShouldEqual(0);
appliedDiscount.ShouldBeNull();
}
public void Can_save_and_load_discount_with_discountRequirements()
{
var discount = new Discount
{
Name = "Discount 1",
DiscountType = DiscountType.AssignedToCategories,
UsePercentage = true,
DiscountPercentage = 1,
DiscountAmount = 2,
StartDateUtc = new DateTime(2010, 01, 01),
EndDateUtc = new DateTime(2010, 01, 02),
RequiresCouponCode = true,
CouponCode = "SecretCode",
DiscountLimitation = DiscountLimitationType.Unlimited,
LimitationTimes = 3
};
discount.DiscountRequirements.Add
(
new DiscountRequirement()
{
DiscountRequirementRuleSystemName = "BillingCountryIs"
}
);
var fromDb = SaveAndLoadEntity(discount);
fromDb.ShouldNotBeNull();
fromDb.Name.ShouldEqual("Discount 1");
fromDb.DiscountRequirements.ShouldNotBeNull();
(fromDb.DiscountRequirements.Count == 1).ShouldBeTrue();
fromDb.DiscountRequirements.First().DiscountRequirementRuleSystemName.ShouldEqual("BillingCountryIs");
}
/// <summary>
/// Gets discount amount
/// </summary>
/// <param name="shoppingCartItem">The shopping cart item</param>
/// <param name="appliedDiscount">Applied discount</param>
/// <returns>Discount amount</returns>
public virtual decimal GetDiscountAmount(ShoppingCartItem shoppingCartItem, out Discount appliedDiscount)
{
var customer = shoppingCartItem.Customer;
appliedDiscount = null;
decimal discountAmount = decimal.Zero;
var productVariant = shoppingCartItem.ProductVariant;
if (productVariant != null)
{
decimal attributesTotalPrice = decimal.Zero;
var pvaValues = _productAttributeParser.ParseProductVariantAttributeValues(shoppingCartItem.AttributesXml);
foreach (var pvaValue in pvaValues)
{
attributesTotalPrice += pvaValue.PriceAdjustment;
}
decimal productVariantDiscountAmount = GetDiscountAmount(productVariant, customer, attributesTotalPrice, shoppingCartItem.Quantity, out appliedDiscount);
discountAmount = productVariantDiscountAmount * shoppingCartItem.Quantity;
}
if (_shoppingCartSettings.RoundPricesDuringCalculation)
discountAmount = Math.Round(discountAmount, 2);
return discountAmount;
}
/// <summary>
/// Gets discount amount
/// </summary>
/// <param name="productVariant">Product variant</param>
/// <param name="customer">The customer</param>
/// <param name="additionalCharge">Additional charge</param>
/// <param name="quantity">Product quantity</param>
/// <param name="appliedDiscount">Applied discount</param>
/// <returns>Discount amount</returns>
public virtual decimal GetDiscountAmount(ProductVariant productVariant,
Customer customer,
decimal additionalCharge,
int quantity,
out Discount appliedDiscount)
{
appliedDiscount = null;
decimal appliedDiscountAmount = decimal.Zero;
//we don't apply discounts to products with price entered by a customer
if (productVariant.CustomerEntersPrice)
return appliedDiscountAmount;
appliedDiscount = GetPreferredDiscount(productVariant, customer, additionalCharge, quantity);
if (appliedDiscount != null)
{
decimal finalPriceWithoutDiscount = GetFinalPrice(productVariant, customer, additionalCharge, false, quantity);
appliedDiscountAmount = appliedDiscount.GetDiscountAmount(finalPriceWithoutDiscount);
}
return appliedDiscountAmount;
}
public new void SetUp()
{
_discountRepo = MockRepository.GenerateMock<IRepository<Discount>>();
var discount1 = new Discount
{
Id = 1,
DiscountType = DiscountType.AssignedToCategories,
Name = "Discount 1",
UsePercentage = true,
DiscountPercentage = 10,
DiscountAmount =0,
DiscountLimitation = DiscountLimitationType.Unlimited,
LimitationTimes = 0,
};
var discount2 = new Discount
{
Id = 2,
DiscountType = DiscountType.AssignedToSkus,
Name = "Discount 2",
UsePercentage = false,
DiscountPercentage = 0,
DiscountAmount = 5,
RequiresCouponCode = true,
CouponCode = "SecretCode",
DiscountLimitation = DiscountLimitationType.NTimesPerCustomer,
LimitationTimes = 3,
};
_discountRepo.Expect(x => x.Table).Return(new List<Discount>() { discount1, discount2 }.AsQueryable());
_eventPublisher = MockRepository.GenerateMock<IEventPublisher>();
_eventPublisher.Expect(x => x.Publish(Arg<object>.Is.Anything));
_storeContext = MockRepository.GenerateMock<IStoreContext>();
var cacheManager = new NasNullCache();
_discountRequirementRepo = MockRepository.GenerateMock<IRepository<DiscountRequirement>>();
_discountUsageHistoryRepo = MockRepository.GenerateMock<IRepository<DiscountUsageHistory>>();
var pluginFinder = new PluginFinder();
_genericAttributeService = MockRepository.GenerateMock<IGenericAttributeService>();
_discountService = new DiscountService(cacheManager, _discountRepo, _discountRequirementRepo,
_discountUsageHistoryRepo, _storeContext, _genericAttributeService, pluginFinder, _eventPublisher);
}
public void Can_get_shopping_cart_total_discount()
{
//customer
var customer = new Customer()
{
Id = 10,
};
//shopping cart
var productVariant1 = new ProductVariant
{
Id = 1,
Name = "Product variant name 1",
Price = 10M,
Published = true,
IsShipEnabled = true,
Product = new Product()
{
Id = 1,
Name = "Product name 1",
Published = true
}
};
var sci1 = new ShoppingCartItem()
{
ProductVariant = productVariant1,
ProductVariantId = productVariant1.Id,
Quantity = 2,
};
var productVariant2 = new ProductVariant
{
Id = 2,
Name = "Product variant name 2",
Price = 12M,
Published = true,
IsShipEnabled = true,
Product = new Product()
{
Id = 2,
Name = "Product name 2",
Published = true
}
};
var sci2 = new ShoppingCartItem()
{
ProductVariant = productVariant2,
ProductVariantId = productVariant2.Id,
Quantity = 3
};
var cart = new List<ShoppingCartItem>() { sci1, sci2 };
cart.ForEach(sci => sci.Customer = customer);
cart.ForEach(sci => sci.CustomerId = customer.Id);
//discounts
var discount1 = new Discount()
{
Id = 1,
Name = "Discount 1",
DiscountType = DiscountType.AssignedToOrderTotal,
DiscountAmount = 3,
DiscountLimitation = DiscountLimitationType.Unlimited,
};
_discountService.Expect(ds => ds.IsDiscountValid(discount1, customer)).Return(true);
_discountService.Expect(ds => ds.GetAllDiscounts(DiscountType.AssignedToOrderTotal)).Return(new List<Discount>() { discount1 });
_discountService.Expect(ds => ds.GetAllDiscounts(DiscountType.AssignedToCategories)).Return(new List<Discount>());
_genericAttributeService.Expect(x => x.GetAttributesForEntity(customer.Id, "Customer"))
.Return(new List<GenericAttribute>()
{
new GenericAttribute()
{
StoreId = _store.Id,
EntityId = customer.Id,
Key = SystemCustomerAttributeNames.SelectedPaymentMethod,
KeyGroup = "Customer",
Value = "test1"
}
});
_paymentService.Expect(ps => ps.GetAdditionalHandlingFee(cart, "test1")).Return(20);
decimal discountAmount;
Discount appliedDiscount;
List<AppliedGiftCard> appliedGiftCards;
int redeemedRewardPoints;
decimal redeemedRewardPointsAmount;
//shipping is taxable, payment fee is taxable
_taxSettings.ShippingIsTaxable = true;
_taxSettings.PaymentMethodAdditionalFeeIsTaxable = true;
//56 - items, 10 - shipping (fixed), 20 - payment fee, 8.6 - tax, [-3] - discount
_orderTotalCalcService.GetShoppingCartTotal(cart, out discountAmount, out appliedDiscount,
out appliedGiftCards, out redeemedRewardPoints, out redeemedRewardPointsAmount)
.ShouldEqual(91.6M);
discountAmount.ShouldEqual(3);
appliedDiscount.ShouldNotBeNull();
appliedDiscount.Name.ShouldEqual("Discount 1");
}
public void Should_not_accept_wrong_discount_code()
{
var discount = new Discount
{
DiscountType = DiscountType.AssignedToSkus,
Name = "Discount 2",
UsePercentage = false,
DiscountPercentage = 0,
DiscountAmount = 5,
RequiresCouponCode = true,
CouponCode = "CouponCode 1",
DiscountLimitation = DiscountLimitationType.Unlimited,
};
var customer = new Customer
{
CustomerGuid = Guid.NewGuid(),
AdminComment = "",
Active = true,
Deleted = false,
CreatedOnUtc = new DateTime(2010, 01, 01),
LastActivityDateUtc = new DateTime(2010, 01, 02)
};
_genericAttributeService.Expect(x => x.GetAttributesForEntity(customer.Id, "Customer"))
.Return(new List<GenericAttribute>()
{
new GenericAttribute()
{
EntityId = customer.Id,
Key = SystemCustomerAttributeNames.DiscountCouponCode,
KeyGroup = "Customer",
Value = "CouponCode 2"
}
});
var result2 = _discountService.IsDiscountValid(discount, customer);
result2.ShouldEqual(false);
}
public static Discount ToEntity(this DiscountModel model, Discount destination)
{
return Mapper.Map(model, destination);
}
/// <summary>
/// Check discount requirements
/// </summary>
/// <param name="discount">Discount</param>
/// <param name="customer">Customer</param>
/// <returns>true - requirement is met; otherwise, false</returns>
public virtual bool IsDiscountValid(Discount discount, Customer customer)
{
if (discount == null)
throw new ArgumentNullException("discount");
var couponCodeToValidate = "";
if (customer != null)
couponCodeToValidate = customer.GetAttribute<string>(SystemCustomerAttributeNames.DiscountCouponCode, _genericAttributeService);
return IsDiscountValid(discount, customer, couponCodeToValidate);
}
/// <summary>
/// Check discount requirements
/// </summary>
/// <param name="discount">Discount</param>
/// <param name="customer">Customer</param>
/// <param name="couponCodeToValidate">Coupon code to validate</param>
/// <returns>true - requirement is met; otherwise, false</returns>
public virtual bool IsDiscountValid(Discount discount, Customer customer, string couponCodeToValidate)
{
if (discount == null)
throw new ArgumentNullException("discount");
//check coupon code
if (discount.RequiresCouponCode)
{
if (String.IsNullOrEmpty(discount.CouponCode))
return false;
if (!discount.CouponCode.Equals(couponCodeToValidate, StringComparison.InvariantCultureIgnoreCase))
return false;
}
//check date range
DateTime now = DateTime.UtcNow;
if (discount.StartDateUtc.HasValue)
{
DateTime startDate = DateTime.SpecifyKind(discount.StartDateUtc.Value, DateTimeKind.Utc);
if (startDate.CompareTo(now) > 0)
return false;
}
if (discount.EndDateUtc.HasValue)
{
DateTime endDate = DateTime.SpecifyKind(discount.EndDateUtc.Value, DateTimeKind.Utc);
if (endDate.CompareTo(now) < 0)
return false;
}
if (!CheckDiscountLimitations(discount, customer))
return false;
//discount requirements
var requirements = discount.DiscountRequirements;
foreach (var req in requirements)
{
var requirementRule = LoadDiscountRequirementRuleBySystemName(req.DiscountRequirementRuleSystemName);
if (requirementRule == null)
continue;
var request = new CheckDiscountRequirementRequest()
{
DiscountRequirement = req,
Customer = customer,
Store = _storeContext.CurrentStore
};
if (!requirementRule.CheckRequirement(request))
return false;
}
return true;
}
/// <summary>
/// Checks discount limitation for customer
/// </summary>
/// <param name="discount">Discount</param>
/// <param name="customer">Customer</param>
/// <returns>Value indicating whether discount can be used</returns>
protected virtual bool CheckDiscountLimitations(Discount discount, Customer customer)
{
if (discount == null)
throw new ArgumentNullException("discount");
switch (discount.DiscountLimitation)
{
case DiscountLimitationType.Unlimited:
{
return true;
}
case DiscountLimitationType.NTimesOnly:
{
var totalDuh = GetAllDiscountUsageHistory(discount.Id, null, null, 0, 1).TotalCount;
return totalDuh < discount.LimitationTimes;
}
case DiscountLimitationType.NTimesPerCustomer:
{
if (customer != null && !customer.IsGuest())
{
//registered customer
var totalDuh = GetAllDiscountUsageHistory(discount.Id, customer.Id, null, 0, 1).TotalCount;
return totalDuh < discount.LimitationTimes;
}
else
{
//guest
return true;
}
}
default:
break;
}
return false;
}
public void Can_get_product_discount()
{
var productVariant = new ProductVariant
{
Id = 1,
Name = "Product variant name 1",
Price = 12.34M,
CustomerEntersPrice = false,
Published = true,
Product = new Product()
{
Id = 1,
Name = "Product name 1",
Published = true
}
};
//customer
Customer customer = null;
//discounts
var discount1 = new Discount()
{
Id = 1,
Name = "Discount 1",
DiscountType = DiscountType.AssignedToSkus,
DiscountAmount = 3,
DiscountLimitation = DiscountLimitationType.Unlimited
};
discount1.AppliedToProductVariants.Add(productVariant);
productVariant.AppliedDiscounts.Add(discount1);
//set HasDiscountsApplied property
productVariant.HasDiscountsApplied = true;
_discountService.Expect(ds => ds.IsDiscountValid(discount1, customer)).Return(true);
_discountService.Expect(ds => ds.GetAllDiscounts(DiscountType.AssignedToCategories)).Return(new List<Discount>());
var discount2 = new Discount()
{
Id = 2,
Name = "Discount 2",
DiscountType = DiscountType.AssignedToSkus,
DiscountAmount = 4,
DiscountLimitation = DiscountLimitationType.Unlimited
};
discount2.AppliedToProductVariants.Add(productVariant);
productVariant.AppliedDiscounts.Add(discount2);
_discountService.Expect(ds => ds.IsDiscountValid(discount2, customer)).Return(true);
var discount3 = new Discount()
{
Id = 3,
Name = "Discount 3",
DiscountType = DiscountType.AssignedToOrderSubTotal,
DiscountAmount = 5,
DiscountLimitation = DiscountLimitationType.Unlimited,
RequiresCouponCode = true,
CouponCode = "SECRET CODE"
};
discount3.AppliedToProductVariants.Add(productVariant);
productVariant.AppliedDiscounts.Add(discount3);
//discount is not valid
_discountService.Expect(ds => ds.IsDiscountValid(discount3, customer)).Return(false);
Discount appliedDiscount;
_priceCalcService.GetDiscountAmount(productVariant, customer, 0, 1, out appliedDiscount).ShouldEqual(4);
appliedDiscount.ShouldNotBeNull();
appliedDiscount.ShouldEqual(discount2);
}
/// <summary>
/// Delete discount
/// </summary>
/// <param name="discount">Discount</param>
public virtual void DeleteDiscount(Discount discount)
{
if (discount == null)
throw new ArgumentNullException("discount");
_discountRepository.Delete(discount);
_cacheManager.RemoveByPattern(DISCOUNTS_PATTERN_KEY);
//event notification
_eventPublisher.EntityDeleted(discount);
}
public void Can_get_final_product_price_with_discount()
{
var productVariant = new ProductVariant
{
Id = 1,
Name = "Product variant name 1",
Price = 12.34M,
CustomerEntersPrice = false,
Published = true,
Product = new Product()
{
Id = 1,
Name = "Product name 1",
Published = true
}
};
//customer
Customer customer = null;
//discounts
var discount1 = new Discount()
{
Id = 1,
Name = "Discount 1",
DiscountType = DiscountType.AssignedToSkus,
DiscountAmount = 3,
DiscountLimitation = DiscountLimitationType.Unlimited
};
discount1.AppliedToProductVariants.Add(productVariant);
productVariant.AppliedDiscounts.Add(discount1);
//set HasDiscountsApplied property
productVariant.HasDiscountsApplied = true;
_discountService.Expect(ds => ds.IsDiscountValid(discount1, customer)).Return(true);
_discountService.Expect(ds => ds.GetAllDiscounts(DiscountType.AssignedToCategories)).Return(new List<Discount>());
_priceCalcService.GetFinalPrice(productVariant, customer, 0, true, 1).ShouldEqual(9.34M);
}
public void Can_get_shipping_total_discount_including_tax()
{
var sci1 = new ShoppingCartItem()
{
AttributesXml = "",
Quantity = 3,
ProductVariant = new ProductVariant()
{
Id = 1,
Weight = 1.5M,
Height = 2.5M,
Length = 3.5M,
Width = 4.5M,
AdditionalShippingCharge = 5.5M,
IsShipEnabled = true,
}
};
var sci2 = new ShoppingCartItem()
{
AttributesXml = "",
Quantity = 4,
ProductVariant = new ProductVariant()
{
Id = 2,
Weight = 11.5M,
Height = 12.5M,
Length = 13.5M,
Width = 14.5M,
AdditionalShippingCharge = 6.5M,
IsShipEnabled = true,
}
};
//sci3 is not shippable
var sci3 = new ShoppingCartItem()
{
AttributesXml = "",
Quantity = 5,
ProductVariant = new ProductVariant()
{
Id = 3,
Weight = 11.5M,
Height = 12.5M,
Length = 13.5M,
Width = 14.5M,
AdditionalShippingCharge = 7.5M,
IsShipEnabled = false,
}
};
var cart = new List<ShoppingCartItem>() { sci1, sci2, sci3 };
var customer = new Customer();
cart.ForEach(sci => sci.Customer = customer);
cart.ForEach(sci => sci.CustomerId = customer.Id);
//discounts
var discount1 = new Discount()
{
Id = 1,
Name = "Discount 1",
DiscountType = DiscountType.AssignedToShipping,
DiscountAmount = 3,
DiscountLimitation = DiscountLimitationType.Unlimited,
};
_discountService.Expect(ds => ds.IsDiscountValid(discount1, customer)).Return(true);
_discountService.Expect(ds => ds.GetAllDiscounts(DiscountType.AssignedToShipping)).Return(new List<Discount>() { discount1 });
decimal taxRate = decimal.Zero;
Discount appliedDiscount = null;
decimal? shipping = null;
shipping = _orderTotalCalcService.GetShoppingCartShippingTotal(cart, true, out taxRate, out appliedDiscount);
appliedDiscount.ShouldNotBeNull();
appliedDiscount.Name.ShouldEqual("Discount 1");
shipping.ShouldNotBeNull();
//10 - default fixed shipping rate, 42.5 - additional shipping change, -3 - discount
shipping.ShouldEqual(54.45);
//10 - default fixed tax rate
taxRate.ShouldEqual(10);
}
