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); }