public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
//invalid by default
var result = new DiscountRequirementValidationResult();
if (request.Customer == null)
{
return(result);
}
//check if rule is applied
var isFirstOrderRuleApplied = _settingService.GetSettingByKey <bool>(string.Format(DiscountRequirementDefaults.SettingsKey, request.DiscountRequirementId));
if (isFirstOrderRuleApplied == false)
{
return(result);
}
//check customer orders
var orders = _orderService.SearchOrders(storeId: request.Store.Id, customerId: request.Customer.Id);
result.IsValid = orders.Count == 0 ? true : false;
return(result);
}
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
//invalid by default
var result = new DiscountRequirementValidationResult();
if (request.Customer.IsGuest())
{
return(result);
}
int orderCount = 0;
try
{
orderCount = _orderService.SearchOrders(customerId: request.Customer.Id).Where(x => x.OrderStatus == Core.Domain.Orders.OrderStatus.Complete).Count();
}
catch { }
var minOrderCount = _settingService.GetSettingByKey <int>(string.Format("DiscountRequirement.WasOrder.OrerCount-{0}", request.DiscountRequirementId));
if (orderCount >= minOrderCount)
{
result.IsValid = true;
return(result);
}
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>Result</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
//invalid by default
var result = new DiscountRequirementValidationResult();
if (request.Customer == null)
{
return(result);
}
//try to get saved restricted customer role identifier
var restrictedRoleId = _settingService.GetSettingByKey <int>(string.Format(DiscountRequirementDefaults.SettingsKey, request.DiscountRequirementId));
if (restrictedRoleId == 0)
{
return(result);
}
//result is valid if the customer belongs to the restricted role
result.IsValid = request.Customer.CustomerRoles.Any(role => role.Id == restrictedRoleId && role.Active);
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>Result</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
//invalid by default
var result = new DiscountRequirementValidationResult();
if (request.Customer == null)
{
return(result);
}
if (request.Customer.BillingAddress == null)
{
return(result);
}
var billingCountryId = _settingService.GetSettingByKey <int>($"DiscountRequirement.BillingCountry-{request.DiscountRequirementId}");
if (billingCountryId == 0)
{
return(result);
}
result.IsValid = request.Customer.BillingAddress.CountryId == billingCountryId;
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>Result</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
//invalid by default
var result = new DiscountRequirementValidationResult();
var restrictedProductVariantIdsStr = _settingService.GetSettingByKey <string>(string.Format("DiscountRequirement.RestrictedProductVariantIds-{0}", request.DiscountRequirementId));
if (String.IsNullOrWhiteSpace(restrictedProductVariantIdsStr))
{
result.IsValid = true;
return(result);
}
if (request.Customer == null)
{
return(result);
}
var restrictedProductIds = new List <int>();
try
{
restrictedProductIds = restrictedProductVariantIdsStr
.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => Convert.ToInt32(x))
.ToList();
}
catch
{
//error parsing
return(result);
}
if (restrictedProductIds.Count == 0)
{
return(result);
}
var customerId = request.Customer.Id;
var orderStatusId = (int)OrderStatus.Complete;
//purchased product
var purchasedProducts = _orderItemRepository.Table.Where(oi => oi.Order.CustomerId == customerId && !oi.Order.Deleted && oi.Order.OrderStatusId == orderStatusId).ToList();
bool allFound = restrictedProductIds
.Select(restrictedProductId => purchasedProducts.Any(purchasedProduct => restrictedProductId == purchasedProduct.ProductId))
.All(found1 => found1);
if (allFound)
{
result.IsValid = true;
return(result);
}
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>true - requirement is met; otherwise, false</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
//invalid by default
var result = new DiscountRequirementValidationResult();
if (request.Customer == null)
{
return(result);
}
var restrictedToCustomerRoleId = _settingService.GetSettingByKey <string>(string.Format("DiscountRequirement.MustBeAssignedToCustomerRole-{0}-{1}", request.DiscountId, request.DiscountRequirementId));
if (String.IsNullOrEmpty(restrictedToCustomerRoleId))
{
return(result);
}
foreach (var customerRole in request.Customer.CustomerRoles.Where(cr => cr.Active).ToList())
{
if (restrictedToCustomerRoleId == customerRole.Id)
{
//valid
result.IsValid = true;
return(result);
}
}
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>Result</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
//invalid by default
var result = new DiscountRequirementValidationResult();
if (request.Customer == null)
{
return(result);
}
if (request.Customer.ShippingAddress == null)
{
return(result);
}
var shippingCountryId = _settingService.GetSettingByKey <int>(string.Format("DiscountRequirement.ShippingCountry-{0}", request.DiscountRequirementId));
if (shippingCountryId == 0)
{
return(result);
}
result.IsValid = request.Customer.ShippingAddress.CountryId == shippingCountryId;
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>Result</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
//invalid by default
var result = new DiscountRequirementValidationResult();
var spentAmountRequirement = _settingService.GetSettingByKey <decimal>(string.Format("DiscountRequirement.HadSpentAmount-{0}", request.DiscountRequirementId));
if (spentAmountRequirement == decimal.Zero)
{
//valid
result.IsValid = true;
return(result);
}
if (request.Customer == null || request.Customer.IsGuest())
{
return(result);
}
var cart = _workContext.CurrentCustomer.ShoppingCartItems
.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart)
.LimitPerStore(_storeContext.CurrentStore.Id)
.ToList();
decimal spentAmount = decimal.Zero;
foreach (var sci in cart)
{
spentAmount += _priceCalculationService.GetSubTotal(sci);
}
//decimal spentAmount = orders.Sum(o => o.OrderTotal);
if (spentAmount > spentAmountRequirement)
{
result.IsValid = true;
}
else
{
result.UserError = _localizationService.GetResource("Plugins.DiscountRules.HadSpentAmount.NotEnough");
}
return(result);
}
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
//invalid by default
var result = new DiscountRequirementValidationResult();
result.IsValid = false;
if (request.Customer == null)
{
return(result);
}
var daysDelta = _settingService.GetSettingByKey <int>(string.Format("DiscountRequirement.OncePerNDay-{0}", request.DiscountRequirementId));
var discountID = _settingService.GetSettingByKey <int>(string.Format("DiscountRequirement.OncePerNDayDiscountID-{0}", request.DiscountRequirementId));
if (discountID == 0)
{
return(result);
}
if (daysDelta == 0)
{
return(result);
}
DateTime minDate = DateTime.Now.AddDays(-1 * daysDelta);
var customerOrders = _orderService.SearchOrders(customerId: request.Customer.Id).Where(x => x.CreatedOnUtc >= minDate && x.OrderStatus != OrderStatus.Cancelled &&
x.DiscountUsageHistory.Where(y => y.DiscountId == discountID).Count() > 0).Count();
if (customerOrders > 0)
{
result.IsValid = false;
return(result);
}
else
{
result.IsValid = true;
return(result);
}
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>Result</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
if (request.DiscountRequirement == null)
{
throw new NopException("Discount requirement is not set");
}
//invalid by default
var result = new DiscountRequirementValidationResult();
var spentAmountRequirement = _settingService.GetSettingByKey <decimal>(string.Format("DiscountRequirement.HadSpentAmount-{0}", request.DiscountRequirement.Id));
if (spentAmountRequirement == decimal.Zero)
{
//valid
result.IsValid = true;
return(result);
}
if (request.Customer == null || request.Customer.IsGuest())
{
return(result);
}
var orders = _orderService.SearchOrders(storeId: request.Store.Id,
customerId: request.Customer.Id,
os: OrderStatus.Complete);
decimal spentAmount = orders.Sum(o => o.OrderTotal);
if (spentAmount > spentAmountRequirement)
{
result.IsValid = true;
}
else
{
result.UserError = _localizationService.GetResource("Plugins.DiscountRules.HadSpentAmount.NotEnough");
}
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the result
/// </returns>
public async Task <DiscountRequirementValidationResult> CheckRequirementAsync(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
//invalid by default
var result = new DiscountRequirementValidationResult();
var spentAmountRequirement = await _settingService.GetSettingByKeyAsync <decimal>($"DiscountRequirement.HadSpentAmount-{request.DiscountRequirementId}");
if (spentAmountRequirement == decimal.Zero)
{
//valid
result.IsValid = true;
return(result);
}
if (request.Customer == null || await _customerService.IsGuestAsync(request.Customer))
{
return(result);
}
var orders = await _orderService.SearchOrdersAsync(request.Store.Id,
customerId : request.Customer.Id,
osIds : new List <int> {
(int)OrderStatus.Complete
});
var spentAmount = orders.Sum(o => o.OrderTotal);
if (spentAmount > spentAmountRequirement)
{
result.IsValid = true;
}
else
{
result.UserError = await _localizationService.GetResourceAsync("Plugins.DiscountRules.HadSpentAmount.NotEnough");
}
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>true - requirement is met; otherwise, false</returns>
public async Task <DiscountRequirementValidationResult> CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
var result = new DiscountRequirementValidationResult();
var spentAmountRequirement = _settingService.GetSettingByKey <decimal>(string.Format("DiscountRequirement.ShoppingCart-{0}", request.DiscountRequirementId));
if (spentAmountRequirement == decimal.Zero)
{
result.IsValid = true;
return(result);
}
var cart = _workContext.CurrentCustomer.ShoppingCartItems
.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart)
.LimitPerStore(_shoppingCartSettings.CartsSharedBetweenStores, request.Store.Id)
.ToList();
if (cart.Count == 0)
{
result.IsValid = false;
return(result);
}
decimal spentAmount = 0;
foreach (var ca in cart)
{
bool calculateWithDiscount = false;
var product = await _productService.GetProductById(ca.ProductId);
if (product != null)
{
spentAmount += (await _priceCalculationService.GetSubTotal(ca, product, calculateWithDiscount)).subTotal;
}
}
result.IsValid = spentAmount > spentAmountRequirement;
return(result);
}
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
//invalid by default
var result = new DiscountRequirementValidationResult();
result.IsValid = false;
if (request.Customer == null)
{
return(result);
}
var daysDelta = _settingService.GetSettingByKey <int>(string.Format("DiscountRequirement.BirthdayDelta-{0}", request.DiscountRequirementId));
if (daysDelta == 0)
{
return(result);
}
var bDay = request.Customer.GetAttribute <DateTime?>(Nop.Core.Domain.Customers.SystemCustomerAttributeNames.DateOfBirth);
DateTime today = DateTime.Now;
if (bDay.HasValue)
{
DateTime rbDay = (DateTime)bDay;
DateTime bDayNow = new DateTime(today.Year, rbDay.Month, rbDay.Day);
if (bDayNow >= today.AddDays(-1 * daysDelta) && bDayNow <= today.AddDays(daysDelta))
{
result.IsValid = true;
return(result);
}
}
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>Result</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
//invalid by default
var result = new DiscountRequirementValidationResult();
if (request.Customer == null)
{
return(result);
}
var fromQuantity = _settingService.GetSettingByKey <int>(string.Format(DiscountRequirementDefaults.SettingsFromKey, request.DiscountRequirementId));
var toQuantity = _settingService.GetSettingByKey <int>(string.Format(DiscountRequirementDefaults.SettingsToKey, request.DiscountRequirementId));
if (fromQuantity == 0 && toQuantity == 0)
{
return(result);
}
var cartQuery = from sci in request.Customer.ShoppingCartItems.LimitPerStore(request.Store.Id)
where sci.ShoppingCartType == ShoppingCartType.ShoppingCart
group sci by sci.ProductId into g
select new { ProductId = g.Key, TotalQuantity = g.Sum(x => x.Quantity) };
var cart = cartQuery.ToList();
var totalQuantity = cart.Sum(x => x.TotalQuantity);
if (totalQuantity >= fromQuantity && totalQuantity <= toQuantity)
{
result.IsValid = true;
}
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>true - requirement is met; otherwise, false</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
var result = new DiscountRequirementValidationResult();
var spentAmountRequirement = _settingService.GetSettingByKey <decimal>(string.Format("DiscountRequirement.ShoppingCart-{0}", request.DiscountRequirementId));
if (spentAmountRequirement == decimal.Zero)
{
result.IsValid = true;
return(result);
}
var cart = _workContext.CurrentCustomer.ShoppingCartItems
.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart)
.LimitPerStore(request.Store.Id)
.ToList();
if (cart.Count == 0)
{
result.IsValid = false;
return(result);
}
decimal spentAmount = 0;
foreach (var ca in cart)
{
bool calculateWithDiscount = false;
spentAmount += _priceCalculationService.GetSubTotal(ca, calculateWithDiscount);
}
result.IsValid = spentAmount > spentAmountRequirement;
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the result
/// </returns>
public async Task <DiscountRequirementValidationResult> CheckRequirementAsync(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
//invalid by default
var result = new DiscountRequirementValidationResult();
var restrictedProductIds = await _settingService.GetSettingByKeyAsync <string>(string.Format(DiscountRequirementDefaults.SETTINGS_KEY, request.DiscountRequirementId));
if (string.IsNullOrWhiteSpace(restrictedProductIds))
{
//valid
result.IsValid = true;
return(result);
}
if (request.Customer == null)
{
return(result);
}
//we support three ways of specifying products:
//1. The comma-separated list of product identifiers (e.g. 77, 123, 156).
//2. The comma-separated list of product identifiers with quantities.
// {Product ID}:{Quantity}. For example, 77:1, 123:2, 156:3
//3. The comma-separated list of product identifiers with quantity range.
// {Product ID}:{Min quantity}-{Max quantity}. For example, 77:1-3, 123:2-5, 156:3-8
var restrictedProducts = restrictedProductIds
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.ToList();
if (!restrictedProducts.Any())
{
return(result);
}
//group products in the cart by product ID
//it could be the same product with distinct product attributes
//that's why we get the total quantity of this product
var cart = (await _shoppingCartService.GetShoppingCartAsync(customer: request.Customer, shoppingCartType: ShoppingCartType.ShoppingCart, storeId: request.Store.Id))
.GroupBy(sci => sci.ProductId)
.Select(g => new { ProductId = g.Key, TotalQuantity = g.Sum(x => x.Quantity) });
var allFound = true;
foreach (var restrictedProduct in restrictedProducts)
{
if (string.IsNullOrWhiteSpace(restrictedProduct))
{
continue;
}
var found1 = false;
foreach (var sci in cart)
{
if (restrictedProduct.Contains(":"))
{
if (restrictedProduct.Contains("-"))
{
//the third way (the quantity rage specified)
//{Product ID}:{Min quantity}-{Max quantity}. For example, 77:1-3, 123:2-5, 156:3-8
if (!int.TryParse(restrictedProduct.Split(':')[0], out var restrictedProductId))
{
//parsing error; exit;
return(result);
}
if (!int.TryParse(restrictedProduct.Split(':')[1].Split('-')[0], out var quantityMin))
{
//parsing error; exit;
return(result);
}
if (!int.TryParse(restrictedProduct.Split(':')[1].Split('-')[1], out var quantityMax))
{
//parsing error; exit;
return(result);
}
if (sci.ProductId == restrictedProductId && quantityMin <= sci.TotalQuantity && sci.TotalQuantity <= quantityMax)
{
found1 = true;
break;
}
}
else
{
//the second way (the quantity specified)
//{Product ID}:{Quantity}. For example, 77:1, 123:2, 156:3
if (!int.TryParse(restrictedProduct.Split(':')[0], out var restrictedProductId))
{
//parsing error; exit;
return(result);
}
if (!int.TryParse(restrictedProduct.Split(':')[1], out var quantity))
{
//parsing error; exit;
return(result);
}
if (sci.ProductId == restrictedProductId && sci.TotalQuantity == quantity)
{
found1 = true;
break;
}
}
}
else
{
//the first way (the quantity is not specified)
if (int.TryParse(restrictedProduct, out var restrictedProductId))
{
if (sci.ProductId == restrictedProductId)
{
found1 = true;
break;
}
}
}
}
if (!found1)
{
allFound = false;
break;
}
}
if (allFound)
{
//valid
result.IsValid = true;
return(result);
}
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>Result</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
//invalid by default
var result = new DiscountRequirementValidationResult();
var productQuantityMin = _settingService.GetSettingByKey <int>($"DiscountRequirement.ProductQuantityMin-{request.DiscountRequirementId}");
var productQuantityMax = _settingService.GetSettingByKey <int>($"DiscountRequirement.ProductQuantityMax-{request.DiscountRequirementId}");
var restrictedProductIds = _settingService.GetSettingByKey <string>($"DiscountRequirement.RestrictedProductIds-{request.DiscountRequirementId}");
if (string.IsNullOrWhiteSpace(restrictedProductIds))
{
return(result);
}
if (productQuantityMin <= 0 || productQuantityMax <= 0 || productQuantityMin > productQuantityMax)
{
return(result);
}
if (request.Customer == null)
{
return(result);
}
//we support comma-separated list of product identifiers (e.g. 77, 123, 156).
var restrictedProducts = restrictedProductIds
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.ToList();
if (!restrictedProducts.Any())
{
return(result);
}
//group products in the cart by product ID
//it could be the same product with distinct product attributes
//that's why we get the total quantity of this product
var cartQuery = from sci in request.Customer.ShoppingCartItems.LimitPerStore(request.Store.Id)
where sci.ShoppingCartType == ShoppingCartType.ShoppingCart
group sci by sci.ProductId into g
select new { ProductId = g.Key, TotalQuantity = g.Sum(x => x.Quantity) };
var cart = cartQuery.ToList();
var totalQuantity = 0;
foreach (var sci in cart)
{
if (restrictedProducts.Any(id => id == sci.ProductId.ToString()))
{
totalQuantity += sci.TotalQuantity;
if (totalQuantity > productQuantityMax)
{
return(result);
}
}
}
result.IsValid = totalQuantity >= productQuantityMin && totalQuantity <= productQuantityMax;
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>Result</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
//invalid by default
var result = new DiscountRequirementValidationResult();
var productQuantityMin = _settingService.GetSettingByKey <int>($"DiscountRequirement.ProductQuantityMin-{request.DiscountRequirementId}");
var productQuantityMax = _settingService.GetSettingByKey <int>($"DiscountRequirement.ProductQuantityMax-{request.DiscountRequirementId}");
var restrictedCategoryIds = _settingService.GetSettingByKey <string>($"DiscountRequirement.RestrictedCategoryIds-{request.DiscountRequirementId}");
var excludedProductIds = _settingService.GetSettingByKey <string>(string.Format("DiscountRequirement.ExcludedProductIds-{0}", request.DiscountRequirementId));
if (string.IsNullOrWhiteSpace(restrictedCategoryIds))
{
return(result);
}
if (productQuantityMin <= 0 || productQuantityMax <= 0 || productQuantityMin > productQuantityMax)
{
return(result);
}
if (request.Customer == null)
{
return(result);
}
//we support comma-separated list of category identifiers (e.g. 77, 123, 156).
var restrictedCategories = restrictedCategoryIds
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.ToList();
if (!restrictedCategories.Any())
{
return(result);
}
var excludedProducts = (excludedProductIds ?? String.Empty)
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.ToList();
//group products in the cart by product ID
//it could be the same product with distinct product attributes
//that's why we get the total quantity of this product
var cartQuery = from sci in request.Customer.ShoppingCartItems
where sci.ShoppingCartType == ShoppingCartType.ShoppingCart &&
sci.StoreId == request.Store.Id
group sci by sci.ProductId into g
select new { ProductId = g.Key, TotalQuantity = g.Sum(x => x.Quantity) };
var cart = cartQuery.ToList();
var totalQuantity = 0;
var productIds = new List <int>();
foreach (var sci in cart)
{
productIds.Add(sci.ProductId);
}
var productCategoryIds = _categoryService.GetProductCategoryIds(productIds.ToArray());
foreach (var sci in cart)
{
if (excludedProducts.Any(id => sci.ProductId.ToString() == id) == false)
{
productCategoryIds.TryGetValue(sci.ProductId, out int[] categories);
if (categories != null && categories.Length > 0)
{
var isProductInRestrictedCategory = false;
for (int i = 0; i < categories.Length; i++)
{
if (isProductInRestrictedCategory == false &&
restrictedCategories.Any(id => id == categories[i].ToString()))
{
totalQuantity += sci.TotalQuantity;
isProductInRestrictedCategory = true;
if (totalQuantity > productQuantityMax)
{
return(result);
}
}
}
}
}
}
result.IsValid = totalQuantity >= productQuantityMin && totalQuantity <= productQuantityMax;
return(result);
}
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
//invalid by default
var result = new DiscountRequirementValidationResult();
if (request.Customer == null)
{
return(result);
}
var restrictedToShippingProviderId = _settingService.GetSettingByKey <string>(string.Format(DiscountRequirementDefaults.SettingsKey, request.DiscountRequirementId));
if (string.IsNullOrEmpty(restrictedToShippingProviderId))
{
return(result);
}
var restrictedToShippingType = _settingService.GetSettingByKey <string>(string.Format(DiscountRequirementDefaults.TypeNameSettingsKey, request.DiscountRequirementId));
if (string.IsNullOrEmpty(restrictedToShippingType))
{
return(result);
}
var restrictedToShippingAmount = _settingService.GetSettingByKey <decimal>(string.Format(DiscountRequirementDefaults.ShippingAmountKey, request.DiscountRequirementId));
if (restrictedToShippingAmount <= 0)
{
return(result);
}
var restrictedToShippingAmountExcludeTax = _settingService.GetSettingByKey <bool>(string.Format(DiscountRequirementDefaults.ShippingAmountExcludeTaxKey, request.DiscountRequirementId));
var customerSelectedShippingOption = request.Customer.GetAttribute <ShippingOption>(SystemCustomerAttributeNames.SelectedShippingOption, _storeContext.CurrentStore.Id);
if (customerSelectedShippingOption != null && customerSelectedShippingOption.ShippingRateComputationMethodSystemName == restrictedToShippingProviderId)
{
//valid
if (customerSelectedShippingOption.Name == restrictedToShippingType)
{
//is order equal or greater than
if (request.Customer.HasShoppingCartItems)
{
var total = request.Customer.ShoppingCartItems.AsEnumerable().Sum(x => x.Quantity * x.Product.Price);
if (total >= restrictedToShippingAmount)
{
result.IsValid = true;
}
}
}
}
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>Result</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
//invalid by default
var result = new DiscountRequirementValidationResult();
var restrictedProductVariantIdsStr = _settingService.GetSettingByKey <string>($"DiscountRequirement.RestrictedProductVariantIds-{request.DiscountRequirementId}");
if (string.IsNullOrWhiteSpace(restrictedProductVariantIdsStr))
{
return(result);
}
if (request.Customer == null)
{
return(result);
}
List <int> restrictedProductIds;
try
{
restrictedProductIds = restrictedProductVariantIdsStr
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => Convert.ToInt32(x))
.ToList();
}
catch
{
//error parsing
return(result);
}
if (restrictedProductIds.Count == 0)
{
return(result);
}
var customerId = request.Customer.Id;
const int orderStatusId = (int)OrderStatus.Complete;
//purchased product
var purchasedProducts = _orderItemRepository.Table.Where(oi => oi.Order.CustomerId == customerId && !oi.Order.Deleted && oi.Order.OrderStatusId == orderStatusId).ToList();
var found = false;
foreach (var restrictedProductId in restrictedProductIds)
{
if (purchasedProducts.Any(purchasedProduct => restrictedProductId == purchasedProduct.ProductId))
{
found = true;
}
if (found)
{
break;
}
}
if (found)
{
result.IsValid = true;
return(result);
}
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>true - requirement is met; otherwise, false</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
//invalid by default
var result = new DiscountRequirementValidationResult();
var restrictedProductIds = _settingService.GetSettingByKey <string>(string.Format("DiscountRequirement.RestrictedProductIds-{0}-{1}", request.DiscountId, request.DiscountRequirementId));
if (String.IsNullOrWhiteSpace(restrictedProductIds))
{
//valid
result.IsValid = true;
return(result);
}
if (request.Customer == null)
{
return(result);
}
//we support three ways of specifying products:
//1. The comma-separated list of product identifiers (e.g. 77, 123, 156).
//2. The comma-separated list of product identifiers with quantities.
// {Product ID}:{Quantity}. For example, 77:1, 123:2, 156:3
//3. The comma-separated list of product identifiers with quantity range.
// {Product ID}:{Min quantity}-{Max quantity}. For example, 77:1-3, 123:2-5, 156:3-8
var restrictedProducts = restrictedProductIds
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.ToList();
if (restrictedProducts.Count == 0)
{
return(result);
}
//group products in the cart by product ID
//it could be the same product with distinct product attributes
//that's why we get the total quantity of this product
var cartQuery = from sci in request.Customer.ShoppingCartItems.LimitPerStore(request.Store.Id)
where sci.ShoppingCartType == ShoppingCartType.ShoppingCart
group sci by sci.ProductId into g
select new { ProductId = g.Key, TotalQuantity = g.Sum(x => x.Quantity) };
var cart = cartQuery.ToList();
bool allFound = true;
foreach (var restrictedProduct in restrictedProducts)
{
if (String.IsNullOrWhiteSpace(restrictedProduct))
{
continue;
}
bool found1 = false;
foreach (var sci in cart)
{
if (restrictedProduct.Contains(":"))
{
if (restrictedProduct.Contains("-"))
{
//the third way (the quantity rage specified)
//{Product ID}:{Min quantity}-{Max quantity}. For example, 77:1-3, 123:2-5, 156:3-8
string restrictedProductId = restrictedProduct.Split(new[] { ':' })[0];
int quantityMin;
if (!int.TryParse(restrictedProduct.Split(new[] { ':' })[1].Split(new[] { '-' })[0], out quantityMin))
{
//parsing error; exit;
return(result);
}
int quantityMax;
if (!int.TryParse(restrictedProduct.Split(new[] { ':' })[1].Split(new[] { '-' })[1], out quantityMax))
{
//parsing error; exit;
return(result);
}
if (sci.ProductId == restrictedProductId && quantityMin <= sci.TotalQuantity && sci.TotalQuantity <= quantityMax)
{
found1 = true;
break;
}
}
else
{
//the second way (the quantity specified)
//{Product ID}:{Quantity}. For example, 77:1, 123:2, 156:3
string restrictedProductId = restrictedProduct.Split(new[] { ':' })[0];
int quantity;
if (!int.TryParse(restrictedProduct.Split(new[] { ':' })[1], out quantity))
{
//parsing error; exit;
return(result);
}
if (sci.ProductId == restrictedProductId && sci.TotalQuantity == quantity)
{
found1 = true;
break;
}
}
}
else
{
//the first way (the quantity is not specified)
if (sci.ProductId == restrictedProduct)
{
found1 = true;
break;
}
}
}
if (!found1)
{
allFound = false;
break;
}
}
if (allFound)
{
//valid
result.IsValid = true;
return(result);
}
return(result);
}
/// <summary>
/// Check discount requirement
/// </summary>
/// <param name="request">Object that contains all information required to check the requirement (Current customer, discount, etc)</param>
/// <returns>Result</returns>
public DiscountRequirementValidationResult CheckRequirement(DiscountRequirementValidationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
//invalid by default
var result = new DiscountRequirementValidationResult();
var restrictedProductIds = _settingService.GetSettingByKey <string>(string.Format("DiscountRequirement.RestrictedProductIds-{0}", request.DiscountRequirementId));
if (String.IsNullOrWhiteSpace(restrictedProductIds))
{
//valid
result.IsValid = true;
return(result);
}
if (request.Customer == null)
{
return(result);
}
//we support three ways of specifying products:
//1. The comma-separated list of product identifiers (e.g. 77, 123, 156).
//2. The comma-separated list of product identifiers with quantities.
// {Product ID}:{Quantity}. For example, 77:1, 123:2, 156:3
//3. The comma-separated list of product identifiers with quantity range.
// {Product ID}:{Min quantity}-{Max quantity}. For example, 77:1-3, 123:2-5, 156:3-8
var restrictedProducts = restrictedProductIds
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.ToList();
if (!restrictedProducts.Any())
{
return(result);
}
//group products in the cart by product ID
//it could be the same product with distinct product attributes
//that's why we get the total quantity of this product
scis = request.Customer.ShoppingCartItems.LimitPerStore(request.Store.Id).ToList();/////////////////////
List <int> found = new List <int>();
foreach (var restrictedProduct in restrictedProducts)
{
if (String.IsNullOrWhiteSpace(restrictedProduct))
{
continue;
}
foreach (var sci in scis)
{
int restrictedProductId;
if (sci != null)
{
//the first way (the quantity is not specified)
if (int.TryParse(restrictedProduct, out restrictedProductId))
{
if (sci.ProductId == restrictedProductId)
{
for (int i = 0; i < sci.Quantity; i++)
{ // adds quantity as different products
valids++;
}
result.productsForDeduction.Add(sci);
}
}
}
}
}
if (valids >= 2)
{
//valid
result.IsValid = true;
return(result);
}
return(result);
}
