コード例 #1
0
        protected void gvProductVariantAttributes_RowCommand(object sender, GridViewCommandEventArgs e)
        {
            if (e.CommandName == "UpdateProductVariantAttribute")
            {
                int         index = Convert.ToInt32(e.CommandArgument);
                GridViewRow row   = gvProductVariantAttributes.Rows[index];

                HiddenField    hfProductVariantAttributeId = row.FindControl("hfProductVariantAttributeId") as HiddenField;
                DropDownList   ddlProductAttribute         = row.FindControl("ddlProductAttribute") as DropDownList;
                TextBox        txtTextPrompt           = row.FindControl("txtTextPrompt") as TextBox;
                CheckBox       cbIsRequired            = row.FindControl("cbIsRequired") as CheckBox;
                DropDownList   ddlAttributeControlType = row.FindControl("ddlAttributeControlType") as DropDownList;
                NumericTextBox txtDisplayOrder         = row.FindControl("txtDisplayOrder") as NumericTextBox;

                int    productVariantAttributeId = int.Parse(hfProductVariantAttributeId.Value);
                int    productAttributeId        = int.Parse(ddlProductAttribute.SelectedItem.Value);
                string textPrompt = txtTextPrompt.Text;
                bool   isRequired = cbIsRequired.Checked;
                AttributeControlTypeEnum attributeControlType = (AttributeControlTypeEnum)Enum.ToObject(typeof(AttributeControlTypeEnum), int.Parse(ddlAttributeControlType.SelectedItem.Value));
                int displayOrder = txtDisplayOrder.Value;

                ProductVariantAttribute productVariantAttribute = ProductAttributeManager.GetProductVariantAttributeById(productVariantAttributeId);

                if (productVariantAttribute != null)
                {
                    ProductAttributeManager.UpdateProductVariantAttribute(productVariantAttribute.ProductVariantAttributeId,
                                                                          productVariantAttribute.ProductVariantId, productAttributeId, textPrompt,
                                                                          isRequired, attributeControlType, displayOrder);
                }

                BindAttributes();
                BindCombinations();
                RefreshSelectCombinationControl();
            }
        }
コード例 #2
0
        public void Can_save_and_load_productVariantAttribute()
        {
            var pva = new ProductVariantAttribute
            {
                TextPrompt           = "TextPrompt 1",
                IsRequired           = true,
                AttributeControlType = AttributeControlType.DropdownList,
                DisplayOrder         = 1,
                Product          = GetTestProduct(),
                ProductAttribute = new ProductAttribute()
                {
                    Name        = "Name 1",
                    Description = "Description 1",
                }
            };

            var fromDb = SaveAndLoadEntity(pva);

            fromDb.ShouldNotBeNull();
            fromDb.TextPrompt.ShouldEqual("TextPrompt 1");
            fromDb.IsRequired.ShouldEqual(true);
            fromDb.AttributeControlType.ShouldEqual(AttributeControlType.DropdownList);
            fromDb.DisplayOrder.ShouldEqual(1);

            fromDb.Product.ShouldNotBeNull();

            fromDb.ProductAttribute.ShouldNotBeNull();
            fromDb.ProductAttribute.Name.ShouldEqual("Name 1");
        }
コード例 #3
0
        protected void btnNewProductVariantAttribute_Click(object sender, EventArgs e)
        {
            try
            {
                ProductVariant productVariant = ProductManager.GetProductVariantById(this.ProductVariantId);
                if (productVariant != null)
                {
                    if (ddlNewProductAttributes.SelectedItem == null)
                    {
                        return;
                    }

                    int productAttributeId = int.Parse(ddlNewProductAttributes.SelectedItem.Value);

                    AttributeControlTypeEnum attributeControlType = (AttributeControlTypeEnum)Enum.ToObject(typeof(AttributeControlTypeEnum), int.Parse(this.ddlAttributeControlType.SelectedItem.Value));

                    ProductVariantAttribute productVariantAttribute = ProductAttributeManager.InsertProductVariantAttribute(productVariant.ProductVariantId,
                                                                                                                            productAttributeId, txtNewTextPrompt.Text, cbNewProductVariantAttributeIsRequired.Checked,
                                                                                                                            attributeControlType, txtNewProductVariantAttributeDisplayOrder.Value);

                    BindAttributes();
                    BindCombinations();
                    RefreshSelectCombinationControl();

                    txtNewProductVariantAttributeDisplayOrder.Value = 1;
                }
            }
            catch (Exception exc)
            {
                processAjaxError(exc);
            }
        }
コード例 #4
0
        protected void btnAdd_Click(object sender, EventArgs e)
        {
            try
            {
                ProductVariantAttribute productVariantAttribute = ProductAttributeManager.GetProductVariantAttributeById(this.ProductVariantAttributeId);
                if (productVariantAttribute != null)
                {
                    ProductVariantAttributeValue productVariantAttributeValue = ProductAttributeManager.InsertProductVariantAttributeValue(productVariantAttribute.ProductVariantAttributeId,
                                                                                                                                           txtNewName.Text, txtNewPriceAdjustment.Value, txtNewWeightAdjustment.Value,
                                                                                                                                           cbNewIsPreSelected.Checked, txtNewDisplayOrder.Value);

                    SaveLocalizableContent(productVariantAttributeValue);

                    BindData();

                    txtNewName.Text              = string.Empty;
                    txtNewPriceAdjustment.Value  = 0;
                    txtNewWeightAdjustment.Value = 0;
                    txtNewDisplayOrder.Value     = 1;
                }
            }
            catch (Exception exc)
            {
                ProcessException(exc);
            }
        }
コード例 #5
0
        protected void btnNewProductVariantAttribute_Click(object sender, EventArgs e)
        {
            try
            {
                ProductVariant productVariant = ProductManager.GetProductVariantByID(this.ProductVariantID);
                if (productVariant != null)
                {
                    if (ddlNewProductAttributes.SelectedItem == null)
                    {
                        return;
                    }

                    //TODO check duplicate
                    int productAttributeID = int.Parse(ddlNewProductAttributes.SelectedItem.Value);

                    AttributeControlTypeEnum attributeControlType = (AttributeControlTypeEnum)Enum.ToObject(typeof(AttributeControlTypeEnum), int.Parse(this.ddlAttributeControlType.SelectedItem.Value));

                    ProductVariantAttribute productVariantAttribute = ProductAttributeManager.InsertProductVariantAttribute(productVariant.ProductVariantID,
                                                                                                                            productAttributeID, txtNewTextPrompt.Text, cbNewProductVariantAttributeIsRequired.Checked,
                                                                                                                            attributeControlType, txtNewProductVariantAttributeDisplayOrder.Value);

                    BindData();

                    txtNewProductVariantAttributeDisplayOrder.Value = 1;
                }
            }
            catch (Exception exc)
            {
                ProcessException(exc);
            }
        }
コード例 #6
0
        public virtual void InsertProductVariantAttribute(ProductVariantAttribute productVariantAttribute)
        {
            Guard.NotNull(productVariantAttribute, nameof(productVariantAttribute));

            _productVariantAttributeRepository.Insert(productVariantAttribute);

            _requestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTES_PATTERN_KEY);
            _requestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTEVALUES_PATTERN_KEY);
        }
コード例 #7
0
        protected void gvProductVariantAttributes_RowDataBound(object sender, GridViewRowEventArgs e)
        {
            if (e.Row.RowType == DataControlRowType.DataRow)
            {
                ProductVariantAttribute productVariantAttribute = (ProductVariantAttribute)e.Row.DataItem;

                Button btnUpdate = e.Row.FindControl("btnUpdate") as Button;
                if (btnUpdate != null)
                {
                    btnUpdate.CommandArgument = e.Row.RowIndex.ToString();
                }

                DropDownList ddlProductAttribute = e.Row.FindControl("ddlProductAttribute") as DropDownList;
                if (ddlProductAttribute != null)
                {
                    ddlProductAttribute.Items.Clear();
                    var productAttributes = ProductAttributeManager.GetAllProductAttributes();
                    foreach (ProductAttribute productAttribute in productAttributes)
                    {
                        ListItem item = new ListItem(productAttribute.Name,
                                                     productAttribute.ProductAttributeId.ToString());
                        ddlProductAttribute.Items.Add(item);
                        if (productAttribute.ProductAttributeId == productVariantAttribute.ProductAttributeId)
                        {
                            item.Selected = true;
                        }
                    }
                }

                DropDownList ddlAttributeControlType = e.Row.FindControl("ddlAttributeControlType") as DropDownList;
                {
                    if (ddlAttributeControlType != null)
                    {
                        CommonHelper.FillDropDownWithEnum(ddlAttributeControlType, typeof(AttributeControlTypeEnum));
                    }
                    CommonHelper.SelectListItem(ddlAttributeControlType, productVariantAttribute.AttributeControlTypeId);
                }

                HyperLink hlAttributeValues = e.Row.FindControl("hlAttributeValues") as HyperLink;
                if (hlAttributeValues != null)
                {
                    if (productVariantAttribute.ShouldHaveValues)
                    {
                        hlAttributeValues.Visible     = true;
                        hlAttributeValues.NavigateUrl = string.Format("{0}ProductVariantAttributeValues.aspx?ProductVariantAttributeID={1}",
                                                                      CommonHelper.GetStoreAdminLocation(),
                                                                      productVariantAttribute.ProductVariantAttributeId);
                        hlAttributeValues.Text = string.Format(GetLocaleResourceString("Admin.ProductVariantAttributes.Values.Count"), productVariantAttribute.ProductVariantAttributeValues.Count);
                    }
                    else
                    {
                        hlAttributeValues.Visible = false;
                    }
                }
            }
        }
コード例 #8
0
 public AttributeDTO(ProductVariantAttribute p)
 {
     this.Id               = p.Id;
     this.Name             = p.ProductAttribute.Name;
     this.AttributeControl = p.AttributeControlType;
     this.Values           = new List <string>();
     foreach (ProductVariantAttributeValue pv in p.ProductVariantAttributeValues)
     {
         this.Values.Add(pv.Name);
     }
     this.isRequired = p.IsRequired;
 }
コード例 #9
0
        public virtual void UpdateProductVariantAttribute(ProductVariantAttribute productVariantAttribute)
        {
            if (productVariantAttribute == null)
            {
                throw new ArgumentNullException("productVariantAttribute");
            }

            _productVariantAttributeRepository.Update(productVariantAttribute);

            _requestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTES_PATTERN_KEY);
            _requestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTEVALUES_PATTERN_KEY);
        }
コード例 #10
0
        public virtual void DeleteProductVariantAttribute(ProductVariantAttribute productVariantAttribute)
        {
            if (productVariantAttribute == null)
            {
                throw new ArgumentNullException("productVariantAttribute");
            }

            _productVariantAttributeRepository.Delete(productVariantAttribute);

            _requestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTES_PATTERN_KEY);
            _requestCache.RemoveByPattern(PRODUCTVARIANTATTRIBUTEVALUES_PATTERN_KEY);

            //event notification
            _eventPublisher.EntityDeleted(productVariantAttribute);
        }
コード例 #11
0
        /// <summary>
        /// A value indicating whether this product variant attribute should have values
        /// </summary>
        /// <param name="productVariantAttribute">Product variant attribute</param>
        /// <returns>Result</returns>
        public static bool ShouldHaveValues(this ProductVariantAttribute productVariantAttribute)
        {
            if (productVariantAttribute == null)
            {
                return(false);
            }

            if (productVariantAttribute.AttributeControlType == AttributeControlType.TextBox)
            {
                return(false);
            }

            //other attribute controle types support values
            return(true);
        }
コード例 #12
0
        /// <summary>
        /// Inserts a product variant attribute mapping
        /// </summary>
        /// <param name="productVariantAttribute">The product variant attribute mapping</param>
        public virtual void InsertProductVariantAttribute(ProductVariantAttribute productVariantAttribute)
        {
            if (productVariantAttribute == null)
            {
                throw new ArgumentNullException("productVariantAttribute");
            }

            _productVariantAttributeRepository.Insert(productVariantAttribute);

            _cacheManager.RemoveByPattern(PRODUCTATTRIBUTES_PATTERN_KEY);
            _cacheManager.RemoveByPattern(PRODUCTVARIANTATTRIBUTES_PATTERN_KEY);
            _cacheManager.RemoveByPattern(PRODUCTVARIANTATTRIBUTEVALUES_PATTERN_KEY);

            //event notification
            _eventPublisher.EntityInserted(productVariantAttribute);
        }
コード例 #13
0
        private void BindData()
        {
            ProductVariantAttribute productVariantAttribute = ProductAttributeManager.GetProductVariantAttributeById(this.ProductVariantAttributeId);

            if (productVariantAttribute != null)
            {
                if (this.HasLocalizableContent)
                {
                    var languages = this.GetLocalizableLanguagesSupported();
                    rptrLanguageTabs.DataSource = languages;
                    rptrLanguageTabs.DataBind();
                    rptrLanguageDivs.DataSource = languages;
                    rptrLanguageDivs.DataBind();
                }

                ProductVariant productVariant = productVariantAttribute.ProductVariant;
                if (productVariant == null)
                {
                    Response.Redirect("Products.aspx");
                }
                ProductAttribute productAttribute = productVariantAttribute.ProductAttribute;
                if (productAttribute == null)
                {
                    Response.Redirect("Products.aspx");
                }

                this.lblTitle.Text            = string.Format(GetLocaleResourceString("Admin.ProductVariantAttributeValues.AddEdit"), Server.HtmlEncode(productAttribute.Name), Server.HtmlEncode(productVariant.FullProductName));
                this.hlProductURL.NavigateUrl = CommonHelper.GetStoreAdminLocation() + "ProductVariantDetails.aspx?ProductVariantID=" + productVariant.ProductVariantId;

                var productVariantAttributeValues = ProductAttributeManager.GetProductVariantAttributeValues(productVariantAttribute.ProductVariantAttributeId);
                if (productVariantAttributeValues.Count > 0)
                {
                    this.gvProductVariantAttributeValues.Visible    = true;
                    this.gvProductVariantAttributeValues.DataSource = productVariantAttributeValues;
                    this.gvProductVariantAttributeValues.DataBind();
                }
                else
                {
                    this.gvProductVariantAttributeValues.Visible = false;
                }
            }
            else
            {
                Response.Redirect("Products.aspx");
            }
        }
コード例 #14
0
        /// <summary>
        /// A value indicating whether this product variant attribute should can have some validation rules
        /// </summary>
        /// <param name="productVariantAttribute">Product variant attribute</param>
        /// <returns>Result</returns>
        public static bool ValidationRulesAllowed(this ProductVariantAttribute productVariantAttribute)
        {
            if (productVariantAttribute == null)
            {
                return(false);
            }

            if (productVariantAttribute.AttributeControlType == AttributeControlType.TextBox ||
                productVariantAttribute.AttributeControlType == AttributeControlType.MultilineTextbox ||
                productVariantAttribute.AttributeControlType == AttributeControlType.FileUpload)
            {
                return(true);
            }

            //other attribute controle types does not have validation
            return(false);
        }
コード例 #15
0
        /// <summary>
        /// A value indicating whether this product variant attribute should have values
        /// </summary>
        /// <param name="productVariantAttribute">Product variant attribute</param>
        /// <returns>Result</returns>
        public static bool ShouldHaveValues(this ProductVariantAttribute productVariantAttribute)
        {
            if (productVariantAttribute == null)
            {
                return(false);
            }

            if (productVariantAttribute.AttributeControlType == AttributeControlType.TextBox ||
                productVariantAttribute.AttributeControlType == AttributeControlType.MultilineTextbox ||
                productVariantAttribute.AttributeControlType == AttributeControlType.Datepicker)
            {
                return(false);
            }
            else
            {
                return(true);
            }
        }
コード例 #16
0
        /// <summary>
        /// A value indicating whether this product variant attribute should have values
        /// </summary>
        /// <param name="productVariantAttribute">Product variant attribute</param>
        /// <returns>Result</returns>
        public static bool ShouldHaveValues(this ProductVariantAttribute productVariantAttribute)
        {
            if (productVariantAttribute == null)
            {
                return(false);
            }

            if (productVariantAttribute.AttributeControlType == AttributeControlType.TextBox ||
                productVariantAttribute.AttributeControlType == AttributeControlType.MultilineTextbox ||
                productVariantAttribute.AttributeControlType == AttributeControlType.Datepicker ||
                productVariantAttribute.AttributeControlType == AttributeControlType.FileUpload)
            {
                return(false);
            }

            // all other attribute control types support values
            return(true);
        }
        public void Can_save_and_load_productVariantAttribute()
        {
            var pva = new ProductVariantAttribute
            {
                TextPrompt           = "TextPrompt 1",
                IsRequired           = true,
                AttributeControlType = AttributeControlType.DropdownList,
                DisplayOrder         = 1,
                ProductVariant       = new ProductVariant()
                {
                    Name         = "Product variant name 1",
                    CreatedOnUtc = new DateTime(2010, 01, 03),
                    UpdatedOnUtc = new DateTime(2010, 01, 04),
                    Product      = new Product()
                    {
                        Name         = "Name 1",
                        Published    = true,
                        Deleted      = false,
                        CreatedOnUtc = new DateTime(2010, 01, 01),
                        UpdatedOnUtc = new DateTime(2010, 01, 02),
                    }
                },
                ProductAttribute = new ProductAttribute()
                {
                    Name        = "Name 1",
                    Description = "Description 1",
                }
            };

            var fromDb = SaveAndLoadEntity(pva);

            fromDb.ShouldNotBeNull();
            fromDb.TextPrompt.ShouldEqual("TextPrompt 1");
            fromDb.IsRequired.ShouldEqual(true);
            fromDb.AttributeControlType.ShouldEqual(AttributeControlType.DropdownList);
            fromDb.DisplayOrder.ShouldEqual(1);

            fromDb.ProductVariant.ShouldNotBeNull();
            fromDb.ProductVariant.Name.ShouldEqual("Product variant name 1");

            fromDb.ProductAttribute.ShouldNotBeNull();
            fromDb.ProductAttribute.Name.ShouldEqual("Name 1");
        }
コード例 #18
0
        public void Can_save_and_load_productVariantAttribute()
        {
            var pva = new ProductVariantAttribute
            {
                TextPrompt                      = "TextPrompt 1",
                IsRequired                      = true,
                AttributeControlType            = AttributeControlType.DropdownList,
                DisplayOrder                    = 1,
                ValidationMinLength             = 2,
                ValidationMaxLength             = 3,
                ValidationFileAllowedExtensions = "ValidationFileAllowedExtensions 1",
                ValidationFileMaximumSize       = 4,
                DefaultValue                    = "DefaultValue 1",
                Product          = GetTestProduct(),
                ProductAttribute = new ProductAttribute()
                {
                    Name        = "Name 1",
                    Description = "Description 1",
                }
            };

            var fromDb = SaveAndLoadEntity(pva);

            fromDb.ShouldNotBeNull();
            fromDb.TextPrompt.ShouldEqual("TextPrompt 1");
            fromDb.IsRequired.ShouldEqual(true);
            fromDb.AttributeControlType.ShouldEqual(AttributeControlType.DropdownList);
            fromDb.DisplayOrder.ShouldEqual(1);
            fromDb.ValidationMinLength.ShouldEqual(2);
            fromDb.ValidationMaxLength.ShouldEqual(3);
            fromDb.ValidationFileAllowedExtensions.ShouldEqual("ValidationFileAllowedExtensions 1");
            fromDb.ValidationFileMaximumSize.ShouldEqual(4);
            fromDb.DefaultValue.ShouldEqual("DefaultValue 1");

            fromDb.Product.ShouldNotBeNull();

            fromDb.ProductAttribute.ShouldNotBeNull();
            fromDb.ProductAttribute.Name.ShouldEqual("Name 1");
        }
コード例 #19
0
        private void BindData()
        {
            ProductVariantAttribute productVariantAttribute = ProductAttributeManager.GetProductVariantAttributeByID(this.ProductVariantAttributeID);

            if (productVariantAttribute != null)
            {
                ProductVariant productVariant = productVariantAttribute.ProductVariant;
                if (productVariant == null)
                {
                    Response.Redirect("Products.aspx");
                }
                ProductAttribute productAttribute = productVariantAttribute.ProductAttribute;
                if (productAttribute == null)
                {
                    Response.Redirect("Products.aspx");
                }

                this.lblTitle.Text            = string.Format(GetLocaleResourceString("Admin.ProductVariantAttributeValues.AddEdit"), Server.HtmlEncode(productAttribute.Name), Server.HtmlEncode(productVariant.FullProductName));
                this.hlProductURL.NavigateUrl = CommonHelper.GetStoreAdminLocation() + "ProductVariantDetails.aspx?ProductVariantID=" + productVariant.ProductVariantID;

                ProductVariantAttributeValueCollection productVariantAttributeValues = productVariantAttribute.ProductVariantAttributeValues;
                if (productVariantAttributeValues.Count > 0)
                {
                    this.gvProductVariantAttributeValues.Visible    = true;
                    this.gvProductVariantAttributeValues.DataSource = productVariantAttributeValues;
                    this.gvProductVariantAttributeValues.DataBind();
                }
                else
                {
                    this.gvProductVariantAttributeValues.Visible = false;
                }
            }
            else
            {
                Response.Redirect("Products.aspx");
            }
        }
コード例 #20
0
        private static dynamic ToDynamic(ProductVariantAttribute productAttribute, DataExporterContext ctx)
        {
            if (productAttribute == null)
            {
                return(null);
            }

            var languageId = ctx.LanguageId;
            var attribute  = productAttribute.ProductAttribute;

            dynamic result       = new DynamicEntity(productAttribute);
            dynamic dynAttribute = new DynamicEntity(attribute);

            dynAttribute.Name        = ctx.GetTranslation(attribute, nameof(attribute.Name), attribute.Name);
            dynAttribute.Description = ctx.GetTranslation(attribute, nameof(attribute.Description), attribute.Description);

            dynAttribute.Values = productAttribute.ProductVariantAttributeValues
                                  .OrderBy(x => x.DisplayOrder)
                                  .Select(x =>
            {
                dynamic dyn    = new DynamicEntity(x);
                dyn.Name       = ctx.GetTranslation(x, nameof(x.Name), x.Name);
                dyn._Localized = GetLocalized(ctx, x, y => y.Name);

                return(dyn);
            })
                                  .ToList();

            dynAttribute._Localized = GetLocalized(ctx, attribute,
                                                   x => x.Name,
                                                   x => x.Description);

            result.Attribute = dynAttribute;

            return(result);
        }
コード例 #21
0
        public static string AddProductAttribute(this ProductVariantAttribute pva, string attributes, string value)
        {
            string result = string.Empty;

            try
            {
                var xmlDoc = new XmlDocument();
                if (String.IsNullOrEmpty(attributes))
                {
                    var element1 = xmlDoc.CreateElement("Attributes");
                    xmlDoc.AppendChild(element1);
                }
                else
                {
                    xmlDoc.LoadXml(attributes);
                }
                var rootElement = (XmlElement)xmlDoc.SelectSingleNode(@"//Attributes");

                XmlElement pvaElement = null;
                //find existing
                var nodeList1 = xmlDoc.SelectNodes(@"//Attributes/ProductVariantAttribute");
                foreach (XmlNode node1 in nodeList1)
                {
                    if (node1.Attributes != null && node1.Attributes["ID"] != null)
                    {
                        string str1 = node1.Attributes["ID"].InnerText.Trim();
                        int    id   = 0;
                        if (int.TryParse(str1, out id))
                        {
                            if (id == pva.Id)
                            {
                                pvaElement = (XmlElement)node1;
                                break;
                            }
                        }
                    }
                }

                //create new one if not found
                if (pvaElement == null)
                {
                    pvaElement = xmlDoc.CreateElement("ProductVariantAttribute");
                    pvaElement.SetAttribute("ID", pva.Id.ToString());
                    rootElement.AppendChild(pvaElement);
                }

                var pvavElement = xmlDoc.CreateElement("ProductVariantAttributeValue");
                pvaElement.AppendChild(pvavElement);

                var pvavVElement = xmlDoc.CreateElement("Value");
                pvavVElement.InnerText = value;
                pvavElement.AppendChild(pvavVElement);

                result = xmlDoc.OuterXml;
            }
            catch (Exception exc)
            {
                Debug.Write(exc.ToString());
            }
            return(result);
        }
コード例 #22
0
 /// <summary>
 /// Adds an attribute
 /// </summary>
 /// <param name="attributes">Attributes</param>
 /// <param name="pva">Product variant attribute</param>
 /// <param name="value">Value</param>
 /// <returns>Attributes</returns>
 public virtual string AddProductAttribute(string attributes, ProductVariantAttribute pva, string value)
 {
     return(pva.AddProductAttribute(attributes, value));
 }
コード例 #23
0
        private void ProcessAttributes(
            Product product,
            Product clone,
            string newName,
            bool copyImages,
            Dictionary <int, Picture> clonedPictures,
            IEnumerable <Language> languages)
        {
            // Former attribute id > clone
            var pvaMap = new Dictionary <int, ProductVariantAttribute>();

            // Former attribute value id > clone
            var pvavMap = new Dictionary <int, ProductVariantAttributeValue>();

            var pictureSeName = _pictureService.GetPictureSeName(newName);

            foreach (var pva in product.ProductVariantAttributes)
            {
                var pvaClone = new ProductVariantAttribute
                {
                    ProductAttributeId     = pva.ProductAttributeId,
                    TextPrompt             = pva.TextPrompt,
                    IsRequired             = pva.IsRequired,
                    AttributeControlTypeId = pva.AttributeControlTypeId,
                    DisplayOrder           = pva.DisplayOrder
                };

                clone.ProductVariantAttributes.Add(pvaClone);

                // Save associated value (used for combinations copying)
                pvaMap[pva.Id] = pvaClone;

                // Product variant attribute values
                foreach (var pvav in pva.ProductVariantAttributeValues)
                {
                    var pvavClone = new ProductVariantAttributeValue
                    {
                        Name             = pvav.Name,
                        Color            = pvav.Color,
                        PriceAdjustment  = pvav.PriceAdjustment,
                        WeightAdjustment = pvav.WeightAdjustment,
                        IsPreSelected    = pvav.IsPreSelected,
                        DisplayOrder     = pvav.DisplayOrder,
                        ValueTypeId      = pvav.ValueTypeId,
                        LinkedProductId  = pvav.LinkedProductId,
                        Quantity         = pvav.Quantity,
                        PictureId        = copyImages ? pvav.PictureId : 0                  // we'll clone this later
                    };

                    pvaClone.ProductVariantAttributeValues.Add(pvavClone);

                    // Save associated value (used for combinations copying)
                    pvavMap.Add(pvav.Id, pvavClone);
                }
            }

            // >>>>>> Commit
            Commit();

            // Attribute value localization
            foreach (var pvav in product.ProductVariantAttributes.SelectMany(x => x.ProductVariantAttributeValues).ToArray())
            {
                foreach (var lang in languages)
                {
                    var name = pvav.GetLocalized(x => x.Name, lang, false, false);
                    if (!String.IsNullOrEmpty(name))
                    {
                        var pvavClone = pvavMap.Get(pvav.Id);
                        if (pvavClone != null)
                        {
                            _localizedEntityService.SaveLocalizedValue(pvavClone, x => x.Name, name, lang.Id);
                        }
                    }
                }
            }

            // Clone attribute value images
            if (copyImages)
            {
                // Reduce value set to those with assigned pictures
                var allValueClonesWithPictures = pvavMap.Values.Where(x => x.PictureId > 0).ToArray();
                // Get those pictures for cloning
                var allPictures = _pictureService.GetPicturesByIds(allValueClonesWithPictures.Select(x => x.PictureId).ToArray(), true);

                foreach (var pvavClone in allValueClonesWithPictures)
                {
                    var picture = allPictures.FirstOrDefault(x => x.Id == pvavClone.PictureId);
                    if (picture != null)
                    {
                        var pictureClone = CopyPicture(picture, pictureSeName);
                        clonedPictures[pvavClone.PictureId] = pictureClone;
                        pvavClone.PictureId = pictureClone.Id;
                    }
                }
            }

            // >>>>>> Commit attributes & values
            Commit();

            // attribute combinations
            using (var scope = new DbContextScope(lazyLoading: false, forceNoTracking: false))
            {
                scope.LoadCollection(product, (Product p) => p.ProductVariantAttributeCombinations);
            }

            foreach (var combination in product.ProductVariantAttributeCombinations)
            {
                // Generate new AttributesXml according to new value IDs
                string newAttributesXml = "";
                var    parsedProductVariantAttributes = _productAttributeParser.ParseProductVariantAttributes(combination.AttributesXml);
                foreach (var oldPva in parsedProductVariantAttributes)
                {
                    if (!pvaMap.ContainsKey(oldPva.Id))
                    {
                        continue;
                    }

                    var newPva = pvaMap.Get(oldPva.Id);

                    if (newPva == null)
                    {
                        continue;
                    }

                    var oldPvaValuesStr = _productAttributeParser.ParseValues(combination.AttributesXml, oldPva.Id);
                    foreach (var oldPvaValueStr in oldPvaValuesStr)
                    {
                        if (newPva.ShouldHaveValues())
                        {
                            // attribute values
                            int oldPvaValue = oldPvaValueStr.Convert <int>();
                            if (pvavMap.ContainsKey(oldPvaValue))
                            {
                                var newPvav = pvavMap.Get(oldPvaValue);
                                if (newPvav != null)
                                {
                                    newAttributesXml = _productAttributeParser.AddProductAttribute(newAttributesXml, newPva, newPvav.Id.ToString());
                                }
                            }
                        }
                        else
                        {
                            // just a text
                            newAttributesXml = _productAttributeParser.AddProductAttribute(newAttributesXml, newPva, oldPvaValueStr);
                        }
                    }
                }

                var newAssignedPictureIds = new HashSet <string>();
                foreach (var strPicId in combination.AssignedPictureIds.EmptyNull().Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
                {
                    var newPic = clonedPictures.Get(strPicId.Convert <int>());
                    if (newPic != null)
                    {
                        newAssignedPictureIds.Add(newPic.Id.ToString(CultureInfo.InvariantCulture));
                    }
                }

                var combinationClone = new ProductVariantAttributeCombination
                {
                    AttributesXml         = newAttributesXml,
                    StockQuantity         = combination.StockQuantity,
                    AllowOutOfStockOrders = combination.AllowOutOfStockOrders,
                    Sku  = combination.Sku,
                    Gtin = combination.Gtin,
                    ManufacturerPartNumber = combination.ManufacturerPartNumber,
                    Price = combination.Price,
                    AssignedPictureIds = copyImages ? String.Join(",", newAssignedPictureIds) : null,
                    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
                };

                clone.ProductVariantAttributeCombinations.Add(combinationClone);
            }

            // >>>>>> Commit combinations
            Commit();
        }
コード例 #24
0
        /// <summary>
        /// Create a copy of product with all depended data
        /// </summary>
        /// <param name="product">The product</param>
        /// <param name="newName">The name of product duplicate</param>
        /// <param name="isPublished">A value indicating whether the product duplicate should be published</param>
        /// <param name="copyImages">A value indicating whether the product images should be copied</param>
        /// <param name="copyAssociatedProducts">A value indicating whether the copy associated products</param>
        /// <returns>Product entity</returns>
        public virtual Product CopyProduct(Product product, string newName, bool isPublished, bool copyImages, bool copyAssociatedProducts = true)
        {
            if (product == null)
            {
                throw new ArgumentNullException("product");
            }

            if (String.IsNullOrEmpty(newName))
            {
                throw new ArgumentException("Product name is required");
            }

            Product productCopy = null;
            var     utcNow      = DateTime.UtcNow;

            // product download & sample download
            int downloadId       = product.DownloadId;
            int?sampleDownloadId = product.SampleDownloadId;

            if (product.IsDownload)
            {
                var download = _downloadService.GetDownloadById(product.DownloadId);
                if (download != null)
                {
                    var downloadCopy = new Download()
                    {
                        DownloadGuid   = Guid.NewGuid(),
                        UseDownloadUrl = download.UseDownloadUrl,
                        DownloadUrl    = download.DownloadUrl,
                        DownloadBinary = download.DownloadBinary,
                        ContentType    = download.ContentType,
                        Filename       = download.Filename,
                        Extension      = download.Extension,
                        IsNew          = download.IsNew,
                    };
                    _downloadService.InsertDownload(downloadCopy);
                    downloadId = downloadCopy.Id;
                }

                if (product.HasSampleDownload)
                {
                    var sampleDownload = _downloadService.GetDownloadById(product.SampleDownloadId.GetValueOrDefault());
                    if (sampleDownload != null)
                    {
                        var sampleDownloadCopy = new Download()
                        {
                            DownloadGuid   = Guid.NewGuid(),
                            UseDownloadUrl = sampleDownload.UseDownloadUrl,
                            DownloadUrl    = sampleDownload.DownloadUrl,
                            DownloadBinary = sampleDownload.DownloadBinary,
                            ContentType    = sampleDownload.ContentType,
                            Filename       = sampleDownload.Filename,
                            Extension      = sampleDownload.Extension,
                            IsNew          = sampleDownload.IsNew
                        };
                        _downloadService.InsertDownload(sampleDownloadCopy);
                        sampleDownloadId = sampleDownloadCopy.Id;
                    }
                }
            }

            // product
            productCopy = new Product()
            {
                ProductTypeId          = product.ProductTypeId,
                ParentGroupedProductId = product.ParentGroupedProductId,
                VisibleIndividually    = product.VisibleIndividually,
                Name                 = newName,
                ShortDescription     = product.ShortDescription,
                FullDescription      = product.FullDescription,
                ProductTemplateId    = product.ProductTemplateId,
                AdminComment         = product.AdminComment,
                ShowOnHomePage       = product.ShowOnHomePage,
                MetaKeywords         = product.MetaKeywords,
                MetaDescription      = product.MetaDescription,
                MetaTitle            = product.MetaTitle,
                AllowCustomerReviews = product.AllowCustomerReviews,
                LimitedToStores      = product.LimitedToStores,
                Sku = product.Sku,
                ManufacturerPartNumber = product.ManufacturerPartNumber,
                Gtin                             = product.Gtin,
                IsGiftCard                       = product.IsGiftCard,
                GiftCardType                     = product.GiftCardType,
                RequireOtherProducts             = product.RequireOtherProducts,
                RequiredProductIds               = product.RequiredProductIds,
                AutomaticallyAddRequiredProducts = product.AutomaticallyAddRequiredProducts,
                IsDownload                       = product.IsDownload,
                DownloadId                       = downloadId,
                UnlimitedDownloads               = product.UnlimitedDownloads,
                MaxNumberOfDownloads             = product.MaxNumberOfDownloads,
                DownloadExpirationDays           = product.DownloadExpirationDays,
                DownloadActivationType           = product.DownloadActivationType,
                HasSampleDownload                = product.HasSampleDownload,
                SampleDownloadId                 = sampleDownloadId,
                HasUserAgreement                 = product.HasUserAgreement,
                UserAgreementText                = product.UserAgreementText,
                IsRecurring                      = product.IsRecurring,
                RecurringCycleLength             = product.RecurringCycleLength,
                RecurringCyclePeriod             = product.RecurringCyclePeriod,
                RecurringTotalCycles             = product.RecurringTotalCycles,
                IsShipEnabled                    = product.IsShipEnabled,
                IsFreeShipping                   = product.IsFreeShipping,
                AdditionalShippingCharge         = product.AdditionalShippingCharge,
                IsEsd                            = product.IsEsd,
                IsTaxExempt                      = product.IsTaxExempt,
                TaxCategoryId                    = product.TaxCategoryId,
                ManageInventoryMethod            = product.ManageInventoryMethod,
                StockQuantity                    = product.StockQuantity,
                DisplayStockAvailability         = product.DisplayStockAvailability,
                DisplayStockQuantity             = product.DisplayStockQuantity,
                MinStockQuantity                 = product.MinStockQuantity,
                LowStockActivityId               = product.LowStockActivityId,
                NotifyAdminForQuantityBelow      = product.NotifyAdminForQuantityBelow,
                BackorderMode                    = product.BackorderMode,
                AllowBackInStockSubscriptions    = product.AllowBackInStockSubscriptions,
                OrderMinimumQuantity             = product.OrderMinimumQuantity,
                OrderMaximumQuantity             = product.OrderMaximumQuantity,
                AllowedQuantities                = product.AllowedQuantities,
                DisableBuyButton                 = product.DisableBuyButton,
                DisableWishlistButton            = product.DisableWishlistButton,
                AvailableForPreOrder             = product.AvailableForPreOrder,
                CallForPrice                     = product.CallForPrice,
                Price                            = product.Price,
                OldPrice                         = product.OldPrice,
                ProductCost                      = product.ProductCost,
                SpecialPrice                     = product.SpecialPrice,
                SpecialPriceStartDateTimeUtc     = product.SpecialPriceStartDateTimeUtc,
                SpecialPriceEndDateTimeUtc       = product.SpecialPriceEndDateTimeUtc,
                CustomerEntersPrice              = product.CustomerEntersPrice,
                MinimumCustomerEnteredPrice      = product.MinimumCustomerEnteredPrice,
                MaximumCustomerEnteredPrice      = product.MaximumCustomerEnteredPrice,
                LowestAttributeCombinationPrice  = product.LowestAttributeCombinationPrice,
                Weight                           = product.Weight,
                Length                           = product.Length,
                Width                            = product.Width,
                Height                           = product.Height,
                AvailableStartDateTimeUtc        = product.AvailableStartDateTimeUtc,
                AvailableEndDateTimeUtc          = product.AvailableEndDateTimeUtc,
                DisplayOrder                     = product.DisplayOrder,
                Published                        = isPublished,
                Deleted                          = product.Deleted,
                CreatedOnUtc                     = utcNow,
                UpdatedOnUtc                     = utcNow,
                DeliveryTimeId                   = product.DeliveryTimeId,
                QuantityUnitId                   = product.QuantityUnitId,
                BasePriceEnabled                 = product.BasePriceEnabled,
                BasePriceMeasureUnit             = product.BasePriceMeasureUnit,
                BasePriceAmount                  = product.BasePriceAmount,
                BasePriceBaseAmount              = product.BasePriceBaseAmount,
                BundleTitleText                  = product.BundleTitleText,
                BundlePerItemShipping            = product.BundlePerItemShipping,
                BundlePerItemPricing             = product.BundlePerItemPricing,
                BundlePerItemShoppingCart        = product.BundlePerItemShoppingCart
            };

            _productService.InsertProduct(productCopy);

            //search engine name
            _urlRecordService.SaveSlug(productCopy, productCopy.ValidateSeName("", productCopy.Name, true), 0);

            var languages = _languageService.GetAllLanguages(true);

            //localization
            foreach (var lang in languages)
            {
                var name = product.GetLocalized(x => x.Name, lang.Id, false, false);
                if (!String.IsNullOrEmpty(name))
                {
                    _localizedEntityService.SaveLocalizedValue(productCopy, x => x.Name, name, lang.Id);
                }

                var shortDescription = product.GetLocalized(x => x.ShortDescription, lang.Id, false, false);
                if (!String.IsNullOrEmpty(shortDescription))
                {
                    _localizedEntityService.SaveLocalizedValue(productCopy, x => x.ShortDescription, shortDescription, lang.Id);
                }

                var fullDescription = product.GetLocalized(x => x.FullDescription, lang.Id, false, false);
                if (!String.IsNullOrEmpty(fullDescription))
                {
                    _localizedEntityService.SaveLocalizedValue(productCopy, x => x.FullDescription, fullDescription, lang.Id);
                }

                var metaKeywords = product.GetLocalized(x => x.MetaKeywords, lang.Id, false, false);
                if (!String.IsNullOrEmpty(metaKeywords))
                {
                    _localizedEntityService.SaveLocalizedValue(productCopy, x => x.MetaKeywords, metaKeywords, lang.Id);
                }

                var metaDescription = product.GetLocalized(x => x.MetaDescription, lang.Id, false, false);
                if (!String.IsNullOrEmpty(metaDescription))
                {
                    _localizedEntityService.SaveLocalizedValue(productCopy, x => x.MetaDescription, metaDescription, lang.Id);
                }

                var metaTitle = product.GetLocalized(x => x.MetaTitle, lang.Id, false, false);
                if (!String.IsNullOrEmpty(metaTitle))
                {
                    _localizedEntityService.SaveLocalizedValue(productCopy, x => x.MetaTitle, metaTitle, lang.Id);
                }

                var bundleTitleText = product.GetLocalized(x => x.BundleTitleText, lang.Id, false, false);
                if (!String.IsNullOrEmpty(bundleTitleText))
                {
                    _localizedEntityService.SaveLocalizedValue(productCopy, x => x.BundleTitleText, bundleTitleText, lang.Id);
                }

                //search engine name
                _urlRecordService.SaveSlug(productCopy, productCopy.ValidateSeName("", name, false), lang.Id);
            }

            // product pictures
            if (copyImages)
            {
                foreach (var productPicture in product.ProductPictures)
                {
                    var picture     = productPicture.Picture;
                    var pictureCopy = _pictureService.InsertPicture(
                        _pictureService.LoadPictureBinary(picture),
                        picture.MimeType,
                        _pictureService.GetPictureSeName(newName),
                        true);
                    _productService.InsertProductPicture(new ProductPicture()
                    {
                        ProductId    = productCopy.Id,
                        PictureId    = pictureCopy.Id,
                        DisplayOrder = productPicture.DisplayOrder
                    });
                }
            }

            // product <-> categories mappings
            foreach (var productCategory in product.ProductCategories)
            {
                var productCategoryCopy = new ProductCategory()
                {
                    ProductId         = productCopy.Id,
                    CategoryId        = productCategory.CategoryId,
                    IsFeaturedProduct = productCategory.IsFeaturedProduct,
                    DisplayOrder      = productCategory.DisplayOrder
                };

                _categoryService.InsertProductCategory(productCategoryCopy);
            }

            // product <-> manufacturers mappings
            foreach (var productManufacturers in product.ProductManufacturers)
            {
                var productManufacturerCopy = new ProductManufacturer()
                {
                    ProductId         = productCopy.Id,
                    ManufacturerId    = productManufacturers.ManufacturerId,
                    IsFeaturedProduct = productManufacturers.IsFeaturedProduct,
                    DisplayOrder      = productManufacturers.DisplayOrder
                };

                _manufacturerService.InsertProductManufacturer(productManufacturerCopy);
            }

            // product <-> releated products mappings
            foreach (var relatedProduct in _productService.GetRelatedProductsByProductId1(product.Id, true))
            {
                _productService.InsertRelatedProduct(
                    new RelatedProduct()
                {
                    ProductId1   = productCopy.Id,
                    ProductId2   = relatedProduct.ProductId2,
                    DisplayOrder = relatedProduct.DisplayOrder
                });
            }

            // product <-> cross sells mappings
            foreach (var csProduct in _productService.GetCrossSellProductsByProductId1(product.Id, true))
            {
                _productService.InsertCrossSellProduct(
                    new CrossSellProduct()
                {
                    ProductId1 = productCopy.Id,
                    ProductId2 = csProduct.ProductId2,
                });
            }

            // product specifications
            foreach (var productSpecificationAttribute in product.ProductSpecificationAttributes)
            {
                var psaCopy = new ProductSpecificationAttribute()
                {
                    ProductId = productCopy.Id,
                    SpecificationAttributeOptionId = productSpecificationAttribute.SpecificationAttributeOptionId,
                    AllowFiltering    = productSpecificationAttribute.AllowFiltering,
                    ShowOnProductPage = productSpecificationAttribute.ShowOnProductPage,
                    DisplayOrder      = productSpecificationAttribute.DisplayOrder
                };
                _specificationAttributeService.InsertProductSpecificationAttribute(psaCopy);
            }

            //store mapping
            var selectedStoreIds = _storeMappingService.GetStoresIdsWithAccess(product);

            foreach (var id in selectedStoreIds)
            {
                _storeMappingService.InsertStoreMapping(productCopy, id);
            }

            // product <-> attributes mappings
            var associatedAttributes      = new Dictionary <int, int>();
            var associatedAttributeValues = new Dictionary <int, int>();

            foreach (var productVariantAttribute in _productAttributeService.GetProductVariantAttributesByProductId(product.Id))
            {
                var productVariantAttributeCopy = new ProductVariantAttribute()
                {
                    ProductId              = productCopy.Id,
                    ProductAttributeId     = productVariantAttribute.ProductAttributeId,
                    TextPrompt             = productVariantAttribute.TextPrompt,
                    IsRequired             = productVariantAttribute.IsRequired,
                    AttributeControlTypeId = productVariantAttribute.AttributeControlTypeId,
                    DisplayOrder           = productVariantAttribute.DisplayOrder
                };
                _productAttributeService.InsertProductVariantAttribute(productVariantAttributeCopy);
                //save associated value (used for combinations copying)
                associatedAttributes.Add(productVariantAttribute.Id, productVariantAttributeCopy.Id);

                // product variant attribute values
                var productVariantAttributeValues = _productAttributeService.GetProductVariantAttributeValues(productVariantAttribute.Id);
                foreach (var productVariantAttributeValue in productVariantAttributeValues)
                {
                    var pvavCopy = new ProductVariantAttributeValue()
                    {
                        ProductVariantAttributeId = productVariantAttributeCopy.Id,
                        Name             = productVariantAttributeValue.Name,
                        ColorSquaresRgb  = productVariantAttributeValue.ColorSquaresRgb,
                        PriceAdjustment  = productVariantAttributeValue.PriceAdjustment,
                        WeightAdjustment = productVariantAttributeValue.WeightAdjustment,
                        IsPreSelected    = productVariantAttributeValue.IsPreSelected,
                        DisplayOrder     = productVariantAttributeValue.DisplayOrder,
                        ValueTypeId      = productVariantAttributeValue.ValueTypeId,
                        LinkedProductId  = productVariantAttributeValue.LinkedProductId,
                        Quantity         = productVariantAttributeValue.Quantity,
                    };
                    _productAttributeService.InsertProductVariantAttributeValue(pvavCopy);

                    //save associated value (used for combinations copying)
                    associatedAttributeValues.Add(productVariantAttributeValue.Id, pvavCopy.Id);

                    //localization
                    foreach (var lang in languages)
                    {
                        var name = productVariantAttributeValue.GetLocalized(x => x.Name, lang.Id, false, false);
                        if (!String.IsNullOrEmpty(name))
                        {
                            _localizedEntityService.SaveLocalizedValue(pvavCopy, x => x.Name, name, lang.Id);
                        }
                    }
                }
            }

            // attribute combinations
            foreach (var combination in _productAttributeService.GetAllProductVariantAttributeCombinations(product.Id))
            {
                //generate new AttributesXml according to new value IDs
                string newAttributesXml = "";
                var    parsedProductVariantAttributes = _productAttributeParser.ParseProductVariantAttributes(combination.AttributesXml);
                foreach (var oldPva in parsedProductVariantAttributes)
                {
                    if (associatedAttributes.ContainsKey(oldPva.Id))
                    {
                        int newPvaId = associatedAttributes[oldPva.Id];
                        var newPva   = _productAttributeService.GetProductVariantAttributeById(newPvaId);
                        if (newPva != null)
                        {
                            var oldPvaValuesStr = _productAttributeParser.ParseValues(combination.AttributesXml, oldPva.Id);
                            foreach (var oldPvaValueStr in oldPvaValuesStr)
                            {
                                if (newPva.ShouldHaveValues())
                                {
                                    //attribute values
                                    int oldPvaValue = int.Parse(oldPvaValueStr);
                                    if (associatedAttributeValues.ContainsKey(oldPvaValue))
                                    {
                                        int newPvavId = associatedAttributeValues[oldPvaValue];
                                        var newPvav   = _productAttributeService.GetProductVariantAttributeValueById(newPvavId);
                                        if (newPvav != null)
                                        {
                                            newAttributesXml = _productAttributeParser.AddProductAttribute(newAttributesXml,
                                                                                                           newPva, newPvav.Id.ToString());
                                        }
                                    }
                                }
                                else
                                {
                                    //just a text
                                    newAttributesXml = _productAttributeParser.AddProductAttribute(newAttributesXml,
                                                                                                   newPva, oldPvaValueStr);
                                }
                            }
                        }
                    }
                }
                var combinationCopy = new ProductVariantAttributeCombination()
                {
                    ProductId             = productCopy.Id,
                    AttributesXml         = newAttributesXml,
                    StockQuantity         = combination.StockQuantity,
                    AllowOutOfStockOrders = combination.AllowOutOfStockOrders,

                    // SmartStore extension
                    Sku  = combination.Sku,
                    Gtin = combination.Gtin,
                    ManufacturerPartNumber = combination.ManufacturerPartNumber,
                    Price = combination.Price,
                    AssignedPictureIds = copyImages ? combination.AssignedPictureIds : null,
                    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
                };
                _productAttributeService.InsertProductVariantAttributeCombination(combinationCopy);
            }

            // tier prices
            foreach (var tierPrice in product.TierPrices)
            {
                _productService.InsertTierPrice(
                    new TierPrice()
                {
                    ProductId      = productCopy.Id,
                    StoreId        = tierPrice.StoreId,
                    CustomerRoleId = tierPrice.CustomerRoleId,
                    Quantity       = tierPrice.Quantity,
                    Price          = tierPrice.Price
                });
            }

            // product <-> discounts mapping
            foreach (var discount in product.AppliedDiscounts)
            {
                productCopy.AppliedDiscounts.Add(discount);
                _productService.UpdateProduct(productCopy);
            }

            // update "HasTierPrices" and "HasDiscountsApplied" properties
            _productService.UpdateHasTierPricesProperty(productCopy);
            _productService.UpdateLowestAttributeCombinationPriceProperty(productCopy);
            _productService.UpdateHasDiscountsApplied(productCopy);

            // associated products
            if (copyAssociatedProducts && product.ProductType != ProductType.BundledProduct)
            {
                var searchContext = new ProductSearchContext()
                {
                    ParentGroupedProductId = product.Id,
                    PageSize   = int.MaxValue,
                    ShowHidden = true
                };

                string copyOf             = _localizationService.GetResource("Admin.Common.CopyOf");
                var    associatedProducts = _productService.SearchProducts(searchContext);

                foreach (var associatedProduct in associatedProducts)
                {
                    var associatedProductCopy = CopyProduct(associatedProduct, string.Format("{0} {1}", copyOf, associatedProduct.Name), isPublished, copyImages, false);
                    associatedProductCopy.ParentGroupedProductId = productCopy.Id;

                    _productService.UpdateProduct(productCopy);
                }
            }

            // bundled products
            var bundledItems = _productService.GetBundleItems(product.Id, true);

            foreach (var bundleItem in bundledItems)
            {
                var newBundleItem = bundleItem.Item.Clone();
                newBundleItem.BundleProductId = productCopy.Id;
                newBundleItem.CreatedOnUtc    = utcNow;
                newBundleItem.UpdatedOnUtc    = utcNow;

                _productService.InsertBundleItem(newBundleItem);

                foreach (var itemFilter in bundleItem.Item.AttributeFilters)
                {
                    var newItemFilter = itemFilter.Clone();
                    newItemFilter.BundleItemId = newBundleItem.Id;

                    _productAttributeService.InsertProductBundleItemAttributeFilter(newItemFilter);
                }
            }

            return(productCopy);
        }
コード例 #25
0
        public IQueryable <ProductVariantAttribute> ManageAttributes(int key, ODataActionParameters parameters)
        {
            var entity = GetExpandedEntity(key, x => x.ProductVariantAttributes);
            var result = new List <ProductVariantAttributeValue>();

            this.ProcessEntity(() =>
            {
                var synchronize = parameters.GetValueSafe <bool>("Synchronize");
                var data        = (parameters["Attributes"] as IEnumerable <ManageAttributeType>)
                                  .Where(x => x.Name.HasValue())
                                  .ToList();

                var attributeNames  = new HashSet <string>(data.Select(x => x.Name), StringComparer.InvariantCultureIgnoreCase);
                var pagedAttributes = _productAttributeService.Value.GetAllProductAttributes(0, 1);
                var attributesData  = pagedAttributes.SourceQuery
                                      .Where(x => attributeNames.Contains(x.Name))
                                      .Select(x => new { x.Id, x.Name })
                                      .ToList();
                var allAttributesDic = attributesData.ToDictionarySafe(x => x.Name, x => x, StringComparer.OrdinalIgnoreCase);

                foreach (var srcAttr in data)
                {
                    var attributeId = 0;
                    if (allAttributesDic.TryGetValue(srcAttr.Name, out var attributeData))
                    {
                        attributeId = attributeData.Id;
                    }
                    else
                    {
                        var attribute = new ProductAttribute {
                            Name = srcAttr.Name
                        };
                        _productAttributeService.Value.InsertProductAttribute(attribute);
                        attributeId = attribute.Id;
                    }

                    var productAttribute = entity.ProductVariantAttributes.FirstOrDefault(x => x.ProductAttribute.Name.IsCaseInsensitiveEqual(srcAttr.Name));
                    if (productAttribute == null)
                    {
                        productAttribute = new ProductVariantAttribute
                        {
                            ProductId              = entity.Id,
                            ProductAttributeId     = attributeId,
                            AttributeControlTypeId = srcAttr.ControlTypeId,
                            DisplayOrder           = entity.ProductVariantAttributes.OrderByDescending(x => x.DisplayOrder).Select(x => x.DisplayOrder).FirstOrDefault() + 1,
                            IsRequired             = srcAttr.IsRequired
                        };

                        entity.ProductVariantAttributes.Add(productAttribute);
                        Service.UpdateProduct(entity);
                    }
                    else if (synchronize)
                    {
                        if (srcAttr.Values.Count <= 0 && productAttribute.ShouldHaveValues())
                        {
                            _productAttributeService.Value.DeleteProductVariantAttribute(productAttribute);
                        }
                        else
                        {
                            productAttribute.AttributeControlTypeId = srcAttr.ControlTypeId;
                            productAttribute.IsRequired             = srcAttr.IsRequired;

                            Service.UpdateProduct(entity);
                        }
                    }

                    var maxDisplayOrder = productAttribute.ProductVariantAttributeValues
                                          .OrderByDescending(x => x.DisplayOrder)
                                          .Select(x => x.DisplayOrder)
                                          .FirstOrDefault();

                    foreach (var srcVal in srcAttr.Values.Where(x => x.Name.HasValue()))
                    {
                        var value = productAttribute.ProductVariantAttributeValues.FirstOrDefault(x => x.Name.IsCaseInsensitiveEqual(srcVal.Name));
                        if (value == null)
                        {
                            value = new ProductVariantAttributeValue
                            {
                                ProductVariantAttributeId = productAttribute.Id,
                                Name             = srcVal.Name,
                                Alias            = srcVal.Alias,
                                Color            = srcVal.Color,
                                PriceAdjustment  = srcVal.PriceAdjustment,
                                WeightAdjustment = srcVal.WeightAdjustment,
                                IsPreSelected    = srcVal.IsPreSelected,
                                DisplayOrder     = ++maxDisplayOrder
                            };

                            productAttribute.ProductVariantAttributeValues.Add(value);
                            Service.UpdateProduct(entity);
                        }
                        else if (synchronize)
                        {
                            value.Alias            = srcVal.Alias;
                            value.Color            = srcVal.Color;
                            value.PriceAdjustment  = srcVal.PriceAdjustment;
                            value.WeightAdjustment = srcVal.WeightAdjustment;
                            value.IsPreSelected    = srcVal.IsPreSelected;

                            Service.UpdateProduct(entity);
                        }
                    }

                    if (synchronize)
                    {
                        foreach (var dstVal in productAttribute.ProductVariantAttributeValues.ToList())
                        {
                            if (!srcAttr.Values.Any(x => x.Name.IsCaseInsensitiveEqual(dstVal.Name)))
                            {
                                _productAttributeService.Value.DeleteProductVariantAttributeValue(dstVal);
                            }
                        }
                    }
                }
            });

            return(entity.ProductVariantAttributes.AsQueryable());
        }
コード例 #26
0
        public IQueryable <ProductVariantAttribute> ManageAttributes(int key, ODataActionParameters parameters)
        {
            var entity = GetExpandedEntity <ICollection <ProductVariantAttribute> >(key, x => x.ProductVariantAttributes);
            var result = new List <ProductVariantAttributeValue>();

            this.ProcessEntity(() =>
            {
                bool synchronize = Convert.ToBoolean(parameters["Synchronize"]);
                var data         = (parameters["Attributes"] as IEnumerable <ManageAttributeType>).Where(x => x.Name.HasValue()).ToList();

                var allAttributes = _productAttributeService.Value.GetAllProductAttributes();

                foreach (var srcAttr in data)
                {
                    var productAttribute = allAttributes.FirstOrDefault(x => x.Name.IsCaseInsensitiveEqual(srcAttr.Name));

                    if (productAttribute == null)
                    {
                        productAttribute = new ProductAttribute()
                        {
                            Name = srcAttr.Name
                        };
                        _productAttributeService.Value.InsertProductAttribute(productAttribute);
                    }

                    var attribute = entity.ProductVariantAttributes.FirstOrDefault(x => x.ProductAttribute.Name.IsCaseInsensitiveEqual(srcAttr.Name));

                    if (attribute == null)
                    {
                        attribute = new ProductVariantAttribute()
                        {
                            ProductId              = entity.Id,
                            ProductAttributeId     = productAttribute.Id,
                            AttributeControlTypeId = srcAttr.ControlTypeId,
                            DisplayOrder           = entity.ProductVariantAttributes.OrderByDescending(x => x.DisplayOrder).Select(x => x.DisplayOrder).FirstOrDefault() + 1,
                            IsRequired             = srcAttr.IsRequired
                        };

                        entity.ProductVariantAttributes.Add(attribute);
                        Service.UpdateProduct(entity);
                    }
                    else if (synchronize)
                    {
                        if (srcAttr.Values.Count <= 0)
                        {
                            _productAttributeService.Value.DeleteProductVariantAttribute(attribute);
                        }
                        else
                        {
                            attribute.AttributeControlTypeId = srcAttr.ControlTypeId;
                            attribute.IsRequired             = srcAttr.IsRequired;

                            Service.UpdateProduct(entity);
                        }
                    }

                    int maxDisplayOrder = attribute.ProductVariantAttributeValues.OrderByDescending(x => x.DisplayOrder).Select(x => x.DisplayOrder).FirstOrDefault();

                    foreach (var srcVal in srcAttr.Values.Where(x => x.Name.HasValue()))
                    {
                        var value = attribute.ProductVariantAttributeValues.FirstOrDefault(x => x.Name.IsCaseInsensitiveEqual(srcVal.Name));

                        if (value == null)
                        {
                            value = new ProductVariantAttributeValue()
                            {
                                ProductVariantAttributeId = attribute.Id,
                                Name             = srcVal.Name,
                                Alias            = srcVal.Alias,
                                Color            = srcVal.ColorSquaresRgb,
                                PriceAdjustment  = srcVal.PriceAdjustment,
                                WeightAdjustment = srcVal.WeightAdjustment,
                                IsPreSelected    = srcVal.IsPreSelected,
                                DisplayOrder     = ++maxDisplayOrder
                            };

                            attribute.ProductVariantAttributeValues.Add(value);
                            Service.UpdateProduct(entity);
                        }
                        else if (synchronize)
                        {
                            value.Alias            = srcVal.Alias;
                            value.Color            = srcVal.ColorSquaresRgb;
                            value.PriceAdjustment  = srcVal.PriceAdjustment;
                            value.WeightAdjustment = srcVal.WeightAdjustment;
                            value.IsPreSelected    = srcVal.IsPreSelected;

                            Service.UpdateProduct(entity);
                        }
                    }

                    if (synchronize)
                    {
                        foreach (var dstVal in attribute.ProductVariantAttributeValues.ToList())
                        {
                            if (!srcAttr.Values.Any(x => x.Name.IsCaseInsensitiveEqual(dstVal.Name)))
                            {
                                _productAttributeService.Value.DeleteProductVariantAttributeValue(dstVal);
                            }
                        }
                    }
                }
                //return null;
            });

            return(entity.ProductVariantAttributes.AsQueryable());
        }
コード例 #27
0
        public virtual int CopyAttributeOptions(ProductVariantAttribute productVariantAttribute, int productAttributeOptionsSetId, bool deleteExistingValues)
        {
            Guard.NotNull(productVariantAttribute, nameof(productVariantAttribute));
            Guard.NotZero(productVariantAttribute.Id, nameof(productVariantAttribute.Id));
            Guard.NotZero(productAttributeOptionsSetId, nameof(productAttributeOptionsSetId));

            if (deleteExistingValues)
            {
                var existingValues = productVariantAttribute.ProductVariantAttributeValues.ToList();
                if (!existingValues.Any())
                {
                    existingValues = GetProductVariantAttributeValues(productVariantAttribute.Id).ToList();
                }

                existingValues.Each(x => DeleteProductVariantAttributeValue(x));
            }

            var result           = 0;
            var attributeOptions = _productAttributeOptionRepository.TableUntracked
                                   .Where(x => x.ProductAttributeOptionsSetId == productAttributeOptionsSetId)
                                   .ToList();

            if (!attributeOptions.Any())
            {
                return(result);
            }

            // Do not insert already existing values (identified by name field).
            var existingValueNames = new HashSet <string>(_productVariantAttributeValueRepository.TableUntracked
                                                          .Where(x => x.ProductVariantAttributeId == productVariantAttribute.Id)
                                                          .Select(x => x.Name)
                                                          .ToList());

            Picture picture = null;
            ProductVariantAttributeValue productVariantAttributeValue = null;
            var pictureIds = attributeOptions.Where(x => x.PictureId != 0).Select(x => x.PictureId).Distinct().ToArray();
            var pictures   = _pictureService.GetPicturesByIds(pictureIds, true).ToDictionarySafe(x => x.Id);

            using (_localizedEntityService.BeginScope())
            {
                foreach (var option in attributeOptions)
                {
                    if (existingValueNames.Contains(option.Name))
                    {
                        continue;
                    }

                    productVariantAttributeValue           = option.Clone();
                    productVariantAttributeValue.PictureId = 0;
                    productVariantAttributeValue.ProductVariantAttributeId = productVariantAttribute.Id;

                    // Copy picture.
                    if (option.PictureId != 0 && pictures.TryGetValue(option.PictureId, out picture))
                    {
                        var pictureBinary = _pictureService.LoadPictureBinary(picture);

                        var newPicture = _pictureService.InsertPicture(
                            pictureBinary,
                            picture.MimeType,
                            picture.SeoFilename,
                            picture.IsNew,
                            picture.Width ?? 0,
                            picture.Height ?? 0,
                            picture.IsTransient
                            );

                        productVariantAttributeValue.PictureId = newPicture.Id;
                    }

                    // No scope commit, we need new entity id.
                    _productVariantAttributeValueRepository.Insert(productVariantAttributeValue);
                    ++result;

                    // Copy localized properties too.
                    var optionProperties = _localizedEntityService.GetLocalizedProperties(option.Id, "ProductAttributeOption");

                    foreach (var property in optionProperties)
                    {
                        _localizedEntityService.InsertLocalizedProperty(new LocalizedProperty
                        {
                            EntityId       = productVariantAttributeValue.Id,
                            LocaleKeyGroup = "ProductVariantAttributeValue",
                            LocaleKey      = property.LocaleKey,
                            LocaleValue    = property.LocaleValue,
                            LanguageId     = property.LanguageId
                        });
                    }
                }
            }

            return(result);
        }
コード例 #28
0
        public new void SetUp()
        {
            #region Test data

            //color (dropdownlist)
            pa1 = new ProductAttribute
            {
                Id   = 1,
                Name = "Color",
            };
            pva1_1 = new ProductVariantAttribute
            {
                Id                   = 11,
                ProductId            = 1,
                TextPrompt           = "Select color:",
                IsRequired           = true,
                AttributeControlType = AttributeControlType.DropdownList,
                DisplayOrder         = 1,
                ProductAttribute     = pa1,
                ProductAttributeId   = pa1.Id
            };
            pvav1_1 = new ProductVariantAttributeValue
            {
                Id                        = 11,
                Name                      = "Green",
                DisplayOrder              = 1,
                ProductVariantAttribute   = pva1_1,
                ProductVariantAttributeId = pva1_1.Id
            };
            pvav1_2 = new ProductVariantAttributeValue
            {
                Id                        = 12,
                Name                      = "Red",
                DisplayOrder              = 2,
                ProductVariantAttribute   = pva1_1,
                ProductVariantAttributeId = pva1_1.Id
            };
            pva1_1.ProductVariantAttributeValues.Add(pvav1_1);
            pva1_1.ProductVariantAttributeValues.Add(pvav1_2);

            //custom option (checkboxes)
            pa2 = new ProductAttribute
            {
                Id   = 2,
                Name = "Some custom option",
            };
            pva2_1 = new ProductVariantAttribute
            {
                Id                   = 21,
                ProductId            = 1,
                TextPrompt           = "Select at least one option:",
                IsRequired           = true,
                AttributeControlType = AttributeControlType.Checkboxes,
                DisplayOrder         = 2,
                ProductAttribute     = pa2,
                ProductAttributeId   = pa2.Id
            };
            pvav2_1 = new ProductVariantAttributeValue
            {
                Id                        = 21,
                Name                      = "Option 1",
                DisplayOrder              = 1,
                ProductVariantAttribute   = pva2_1,
                ProductVariantAttributeId = pva2_1.Id
            };
            pvav2_2 = new ProductVariantAttributeValue
            {
                Id                        = 22,
                Name                      = "Option 2",
                DisplayOrder              = 2,
                ProductVariantAttribute   = pva2_1,
                ProductVariantAttributeId = pva2_1.Id
            };
            pva2_1.ProductVariantAttributeValues.Add(pvav2_1);
            pva2_1.ProductVariantAttributeValues.Add(pvav2_2);

            //custom text
            pa3 = new ProductAttribute
            {
                Id   = 3,
                Name = "Custom text",
            };
            pva3_1 = new ProductVariantAttribute
            {
                Id                   = 31,
                ProductId            = 1,
                TextPrompt           = "Enter custom text:",
                IsRequired           = true,
                AttributeControlType = AttributeControlType.TextBox,
                DisplayOrder         = 1,
                ProductAttribute     = pa1,
                ProductAttributeId   = pa3.Id
            };


            #endregion

            _productAttributeRepo = MockRepository.GenerateMock <IRepository <ProductAttribute> >();
            _productAttributeRepo.Expect(x => x.Table).Return(new List <ProductAttribute>()
            {
                pa1, pa2, pa3
            }.AsQueryable());
            _productAttributeRepo.Expect(x => x.GetById(pa1.Id)).Return(pa1);
            _productAttributeRepo.Expect(x => x.GetById(pa2.Id)).Return(pa2);
            _productAttributeRepo.Expect(x => x.GetById(pa3.Id)).Return(pa3);

            _productVariantAttributeRepo = MockRepository.GenerateMock <IRepository <ProductVariantAttribute> >();
            _productVariantAttributeRepo.Expect(x => x.Table).Return(new List <ProductVariantAttribute>()
            {
                pva1_1, pva2_1, pva3_1
            }.AsQueryable());
            _productVariantAttributeRepo.Expect(x => x.GetById(pva1_1.Id)).Return(pva1_1);
            _productVariantAttributeRepo.Expect(x => x.GetById(pva2_1.Id)).Return(pva2_1);
            _productVariantAttributeRepo.Expect(x => x.GetById(pva3_1.Id)).Return(pva3_1);

            _productVariantAttributeCombinationRepo = MockRepository.GenerateMock <IRepository <ProductVariantAttributeCombination> >();
            _productVariantAttributeCombinationRepo.Expect(x => x.Table).Return(new List <ProductVariantAttributeCombination>().AsQueryable());

            _productVariantAttributeValueRepo = MockRepository.GenerateMock <IRepository <ProductVariantAttributeValue> >();
            _productVariantAttributeValueRepo.Expect(x => x.Table).Return(new List <ProductVariantAttributeValue>()
            {
                pvav1_1, pvav1_2, pvav2_1, pvav2_2
            }.AsQueryable());
            _productVariantAttributeValueRepo.Expect(x => x.GetById(pvav1_1.Id)).Return(pvav1_1);
            _productVariantAttributeValueRepo.Expect(x => x.GetById(pvav1_2.Id)).Return(pvav1_2);
            _productVariantAttributeValueRepo.Expect(x => x.GetById(pvav2_1.Id)).Return(pvav2_1);
            _productVariantAttributeValueRepo.Expect(x => x.GetById(pvav2_2.Id)).Return(pvav2_2);

            _productBundleItemAttributeFilter = MockRepository.GenerateMock <IRepository <ProductBundleItemAttributeFilter> >();

            _eventPublisher = MockRepository.GenerateMock <IEventPublisher>();
            _eventPublisher.Expect(x => x.Publish(Arg <object> .Is.Anything));

            _pictureService = MockRepository.GenerateMock <IPictureService>();

            var cacheManager = new NullCache();

            _productAttributeService = new ProductAttributeService(cacheManager,
                                                                   _productAttributeRepo,
                                                                   _productVariantAttributeRepo,
                                                                   _productVariantAttributeCombinationRepo,
                                                                   _productVariantAttributeValueRepo,
                                                                   _productBundleItemAttributeFilter,
                                                                   _eventPublisher,
                                                                   _pictureService);

            _productAttributeParser = new ProductAttributeParser(_productAttributeService, new MemoryRepository <ProductVariantAttributeCombination>(), NullCache.Instance);



            var workingLanguage = new Language();
            _workContext = MockRepository.GenerateMock <IWorkContext>();
            _workContext.Expect(x => x.WorkingLanguage).Return(workingLanguage);
            _currencyService     = MockRepository.GenerateMock <ICurrencyService>();
            _localizationService = MockRepository.GenerateMock <ILocalizationService>();
            _localizationService.Expect(x => x.GetResource("GiftCardAttribute.For.Virtual")).Return("For: {0} <{1}>");
            _localizationService.Expect(x => x.GetResource("GiftCardAttribute.From.Virtual")).Return("From: {0} <{1}>");
            _localizationService.Expect(x => x.GetResource("GiftCardAttribute.For.Physical")).Return("For: {0}");
            _localizationService.Expect(x => x.GetResource("GiftCardAttribute.From.Physical")).Return("From: {0}");
            _taxService              = MockRepository.GenerateMock <ITaxService>();
            _priceFormatter          = MockRepository.GenerateMock <IPriceFormatter>();
            _downloadService         = MockRepository.GenerateMock <IDownloadService>();
            _webHelper               = MockRepository.GenerateMock <IWebHelper>();
            _priceCalculationService = MockRepository.GenerateMock <IPriceCalculationService>();
            _shoppingCartSettings    = MockRepository.GenerateMock <ShoppingCartSettings>();

            _productAttributeFormatter = new ProductAttributeFormatter(_workContext,
                                                                       _productAttributeService,
                                                                       _productAttributeParser,
                                                                       _priceCalculationService,
                                                                       _currencyService,
                                                                       _localizationService,
                                                                       _taxService,
                                                                       _priceFormatter,
                                                                       _downloadService,
                                                                       _webHelper,
                                                                       _shoppingCartSettings);
        }
コード例 #29
0
        /// <summary>
        /// Create a copy of product variant with all depended data
        /// </summary>
        /// <param name="productVariant">The product variant to copy</param>
        /// <param name="productId">The product identifier</param>
        /// <param name="newName">The name of product variant duplicate</param>
        /// <param name="isPublished">A value indicating whether the product variant duplicate should be published</param>
        /// <param name="copyImage">A value indicating whether the product variant image should be copied</param>
        /// <returns>Product variant copy</returns>
        public virtual ProductVariant CopyProductVariant(ProductVariant productVariant, int productId,
                                                         string newName, bool isPublished, bool copyImage)
        {
            if (productVariant == null)
            {
                throw new ArgumentNullException("productVariant");
            }

            var languages = _languageService.GetAllLanguages(true);

            // product variant picture
            int pictureId = 0;

            if (copyImage)
            {
                var picture = _pictureService.GetPictureById(productVariant.PictureId);
                if (picture != null)
                {
                    var pictureCopy = _pictureService.InsertPicture(
                        _pictureService.LoadPictureBinary(picture),
                        picture.MimeType,
                        _pictureService.GetPictureSeName(productVariant.Name),
                        true);
                    pictureId = pictureCopy.Id;
                }
            }

            // product variant download & sample download
            int downloadId       = productVariant.DownloadId;
            int sampleDownloadId = productVariant.SampleDownloadId;

            if (productVariant.IsDownload)
            {
                var download = _downloadService.GetDownloadById(productVariant.DownloadId);
                if (download != null)
                {
                    var downloadCopy = new Download()
                    {
                        DownloadGuid   = Guid.NewGuid(),
                        UseDownloadUrl = download.UseDownloadUrl,
                        DownloadUrl    = download.DownloadUrl,
                        DownloadBinary = download.DownloadBinary,
                        ContentType    = download.ContentType,
                        Filename       = download.Filename,
                        Extension      = download.Extension,
                        IsNew          = download.IsNew,
                    };
                    _downloadService.InsertDownload(downloadCopy);
                    downloadId = downloadCopy.Id;
                }

                if (productVariant.HasSampleDownload)
                {
                    var sampleDownload = _downloadService.GetDownloadById(productVariant.SampleDownloadId);
                    if (sampleDownload != null)
                    {
                        var sampleDownloadCopy = new Download()
                        {
                            DownloadGuid   = Guid.NewGuid(),
                            UseDownloadUrl = sampleDownload.UseDownloadUrl,
                            DownloadUrl    = sampleDownload.DownloadUrl,
                            DownloadBinary = sampleDownload.DownloadBinary,
                            ContentType    = sampleDownload.ContentType,
                            Filename       = sampleDownload.Filename,
                            Extension      = sampleDownload.Extension,
                            IsNew          = sampleDownload.IsNew
                        };
                        _downloadService.InsertDownload(sampleDownloadCopy);
                        sampleDownloadId = sampleDownloadCopy.Id;
                    }
                }
            }

            // product variant
            var productVariantCopy = new ProductVariant()
            {
                ProductId                 = productId,
                Name                      = newName,
                Sku                       = productVariant.Sku,
                Description               = productVariant.Description,
                AdminComment              = productVariant.AdminComment,
                ManufacturerPartNumber    = productVariant.ManufacturerPartNumber,
                Gtin                      = productVariant.Gtin,
                IsGiftCard                = productVariant.IsGiftCard,
                GiftCardType              = productVariant.GiftCardType,
                RequireOtherProducts      = productVariant.RequireOtherProducts,
                RequiredProductVariantIds = productVariant.RequiredProductVariantIds,
                AutomaticallyAddRequiredProductVariants = productVariant.AutomaticallyAddRequiredProductVariants,
                IsDownload                    = productVariant.IsDownload,
                DownloadId                    = downloadId,
                UnlimitedDownloads            = productVariant.UnlimitedDownloads,
                MaxNumberOfDownloads          = productVariant.MaxNumberOfDownloads,
                DownloadExpirationDays        = productVariant.DownloadExpirationDays,
                DownloadActivationType        = productVariant.DownloadActivationType,
                HasSampleDownload             = productVariant.HasSampleDownload,
                SampleDownloadId              = sampleDownloadId,
                HasUserAgreement              = productVariant.HasUserAgreement,
                UserAgreementText             = productVariant.UserAgreementText,
                IsRecurring                   = productVariant.IsRecurring,
                RecurringCycleLength          = productVariant.RecurringCycleLength,
                RecurringCyclePeriod          = productVariant.RecurringCyclePeriod,
                RecurringTotalCycles          = productVariant.RecurringTotalCycles,
                IsShipEnabled                 = productVariant.IsShipEnabled,
                IsFreeShipping                = productVariant.IsFreeShipping,
                AdditionalShippingCharge      = productVariant.AdditionalShippingCharge,
                IsTaxExempt                   = productVariant.IsTaxExempt,
                TaxCategoryId                 = productVariant.TaxCategoryId,
                ManageInventoryMethod         = productVariant.ManageInventoryMethod,
                StockQuantity                 = productVariant.StockQuantity,
                DisplayStockAvailability      = productVariant.DisplayStockAvailability,
                DisplayStockQuantity          = productVariant.DisplayStockQuantity,
                MinStockQuantity              = productVariant.MinStockQuantity,
                LowStockActivityId            = productVariant.LowStockActivityId,
                NotifyAdminForQuantityBelow   = productVariant.NotifyAdminForQuantityBelow,
                BackorderMode                 = productVariant.BackorderMode,
                AllowBackInStockSubscriptions = productVariant.AllowBackInStockSubscriptions,
                OrderMinimumQuantity          = productVariant.OrderMinimumQuantity,
                OrderMaximumQuantity          = productVariant.OrderMaximumQuantity,
                AllowedQuantities             = productVariant.AllowedQuantities,
                DisableBuyButton              = productVariant.DisableBuyButton,
                DisableWishlistButton         = productVariant.DisableWishlistButton,
                CallForPrice                  = productVariant.CallForPrice,
                Price        = productVariant.Price,
                OldPrice     = productVariant.OldPrice,
                ProductCost  = productVariant.ProductCost,
                SpecialPrice = productVariant.SpecialPrice,
                SpecialPriceStartDateTimeUtc = productVariant.SpecialPriceStartDateTimeUtc,
                SpecialPriceEndDateTimeUtc   = productVariant.SpecialPriceEndDateTimeUtc,
                CustomerEntersPrice          = productVariant.CustomerEntersPrice,
                MinimumCustomerEnteredPrice  = productVariant.MinimumCustomerEnteredPrice,
                MaximumCustomerEnteredPrice  = productVariant.MaximumCustomerEnteredPrice,
                Weight    = productVariant.Weight,
                Length    = productVariant.Length,
                Width     = productVariant.Width,
                Height    = productVariant.Height,
                PictureId = pictureId,
                AvailableStartDateTimeUtc = productVariant.AvailableStartDateTimeUtc,
                AvailableEndDateTimeUtc   = productVariant.AvailableEndDateTimeUtc,
                Published    = isPublished,
                Deleted      = productVariant.Deleted,
                DisplayOrder = productVariant.DisplayOrder,
                CreatedOnUtc = DateTime.UtcNow,
                UpdatedOnUtc = DateTime.UtcNow
            };

            _productService.InsertProductVariant(productVariantCopy);

            //localization
            foreach (var lang in languages)
            {
                var name = productVariant.GetLocalized(x => x.Name, lang.Id, false, false);
                if (!String.IsNullOrEmpty(name))
                {
                    _localizedEntityService.SaveLocalizedValue(productVariantCopy, x => x.Name, name, lang.Id);
                }

                var description = productVariant.GetLocalized(x => x.Description, lang.Id, false, false);
                if (!String.IsNullOrEmpty(description))
                {
                    _localizedEntityService.SaveLocalizedValue(productVariantCopy, x => x.Description, description, lang.Id);
                }
            }

            // product variant <-> attributes mappings
            var associatedAttributes      = new Dictionary <int, int>();
            var associatedAttributeValues = new Dictionary <int, int>();

            foreach (var productVariantAttribute in _productAttributeService.GetProductVariantAttributesByProductVariantId(productVariant.Id))
            {
                var productVariantAttributeCopy = new ProductVariantAttribute()
                {
                    ProductVariantId       = productVariantCopy.Id,
                    ProductAttributeId     = productVariantAttribute.ProductAttributeId,
                    TextPrompt             = productVariantAttribute.TextPrompt,
                    IsRequired             = productVariantAttribute.IsRequired,
                    AttributeControlTypeId = productVariantAttribute.AttributeControlTypeId,
                    DisplayOrder           = productVariantAttribute.DisplayOrder
                };
                _productAttributeService.InsertProductVariantAttribute(productVariantAttributeCopy);
                //save associated value (used for combinations copying)
                associatedAttributes.Add(productVariantAttribute.Id, productVariantAttributeCopy.Id);

                // product variant attribute values
                var productVariantAttributeValues = _productAttributeService.GetProductVariantAttributeValues(productVariantAttribute.Id);
                foreach (var productVariantAttributeValue in productVariantAttributeValues)
                {
                    var pvavCopy = new ProductVariantAttributeValue()
                    {
                        ProductVariantAttributeId = productVariantAttributeCopy.Id,
                        Name             = productVariantAttributeValue.Name,
                        PriceAdjustment  = productVariantAttributeValue.PriceAdjustment,
                        WeightAdjustment = productVariantAttributeValue.WeightAdjustment,
                        IsPreSelected    = productVariantAttributeValue.IsPreSelected,
                        DisplayOrder     = productVariantAttributeValue.DisplayOrder
                    };
                    _productAttributeService.InsertProductVariantAttributeValue(pvavCopy);

                    //save associated value (used for combinations copying)
                    associatedAttributeValues.Add(productVariantAttributeValue.Id, pvavCopy.Id);

                    //localization
                    foreach (var lang in languages)
                    {
                        var name = productVariantAttributeValue.GetLocalized(x => x.Name, lang.Id, false, false);
                        if (!String.IsNullOrEmpty(name))
                        {
                            _localizedEntityService.SaveLocalizedValue(pvavCopy, x => x.Name, name, lang.Id);
                        }
                    }
                }
            }
            foreach (var combination in _productAttributeService.GetAllProductVariantAttributeCombinations(productVariant.Id))
            {
                //generate new AttributesXml according to new value IDs
                string newAttributesXml = "";
                var    parsedProductVariantAttributes = _productAttributeParser.ParseProductVariantAttributes(combination.AttributesXml);
                foreach (var oldPva in parsedProductVariantAttributes)
                {
                    if (associatedAttributes.ContainsKey(oldPva.Id))
                    {
                        int newPvaId = associatedAttributes[oldPva.Id];
                        var newPva   = _productAttributeService.GetProductVariantAttributeById(newPvaId);
                        if (newPva != null)
                        {
                            var oldPvaValuesStr = _productAttributeParser.ParseValues(combination.AttributesXml, oldPva.Id);
                            foreach (var oldPvaValueStr in oldPvaValuesStr)
                            {
                                if (newPva.ShouldHaveValues())
                                {
                                    //attribute values
                                    int oldPvaValue = int.Parse(oldPvaValueStr);
                                    if (associatedAttributeValues.ContainsKey(oldPvaValue))
                                    {
                                        int newPvavId = associatedAttributeValues[oldPvaValue];
                                        var newPvav   = _productAttributeService.GetProductVariantAttributeValueById(newPvavId);
                                        if (newPvav != null)
                                        {
                                            newAttributesXml = _productAttributeParser.AddProductAttribute(newAttributesXml,
                                                                                                           newPva, newPvav.Id.ToString());
                                        }
                                    }
                                }
                                else
                                {
                                    //just a text
                                    newAttributesXml = _productAttributeParser.AddProductAttribute(newAttributesXml,
                                                                                                   newPva, oldPvaValueStr);
                                }
                            }
                        }
                    }
                }
                var combinationCopy = new ProductVariantAttributeCombination()
                {
                    ProductVariantId      = productVariantCopy.Id,
                    AttributesXml         = newAttributesXml,
                    StockQuantity         = combination.StockQuantity,
                    AllowOutOfStockOrders = combination.AllowOutOfStockOrders,
                    Sku = combination.Sku,
                    ManufacturerPartNumber = combination.ManufacturerPartNumber,
                    Gtin = combination.Gtin
                };
                _productAttributeService.InsertProductVariantAttributeCombination(combinationCopy);
            }

            // product variant tier prices
            foreach (var tierPrice in productVariant.TierPrices)
            {
                _productService.InsertTierPrice(
                    new TierPrice()
                {
                    ProductVariantId = productVariantCopy.Id,
                    CustomerRoleId   = tierPrice.CustomerRoleId,
                    Quantity         = tierPrice.Quantity,
                    Price            = tierPrice.Price
                });
            }

            // product variant <-> discounts mapping
            foreach (var discount in productVariant.AppliedDiscounts)
            {
                productVariantCopy.AppliedDiscounts.Add(discount);
                _productService.UpdateProductVariant(productVariantCopy);
            }


            //update "HasTierPrices" and "HasDiscountsApplied" properties
            _productService.UpdateHasTierPricesProperty(productVariantCopy);
            _productService.UpdateHasDiscountsApplied(productVariantCopy);


            return(productVariantCopy);
        }
コード例 #30
0
        private void ProcessAttributes(Product product, Product clone, IEnumerable <Language> languages)
        {
            using (var scope = new DbContextScope(lazyLoading: false, forceNoTracking: false))
            {
                scope.LoadCollection(product, (Product p) => p.ProductVariantAttributes);
                scope.LoadCollection(product, (Product p) => p.ProductVariantAttributeCombinations);
            }

            // Former attribute id > clone.
            var pvaMap = new Dictionary <int, ProductVariantAttribute>();
            // Former attribute value id > clone.
            var pvavMap = new Dictionary <int, ProductVariantAttributeValue>();

            // Product attributes.
            foreach (var pva in product.ProductVariantAttributes)
            {
                var pvaClone = new ProductVariantAttribute
                {
                    ProductId              = clone.Id,
                    ProductAttributeId     = pva.ProductAttributeId,
                    TextPrompt             = pva.TextPrompt,
                    IsRequired             = pva.IsRequired,
                    AttributeControlTypeId = pva.AttributeControlTypeId,
                    DisplayOrder           = pva.DisplayOrder
                };
                _productAttributeService.InsertProductVariantAttribute(pvaClone);

                // Save associated value (used for combinations copying).
                pvaMap[pva.Id] = pvaClone;
            }

            // >>>>>> Commit attributes.
            Commit();

            // Product variant attribute values.
            foreach (var pva in product.ProductVariantAttributes)
            {
                var pvaClone = pvaMap[pva.Id];
                foreach (var pvav in pva.ProductVariantAttributeValues)
                {
                    var pvavClone = new ProductVariantAttributeValue
                    {
                        ProductVariantAttributeId = pvaClone.Id,
                        Name             = pvav.Name,
                        Color            = pvav.Color,
                        PriceAdjustment  = pvav.PriceAdjustment,
                        WeightAdjustment = pvav.WeightAdjustment,
                        IsPreSelected    = pvav.IsPreSelected,
                        DisplayOrder     = pvav.DisplayOrder,
                        ValueTypeId      = pvav.ValueTypeId,
                        LinkedProductId  = pvav.LinkedProductId,
                        Quantity         = pvav.Quantity,
                        MediaFileId      = pvav.MediaFileId
                    };

                    _productAttributeService.InsertProductVariantAttributeValue(pvavClone);

                    // Save associated value (used for combinations copying)
                    pvavMap.Add(pvav.Id, pvavClone);
                }
            }

            // >>>>>> Commit attribute values.
            Commit();

            // Attribute value localization.
            foreach (var pvav in product.ProductVariantAttributes.SelectMany(x => x.ProductVariantAttributeValues).ToArray())
            {
                foreach (var lang in languages)
                {
                    var name = pvav.GetLocalized(x => x.Name, lang, false, false);
                    if (!string.IsNullOrEmpty(name))
                    {
                        var pvavClone = pvavMap.Get(pvav.Id);
                        if (pvavClone != null)
                        {
                            _localizedEntityService.SaveLocalizedValue(pvavClone, x => x.Name, name, lang.Id);
                        }
                    }
                }
            }

            // Attribute combinations.
            foreach (var combination in product.ProductVariantAttributeCombinations)
            {
                // Generate new AttributesXml according to new value IDs.
                string newAttributesXml = "";
                var    parsedProductVariantAttributes = _productAttributeParser.ParseProductVariantAttributes(combination.AttributesXml);
                foreach (var oldPva in parsedProductVariantAttributes)
                {
                    if (!pvaMap.ContainsKey(oldPva.Id))
                    {
                        continue;
                    }

                    var newPva = pvaMap.Get(oldPva.Id);

                    if (newPva == null)
                    {
                        continue;
                    }

                    var oldPvaValuesStr = _productAttributeParser.ParseValues(combination.AttributesXml, oldPva.Id);
                    foreach (var oldPvaValueStr in oldPvaValuesStr)
                    {
                        if (newPva.ShouldHaveValues())
                        {
                            var oldPvaValue = oldPvaValueStr.ToInt();
                            if (pvavMap.ContainsKey(oldPvaValue))
                            {
                                var newPvav = pvavMap.Get(oldPvaValue);
                                if (newPvav != null)
                                {
                                    newAttributesXml = _productAttributeParser.AddProductAttribute(newAttributesXml, newPva, newPvav.Id.ToString());
                                }
                            }
                        }
                        else
                        {
                            // Simple text value.
                            newAttributesXml = _productAttributeParser.AddProductAttribute(newAttributesXml, newPva, oldPvaValueStr);
                        }
                    }
                }

                var combinationClone = new ProductVariantAttributeCombination
                {
                    ProductId             = clone.Id,
                    AttributesXml         = newAttributesXml,
                    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
                };

                _productAttributeService.InsertProductVariantAttributeCombination(combinationClone);
            }

            // >>>>>> Commit combinations.
            Commit();
        }