public ProductBundleItemData(ProductBundleItem item)
		{
			Item = item;	// can be null... test with IsValid
		}
		public IList<ProductBundleItem> ProductBundleItems()
		{
			#region gaming

			var utcNow = DateTime.UtcNow;
			var bundlePs3AssassinCreed = _ctx.Set<Product>().First(x => x.Sku == "Sony-PS399105");

			var bundleItemPs3AssassinCreed1 = new ProductBundleItem()
			{
				BundleProduct = bundlePs3AssassinCreed,
				Product = _ctx.Set<Product>().First(x => x.Sku == "Sony-PS399000"),
				Quantity = 1,
				Discount = 20.0M,
				Visible = true,
				Published = true,
				DisplayOrder = 1,
				CreatedOnUtc = utcNow,
				UpdatedOnUtc = utcNow
			};

			var bundleItemPs3AssassinCreed2 = new ProductBundleItem()
			{
				BundleProduct = bundlePs3AssassinCreed,
				Product = _ctx.Set<Product>().First(x => x.Sku == "Sony-PS399004"),
				Quantity = 2,
				Discount = 30.0M,
				Visible = true,
				Published = true,
				DisplayOrder = 2,
				CreatedOnUtc = utcNow,
				UpdatedOnUtc = utcNow
			};

			var bundleItemPs3AssassinCreed3 = new ProductBundleItem()
			{
				BundleProduct = bundlePs3AssassinCreed,
				Product = _ctx.Set<Product>().First(x => x.Sku == "Ubi-acreed3"),
				Quantity = 1,
				Discount = 20.0M,
				Visible = true,
				Published = true,
				DisplayOrder = 3,
				CreatedOnUtc = utcNow,
				UpdatedOnUtc = utcNow
			};


			var bundlePs4 = _ctx.Set<Product>().First(x => x.Sku == "Sony-PS410099");

			var bundleItemPs41 = new ProductBundleItem()
			{
				BundleProduct = bundlePs4,
				Product = _ctx.Set<Product>().First(x => x.Sku == "Sony-PS410034"),
				Quantity = 1,
				Visible = true,
				Published = true,
				DisplayOrder = 1,
				CreatedOnUtc = utcNow,
				UpdatedOnUtc = utcNow
			};

			var bundleItemPs42 = new ProductBundleItem()
			{
				BundleProduct = bundlePs4,
				Product = _ctx.Set<Product>().First(x => x.Sku == "Sony-PS410037"),
				Quantity = 1,
				Visible = true,
				Published = true,
				DisplayOrder = 2,
				CreatedOnUtc = utcNow,
				UpdatedOnUtc = utcNow
			};

			var bundleItemPs43 = new ProductBundleItem()
			{
				BundleProduct = bundlePs4,
				Product = _ctx.Set<Product>().First(x => x.Sku == "Sony-PS410040"),
				Quantity = 1,
				Visible = true,
				Published = true,
				DisplayOrder = 3,
				CreatedOnUtc = utcNow,
				UpdatedOnUtc = utcNow
			};

			#endregion gaming

			var entities = new List<ProductBundleItem>
			{
				bundleItemPs3AssassinCreed1, bundleItemPs3AssassinCreed2, bundleItemPs3AssassinCreed3,
				bundleItemPs41, bundleItemPs42, bundleItemPs43
			};

			this.Alter(entities);
			return entities;
		}
        /// <summary>
        /// Validates shopping cart item
        /// </summary>
        /// <param name="customer">Customer</param>
        /// <param name="shoppingCartType">Shopping cart type</param>
		/// <param name="product">Product</param>
		/// <param name="storeId">Store identifier</param>
        /// <param name="selectedAttributes">Selected attributes</param>
        /// <param name="customerEnteredPrice">Customer entered price</param>
        /// <param name="quantity">Quantity</param>
		/// <param name="automaticallyAddRequiredProductsIfEnabled">Automatically add required products if enabled</param>
        /// <param name="getStandardWarnings">A value indicating whether we should validate a product for standard properties</param>
        /// <param name="getAttributesWarnings">A value indicating whether we should validate product attributes</param>
        /// <param name="getGiftCardWarnings">A value indicating whether we should validate gift card properties</param>
        /// <param name="getRequiredProductWarnings">A value indicating whether we should validate required products (products which require other products to be added to the cart)</param>
		/// <param name="getBundleWarnings">A value indicating whether we should validate bundle and bundle items</param>
		/// <param name="bundleItem">Product bundle item if bundles should be validated</param>
		/// <param name="childItems">Child cart items to validate bundle items</param>
        /// <returns>Warnings</returns>
        public virtual IList<string> GetShoppingCartItemWarnings(Customer customer, ShoppingCartType shoppingCartType,
			Product product, int storeId, 
			string selectedAttributes, decimal customerEnteredPrice,
			int quantity, bool automaticallyAddRequiredProductsIfEnabled,
            bool getStandardWarnings = true, bool getAttributesWarnings = true, 
            bool getGiftCardWarnings = true, bool getRequiredProductWarnings = true,
			bool getBundleWarnings = true, ProductBundleItem bundleItem = null, IList<OrganizedShoppingCartItem> childItems = null)
        {
            if (product == null)
                throw new ArgumentNullException("product");

            var warnings = new List<string>();
            
            //standard properties
            if (getStandardWarnings)
                warnings.AddRange(GetStandardWarnings(customer, shoppingCartType, product, selectedAttributes, customerEnteredPrice, quantity));

            //selected attributes
            if (getAttributesWarnings)
                warnings.AddRange(GetShoppingCartItemAttributeWarnings(customer, shoppingCartType, product, selectedAttributes, quantity, bundleItem));

            //gift cards
            if (getGiftCardWarnings)
                warnings.AddRange(GetShoppingCartItemGiftCardWarnings(shoppingCartType, product, selectedAttributes));

            //required products
            if (getRequiredProductWarnings)
				warnings.AddRange(GetRequiredProductWarnings(customer, shoppingCartType, product, storeId, automaticallyAddRequiredProductsIfEnabled));

			// bundle and bundle item warnings
			if (getBundleWarnings)
			{
				if (bundleItem != null)
					warnings.AddRange(GetBundleItemWarnings(bundleItem));

				if (childItems != null)
					warnings.AddRange(GetBundleItemWarnings(childItems));
			}
            
            return warnings;
        }
        /// <summary>
		/// Add a product to shopping cart
        /// </summary>
        /// <param name="customer">Customer</param>
		/// <param name="product">Product</param>
        /// <param name="shoppingCartType">Shopping cart type</param>
		/// <param name="storeId">Store identifier</param>
        /// <param name="selectedAttributes">Selected attributes</param>
        /// <param name="customerEnteredPrice">The price enter by a customer</param>
        /// <param name="quantity">Quantity</param>
		/// <param name="automaticallyAddRequiredProductsIfEnabled">Automatically add required products if enabled</param>
		/// <param name="shoppingCartItemId">Identifier fo the new shopping cart item</param>
		/// <param name="parentItemId">Identifier of the parent shopping cart item</param>
		/// <param name="bundleItem">Product bundle item</param>
        /// <returns>Warnings</returns>
        public virtual IList<string> AddToCart(Customer customer, Product product,
			ShoppingCartType shoppingCartType, int storeId, string selectedAttributes,
			decimal customerEnteredPrice, int quantity, bool automaticallyAddRequiredProductsIfEnabled,
			out int shoppingCartItemId, int? parentItemId = null, ProductBundleItem bundleItem = null)
        {
			shoppingCartItemId = 0;

            if (customer == null)
                throw new ArgumentNullException("customer");

            if (product == null)
                throw new ArgumentNullException("product");

            var warnings = new List<string>();
            if (shoppingCartType == ShoppingCartType.ShoppingCart && !_permissionService.Authorize(StandardPermissionProvider.EnableShoppingCart, customer))
            {
                warnings.Add("Shopping cart is disabled");
                return warnings;
            }
            if (shoppingCartType == ShoppingCartType.Wishlist && !_permissionService.Authorize(StandardPermissionProvider.EnableWishlist, customer))
            {
                warnings.Add("Wishlist is disabled");
                return warnings;
            }

            if (quantity <= 0)
            {
                warnings.Add(_localizationService.GetResource("ShoppingCart.QuantityShouldPositive"));
                return warnings;
            }

			if (parentItemId.HasValue && (parentItemId.Value == 0 || bundleItem == null || bundleItem.Id == 0))
			{
				warnings.Add(_localizationService.GetResource("ShoppingCart.Bundle.BundleItemNotFound").FormatWith(bundleItem.GetLocalizedName()));
				return warnings;
			}

            //reset checkout info
			_customerService.ResetCheckoutData(customer, storeId);

			var cart = customer.GetCartItems(shoppingCartType, storeId);
			OrganizedShoppingCartItem shoppingCartItem = null;

			if (bundleItem == null)
			{
				shoppingCartItem = FindShoppingCartItemInTheCart(cart, shoppingCartType, product, selectedAttributes, customerEnteredPrice);
			}

            if (shoppingCartItem != null)
            {
                //update existing shopping cart item
                int newQuantity = shoppingCartItem.Item.Quantity + quantity;

                warnings.AddRange(
					GetShoppingCartItemWarnings(customer, shoppingCartType, product, storeId, selectedAttributes, customerEnteredPrice, newQuantity, 
						automaticallyAddRequiredProductsIfEnabled, bundleItem: bundleItem)
				);

                if (warnings.Count == 0)
                {
                    shoppingCartItem.Item.AttributesXml = selectedAttributes;
                    shoppingCartItem.Item.Quantity = newQuantity;
                    shoppingCartItem.Item.UpdatedOnUtc = DateTime.UtcNow;
                    _customerService.UpdateCustomer(customer);

                    //event notification
                    _eventPublisher.EntityUpdated(shoppingCartItem.Item);
                }
            }
            else
            {
                //new shopping cart item
                warnings.AddRange(
					GetShoppingCartItemWarnings(customer, shoppingCartType, product, storeId, selectedAttributes, customerEnteredPrice, quantity,
						automaticallyAddRequiredProductsIfEnabled, bundleItem: bundleItem)
				);

                if (warnings.Count == 0)
                {
                    //maximum items validation
                    switch (shoppingCartType)
                    {
                        case ShoppingCartType.ShoppingCart:
                            if (cart.Count >= _shoppingCartSettings.MaximumShoppingCartItems)
                            {
                                warnings.Add(_localizationService.GetResource("ShoppingCart.MaximumShoppingCartItems"));
                                return warnings;
                            }
                            break;
                        case ShoppingCartType.Wishlist:
                            if (cart.Count >= _shoppingCartSettings.MaximumWishlistItems)
                            {
                                warnings.Add(_localizationService.GetResource("ShoppingCart.MaximumWishlistItems"));
                                return warnings;
                            }
                            break;
                        default:
                            break;
                    }

                    DateTime now = DateTime.UtcNow;
                    var cartItem = new ShoppingCartItem()
                    {
                        ShoppingCartType = shoppingCartType,
						StoreId = storeId,
                        Product = product,
                        AttributesXml = selectedAttributes,
                        CustomerEnteredPrice = customerEnteredPrice,
                        Quantity = quantity,
                        CreatedOnUtc = now,
                        UpdatedOnUtc = now,
						ParentItemId = parentItemId
                    };

					if (bundleItem != null)
						cartItem.BundleItemId = bundleItem.Id;

                    customer.ShoppingCartItems.Add(cartItem);
                    _customerService.UpdateCustomer(customer);

					shoppingCartItemId = cartItem.Id;

                    //event notification
                    _eventPublisher.EntityInserted(cartItem);
                }
            }

            return warnings;
        }
        /// <summary>
        /// Validates shopping cart item attributes
        /// </summary>
		/// <param name="customer">The customer</param>
        /// <param name="shoppingCartType">Shopping cart type</param>
		/// <param name="product">Product</param>
        /// <param name="selectedAttributes">Selected attributes</param>
		/// <param name="quantity">Quantity</param>
		/// <param name="bundleItem">Product bundle item</param>
        /// <returns>Warnings</returns>
		public virtual IList<string> GetShoppingCartItemAttributeWarnings(Customer customer, ShoppingCartType shoppingCartType,
			Product product, string selectedAttributes, int quantity = 1, ProductBundleItem bundleItem = null)
        {
            if (product == null)
                throw new ArgumentNullException("product");

            var warnings = new List<string>();

			if (bundleItem != null && !bundleItem.BundleProduct.BundlePerItemPricing)
				return warnings;	// customer cannot select anything... selectedAttribute is always empty

            //selected attributes
            var pva1Collection = _productAttributeParser.ParseProductVariantAttributes(selectedAttributes);
            foreach (var pva1 in pva1Collection)
            {
                var pv1 = pva1.Product;
                if (pv1 != null)
                {
                    if (pv1.Id != product.Id)
                    {
                        warnings.Add("Attribute error");
                    }
                }
                else
                {
                    warnings.Add("Attribute error");
                    return warnings;
                }
            }

            //existing product attributes
            var pva2Collection = product.ProductVariantAttributes;
            foreach (var pva2 in pva2Collection)
            {
                if (pva2.IsRequired)
                {
                    bool found = false;
                    //selected product attributes
                    foreach (var pva1 in pva1Collection)
                    {
                        if (pva1.Id == pva2.Id)
                        {
                            var pvaValuesStr = _productAttributeParser.ParseValues(selectedAttributes, pva1.Id);
                            foreach (string str1 in pvaValuesStr)
                            {
                                if (!String.IsNullOrEmpty(str1.Trim()))
                                {
                                    found = true;
                                    break;
                                }
                            }
                        }
                    }

					if (!found && bundleItem != null && bundleItem.FilterAttributes && !bundleItem.AttributeFilters.Exists(x => x.AttributeId == pva2.ProductAttributeId))
					{
						found = true;	// attribute is filtered out on bundle item level... it cannot be selected by customer
					}

                    if (!found)
                    {
                        if (pva2.TextPrompt.HasValue())
                            warnings.Add(pva2.TextPrompt);
                        else
                            warnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.SelectAttribute"), pva2.ProductAttribute.GetLocalized(a => a.Name)));
                    }
                }
            }

			if (warnings.Count == 0)
			{
				var pvaValues = _productAttributeParser.ParseProductVariantAttributeValues(selectedAttributes);
				foreach (var pvaValue in pvaValues)
				{
					if (pvaValue.ValueType ==  ProductVariantAttributeValueType.ProductLinkage)
					{
						var linkedProduct = _productService.GetProductById(pvaValue.LinkedProductId);
						if (linkedProduct != null)
						{
							var linkageWarnings = GetShoppingCartItemWarnings(customer, shoppingCartType, linkedProduct, _storeContext.CurrentStore.Id,
								"", decimal.Zero, quantity * pvaValue.Quantity, false, true, true, true, true);

							foreach (var linkageWarning in linkageWarnings)
							{
								string msg = _localizationService.GetResource("ShoppingCart.ProductLinkageAttributeWarning").FormatWith(
									pvaValue.ProductVariantAttribute.ProductAttribute.GetLocalized(a => a.Name),
									pvaValue.GetLocalized(a => a.Name),
									linkageWarning);

								warnings.Add(msg);
							}
						}
						else
						{
							string msg = _localizationService.GetResource("ShoppingCart.ProductLinkageProductNotLoading").FormatWith(pvaValue.LinkedProductId);
							warnings.Add(msg);
						}
					}
				}
			}

            return warnings;
        }
		/// <summary>
		/// Validates bundle items
		/// </summary>
		/// <param name="shoppingCartType">Shopping cart type</param>
		/// <param name="bundleItem">Product bundle item</param>
		/// <returns>Warnings</returns>
		public virtual IList<string> GetBundleItemWarnings(ProductBundleItem bundleItem)
		{
			var warnings = new List<string>();

			if (bundleItem != null)
			{
				string name = bundleItem.GetLocalizedName();

				if (!bundleItem.Published)
					warnings.Add(_localizationService.GetResource("ShoppingCart.Bundle.BundleItemUnpublished").FormatWith(name));

				if (bundleItem.ProductId == 0 || bundleItem.BundleProductId == 0 || bundleItem.Product == null || bundleItem.BundleProduct == null)
					warnings.Add(_localizationService.GetResource("ShoppingCart.Bundle.MissingProduct").FormatWith(name));

				if (bundleItem.Quantity <= 0)
					warnings.Add(_localizationService.GetResource("ShoppingCart.Bundle.Quantity").FormatWith(name));

				if (bundleItem.Product.IsDownload || bundleItem.Product.IsRecurring)
					warnings.Add(_localizationService.GetResource("ShoppingCart.Bundle.ProductResrictions").FormatWith(name));
			}

			return warnings;
		}
		public static ProductBundleItem ToEntity(this ProductBundleItemModel model, ProductBundleItem destination)
		{
			return Mapper.Map(model, destination);
		}
		public virtual void AddToCart(List<string> warnings, Product product, NameValueCollection form, ShoppingCartType cartType, decimal customerEnteredPrice,
			int quantity, bool addRequiredProducts, int? parentCartItemId = null, ProductBundleItem bundleItem = null)
		{
			int newCartItemId;
			string selectedAttributes = "";
			int bundleItemId = (bundleItem == null ? 0 : bundleItem.Id);

			var attributes = _productAttributeService.GetProductVariantAttributesByProductId(product.Id);

			selectedAttributes = form.CreateSelectedAttributesXml(product.Id, attributes, _productAttributeParser, _localizationService, _downloadService,
				_catalogSettings, null, warnings, true, bundleItemId);

			if (product.ProductType == ProductType.BundledProduct && selectedAttributes.HasValue())
			{
				warnings.Add(_localizationService.GetResource("ShoppingCart.Bundle.NoAttributes"));
				return;
			}

			if (product.IsGiftCard)
			{
				selectedAttributes = form.AddGiftCardAttribute(selectedAttributes, product.Id, _productAttributeParser, bundleItemId);
			}

			warnings.AddRange(
				AddToCart(_workContext.CurrentCustomer, product, cartType, _storeContext.CurrentStore.Id,
					selectedAttributes, customerEnteredPrice, quantity, addRequiredProducts, out newCartItemId, parentCartItemId, bundleItem)
			);

			if (product.ProductType == ProductType.BundledProduct && warnings.Count <= 0 && newCartItemId != 0 && bundleItem == null)
			{
				foreach (var item in _productService.GetBundleItems(product.Id).Select(x => x.Item))
				{
					AddToCart(warnings, item.Product, form, cartType, decimal.Zero, item.Quantity, false, newCartItemId, item);
				}

				if (warnings.Count > 0)
					DeleteShoppingCartItem(newCartItemId);
			}
		}
Exemplo n.º 9
0
        /// <summary>
        /// Inserts a product bundle item
        /// </summary>
        /// <param name="bundleItem">Product bundle item</param>
        public virtual void InsertBundleItem(ProductBundleItem bundleItem)
        {
            if (bundleItem == null)
                throw new ArgumentNullException("bundleItem");

            if (bundleItem.BundleProductId == 0)
                throw new SmartException("BundleProductId of a bundle item cannot be 0.");

            if (bundleItem.ProductId == 0)
                throw new SmartException("ProductId of a bundle item cannot be 0.");

            if (bundleItem.ProductId == bundleItem.BundleProductId)
                throw new SmartException("A bundle item cannot be an element of itself.");

            _productBundleItemRepository.Insert(bundleItem);

            //event notification
            _eventPublisher.EntityInserted(bundleItem);
        }
Exemplo n.º 10
0
        public virtual void DeleteProductBundleItemAttributeFilter(ProductBundleItem bundleItem)
        {
            if (bundleItem != null && bundleItem.Id != 0)
            {
                var attributeFilterQuery =
                    from x in _productBundleItemAttributeFilterRepository.Table
                    where x.BundleItemId == bundleItem.Id
                    select x;

                attributeFilterQuery.ToList().Each(x => DeleteProductBundleItemAttributeFilter(x));
            }
        }
Exemplo n.º 11
0
        /// <summary>
        /// Deletes a product bundle item
        /// </summary>
        /// <param name="bundleItem">Product bundle item</param>
        public virtual void DeleteBundleItem(ProductBundleItem bundleItem)
        {
            if (bundleItem == null)
                throw new ArgumentNullException("bundleItem");

            _productBundleItemRepository.Delete(bundleItem);

            //event notification
            _eventPublisher.EntityDeleted(bundleItem);
        }
Exemplo n.º 12
0
        public virtual void UpdateBundleItem(ProductBundleItem bundleItem)
        {
            Guard.NotNull(bundleItem, nameof(bundleItem));

            _productBundleItemRepository.Update(bundleItem);
        }
Exemplo n.º 13
0
        public void WriteProduct(dynamic product, string node)
        {
            if (product == null)
            {
                return;
            }

            Product entity = product.Entity;

            if (node.HasValue())
            {
                _writer.WriteStartElement(node);
            }

            decimal?basePriceAmount                 = product.BasePriceAmount;
            int?    basePriceBaseAmount             = product.BasePriceBaseAmount;
            decimal?lowestAttributeCombinationPrice = product.LowestAttributeCombinationPrice;

            _writer.Write("Id", entity.Id.ToString());
            _writer.Write("Name", (string)product.Name);
            _writer.Write("SeName", (string)product.SeName);
            _writer.Write("ShortDescription", (string)product.ShortDescription);
            _writer.Write("FullDescription", (string)product.FullDescription);
            _writer.Write("AdminComment", (string)product.AdminComment);
            _writer.Write("ProductTemplateId", entity.ProductTemplateId.ToString());
            _writer.Write("ProductTemplateViewPath", (string)product._ProductTemplateViewPath);
            _writer.Write("ShowOnHomePage", entity.ShowOnHomePage.ToString());
            _writer.Write("HomePageDisplayOrder", entity.HomePageDisplayOrder.ToString());
            _writer.Write("MetaKeywords", (string)product.MetaKeywords);
            _writer.Write("MetaDescription", (string)product.MetaDescription);
            _writer.Write("MetaTitle", (string)product.MetaTitle);
            _writer.Write("AllowCustomerReviews", entity.AllowCustomerReviews.ToString());
            _writer.Write("ApprovedRatingSum", entity.ApprovedRatingSum.ToString());
            _writer.Write("NotApprovedRatingSum", entity.NotApprovedRatingSum.ToString());
            _writer.Write("ApprovedTotalReviews", entity.ApprovedTotalReviews.ToString());
            _writer.Write("NotApprovedTotalReviews", entity.NotApprovedTotalReviews.ToString());
            _writer.Write("Published", entity.Published.ToString());
            _writer.Write("CreatedOnUtc", entity.CreatedOnUtc.ToString(_culture));
            _writer.Write("UpdatedOnUtc", entity.UpdatedOnUtc.ToString(_culture));
            _writer.Write("SubjectToAcl", entity.SubjectToAcl.ToString());
            _writer.Write("LimitedToStores", entity.LimitedToStores.ToString());
            _writer.Write("ProductTypeId", entity.ProductTypeId.ToString());
            _writer.Write("ParentGroupedProductId", entity.ParentGroupedProductId.ToString());
            _writer.Write("Sku", (string)product.Sku);
            _writer.Write("ManufacturerPartNumber", (string)product.ManufacturerPartNumber);
            _writer.Write("Gtin", (string)product.Gtin);
            _writer.Write("IsGiftCard", entity.IsGiftCard.ToString());
            _writer.Write("GiftCardTypeId", entity.GiftCardTypeId.ToString());
            _writer.Write("RequireOtherProducts", entity.RequireOtherProducts.ToString());
            _writer.Write("RequiredProductIds", entity.RequiredProductIds);
            _writer.Write("AutomaticallyAddRequiredProducts", entity.AutomaticallyAddRequiredProducts.ToString());
            _writer.Write("IsDownload", entity.IsDownload.ToString());
            _writer.Write("DownloadId", entity.DownloadId.ToString());
            _writer.Write("UnlimitedDownloads", entity.UnlimitedDownloads.ToString());
            _writer.Write("MaxNumberOfDownloads", entity.MaxNumberOfDownloads.ToString());
            _writer.Write("DownloadExpirationDays", entity.DownloadExpirationDays.HasValue ? entity.DownloadExpirationDays.Value.ToString() : "");
            _writer.Write("DownloadActivationTypeId", entity.DownloadActivationTypeId.ToString());
            _writer.Write("HasSampleDownload", entity.HasSampleDownload.ToString());
            _writer.Write("SampleDownloadId", entity.SampleDownloadId.HasValue ? entity.SampleDownloadId.Value.ToString() : "");
            _writer.Write("HasUserAgreement", entity.HasUserAgreement.ToString());
            _writer.Write("UserAgreementText", entity.UserAgreementText);
            _writer.Write("IsRecurring", entity.IsRecurring.ToString());
            _writer.Write("RecurringCycleLength", entity.RecurringCycleLength.ToString());
            _writer.Write("RecurringCyclePeriodId", entity.RecurringCyclePeriodId.ToString());
            _writer.Write("RecurringTotalCycles", entity.RecurringTotalCycles.ToString());
            _writer.Write("IsShipEnabled", entity.IsShipEnabled.ToString());
            _writer.Write("IsFreeShipping", entity.IsFreeShipping.ToString());
            _writer.Write("AdditionalShippingCharge", entity.AdditionalShippingCharge.ToString(_culture));
            _writer.Write("IsTaxExempt", entity.IsTaxExempt.ToString());
            _writer.Write("TaxCategoryId", entity.TaxCategoryId.ToString());
            _writer.Write("ManageInventoryMethodId", entity.ManageInventoryMethodId.ToString());
            _writer.Write("StockQuantity", entity.StockQuantity.ToString());
            _writer.Write("DisplayStockAvailability", entity.DisplayStockAvailability.ToString());
            _writer.Write("DisplayStockQuantity", entity.DisplayStockQuantity.ToString());
            _writer.Write("MinStockQuantity", entity.MinStockQuantity.ToString());
            _writer.Write("LowStockActivityId", entity.LowStockActivityId.ToString());
            _writer.Write("NotifyAdminForQuantityBelow", entity.NotifyAdminForQuantityBelow.ToString());
            _writer.Write("BackorderModeId", entity.BackorderModeId.ToString());
            _writer.Write("AllowBackInStockSubscriptions", entity.AllowBackInStockSubscriptions.ToString());
            _writer.Write("OrderMinimumQuantity", entity.OrderMinimumQuantity.ToString());
            _writer.Write("OrderMaximumQuantity", entity.OrderMaximumQuantity.ToString());
            _writer.Write("AllowedQuantities", entity.AllowedQuantities);
            _writer.Write("DisableBuyButton", entity.DisableBuyButton.ToString());
            _writer.Write("DisableWishlistButton", entity.DisableWishlistButton.ToString());
            _writer.Write("AvailableForPreOrder", entity.AvailableForPreOrder.ToString());
            _writer.Write("CallForPrice", entity.CallForPrice.ToString());
            _writer.Write("Price", entity.Price.ToString(_culture));
            _writer.Write("OldPrice", entity.OldPrice.ToString(_culture));
            _writer.Write("ProductCost", entity.ProductCost.ToString(_culture));
            _writer.Write("SpecialPrice", entity.SpecialPrice.HasValue ? entity.SpecialPrice.Value.ToString(_culture) : "");
            _writer.Write("SpecialPriceStartDateTimeUtc", entity.SpecialPriceStartDateTimeUtc.HasValue ? entity.SpecialPriceStartDateTimeUtc.Value.ToString(_culture) : "");
            _writer.Write("SpecialPriceEndDateTimeUtc", entity.SpecialPriceEndDateTimeUtc.HasValue ? entity.SpecialPriceEndDateTimeUtc.Value.ToString(_culture) : "");
            _writer.Write("CustomerEntersPrice", entity.CustomerEntersPrice.ToString());
            _writer.Write("MinimumCustomerEnteredPrice", entity.MinimumCustomerEnteredPrice.ToString(_culture));
            _writer.Write("MaximumCustomerEnteredPrice", entity.MaximumCustomerEnteredPrice.ToString(_culture));
            _writer.Write("HasTierPrices", entity.HasTierPrices.ToString());
            _writer.Write("HasDiscountsApplied", entity.HasDiscountsApplied.ToString());
            _writer.Write("Weight", ((decimal)product.Weight).ToString(_culture));
            _writer.Write("Length", ((decimal)product.Length).ToString(_culture));
            _writer.Write("Width", ((decimal)product.Width).ToString(_culture));
            _writer.Write("Height", ((decimal)product.Height).ToString(_culture));
            _writer.Write("AvailableStartDateTimeUtc", entity.AvailableStartDateTimeUtc.HasValue ? entity.AvailableStartDateTimeUtc.Value.ToString(_culture) : "");
            _writer.Write("AvailableEndDateTimeUtc", entity.AvailableEndDateTimeUtc.HasValue ? entity.AvailableEndDateTimeUtc.Value.ToString(_culture) : "");
            _writer.Write("BasePriceEnabled", ((bool)product.BasePriceEnabled).ToString());
            _writer.Write("BasePriceMeasureUnit", (string)product.BasePriceMeasureUnit);
            _writer.Write("BasePriceAmount", basePriceAmount.HasValue ? basePriceAmount.Value.ToString(_culture) : "");
            _writer.Write("BasePriceBaseAmount", basePriceBaseAmount.HasValue ? basePriceBaseAmount.Value.ToString() : "");
            _writer.Write("BasePriceHasValue", ((bool)product.BasePriceHasValue).ToString());
            _writer.Write("BasePriceInfo", (string)product._BasePriceInfo);
            _writer.Write("VisibleIndividually", entity.VisibleIndividually.ToString());
            _writer.Write("DisplayOrder", entity.DisplayOrder.ToString());
            _writer.Write("BundleTitleText", entity.BundleTitleText);
            _writer.Write("BundlePerItemPricing", entity.BundlePerItemPricing.ToString());
            _writer.Write("BundlePerItemShipping", entity.BundlePerItemShipping.ToString());
            _writer.Write("BundlePerItemShoppingCart", entity.BundlePerItemShoppingCart.ToString());
            _writer.Write("LowestAttributeCombinationPrice", lowestAttributeCombinationPrice.HasValue ? lowestAttributeCombinationPrice.Value.ToString(_culture) : "");
            _writer.Write("IsEsd", entity.IsEsd.ToString());

            WriteLocalized(product);

            WriteDeliveryTime(product.DeliveryTime, "DeliveryTime");

            WriteQuantityUnit(product.QuantityUnit, "QuantityUnit");

            if (product.AppliedDiscounts != null)
            {
                _writer.WriteStartElement("AppliedDiscounts");
                foreach (dynamic discount in product.AppliedDiscounts)
                {
                    Discount entityDiscount = discount.Entity;

                    _writer.WriteStartElement("AppliedDiscount");
                    _writer.Write("Id", entityDiscount.Id.ToString());
                    _writer.Write("Name", (string)discount.Name);
                    _writer.Write("DiscountTypeId", entityDiscount.DiscountTypeId.ToString());
                    _writer.Write("UsePercentage", entityDiscount.UsePercentage.ToString());
                    _writer.Write("DiscountPercentage", entityDiscount.DiscountPercentage.ToString(_culture));
                    _writer.Write("DiscountAmount", entityDiscount.DiscountAmount.ToString(_culture));
                    _writer.Write("StartDateUtc", entityDiscount.StartDateUtc.HasValue ? entityDiscount.StartDateUtc.Value.ToString(_culture) : "");
                    _writer.Write("EndDateUtc", entityDiscount.EndDateUtc.HasValue ? entityDiscount.EndDateUtc.Value.ToString(_culture) : "");
                    _writer.Write("RequiresCouponCode", entityDiscount.RequiresCouponCode.ToString());
                    _writer.Write("CouponCode", entityDiscount.CouponCode);
                    _writer.Write("DiscountLimitationId", entityDiscount.DiscountLimitationId.ToString());
                    _writer.Write("LimitationTimes", entityDiscount.LimitationTimes.ToString());
                    _writer.WriteEndElement();                  // AppliedDiscount
                }
                _writer.WriteEndElement();                      // AppliedDiscounts
            }

            if (product.TierPrices != null)
            {
                _writer.WriteStartElement("TierPrices");
                foreach (dynamic tierPrice in product.TierPrices)
                {
                    TierPrice entityTierPrice = tierPrice.Entity;

                    _writer.WriteStartElement("TierPrice");
                    _writer.Write("Id", entityTierPrice.Id.ToString());
                    _writer.Write("ProductId", entityTierPrice.ProductId.ToString());
                    _writer.Write("StoreId", entityTierPrice.StoreId.ToString());
                    _writer.Write("CustomerRoleId", entityTierPrice.CustomerRoleId.HasValue ? entityTierPrice.CustomerRoleId.Value.ToString() : "");
                    _writer.Write("Quantity", entityTierPrice.Quantity.ToString());
                    _writer.Write("Price", entityTierPrice.Price.ToString(_culture));
                    _writer.WriteEndElement();                  // TierPrice
                }
                _writer.WriteEndElement();                      // TierPrices
            }

            if (product.ProductTags != null)
            {
                _writer.WriteStartElement("ProductTags");
                foreach (dynamic tag in product.ProductTags)
                {
                    _writer.WriteStartElement("ProductTag");
                    _writer.Write("Id", ((int)tag.Id).ToString());
                    _writer.Write("Name", (string)tag.Name);
                    _writer.Write("SeName", (string)tag.SeName);

                    WriteLocalized(tag);

                    _writer.WriteEndElement();                  // ProductTag
                }
                _writer.WriteEndElement();                      // ProductTags
            }

            if (product.ProductAttributes != null)
            {
                _writer.WriteStartElement("ProductAttributes");
                foreach (dynamic pva in product.ProductAttributes)
                {
                    ProductVariantAttribute entityPva = pva.Entity;

                    _writer.WriteStartElement("ProductAttribute");
                    _writer.Write("Id", entityPva.Id.ToString());
                    _writer.Write("TextPrompt", (string)pva.TextPrompt);
                    _writer.Write("IsRequired", entityPva.IsRequired.ToString());
                    _writer.Write("AttributeControlTypeId", entityPva.AttributeControlTypeId.ToString());
                    _writer.Write("DisplayOrder", entityPva.DisplayOrder.ToString());

                    _writer.WriteStartElement("Attribute");
                    _writer.Write("Id", ((int)pva.Attribute.Id).ToString());
                    _writer.Write("Alias", (string)pva.Attribute.Alias);
                    _writer.Write("Name", (string)pva.Attribute.Name);
                    _writer.Write("Description", (string)pva.Attribute.Description);

                    WriteLocalized(pva.Attribute);

                    _writer.WriteEndElement();                          // Attribute

                    _writer.WriteStartElement("AttributeValues");
                    foreach (dynamic value in pva.Attribute.Values)
                    {
                        ProductVariantAttributeValue entityPvav = value.Entity;

                        _writer.WriteStartElement("AttributeValue");
                        _writer.Write("Id", entityPvav.Id.ToString());
                        _writer.Write("Alias", (string)value.Alias);
                        _writer.Write("Name", (string)value.Name);
                        _writer.Write("ColorSquaresRgb", (string)value.ColorSquaresRgb);
                        _writer.Write("PriceAdjustment", ((decimal)value.PriceAdjustment).ToString(_culture));
                        _writer.Write("WeightAdjustment", ((decimal)value.WeightAdjustment).ToString(_culture));
                        _writer.Write("IsPreSelected", entityPvav.IsPreSelected.ToString());
                        _writer.Write("DisplayOrder", entityPvav.DisplayOrder.ToString());
                        _writer.Write("ValueTypeId", entityPvav.ValueTypeId.ToString());
                        _writer.Write("LinkedProductId", entityPvav.LinkedProductId.ToString());
                        _writer.Write("Quantity", entityPvav.Quantity.ToString());

                        WriteLocalized(value);

                        _writer.WriteEndElement();              // AttributeValue
                    }
                    _writer.WriteEndElement();                  // AttributeValues

                    _writer.WriteEndElement();                  // ProductAttribute
                }
                _writer.WriteEndElement();                      // ProductAttributes
            }

            if (product.ProductAttributeCombinations != null)
            {
                _writer.WriteStartElement("ProductAttributeCombinations");
                foreach (dynamic combination in product.ProductAttributeCombinations)
                {
                    ProductVariantAttributeCombination entityPvac = combination.Entity;

                    _writer.WriteStartElement("ProductAttributeCombination");
                    _writer.Write("Id", entityPvac.Id.ToString());
                    _writer.Write("StockQuantity", entityPvac.StockQuantity.ToString());
                    _writer.Write("AllowOutOfStockOrders", entityPvac.AllowOutOfStockOrders.ToString());
                    _writer.Write("AttributesXml", entityPvac.AttributesXml);
                    _writer.Write("Sku", entityPvac.Sku);
                    _writer.Write("Gtin", entityPvac.Gtin);
                    _writer.Write("ManufacturerPartNumber", entityPvac.ManufacturerPartNumber);
                    _writer.Write("Price", entityPvac.Price.HasValue ? entityPvac.Price.Value.ToString(_culture) : "");
                    _writer.Write("Length", entityPvac.Length.HasValue ? entityPvac.Length.Value.ToString(_culture) : "");
                    _writer.Write("Width", entityPvac.Width.HasValue ? entityPvac.Width.Value.ToString(_culture) : "");
                    _writer.Write("Height", entityPvac.Height.HasValue ? entityPvac.Height.Value.ToString(_culture) : "");
                    _writer.Write("BasePriceAmount", entityPvac.BasePriceAmount.HasValue ? entityPvac.BasePriceAmount.Value.ToString(_culture) : "");
                    _writer.Write("BasePriceBaseAmount", entityPvac.BasePriceBaseAmount.HasValue ? entityPvac.BasePriceBaseAmount.Value.ToString() : "");
                    _writer.Write("AssignedPictureIds", entityPvac.AssignedPictureIds);
                    _writer.Write("DeliveryTimeId", entityPvac.DeliveryTimeId.HasValue ? entityPvac.DeliveryTimeId.Value.ToString() : "");
                    _writer.Write("IsActive", entityPvac.IsActive.ToString());

                    WriteDeliveryTime(combination.DeliveryTime, "DeliveryTime");

                    WriteQuantityUnit(combination.QuantityUnit, "QuantityUnit");

                    _writer.WriteStartElement("Pictures");
                    foreach (dynamic assignedPicture in combination.Pictures)
                    {
                        WritePicture(assignedPicture, "Picture");
                    }
                    _writer.WriteEndElement();             // Pictures

                    _writer.WriteEndElement();             // ProductAttributeCombination
                }
                _writer.WriteEndElement();                 // ProductAttributeCombinations
            }

            if (product.ProductPictures != null)
            {
                _writer.WriteStartElement("ProductPictures");
                foreach (dynamic productPicture in product.ProductPictures)
                {
                    ProductPicture entityProductPicture = productPicture.Entity;

                    _writer.WriteStartElement("ProductPicture");
                    _writer.Write("Id", entityProductPicture.Id.ToString());
                    _writer.Write("DisplayOrder", entityProductPicture.DisplayOrder.ToString());

                    WritePicture(productPicture.Picture, "Picture");

                    _writer.WriteEndElement();                  // ProductPicture
                }
                _writer.WriteEndElement();                      // ProductPictures
            }

            if (product.ProductCategories != null)
            {
                _writer.WriteStartElement("ProductCategories");
                foreach (dynamic productCategory in product.ProductCategories)
                {
                    ProductCategory entityProductCategory = productCategory.Entity;

                    _writer.WriteStartElement("ProductCategory");
                    _writer.Write("Id", entityProductCategory.Id.ToString());
                    _writer.Write("DisplayOrder", entityProductCategory.DisplayOrder.ToString());
                    _writer.Write("IsFeaturedProduct", entityProductCategory.IsFeaturedProduct.ToString());

                    WriteCategory(productCategory.Category, "Category");

                    _writer.WriteEndElement();                  // ProductCategory
                }
                _writer.WriteEndElement();                      // ProductCategories
            }

            if (product.ProductManufacturers != null)
            {
                _writer.WriteStartElement("ProductManufacturers");
                foreach (dynamic productManu in product.ProductManufacturers)
                {
                    ProductManufacturer entityProductManu = productManu.Entity;

                    _writer.WriteStartElement("ProductManufacturer");

                    _writer.Write("Id", entityProductManu.Id.ToString());
                    _writer.Write("DisplayOrder", entityProductManu.DisplayOrder.ToString());
                    _writer.Write("IsFeaturedProduct", entityProductManu.IsFeaturedProduct.ToString());

                    WriteManufacturer(productManu.Manufacturer, "Manufacturer");

                    _writer.WriteEndElement();                  // ProductManufacturer
                }
                _writer.WriteEndElement();                      // ProductManufacturers
            }

            if (product.ProductSpecificationAttributes != null)
            {
                _writer.WriteStartElement("ProductSpecificationAttributes");
                foreach (dynamic psa in product.ProductSpecificationAttributes)
                {
                    ProductSpecificationAttribute entityPsa = psa.Entity;

                    _writer.WriteStartElement("ProductSpecificationAttribute");

                    _writer.Write("Id", entityPsa.Id.ToString());
                    _writer.Write("ProductId", entityPsa.ProductId.ToString());
                    _writer.Write("SpecificationAttributeOptionId", entityPsa.SpecificationAttributeOptionId.ToString());
                    _writer.Write("AllowFiltering", entityPsa.AllowFiltering.ToString());
                    _writer.Write("ShowOnProductPage", entityPsa.ShowOnProductPage.ToString());
                    _writer.Write("DisplayOrder", entityPsa.DisplayOrder.ToString());

                    dynamic option = psa.SpecificationAttributeOption;
                    SpecificationAttributeOption entitySao = option.Entity;
                    SpecificationAttribute       entitySa  = option.SpecificationAttribute.Entity;

                    _writer.WriteStartElement("SpecificationAttributeOption");
                    _writer.Write("Id", entitySao.Id.ToString());
                    _writer.Write("SpecificationAttributeId", entitySao.SpecificationAttributeId.ToString());
                    _writer.Write("DisplayOrder", entitySao.DisplayOrder.ToString());
                    _writer.Write("Name", (string)option.Name);

                    WriteLocalized(option);

                    _writer.WriteStartElement("SpecificationAttribute");
                    _writer.Write("Id", entitySa.Id.ToString());
                    _writer.Write("Name", (string)option.SpecificationAttribute.Name);
                    _writer.Write("DisplayOrder", entitySa.DisplayOrder.ToString());

                    WriteLocalized(option.SpecificationAttribute);

                    _writer.WriteEndElement();                  // SpecificationAttribute
                    _writer.WriteEndElement();                  // SpecificationAttributeOption

                    _writer.WriteEndElement();                  // ProductSpecificationAttribute
                }
                _writer.WriteEndElement();                      // ProductSpecificationAttributes
            }

            if (product.ProductBundleItems != null)
            {
                _writer.WriteStartElement("ProductBundleItems");
                foreach (dynamic bundleItem in product.ProductBundleItems)
                {
                    ProductBundleItem entityPbi = bundleItem.Entity;

                    _writer.WriteStartElement("ProductBundleItem");
                    _writer.Write("Id", entityPbi.Id.ToString());
                    _writer.Write("ProductId", entityPbi.ProductId.ToString());
                    _writer.Write("BundleProductId", entityPbi.BundleProductId.ToString());
                    _writer.Write("Quantity", entityPbi.Quantity.ToString());
                    _writer.Write("Discount", entityPbi.Discount.HasValue ? entityPbi.Discount.Value.ToString(_culture) : "");
                    _writer.Write("DiscountPercentage", entityPbi.DiscountPercentage.ToString());
                    _writer.Write("Name", (string)bundleItem.Name);
                    _writer.Write("ShortDescription", (string)bundleItem.ShortDescription);
                    _writer.Write("FilterAttributes", entityPbi.FilterAttributes.ToString());
                    _writer.Write("HideThumbnail", entityPbi.HideThumbnail.ToString());
                    _writer.Write("Visible", entityPbi.Visible.ToString());
                    _writer.Write("Published", entityPbi.Published.ToString());
                    _writer.Write("DisplayOrder", ((int)bundleItem.DisplayOrder).ToString());
                    _writer.Write("CreatedOnUtc", entityPbi.CreatedOnUtc.ToString(_culture));
                    _writer.Write("UpdatedOnUtc", entityPbi.UpdatedOnUtc.ToString(_culture));

                    WriteLocalized(bundleItem);

                    _writer.WriteEndElement();                  // ProductBundleItem
                }
                _writer.WriteEndElement();                      // ProductBundleItems
            }

            if (node.HasValue())
            {
                _writer.WriteEndElement();
            }
        }
Exemplo n.º 14
0
 public static ProductBundleItem ToEntity(this ProductBundleItemModel model, ProductBundleItem destination)
 {
     return(Mapper.Map(model, destination));
 }
Exemplo n.º 15
0
 public static ProductBundleItemModel ToModel(this ProductBundleItem entity)
 {
     return(Mapper.Map <ProductBundleItem, ProductBundleItemModel>(entity));
 }