public virtual Task <IList <OrganizedShoppingCartItem> > GetCartItemsAsync( Customer customer = null, ShoppingCartType cartType = ShoppingCartType.ShoppingCart, int storeId = 0) { customer ??= _workContext.CurrentCustomer; var cacheKey = CartItemsKey.FormatInvariant(customer.Id, (int)cartType, storeId); var result = _requestCache.Get(cacheKey, async() => { var cartItems = new List <ShoppingCartItem>(); // TODO: (ms) (core) Do we need to check for ShoppingCartItems.Product.ProductVariantAttribute is loaded too? Would this direct access be even possible then? if (_db.IsCollectionLoaded(customer, x => x.ShoppingCartItems)) { var filteredCartItems = customer.ShoppingCartItems .Where(x => x.CustomerId == customer.Id && x.ShoppingCartTypeId == (int)cartType); if (storeId > 0) { filteredCartItems = cartItems.Where(x => x.StoreId == storeId); } cartItems = filteredCartItems.ToList(); } else { // TODO: (core) Re-apply data to Customer.ShoppingCartItems collection to prevent reloads. cartItems = await _db.ShoppingCartItems .Include(x => x.Product) .ThenInclude(x => x.ProductVariantAttributes) .ApplyStandardFilter(cartType, storeId, customer) .ToListAsync(); } // Prefetch all product variant attributes var allAttributes = new ProductVariantAttributeSelection(string.Empty); var allAttributeMaps = cartItems.SelectMany(x => x.AttributeSelection.AttributesMap); foreach (var attribute in allAttributeMaps) { if (allAttributes.AttributesMap.Contains(attribute)) { continue; } allAttributes.AddAttribute(attribute.Key, attribute.Value); } // TODO: (ms) (core) Check if this is sufficient and good prefetch -> what about caching or skipping already loaded? await _productAttributeMaterializer.MaterializeProductVariantAttributesAsync(allAttributes); return(await OrganizeCartItemsAsync(cartItems)); }); return(result); }
public virtual Task <List <OrganizedShoppingCartItem> > GetCartItemsAsync( Customer customer = null, ShoppingCartType cartType = ShoppingCartType.ShoppingCart, int storeId = 0) { customer ??= _workContext.CurrentCustomer; var cacheKey = CartItemsKey.FormatInvariant(customer.Id, (int)cartType, storeId); var result = _requestCache.Get(cacheKey, async() => { var cartItems = new List <ShoppingCartItem>(); if (_db.IsCollectionLoaded(customer, x => x.ShoppingCartItems)) { var filteredCartItems = customer.ShoppingCartItems .Where(x => x.CustomerId == customer.Id && x.ShoppingCartTypeId == (int)cartType); if (storeId > 0) { filteredCartItems = filteredCartItems.Where(x => x.StoreId == storeId); } cartItems = filteredCartItems.ToList(); } else { cartItems = await _db.ShoppingCartItems .Include(x => x.Product) .ThenInclude(x => x.ProductVariantAttributes) .ApplyStandardFilter(cartType, storeId, customer) .ToListAsync(); customer.ShoppingCartItems = cartItems; } // Prefetch all product variant attributes var allAttributes = new ProductVariantAttributeSelection(string.Empty); var allAttributeMaps = cartItems.SelectMany(x => x.AttributeSelection.AttributesMap); foreach (var attribute in allAttributeMaps) { if (allAttributes.AttributesMap.Contains(attribute)) { continue; } allAttributes.AddAttribute(attribute.Key, attribute.Value); } await _productAttributeMaterializer.MaterializeProductVariantAttributesAsync(allAttributes); return(await OrganizeCartItemsAsync(cartItems)); }); return(result); }
public virtual Task <List <OrganizedShoppingCartItem> > GetCartItemsAsync( Customer customer = null, ShoppingCartType cartType = ShoppingCartType.ShoppingCart, int storeId = 0) { customer ??= _workContext.CurrentCustomer; var cacheKey = CartItemsKey.FormatInvariant(customer.Id, (int)cartType, storeId); var result = _requestCache.Get(cacheKey, async() => { await _db.LoadCollectionAsync(customer, x => x.ShoppingCartItems, false, x => { return(x .Include(x => x.Product) .ThenInclude(x => x.ProductVariantAttributes)); }); var cartItems = customer.ShoppingCartItems.FilterByCartType(cartType, storeId); // Prefetch all product variant attributes var allAttributes = new ProductVariantAttributeSelection(string.Empty); var allAttributeMaps = cartItems.SelectMany(x => x.AttributeSelection.AttributesMap); foreach (var attribute in allAttributeMaps) { if (allAttributes.AttributesMap.Contains(attribute)) { continue; } allAttributes.AddAttribute(attribute.Key, attribute.Value); } await _productAttributeMaterializer.MaterializeProductVariantAttributesAsync(allAttributes); return(await OrganizeCartItemsAsync(cartItems)); }); return(result); }
// TODO: (ms) (core) TESTING! Make sure it works in any case - Works for ReOrder(). public virtual async Task <bool> AddToCartAsync(AddToCartContext ctx) { Guard.NotNull(ctx, nameof(ctx)); // This is called when customer adds a product to cart ctx.Customer ??= _workContext.CurrentCustomer; ctx.StoreId ??= _storeContext.CurrentStore.Id; ctx.Customer.ResetCheckoutData(ctx.StoreId.Value); // Checks whether attributes have been selected if (ctx.VariantQuery != null) { // Create attribute selection from product attributes var attributes = await _productAttributeMaterializer.MaterializeProductVariantAttributesAsync(ctx.Item.AttributeSelection); ctx.RawAttributes = ctx.Item.RawAttributes; // Check context for bundle item errors if (ctx.Product.ProductType == ProductType.BundledProduct && ctx.RawAttributes.HasValue()) { ctx.Warnings.Add(T("ShoppingCart.Bundle.NoAttributes")); if (ctx.BundleItem != null) { return(false); } } } if (!await _cartValidator.ValidateAccessPermissionsAsync(ctx.Customer, ctx.CartType, ctx.Warnings)) { return(false); } var cartItems = await GetCartItemsAsync(ctx.Customer, ctx.CartType, ctx.StoreId.Value); // Adds required products automatically if it is enabled if (ctx.AutomaticallyAddRequiredProductsIfEnabled) { var requiredProductIds = ctx.Product.ParseRequiredProductIds(); if (requiredProductIds.Any()) { var cartProductIds = cartItems.Select(x => x.Item.ProductId); var missingRequiredProductIds = requiredProductIds.Except(cartProductIds); var missingRequiredProducts = await _db.Products.GetManyAsync(missingRequiredProductIds); foreach (var product in missingRequiredProducts) { var item = new ShoppingCartItem { CustomerEnteredPrice = ctx.CustomerEnteredPrice.Amount, RawAttributes = ctx.AttributeSelection.AsJson(), ShoppingCartType = ctx.CartType, StoreId = ctx.StoreId.Value, Quantity = ctx.Quantity, Customer = ctx.Customer, Product = product, ParentItemId = product.ParentGroupedProductId, BundleItemId = ctx.BundleItem?.Id }; await AddItemToCartAsync(new AddToCartContext { Item = item, ChildItems = ctx.ChildItems, Customer = ctx.Customer }); } } } // Checks whether required products are still missing await _cartValidator.ValidateRequiredProductsAsync(ctx.Product, cartItems, ctx.Warnings); ShoppingCartItem existingCartItem = null; if (ctx.BundleItem == null) { existingCartItem = cartItems.FindItemInCart(ctx.CartType, ctx.Product, ctx.AttributeSelection, ctx.CustomerEnteredPrice)?.Item; } // Add item to cart (if no warnings accured) if (existingCartItem != null) { // Product is already in cart, find existing item var newQuantity = ctx.Quantity + existingCartItem.Quantity; if (!await _cartValidator.ValidateAddToCartItemAsync(ctx, existingCartItem, cartItems)) { return(false); } // Update cart item existingCartItem.Quantity = newQuantity; existingCartItem.UpdatedOnUtc = DateTime.UtcNow; existingCartItem.RawAttributes = ctx.AttributeSelection.AsJson(); _db.TryUpdate(ctx.Customer); await _db.SaveChangesAsync(); } else { if (!_cartValidator.ValidateItemsMaximumCartQuantity(ctx.CartType, cartItems.Count, ctx.Warnings)) { return(false); } // Product is not in cart yet, create new item var cartItem = new ShoppingCartItem { CustomerEnteredPrice = ctx.CustomerEnteredPrice.Amount, RawAttributes = ctx.RawAttributes, ShoppingCartType = ctx.CartType, StoreId = ctx.StoreId.Value, Quantity = ctx.Quantity, Customer = ctx.Customer, Product = ctx.Product, ProductId = ctx.Product.Id, ParentItemId = null, BundleItemId = ctx.BundleItem?.Id }; if (!await _cartValidator.ValidateAddToCartItemAsync(ctx, cartItem, cartItems)) { return(false); } // Check whether the product is part of a bundle, the bundle item or just any item. // If product is no child of bundle or no bundle at all if (ctx.BundleItem == null) { // Set cart item as item for simple & bundle products, only if its not set by the caller ctx.Item ??= cartItem; } else { ctx.ChildItems.Add(cartItem); } } _requestCache.RemoveByPattern(CartItemsPatternKey); // If ctx.Product is a bundle product and the setting to automatically add bundle products is true, try to add all corresponding BundleItems. if (ctx.AutomaticallyAddBundleProductsIfEnabled && ctx.Product.ProductType == ProductType.BundledProduct && ctx.BundleItem == null && ctx.Warnings.Count == 0) { var bundleItems = await _db.ProductBundleItem .Include(x => x.Product) .Include(x => x.BundleProduct) .ApplyBundledProductsFilter(new[] { ctx.Product.Id }, true) .ToListAsync(); foreach (var bundleItem in bundleItems) { var bundleItemContext = new AddToCartContext { Warnings = new(), Item = ctx.Item, StoreId = ctx.StoreId, Customer = ctx.Customer, CartType = ctx.CartType, BundleItem = bundleItem, ChildItems = ctx.ChildItems, Product = bundleItem.Product, Quantity = bundleItem.Quantity, VariantQuery = ctx.VariantQuery, RawAttributes = ctx.RawAttributes, CustomerEnteredPrice = ctx.CustomerEnteredPrice, AutomaticallyAddRequiredProductsIfEnabled = ctx.AutomaticallyAddRequiredProductsIfEnabled, }; // If bundleItem could not be added to the shopping cart, remove child items if (!await AddToCartAsync(bundleItemContext)) { ctx.ChildItems.Clear(); break; } } } // If context is no bundleItem, add item (parent) and its children (grouped product) if ((ctx.Product.ProductType == ProductType.SimpleProduct || ctx.AutomaticallyAddBundleProductsIfEnabled) && ctx.BundleItem == null && ctx.Warnings.Count == 0) { await AddItemToCartAsync(ctx); } return(true); }
public virtual async Task <string> FormatAttributesAsync( ProductVariantAttributeSelection selection, Product product, Customer customer = null, string separator = "<br />", bool htmlEncode = true, bool includePrices = true, bool includeProductAttributes = true, bool includeGiftCardAttributes = true, bool includeHyperlinks = true, ProductBatchContext batchContext = null) { Guard.NotNull(selection, nameof(selection)); Guard.NotNull(product, nameof(product)); customer ??= _workContext.CurrentCustomer; using var pool = StringBuilderPool.Instance.Get(out var result); if (includeProductAttributes) { var languageId = _workContext.WorkingLanguage.Id; var attributes = await _productAttributeMaterializer.MaterializeProductVariantAttributesAsync(selection); var attributesDic = attributes.ToDictionary(x => x.Id); // Key: ProductVariantAttributeValue.Id, value: calculated attribute price adjustment. var priceAdjustments = includePrices && _catalogSettings.ShowVariantCombinationPriceAdjustment ? await _priceCalculationService.CalculateAttributePriceAdjustmentsAsync(product, selection, 1, _priceCalculationService.CreateDefaultOptions(false, customer, null, batchContext)) : new Dictionary <int, CalculatedPriceAdjustment>(); foreach (var kvp in selection.AttributesMap) { if (!attributesDic.TryGetValue(kvp.Key, out var pva)) { continue; } foreach (var value in kvp.Value) { var valueStr = value.ToString().EmptyNull(); var pvaAttribute = string.Empty; if (pva.IsListTypeAttribute()) { var pvaValue = pva.ProductVariantAttributeValues.FirstOrDefault(x => x.Id == valueStr.ToInt()); if (pvaValue != null) { pvaAttribute = "{0}: {1}".FormatInvariant( pva.ProductAttribute.GetLocalized(x => x.Name, languageId), pvaValue.GetLocalized(x => x.Name, languageId)); if (includePrices) { if (_shoppingCartSettings.ShowLinkedAttributeValueQuantity && pvaValue.ValueType == ProductVariantAttributeValueType.ProductLinkage && pvaValue.Quantity > 1) { pvaAttribute = pvaAttribute + " × " + pvaValue.Quantity; } if (priceAdjustments.TryGetValue(pvaValue.Id, out var adjustment)) { if (adjustment.Price > 0) { pvaAttribute += $" (+{adjustment.Price})"; } else if (adjustment.Price < 0) { pvaAttribute += $" (-{adjustment.Price * -1})"; } } } if (htmlEncode) { pvaAttribute = pvaAttribute.HtmlEncode(); } } } else if (pva.AttributeControlType == AttributeControlType.MultilineTextbox) { string attributeName = pva.ProductAttribute.GetLocalized(x => x.Name, languageId); pvaAttribute = "{0}: {1}".FormatInvariant( htmlEncode ? attributeName.HtmlEncode() : attributeName, HtmlUtils.ConvertPlainTextToHtml(valueStr.HtmlEncode())); } else if (pva.AttributeControlType == AttributeControlType.FileUpload) { if (Guid.TryParse(valueStr, out var downloadGuid) && downloadGuid != Guid.Empty) { var download = await _db.Downloads .AsNoTracking() .Include(x => x.MediaFile) .Where(x => x.DownloadGuid == downloadGuid) .FirstOrDefaultAsync(); if (download?.MediaFile != null) { var attributeText = string.Empty; var fileName = htmlEncode ? download.MediaFile.Name.HtmlEncode() : download.MediaFile.Name; if (includeHyperlinks) { // TODO: (core) add a method for getting URL (use routing because it handles all SEO friendly URLs). var downloadLink = _webHelper.GetStoreLocation(false) + "download/getfileupload/?downloadId=" + download.DownloadGuid; attributeText = $"<a href=\"{downloadLink}\" class=\"fileuploadattribute\">{fileName}</a>"; } else { attributeText = fileName; } string attributeName = pva.ProductAttribute.GetLocalized(a => a.Name, languageId); pvaAttribute = "{0}: {1}".FormatInvariant( htmlEncode ? attributeName.HtmlEncode() : attributeName, attributeText); } } } else { // TextBox, Datepicker pvaAttribute = "{0}: {1}".FormatInvariant(pva.ProductAttribute.GetLocalized(x => x.Name, languageId), valueStr); if (htmlEncode) { pvaAttribute = pvaAttribute.HtmlEncode(); } } result.Grow(pvaAttribute, separator); } } } if (includeGiftCardAttributes && product.IsGiftCard) { var gci = selection.GiftCardInfo; if (gci != null) { // Sender. var giftCardFrom = product.GiftCardType == GiftCardType.Virtual ? (await _localizationService.GetResourceAsync("GiftCardAttribute.From.Virtual")).FormatInvariant(gci.SenderName, gci.SenderEmail) : (await _localizationService.GetResourceAsync("GiftCardAttribute.From.Physical")).FormatInvariant(gci.SenderName); // Recipient. var giftCardFor = product.GiftCardType == GiftCardType.Virtual ? (await _localizationService.GetResourceAsync("GiftCardAttribute.For.Virtual")).FormatInvariant(gci.RecipientName, gci.RecipientEmail) : (await _localizationService.GetResourceAsync("GiftCardAttribute.For.Physical")).FormatInvariant(gci.RecipientName); if (htmlEncode) { giftCardFrom = giftCardFrom.HtmlEncode(); giftCardFor = giftCardFor.HtmlEncode(); } result.Grow(giftCardFrom, separator); result.Grow(giftCardFor, separator); } } return(result.ToString()); }
// was GetShoppingCartItemAttributeWarnings public virtual async Task <IList <string> > ValidateProductAttributesAsync(AddToCartContext ctx, IEnumerable <OrganizedShoppingCartItem> shoppingCart) { Guard.NotNull(ctx, nameof(ctx)); var warnings = new List <string>(); // Customer cannot select anything cause bundles have no attributes if (ctx.Product.ProductType == ProductType.BundledProduct || ctx.BundleItem != null && !ctx.BundleItem.BundleProduct.BundlePerItemPricing) { return(warnings); } // Get selected product variant attributes var selectedAttributes = await _productAttributeMaterializer.MaterializeProductVariantAttributesAsync(ctx.AttributeSelection); foreach (var attribute in selectedAttributes) { if (attribute.Product == null || attribute.Product.Id != ctx.Product.Id) { warnings.Add(T("ShoppingCart.AttributeError")); ctx.Warnings.AddRange(warnings); return(warnings); } } // Get existing product variant attributes foreach (var existingAttribute in ctx.Product.ProductVariantAttributes) { if (!existingAttribute.IsRequired) { continue; } var found = false; // Selected product attributes foreach (var selectedAttribute in selectedAttributes) { if (selectedAttribute.Id == existingAttribute.Id) { var values = ctx.AttributeSelection.GetAttributeValues(selectedAttribute.Id).Select(x => x.ToString()).ToList(); found = values.Find(x => x.HasValue()).HasValue(); if (found) { break; } } } // If attribute is filtered out by bundle item, it cannot be selected by the customer found = !found && (ctx.BundleItem?.FilterAttributes ?? false) ? !ctx.BundleItem.AttributeFilters.Any(x => x.AttributeId == existingAttribute.ProductAttributeId) : true; if (!found) { warnings.Add(T( "ShoppingCart.SelectAttribute", existingAttribute.TextPrompt.IsEmpty() ? existingAttribute.ProductAttribute.GetLocalized(x => x.Name) : existingAttribute.GetLocalized(x => x.TextPrompt) )); } } if (warnings.Count > 0) { ctx.Warnings.AddRange(warnings); return(warnings); } // Checks whether there is an active selected attribute combination if (ctx.AttributeSelection.AttributesMap.Any()) { var combination = await _productAttributeMaterializer.FindAttributeCombinationAsync(ctx.Product.Id, ctx.AttributeSelection); if (combination != null && !combination.IsActive) { warnings.Add(T("ShoppingCart.NotAvailable")); } } var attributeValues = await _productAttributeMaterializer.MaterializeProductVariantAttributeValuesAsync(ctx.AttributeSelection); var linkedProductIds = attributeValues .Where(x => x.ValueType == ProductVariantAttributeValueType.ProductLinkage) .Select(x => x.LinkedProductId) .Distinct(); // Get products linked to attributes var linkedProducts = await _db.Products.GetManyAsync(linkedProductIds); // Filter products which could not be loaded var notFoundProductIds = linkedProductIds.Except(linkedProducts.Select(x => x.Id)); foreach (var productId in notFoundProductIds) { warnings.Add(T("ShoppingCart.ProductLinkageProductNotLoading", productId)); } // Validate each linkedProduct, create shopping cart item from linkedProduct and run validation foreach (var attributeValue in attributeValues) { var linkedProduct = linkedProducts.FirstOrDefault(x => x.Id == attributeValue.LinkedProductId); if (linkedProduct == null) { warnings.Add(T("ShoppingCart.ProductLinkageProductNotLoading", attributeValue.LinkedProductId)); continue; } var newCtx = new AddToCartContext { Product = linkedProduct, Customer = ctx.Customer, CartType = ctx.CartType, StoreId = ctx.StoreId, Quantity = ctx.Quantity * attributeValue.Quantity }; var linkageWarnings = await ValidateCartItemAsync(newCtx, shoppingCart); foreach (var linkageWarning in linkageWarnings) { warnings.Add( T("ShoppingCart.ProductLinkageAttributeWarning", attributeValue.ProductVariantAttribute.ProductAttribute.GetLocalized(x => x.Name), attributeValue.GetLocalized(x => x.Name), linkageWarning) ); } } ctx.Warnings.AddRange(warnings); return(warnings); }
public virtual async Task <bool> ValidateProductAttributesAsync(ShoppingCartItem cartItem, IEnumerable <OrganizedShoppingCartItem> cartItems, IList <string> warnings) { Guard.NotNull(cartItem, nameof(cartItem)); // Check if the product is a bundle. Since bundles have no attributes, the customer has nothing to select if (cartItem.Product.ProductType == ProductType.BundledProduct || cartItem.BundleItem?.BundleProduct != null && !cartItem.BundleItem.BundleProduct.BundlePerItemPricing) { if (cartItem.RawAttributes.HasValue()) { warnings.Add(T("ShoppingCart.Bundle.NoAttributes")); } return(true); } // Get selected product variant attributes and check for product errors var selectedAttributes = await _productAttributeMaterializer.MaterializeProductVariantAttributesAsync(cartItem.AttributeSelection); foreach (var attribute in selectedAttributes) { if (attribute.Product == null || attribute.Product.Id != cartItem.Product.Id) { warnings.Add(T("ShoppingCart.AttributeError")); return(false); } } await _db.LoadCollectionAsync(cartItem.Product, x => x.ProductVariantAttributes, false, q => q.Include(x => x.ProductAttribute)); var currentWarnings = new List <string>(); // Get existing product variant attributes foreach (var existingAttribute in cartItem.Product.ProductVariantAttributes) { if (!existingAttribute.IsRequired) { continue; } var found = false; // Selected product attributes foreach (var selectedAttribute in selectedAttributes) { if (selectedAttribute.Id == existingAttribute.Id) { var values = cartItem.AttributeSelection.GetAttributeValues(selectedAttribute.Id) .Select(x => x.ToString()) .ToList(); found = values.Find(x => x.HasValue()).HasValue(); if (found) { break; } } } // If attribute is filtered out by bundle item, it cannot be selected by the customer if (!found && (cartItem.BundleItem?.FilterAttributes ?? false) && !cartItem.BundleItem.AttributeFilters.Any(x => x.AttributeId == existingAttribute.ProductAttributeId)) { found = true; } if (!found) { currentWarnings.Add(T( "ShoppingCart.SelectAttribute", existingAttribute.TextPrompt.IsEmpty() ? existingAttribute.ProductAttribute.GetLocalized(x => x.Name) : existingAttribute.GetLocalized(x => x.TextPrompt) )); } } if (currentWarnings.Any()) { warnings.AddRange(currentWarnings); return(false); } // Checks whether there is an active selected attribute combination if (cartItem.AttributeSelection.AttributesMap.Any()) { var combination = await _productAttributeMaterializer.FindAttributeCombinationAsync(cartItem.Product.Id, cartItem.AttributeSelection); if (combination != null && !combination.IsActive) { currentWarnings.Add(T("ShoppingCart.NotAvailable")); } } var attributeValues = await _productAttributeMaterializer.MaterializeProductVariantAttributeValuesAsync(cartItem.AttributeSelection); var linkedProductIds = attributeValues .Where(x => x.ValueType == ProductVariantAttributeValueType.ProductLinkage) .Select(x => x.LinkedProductId) .Distinct(); // Get products linked to attributes var linkedProducts = await _db.Products.GetManyAsync(linkedProductIds); // Filter products which could not be loaded var notFoundProductIds = linkedProductIds.Except(linkedProducts.Select(x => x.Id)); foreach (var productId in notFoundProductIds) { currentWarnings.Add(T("ShoppingCart.ProductLinkageProductNotLoading", productId)); } // Validate each linkedProduct, create shopping cart item from linkedProduct and run validation foreach (var linkedProductId in linkedProductIds) { var linkedProduct = linkedProducts.FirstOrDefault(x => x.Id == linkedProductId); var linkedAttributeValue = attributeValues.FirstOrDefault(x => x.LinkedProductId == linkedProductId); if (linkedProduct == null || linkedAttributeValue == null) { currentWarnings.Add(T("ShoppingCart.ProductLinkageProductNotLoading", linkedProductId)); continue; } var item = new ShoppingCartItem { ProductId = linkedProduct.Id, Product = linkedProduct, ShoppingCartType = cartItem.ShoppingCartType, Customer = cartItem.Customer, StoreId = cartItem.StoreId, Quantity = cartItem.Quantity * linkedAttributeValue.Quantity }; var ctx = new AddToCartContext { Product = linkedProduct, Customer = cartItem.Customer, CartType = cartItem.ShoppingCartType, StoreId = cartItem.StoreId, Quantity = cartItem.Quantity * linkedAttributeValue.Quantity }; // Get product linkage warnings await ValidateAddToCartItemAsync(ctx, item, cartItems); foreach (var linkageWarning in ctx.Warnings) { currentWarnings.Add( T("ShoppingCart.ProductLinkageAttributeWarning", linkedAttributeValue.ProductVariantAttribute.ProductAttribute.GetLocalized(x => x.Name), linkedAttributeValue.GetLocalized(x => x.Name), linkageWarning) ); } } warnings.AddRange(currentWarnings); return(!currentWarnings.Any()); }
// TODO: (ms) (core) AddToCartContext needs to have bundleItem and childItems already included correctly, they get just added... public virtual async Task <IList <string> > AddToCartAsync(AddToCartContext ctx) { Guard.NotNull(ctx, nameof(ctx)); // This is called when customer adds a product to cart var warnings = new List <string>(); ctx.Customer ??= _workContext.CurrentCustomer; ctx.StoreId ??= _storeContext.CurrentStore.Id; ctx.Customer.ResetCheckoutData(ctx.StoreId.Value); // Checks whether attributes have been selected if (ctx.VariantQuery != null) { // Create attribute selection from product attributes var attributes = await _productAttributeMaterializer.MaterializeProductVariantAttributesAsync(ctx.Item.AttributeSelection); ctx.RawAttributes = ctx.Item.AttributeSelection.AsJson(); // Check context for bundle item errors if (ctx.Product.ProductType == ProductType.BundledProduct && ctx.RawAttributes.HasValue()) { ctx.Warnings.Add(T("ShoppingCart.Bundle.NoAttributes")); if (ctx.BundleItem != null) { return(ctx.Warnings); } } } warnings.AddRange(await _cartValidator.ValidateAccessPermissionsAsync(ctx)); if (warnings.Count > 0) { return(warnings); } var shoppingCart = await GetCartItemsAsync(ctx.Customer, ctx.CartType, ctx.StoreId.Value); // Adds required products automatically if it is enabled if (ctx.AutomaticallyAddRequiredProductsIfEnabled) { var requiredProductIds = ctx.Product.ParseRequiredProductIds(); if (requiredProductIds.Any()) { var cartProductIds = shoppingCart.Select(x => x.Item.ProductId); var missingRequiredProductIds = requiredProductIds.Except(cartProductIds); var missingRequiredProducts = await _db.Products.GetManyAsync(missingRequiredProductIds); foreach (var product in missingRequiredProducts) { var item = new ShoppingCartItem { CustomerEnteredPrice = ctx.CustomerEnteredPrice, RawAttributes = ctx.AttributeSelection.AsJson(), ShoppingCartType = ctx.CartType, StoreId = ctx.StoreId.Value, Quantity = ctx.Quantity, Customer = ctx.Customer, Product = product, ParentItemId = product.ParentGroupedProductId, BundleItemId = ctx.BundleItem?.Id }; await AddItemToCartAsync(new AddToCartContext { Item = item, ChildItems = ctx.ChildItems, Customer = ctx.Customer }); } } } // Checks whether required products are still missing warnings.AddRange(await _cartValidator.ValidateRequiredProductsAsync(ctx, shoppingCart)); OrganizedShoppingCartItem existingCartItem = null; if (ctx.BundleItem == null) { existingCartItem = shoppingCart.FindItemInCart(ctx.CartType, ctx.Product, ctx.AttributeSelection, ctx.CustomerEnteredPrice); } // Add item to cart (if no warnings accured) if (existingCartItem != null) { // Product is already in cart, find existing item ctx.Quantity += existingCartItem.Item.Quantity; warnings.AddRange(await _cartValidator.ValidateCartItemAsync(ctx, shoppingCart)); if (warnings.Count > 0) { return(warnings); } // Update cart item existingCartItem.Item.Quantity = ctx.Quantity; existingCartItem.Item.UpdatedOnUtc = DateTime.UtcNow; existingCartItem.Item.RawAttributes = ctx.AttributeSelection.AsJson(); _db.TryUpdate(ctx.Customer); await _db.SaveChangesAsync(); } else { warnings.AddRange(await _cartValidator.ValidateCartItemAsync(ctx, shoppingCart)); if (warnings.Count > 0) { return(warnings); } var warning = _cartValidator.ValidateCartItemsMaximum(ctx.CartType, shoppingCart.Count); if (warning.Count > 0) { ctx.Warnings.AddRange(warning); warnings.AddRange(warning); return(warnings); } // Product is not in cart yet, create new item var cartItem = new ShoppingCartItem { CustomerEnteredPrice = ctx.CustomerEnteredPrice, RawAttributes = ctx.AttributeSelection.AsJson(), ShoppingCartType = ctx.CartType, StoreId = ctx.StoreId.Value, Quantity = ctx.Quantity, Customer = ctx.Customer, Product = ctx.Product, ParentItemId = null, BundleItemId = ctx.BundleItem?.Id }; // If product is no bundle, add it as cartItem if (ctx.BundleItem == null) { Debug.Assert(ctx.Item == null, "Add to cart item already specified"); ctx.Item = cartItem; } else { ctx.ChildItems.Add(cartItem); } } _requestCache.RemoveByPattern(CartItemsPatternKey); // If ctx.Product is a bundle product, try adding all corresponding bundleItems if (ctx.Product.ProductType == ProductType.BundledProduct && ctx.BundleItem == null && warnings.Count == 0) { // Get all bundle items and add each to the cart var bundleItems = _db.IsCollectionLoaded(ctx.Product, x => x.ProductBundleItems) ? ctx.Product.ProductBundleItems : await _db.ProductBundleItem .ApplyBundledProductsFilter(new[] { ctx.Product.Id }) .ToListAsync(); foreach (var bundleItem in bundleItems) { // Try add each bundleItem to the cart warnings.AddRange( await AddToCartAsync( new AddToCartContext { Item = ctx.Item, Customer = ctx.Customer, BundleItem = bundleItem, Warnings = ctx.Warnings, CartType = ctx.CartType, StoreId = ctx.StoreId.Value, ChildItems = ctx.ChildItems, Product = bundleItem.Product, Quantity = bundleItem.Quantity, VariantQuery = ctx.VariantQuery, AutomaticallyAddRequiredProductsIfEnabled = ctx.AutomaticallyAddRequiredProductsIfEnabled }) ); // If bundleItem could not be added to the shopping cart, remove child items if (warnings.Count > 0) { ctx.ChildItems.Clear(); break; } } } // If context is no bundleItem, add item (parent) and its children (grouped product) if (ctx.BundleItem == null && warnings.Count == 0) { await AddItemToCartAsync(ctx); } return(warnings); }
private async Task ProcessAttributes(DbContextScope scope, Product product, Product clone, IEnumerable <Language> languages) { var localizedKeySelectors = new List <Expression <Func <ProductVariantAttributeValue, string> > > { x => x.Name, x => x.Alias }; await _db.LoadCollectionAsync(product, x => x.ProductVariantAttributes); await _db.LoadCollectionAsync(product, x => x.ProductVariantAttributeCombinations); // Former attribute id > clone. var attributeMap = new Dictionary <int, ProductVariantAttribute>(); // Former attribute value id > clone. var valueMap = new Dictionary <int, ProductVariantAttributeValue>(); var newCombinations = new List <ProductVariantAttributeCombination>(); // Product attributes. foreach (var attribute in product.ProductVariantAttributes) { // Save associated value (used for combinations copying). attributeMap[attribute.Id] = new ProductVariantAttribute { ProductId = clone.Id, ProductAttributeId = attribute.ProductAttributeId, TextPrompt = attribute.TextPrompt, IsRequired = attribute.IsRequired, AttributeControlTypeId = attribute.AttributeControlTypeId, DisplayOrder = attribute.DisplayOrder }; } // Reverse tracking order to have the clones in the same order in the database as the originals. _db.ProductVariantAttributes.AddRange(attributeMap.Select(x => x.Value).Reverse()); // >>>>>> Commit attributes. await scope.CommitAsync(); // Product variant attribute values. foreach (var attribute in product.ProductVariantAttributes) { var attributeClone = attributeMap[attribute.Id]; foreach (var value in attribute.ProductVariantAttributeValues) { // Save associated value (used for combinations copying). valueMap.Add(value.Id, new ProductVariantAttributeValue { ProductVariantAttributeId = attributeClone.Id, Name = value.Name, Color = value.Color, PriceAdjustment = value.PriceAdjustment, WeightAdjustment = value.WeightAdjustment, IsPreSelected = value.IsPreSelected, DisplayOrder = value.DisplayOrder, ValueTypeId = value.ValueTypeId, LinkedProductId = value.LinkedProductId, Quantity = value.Quantity, MediaFileId = value.MediaFileId }); } } // Reverse tracking order to have the clones in the same order in the database as the originals. _db.ProductVariantAttributeValues.AddRange(valueMap.Select(x => x.Value).Reverse()); // >>>>>> Commit attribute values. await scope.CommitAsync(); // Attribute value localization. var allValues = product.ProductVariantAttributes .Reverse() .SelectMany(x => x.ProductVariantAttributeValues.Reverse()) .ToArray(); foreach (var value in allValues) { if (valueMap.TryGetValue(value.Id, out var newValue)) { await ProcessLocalizations(value, newValue, localizedKeySelectors, languages); } } // >>>>>> Commit localized values. await scope.CommitAsync(); // Attribute combinations. foreach (var combination in product.ProductVariantAttributeCombinations) { var oldAttributesMap = combination.AttributeSelection.AttributesMap; var oldAttributes = await _productAttributeMaterializer.MaterializeProductVariantAttributesAsync(combination.AttributeSelection); var newSelection = new ProductVariantAttributeSelection(null); foreach (var oldAttribute in oldAttributes) { if (attributeMap.TryGetValue(oldAttribute.Id, out var newAttribute)) { var item = oldAttributesMap.FirstOrDefault(x => x.Key == oldAttribute.Id); if (item.Key != 0) { foreach (var value in item.Value) { if (newAttribute.IsListTypeAttribute()) { var oldValueId = value.ToString().EmptyNull().ToInt(); if (valueMap.TryGetValue(oldValueId, out var newValue)) { newSelection.AddAttributeValue(newAttribute.Id, newValue.Id); } } else { newSelection.AddAttributeValue(newAttribute.Id, value); } } } } } newCombinations.Add(new ProductVariantAttributeCombination { ProductId = clone.Id, RawAttributes = newSelection.AsJson(), StockQuantity = combination.StockQuantity, AllowOutOfStockOrders = combination.AllowOutOfStockOrders, Sku = combination.Sku, Gtin = combination.Gtin, ManufacturerPartNumber = combination.ManufacturerPartNumber, Price = combination.Price, AssignedMediaFileIds = combination.AssignedMediaFileIds, Length = combination.Length, Width = combination.Width, Height = combination.Height, BasePriceAmount = combination.BasePriceAmount, BasePriceBaseAmount = combination.BasePriceBaseAmount, DeliveryTimeId = combination.DeliveryTimeId, QuantityUnitId = combination.QuantityUnitId, IsActive = combination.IsActive //IsDefaultCombination = combination.IsDefaultCombination }); } // Reverse tracking order to have the clones in the same order in the database as the originals. _db.ProductVariantAttributeCombinations.AddRange(newCombinations.AsEnumerable().Reverse()); // >>>>>> Commit combinations. await scope.CommitAsync(); }