Exemple #1
0
        public static void SaveProduct(ProductDetailModel model)
        {
            using (var db = AliShopEntities.New())
            {
                var options   = model.Product.Options;
                var store     = db.AliStore.First(i => i.StoreId == model.Store.StoreId);
                var imageList = model.RunParams["imageBigViewURL"]
                                .ToObject <string[]>()
                                .Concat(model.Product.SkuValues
                                        .Where(i => !string.IsNullOrWhiteSpace(i.ImageUrl))
                                        .Select(i => i.ImageUrl))
                                .Select(delegate(string imageUrl)
                {
                    var imageSHA1 = new ImageSHA1();

                    imageSHA1.OriginalUrl.Add(imageUrl);
                    imageSHA1.NewUrl = imageUrl.Replace("/" + Path.GetFileName(imageUrl), ".jpg");

                    return(imageSHA1);
                });

                var imageListSHA1 = new HashSet <ImageSHA1>();

                Parallel.ForEach(imageList, delegate(ImageSHA1 currentImage)
                {
                    currentImage.SHA1 = ComputeSHA1ForWebResource(currentImage.NewUrl);

                    if (currentImage.SHA1 == null)
                    {
                        return;
                    }

                    lock (imageListSHA1)
                    {
                        var imageSHA1 = imageListSHA1.FirstOrDefault(i => i.SHA1 == currentImage.SHA1);

                        if (imageSHA1 == null)
                        {
                            imageListSHA1.Add(currentImage);
                        }
                        else
                        {
                            imageSHA1.OriginalUrl.AddRange(currentImage.OriginalUrl);
                        }
                    }
                });

                store.Feedback      = model.Store.Feedback;
                store.LastUpdate    = DateTime.UtcNow;
                store.Name          = Program.ToTitle(model.Store.StoreName);
                store.PageConfigXml = JsonConvert.DeserializeXNode(model.PageConfig.ToString(), "Root").ToString();
                store.Score         = model.Store.Rating;
                store.Since         = model.Store.Since;

                db.SaveChanges();

                var product     = db.AliProduct.Include("AliProductOption", "AliProductImage", "AliProductSpecific", "AliProductVariant").FirstOrDefault(i => i.ProductId == model.Product.ProductId);
                var productLink = db.AliProductLink.First(i => i.ProductId == model.Product.ProductId);

                if (product == null)
                {
                    product         = new AliProduct();
                    product.Enabled = true;
                    product.Create  = DateTime.UtcNow;

                    db.AliProduct.Add(product);
                }
                else
                {
                    product.LastUpdate = DateTime.UtcNow;
                }

                product.AliStoreId       = store.AliStoreId;
                product.AliProductLinkId = productLink.AliProductLinkId;
                product.ProductId        = model.Product.ProductId;
                product.OrdersCount      = model.Product.OrderCount;
                product.ProcessingTime   = model.Product.ProcessingTime;
                product.Rating           = model.Product.Rating;
                product.RunParamsXml     = JsonConvert.DeserializeXNode(model.RunParams.ToString(), "Root").ToString();
                product.Title            = Program.ToTitle(model.Product.Title);
                product.Enabled          = model.Product.NoLongerAvailable != true;

                db.SaveChanges();

                db.AliProductOption.RemoveRange(product.AliProductOption.Where(i => !options.Contains(i.Name, StringComparer.InvariantCultureIgnoreCase)));

                for (var i = 0; i < model.Product.Options.Length; i++)
                {
                    var option        = model.Product.Options[i];
                    var productOption = product.AliProductOption.FirstOrDefault(item => item.Name.Equals(option, StringComparison.InvariantCultureIgnoreCase));

                    if (productOption == null)
                    {
                        product.AliProductOption.Add(new AliProductOption
                        {
                            AliProductId     = product.AliProductId,
                            AliProductLinkId = productLink.AliProductLinkId,
                            AliStoreId       = store.AliStoreId,
                            Create           = DateTime.UtcNow,
                            Name             = Program.ToTitle(option),
                            Number           = i + 1,
                            ProductId        = model.Product.ProductId
                        });
                    }
                    else
                    {
                        productOption.Number     = i + 1;
                        productOption.LastUpdate = DateTime.UtcNow;
                    }
                }

                db.SaveChanges();

                db.AliProductImage.RemoveRange(product.AliProductImage.Where(i => !imageListSHA1.Any(s => s.SHA1 == i.SHA1)));

                foreach (var image in imageListSHA1.Where(s => !product.AliProductImage.Any(i => i.SHA1 == s.SHA1)))
                {
                    product.AliProductImage.Add(new AliProductImage
                    {
                        AliProductId     = product.AliProductId,
                        AliProductLinkId = productLink.AliProductLinkId,
                        AliStoreId       = store.AliStoreId,
                        Create           = DateTime.UtcNow,
                        ProductId        = model.Product.ProductId,
                        Enabled          = true,
                        Url  = image.NewUrl,
                        SHA1 = image.SHA1
                    });
                }

                db.SaveChanges();

                var productSpecs = model.Product.ProductSpecs.Select(i => new AliProductSpecific
                {
                    AliProductId     = product.AliProductId,
                    AliProductLinkId = productLink.AliProductLinkId,
                    AliStoreId       = store.AliStoreId,
                    Create           = DateTime.UtcNow,
                    ProductId        = model.Product.ProductId,
                    Name             = Program.ToTitle(i.Name),
                    Value            = Program.ToTitle(i.Value),
                    Type             = "item-specifics"
                }).ToList();

                productSpecs.AddRange(model.Product.PackagingSpecs.Select(i => new AliProductSpecific
                {
                    AliProductId     = product.AliProductId,
                    AliProductLinkId = productLink.AliProductLinkId,
                    AliStoreId       = store.AliStoreId,
                    Create           = DateTime.UtcNow,
                    ProductId        = model.Product.ProductId,
                    Name             = Program.ToTitle(i.Name),
                    Value            = Program.ToTitle(i.Value),
                    Type             = "packaging-details"
                }));

                db.AliProductSpecific.RemoveRange(product.AliProductSpecific.Where(i => !productSpecs.Any(s => s.Type == i.Type && s.Name.Equals(i.Name, StringComparison.InvariantCultureIgnoreCase))));

                foreach (var item in productSpecs.Where(spec => !product.AliProductSpecific.Any(i => i.Type == spec.Type && i.Name.Equals(spec.Name, StringComparison.InvariantCultureIgnoreCase))))
                {
                    product.AliProductSpecific.Add(item);
                }

                db.SaveChanges();

                foreach (var variant in product.AliProductVariant.Where(i => !model.Product.ProductSku.Select(s => s.SkuPropIds).Contains(i.SkuPropIds)))
                {
                    variant.Enabled    = false;
                    variant.LastUpdate = DateTime.UtcNow;
                }

                foreach (var sku in model.Product.ProductSku)
                {
                    var skuIds            = sku.SkuPropIds.Split(',');
                    var skuValues         = model.Product.SkuValues.Where(i => skuIds.Contains(i.SkuId.ToString(), StringComparer.InvariantCultureIgnoreCase)).ToArray();
                    var variant           = product.AliProductVariant.FirstOrDefault(i => i.SkuPropIds == sku.SkuPropIds);
                    var skuValueWithImage = skuValues.FirstOrDefault(i => i.ImageUrl != null);
                    var aliProductImageId = default(long?);

                    if (skuValueWithImage != null)
                    {
                        var imageSHA1 = imageListSHA1.FirstOrDefault(i => i.OriginalUrl.Contains(skuValueWithImage.ImageUrl, StringComparer.InvariantCultureIgnoreCase));

                        if (imageSHA1 != null)
                        {
                            aliProductImageId = product.AliProductImage.First(i => i.SHA1 == imageSHA1.SHA1).AliProductImageId;
                        }
                    }

                    if (variant == null)
                    {
                        variant = new AliProductVariant();

                        variant.Enabled = true;
                        variant.Create  = DateTime.UtcNow;

                        product.AliProductVariant.Add(variant);
                    }
                    else
                    {
                        variant.LastUpdate = DateTime.UtcNow;
                    }

                    variant.AliProductId            = product.AliProductId;
                    variant.AliProductImageId       = aliProductImageId;
                    variant.AliProductLinkId        = productLink.AliProductLinkId;
                    variant.AliStoreId              = store.AliStoreId;
                    variant.AvailableQuantity       = sku.SkuVal.AvailQuantity;
                    variant.DiscountPrice           = sku.SkuVal.IsActivity ? sku.SkuVal.ActSkuPrice : (decimal?)null;
                    variant.DiscountTimeLeftMinutes = model.Product.DiscountTimeLeftMinutes;
                    variant.DiscountUpdateTime      = variant.DiscountTimeLeftMinutes == null ? default(DateTime?) : DateTime.UtcNow;
                    variant.InventoryQuantity       = sku.SkuVal.Inventory;
                    variant.Option1       = skuValues.Length > 0 ? !string.IsNullOrWhiteSpace(skuValues[0].Name) ? skuValues[0].Name : Program.ToTitle(skuValues[0].Title) : null;
                    variant.Option2       = skuValues.Length > 1 ? !string.IsNullOrWhiteSpace(skuValues[1].Name) ? skuValues[1].Name : Program.ToTitle(skuValues[1].Title) : null;
                    variant.Option3       = skuValues.Length > 2 ? !string.IsNullOrWhiteSpace(skuValues[2].Name) ? skuValues[2].Name : Program.ToTitle(skuValues[2].Title) : null;
                    variant.OriginalPrice = sku.SkuVal.SkuPrice;
                    variant.ProductId     = model.Product.ProductId;
                    variant.SkuProductXml = JsonConvert.DeserializeXNode(JsonConvert.SerializeObject(sku), "Root").ToString();
                    variant.SkuPropIds    = sku.SkuPropIds;
                    variant.Weight        = model.Product.Weight;
                }

                db.SaveChanges();

                var shopifyProduct = db.AliShopifyProduct.FirstOrDefault(i => i.AliProductId == product.AliProductId);

                if (shopifyProduct == null)
                {
                    shopifyProduct                 = new AliShopifyProduct();
                    shopifyProduct.Create          = DateTime.UtcNow;
                    shopifyProduct.ExistsOnShopify = false;
                    shopifyProduct.Published       = false;

                    db.AliShopifyProduct.Add(shopifyProduct);
                }
                else
                {
                    shopifyProduct.LastUpdate = DateTime.UtcNow;
                }

                shopifyProduct.AliProductId            = product.AliProductId;
                shopifyProduct.RequiredUpdateOnShopify = true;

                db.SaveChanges();
            }
        }
Exemple #2
0
        public static ShopifyProduct ChangeShopifyProduct(AliShopifyProduct refProduct, CalcPriceModel[] calculationPrices, ShopifyProduct shopifyProduct, int stockSafetyMargin, string handleFriendly, string title)
        {
            var shopifyVariants             = default(IEnumerable <ShopifyProductVariant>);
            var shopifyImages               = default(IEnumerable <ShopifyProductImage>);
            var aliProductSpecificBrandName = refProduct.AliProduct.AliProductSpecific.Where(i => i.Name.ToLower() == "brand name").FirstOrDefault();
            var shopsFromCountry            = "China";
            var shipsFromQuery              = refProduct.AliProduct.AliProductOption
                                              .Where(i => i.Name.Equals("Ships From", StringComparison.InvariantCultureIgnoreCase));

            if (shopifyProduct == null)
            {
                shopifyProduct  = new ShopifyProduct();
                shopifyVariants = new ShopifyProductVariant[0];
                shopifyImages   = new ShopifyProductImage[0];
            }
            else
            {
                shopifyVariants = shopifyProduct.Variants;
                shopifyImages   = shopifyProduct.Images;
            }

            shopifyProduct.Title     = title;
            shopifyProduct.Handle    = handleFriendly;
            shopifyProduct.BodyHtml  = "<h3 style='margin-top: 25px;'>Item Specifics</h3>";
            shopifyProduct.BodyHtml += string.Join("<br />",
                                                   refProduct.AliProduct.AliProductSpecific
                                                   .Where(i => i.Type == "item-specifics")
                                                   .Select(i => $"{Program.ToTitle(i.Name)}: {Program.ToTitle(i.Value)}")
                                                   );
            shopifyProduct.BodyHtml += "<br /><h3 style='margin-top: 15px;'>Packaging Details</h3>";
            shopifyProduct.BodyHtml += string.Join("<br />",
                                                   refProduct.AliProduct.AliProductSpecific
                                                   .Where(i => i.Type == "packaging-details")
                                                   .Select(i => $"{Program.ToTitle(i.Name)}: {Program.ToTitle(i.Value)}")
                                                   );

            if (!shipsFromQuery.Any() ||
                refProduct.AliProduct.AliProductOption
                .Any(i =>
                     i.Name.Equals("Ships From", StringComparison.InvariantCultureIgnoreCase) &&
                     refProduct.AliProduct.AliProductVariant
                     .Where(v => v.Enabled)
                     .Select(v => i.Number == 1 ? v.Option1 : i.Number == 2 ? v.Option2 : v.Option3)
                     .Contains(shopsFromCountry, StringComparer.InvariantCultureIgnoreCase)
                     ))
            {
                if (!refProduct.AliProduct.Enabled && shopifyProduct.PublishedAt != null)
                {
                    shopifyProduct.Published   = false;
                    shopifyProduct.PublishedAt = null;
                }

                if (refProduct.AliProduct.Enabled && shopifyProduct.PublishedAt == null)
                {
                    shopifyProduct.Published   = true;
                    shopifyProduct.PublishedAt = DateTime.UtcNow;
                }
            }
            else
            {
                shopifyProduct.Published   = false;
                shopifyProduct.PublishedAt = null;
            }

            if (aliProductSpecificBrandName == null)
            {
                shopifyProduct.Vendor = null;
            }
            else
            {
                shopifyProduct.Vendor = Program.ToTitle(aliProductSpecificBrandName.Value);
            }

            if (shipsFromQuery.Any())
            {
                shopifyProduct.Options = refProduct.AliProduct.AliProductOption
                                         .Where(i => !i.Name.Equals("Ships From", StringComparison.InvariantCultureIgnoreCase))
                                         .OrderBy(i => i.Number)
                                         .Select(i => new ShopifyProductOption
                {
                    Name   = Program.ToTitle(i.Name),
                    Values = refProduct.AliProduct.AliProductVariant
                             .Where(v => v.Enabled)
                             .Select(v => i.Number == 1 ? v.Option1 : i.Number == 2 ? v.Option2 : v.Option3)
                             .Distinct()
                });
            }
            else
            {
                shopifyProduct.Options = refProduct.AliProduct.AliProductOption
                                         .OrderBy(i => i.Number)
                                         .Select(i => new ShopifyProductOption
                {
                    Name   = Program.ToTitle(i.Name),
                    Values = refProduct.AliProduct.AliProductVariant
                             .Where(v => v.Enabled)
                             .Select(v => i.Number == 1 ? v.Option1 : i.Number == 2 ? v.Option2 : v.Option3)
                             .Distinct()
                });
            }

            if (shopifyProduct.Options.Any())
            {
                shopifyProduct.Options = shopifyProduct.Options.ToArray();

                var position = 0;

                foreach (var option in shopifyProduct.Options)
                {
                    option.Position = ++position;
                }
            }
            else
            {
                shopifyProduct.Options = null;
            }

            shopifyProduct.Images = refProduct.AliProduct.AliProductImage
                                    .Select(i => i.Url)
                                    .Distinct()
                                    .Select(delegate(string url)
            {
                var shopifyImage = GetShopifyImageFromUrl(url, shopifyImages);

                if (shopifyImage == null)
                {
                    return(new ShopifyProductImage
                    {
                        Src = url,
                        VariantIds = new long[0]
                    });
                }

                return(new ShopifyProductImage
                {
                    Id = shopifyImage.Id,
                    VariantIds = new long[0]
                });
            });

            shopifyProduct.Variants = refProduct.AliProduct.AliProductVariant
                                      .Where(i => i.Enabled && i.AvailableQuantity > 0)
                                      .OrderByDescending(i => i.AvailableQuantity)
                                      .Select(delegate(AliProductVariant variant)
            {
                var skuRefID       = variant.AliProductVariantId.ToString();
                var shopifyVariant = shopifyVariants.FirstOrDefault(i => i.SKU == skuRefID);
                var currentPrice   = calculationPrices.First(i => i.AliProductVariantId == variant.AliProductVariantId);
                var shopifyImage   = default(ShopifyProductImage);

                if (variant.AliProductImage != null)
                {
                    shopifyImage = GetShopifyImageFromUrl(variant.AliProductImage.Url, shopifyImages);
                }

                var model = new ShopifyProductVariant
                {
                    Barcode             = skuRefID,
                    FulfillmentService  = ShopifyProductFulfillmentService.Manual,
                    InventoryManagement = ShopifyProductInventoryManagement.Shopify,
                    InventoryPolicy     = ShopifyProductInventoryPolicy.Deny,
                    ImageId             = shopifyImage == null ? null : shopifyImage.Id,
                    Price            = (double)currentPrice.CalcPrice,
                    CompareAtPrice   = currentPrice.CalcCompareAtPrice == null ? 0 : (double)currentPrice.CalcCompareAtPrice,
                    RequiresShipping = true,
                    SKU     = skuRefID,
                    Taxable = false,
                    Title   = refProduct.AliProduct.AliProductVariant
                              .Where(i => i.Enabled).Count() - shipsFromQuery.Count() <= 1 ?
                              Program.ToTitle(refProduct.AliProduct.Title) :
                              null,
                    Weight     = 0.1,
                    WeightUnit = "kg",
                };

                var shipsFrom = shipsFromQuery.FirstOrDefault();

                if (currentPrice.UseDiscount && variant.DiscountPrice.Value > 1.99M ||
                    !currentPrice.UseDiscount && variant.OriginalPrice > 1.99M ||
                    shipsFrom != null && (
                        shipsFrom.Number == 1 && !variant.Option1.Equals(shopsFromCountry, StringComparison.InvariantCultureIgnoreCase) ||
                        shipsFrom.Number == 2 && !variant.Option2.Equals(shopsFromCountry, StringComparison.InvariantCultureIgnoreCase) ||
                        shipsFrom.Number == 3 && !variant.Option3.Equals(shopsFromCountry, StringComparison.InvariantCultureIgnoreCase)
                        ))
                {
                    return(null);
                }

                if (shipsFrom == null)
                {
                    model.Option1 = Program.ToTitle(variant.Option1);
                    model.Option2 = Program.ToTitle(variant.Option2);
                    model.Option3 = Program.ToTitle(variant.Option3);
                }
                else
                {
                    if (shipsFrom.Number == 1)
                    {
                        model.Option1 = Program.ToTitle(variant.Option2);
                        model.Option2 = Program.ToTitle(variant.Option3);
                    }

                    if (shipsFrom.Number == 2)
                    {
                        model.Option1 = Program.ToTitle(variant.Option1);
                        model.Option2 = Program.ToTitle(variant.Option3);
                    }

                    if (shipsFrom.Number == 3)
                    {
                        model.Option1 = Program.ToTitle(variant.Option1);
                        model.Option2 = Program.ToTitle(variant.Option2);
                    }
                }

                if (string.IsNullOrWhiteSpace(model.Option1) ||
                    string.IsNullOrWhiteSpace(model.Option2) &&
                    (
                        refProduct.AliProduct.AliProductVariant.GroupBy(i => i.Option1).Any(i => i.Count() > 1) ||
                        Regex.IsMatch(model.Option1, "^\\d*$"))
                    )
                {
                    model.Option1 = "SKU " + variant.AliProductVariantId;
                }

                if (variant.AliProductImageId != null)
                {
                    model.Option1 += " (As Picture)";
                }

                var stockQuantity = variant.AvailableQuantity.Value - stockSafetyMargin;

                if (stockQuantity < 0)
                {
                    stockQuantity = 0;
                }

                if (shopifyVariant == null)
                {
                    model.InventoryQuantity = stockQuantity;
                }
                else
                {
                    model.Id       = shopifyVariant.Id;
                    model.Position = shopifyVariant.Position;
                    model.InventoryQuantityAdjustment = stockQuantity - shopifyVariant.InventoryQuantity;
                }

                return(model);
            });

            shopifyProduct.Variants = shopifyProduct.Variants
                                      .Where(i => i != null)
                                      .Take(100)
                                      .ToArray();

            if (!shopifyProduct.Variants.Any())
            {
                shopifyProduct.Options     = null;
                shopifyProduct.Variants    = null;
                shopifyProduct.Published   = false;
                shopifyProduct.PublishedAt = null;
            }

            return(shopifyProduct);
        }
Exemple #3
0
        internal static ShopifyProduct UpdateVariantsOnShopify(ShopifyProductService shopifyProductService, AliShopifyProduct refProduct, ShopifyProduct shopifyProduct)
        {
            var updateShopifyProduct = default(ShopifyProduct);

            if (shopifyProduct.Variants.Any())
            {
                shopifyProduct.Variants = shopifyProduct.Variants
                                          .Select(delegate(ShopifyProductVariant shopifyVariant)
                {
                    if (string.IsNullOrWhiteSpace(shopifyVariant.SKU) && shopifyProduct.Variants.Count() == 1)
                    {
                        return(shopifyVariant);
                    }

                    var variant = refProduct.AliProduct.AliProductVariant.FirstOrDefault(i => i.AliProductVariantId.ToString() == shopifyVariant.SKU);

                    if (variant == null || !variant.Enabled)
                    {
                        return(null);
                    }

                    var shopifyImage = default(ShopifyProductImage);

                    if (variant.AliProductImage != null)
                    {
                        shopifyImage = ShopifyHelper.GetShopifyImageFromUrl(variant.AliProductImage.Url, shopifyProduct.Images);
                    }

                    if (shopifyImage != null)
                    {
                        shopifyVariant.ImageId = shopifyImage.Id;
                    }

                    return(shopifyVariant);
                })
                                          .Where(i => i != null)
                                          .ToArray();

                ShopifyCall.ExecuteCall(delegate()
                {
                    var task = shopifyProductService.UpdateAsync(shopifyProduct);

                    task.Wait();

                    updateShopifyProduct = task.Result;
                });
            }

            return(updateShopifyProduct ?? shopifyProduct);
        }