Exemplo n.º 1
0
    private void ProcessCsv()
    {
        if (chboxDisableProducts.Checked)
        {
            ProductService.DisableAllProducts();
        }

        long count = 0;

        using (var csv = new CsvHelper.CsvReader(new StreamReader(_fullPath, Encodings.GetEncoding())))
        {
            csv.Configuration.Delimiter       = Separators.GetCharSeparator();
            csv.Configuration.HasHeaderRecord = _hasHeadrs;
            while (csv.Read())
            {
                count++;
            }
        }

        ImportStatistic.TotalRow = count;

        using (var csv = new CsvHelper.CsvReader(new StreamReader(_fullPath, Encodings.GetEncoding())))
        {
            csv.Configuration.Delimiter       = Separators.GetCharSeparator();
            csv.Configuration.HasHeaderRecord = _hasHeadrs;

            while (csv.Read())
            {
                if (!ImportStatistic.IsRun)
                {
                    csv.Dispose();
                    FileHelpers.DeleteFile(_fullPath);
                    return;
                }
                try
                {
                    //Added by Evgeni to Remove dots
                    //   csv.CurrentRecord[0] = csv.CurrentRecord[0].Replace(".", "").Replace(" ", "");
                    // Step by rows
                    var productInStrings = new Dictionary <ProductFields.Fields, string>();

                    string nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Sku);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Sku, Convert.ToString(csv[FieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Name).Trim('*');
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        var name = Convert.ToString(csv[FieldMapping[nameField]]);
                        if (!string.IsNullOrEmpty(name))
                        {
                            productInStrings.Add(ProductFields.Fields.Name, name);
                        }
                        else
                        {
                            LogInvalidData(string.Format(Resource.Admin_ImportCsv_CanNotEmpty, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Name), ImportStatistic.RowPosition + 2));
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Enabled).Trim('*');
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        string enabled = Convert.ToString(csv[FieldMapping[nameField]]);
                        productInStrings.Add(ProductFields.Fields.Enabled, enabled);
                        //product.Enabled = !string.IsNullOrEmpty(enabled) && enabled.Trim().Equals("+");
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Discount);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        var discount = Convert.ToString(csv[FieldMapping[nameField]]);
                        if (string.IsNullOrEmpty(discount))
                        {
                            discount = "0";
                        }
                        decimal tmp;
                        if (decimal.TryParse(discount, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Discount, tmp.ToString());
                        }
                        else if (decimal.TryParse(discount, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Discount, tmp.ToString());
                        }
                        else
                        {
                            LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Discount), ImportStatistic.RowPosition + 2));
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Weight);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        var weight = Convert.ToString(csv[FieldMapping[nameField]]);
                        if (string.IsNullOrEmpty(weight))
                        {
                            weight = "0";
                        }
                        decimal tmp;
                        if (decimal.TryParse(weight, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Weight, tmp.ToString());
                        }
                        else if (decimal.TryParse(weight, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Weight, tmp.ToString());
                        }
                        else
                        {
                            LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Weight), ImportStatistic.RowPosition + 2));
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Size);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Size, Convert.ToString(csv[FieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.BriefDescription);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.BriefDescription, Convert.ToString(csv[FieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Description);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Description, Convert.ToString(csv[FieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Price).Trim('*');
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        var price = Convert.ToString(csv[FieldMapping[nameField]]);
                        if (string.IsNullOrEmpty(price))
                        {
                            price = "0";
                        }
                        decimal tmp;
                        if (decimal.TryParse(price, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Price, tmp.ToString());
                        }
                        else if (decimal.TryParse(price, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Price, tmp.ToString());
                        }
                        else
                        {
                            LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Price), ImportStatistic.RowPosition + 2));
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.PurchasePrice);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        var sypplyprice = Convert.ToString(csv[FieldMapping[nameField]]);
                        if (string.IsNullOrEmpty(sypplyprice))
                        {
                            sypplyprice = "0";
                        }
                        decimal tmp;
                        if (decimal.TryParse(sypplyprice, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.PurchasePrice, tmp.ToString());
                        }
                        else if (decimal.TryParse(sypplyprice, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.PurchasePrice, tmp.ToString());
                        }
                        else
                        {
                            LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.PurchasePrice), ImportStatistic.RowPosition + 2));
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.ShippingPrice);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        var shippingPrice = Convert.ToString(csv[FieldMapping[nameField]]);
                        if (string.IsNullOrEmpty(shippingPrice))
                        {
                            shippingPrice = "0";
                        }
                        decimal tmp;
                        if (decimal.TryParse(shippingPrice, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.ShippingPrice, tmp.ToString());
                        }
                        else if (decimal.TryParse(shippingPrice, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.ShippingPrice, tmp.ToString());
                        }
                        else
                        {
                            LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.ShippingPrice), ImportStatistic.RowPosition + 2));
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Amount);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        var amount = Convert.ToString(csv[FieldMapping[nameField]]);
                        if (string.IsNullOrEmpty(amount))
                        {
                            amount = "0";
                        }
                        int tmp;
                        if (int.TryParse(amount, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Amount, amount);
                        }
                        else
                        {
                            LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Amount), ImportStatistic.RowPosition + 2));
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Unit);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Unit, Convert.ToString(csv[FieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.ParamSynonym);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        string rewurl = Convert.ToString(csv[FieldMapping[nameField]]);
                        productInStrings.Add(ProductFields.Fields.ParamSynonym, rewurl);
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Title);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Title, Convert.ToString(csv[FieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.MetaKeywords);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.MetaKeywords, Convert.ToString(csv[FieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.MetaDescription);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.MetaDescription, Convert.ToString(csv[FieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Photos);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Photos, Convert.ToString(csv[FieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Markers);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Markers, Convert.ToString(csv[FieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Properties);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Properties, Convert.ToString(csv[FieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Producer);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Producer, Convert.ToString(csv[FieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.OrderByRequest);
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        string orderbyrequest = Convert.ToString(csv[FieldMapping[nameField]]);
                        productInStrings.Add(ProductFields.Fields.OrderByRequest, orderbyrequest);
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Category).Trim('*');
                    if (FieldMapping.ContainsKey(nameField))
                    {
                        var parentCategory = Convert.ToString(csv[FieldMapping[nameField]]);
                        if (!string.IsNullOrEmpty(parentCategory))
                        {
                            productInStrings.Add(ProductFields.Fields.Category, parentCategory);
                        }
                    }

                    ImportProduct.UpdateInsertProduct(productInStrings);
                }
                catch (Exception ex)
                {
                    MsgErr(ex.Message + " at csv");
                    Debug.LogError(ex);
                }
            }
            CategoryService.RecalculateProductsCountManual();
        }
        ImportStatistic.IsRun = false;
        LuceneSearch.CreateAllIndexInBackground();
        CacheManager.Clean();
        FileHelpers.DeleteFilesFromImageTempInBackground();
        FileHelpers.DeleteFile(_fullPath);
    }
        private void ProcessCsv()
        {
            string _filePath = FoldersHelper.GetPathAbsolut(FolderType.PriceTemp);
            string _fullPath = string.Format("{0}{1}", _filePath, "ostatki.csv");

            LogInvalidData("Start working on Update (1C). File " + _fullPath + DateTime.Now.ToString());


            if (!File.Exists(_fullPath))
            {
                return;
            }

            long count = 0;

            using (var csv = new CsvHelper.CsvReader(new StreamReader(_fullPath, Encodings.GetEncoding())))
            {
                csv.Configuration.Delimiter       = Separators.GetCharSeparator();
                csv.Configuration.HasHeaderRecord = true;
                while (csv.Read())
                {
                    count++;
                }
            }

            ImportStatistic.TotalRow = count;

            LogInvalidData("ImportStatistic.TotalRow = " + count.ToString() + DateTime.Now.ToString());

            using (var csv = new CsvHelper.CsvReader(new StreamReader(_fullPath, Encodings.GetEncoding())))
            {
                csv.Configuration.Delimiter       = Separators.GetCharSeparator();
                csv.Configuration.HasHeaderRecord = true;


                bool firstRead = true;
                while (csv.Read())
                {
                    try
                    {
                        if (firstRead)
                        {
                            for (int i = 0; i < csv.FieldHeaders.Length; i++)
                            {
                                FieldMapping.Add(csv.FieldHeaders[i], i);
                            }
                            firstRead = false;
                        }


                        var productInStrings = new Dictionary <ProductFields.Fields, string>();

                        string nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Sku);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            productInStrings.Add(ProductFields.Fields.Sku, Convert.ToString(csv[FieldMapping[nameField]]));
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Name).Trim('*');
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            var name = Convert.ToString(csv[FieldMapping[nameField]]);
                            if (!string.IsNullOrEmpty(name))
                            {
                                productInStrings.Add(ProductFields.Fields.Name, name);
                            }
                            else
                            {
                                LogInvalidData(string.Format(Resource.Admin_ImportCsv_CanNotEmpty, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Name), ImportStatistic.RowPosition + 2));
                                continue;
                            }
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Enabled).Trim('*');
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            string enabled = Convert.ToString(csv[FieldMapping[nameField]]);
                            productInStrings.Add(ProductFields.Fields.Enabled, enabled);
                            //product.Enabled = !string.IsNullOrEmpty(enabled) && enabled.Trim().Equals("+");
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Discount);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            var discount = Convert.ToString(csv[FieldMapping[nameField]]);
                            if (string.IsNullOrEmpty(discount))
                            {
                                discount = "0";
                            }
                            decimal tmp;
                            if (decimal.TryParse(discount, out tmp))
                            {
                                productInStrings.Add(ProductFields.Fields.Discount, tmp.ToString());
                            }
                            else if (decimal.TryParse(discount, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                            {
                                productInStrings.Add(ProductFields.Fields.Discount, tmp.ToString());
                            }
                            else
                            {
                                LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Discount), ImportStatistic.RowPosition + 2));
                                continue;
                            }
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Weight);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            var weight = Convert.ToString(csv[FieldMapping[nameField]]);
                            if (string.IsNullOrEmpty(weight))
                            {
                                weight = "0";
                            }
                            decimal tmp;
                            if (decimal.TryParse(weight, out tmp))
                            {
                                productInStrings.Add(ProductFields.Fields.Weight, tmp.ToString());
                            }
                            else if (decimal.TryParse(weight, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                            {
                                productInStrings.Add(ProductFields.Fields.Weight, tmp.ToString());
                            }
                            else
                            {
                                LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Weight), ImportStatistic.RowPosition + 2));
                                continue;
                            }
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Size);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            productInStrings.Add(ProductFields.Fields.Size, Convert.ToString(csv[FieldMapping[nameField]]));
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.BriefDescription);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            productInStrings.Add(ProductFields.Fields.BriefDescription, Convert.ToString(csv[FieldMapping[nameField]]));
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Description);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            productInStrings.Add(ProductFields.Fields.Description, Convert.ToString(csv[FieldMapping[nameField]]));
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Price).Trim('*');
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            var price = Convert.ToString(csv[FieldMapping[nameField]]);
                            if (string.IsNullOrEmpty(price))
                            {
                                price = "0";
                            }
                            decimal tmp;
                            if (decimal.TryParse(price, out tmp))
                            {
                                productInStrings.Add(ProductFields.Fields.Price, tmp.ToString());
                            }
                            else if (decimal.TryParse(price, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                            {
                                productInStrings.Add(ProductFields.Fields.Price, tmp.ToString());
                            }
                            else
                            {
                                LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Price), ImportStatistic.RowPosition + 2));
                                continue;
                            }
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.PurchasePrice);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            var sypplyprice = Convert.ToString(csv[FieldMapping[nameField]]);
                            if (string.IsNullOrEmpty(sypplyprice))
                            {
                                sypplyprice = "0";
                            }
                            decimal tmp;
                            if (decimal.TryParse(sypplyprice, out tmp))
                            {
                                productInStrings.Add(ProductFields.Fields.PurchasePrice, tmp.ToString());
                            }
                            else if (decimal.TryParse(sypplyprice, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                            {
                                productInStrings.Add(ProductFields.Fields.PurchasePrice, tmp.ToString());
                            }
                            else
                            {
                                LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.PurchasePrice), ImportStatistic.RowPosition + 2));
                                continue;
                            }
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.ShippingPrice);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            var shippingPrice = Convert.ToString(csv[FieldMapping[nameField]]);
                            if (string.IsNullOrEmpty(shippingPrice))
                            {
                                shippingPrice = "0";
                            }
                            decimal tmp;
                            if (decimal.TryParse(shippingPrice, out tmp))
                            {
                                productInStrings.Add(ProductFields.Fields.ShippingPrice, tmp.ToString());
                            }
                            else if (decimal.TryParse(shippingPrice, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                            {
                                productInStrings.Add(ProductFields.Fields.ShippingPrice, tmp.ToString());
                            }
                            else
                            {
                                LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.ShippingPrice), ImportStatistic.RowPosition + 2));
                                continue;
                            }
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Amount);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            var amount = Convert.ToString(csv[FieldMapping[nameField]]);
                            if (string.IsNullOrEmpty(amount))
                            {
                                amount = "0";
                            }
                            int tmp;
                            if (int.TryParse(amount, out tmp))
                            {
                                productInStrings.Add(ProductFields.Fields.Amount, amount);
                            }
                            else
                            {
                                LogInvalidData(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Amount), ImportStatistic.RowPosition + 2));
                                continue;
                            }
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Unit);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            productInStrings.Add(ProductFields.Fields.Unit, Convert.ToString(csv[FieldMapping[nameField]]));
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.ParamSynonym);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            string rewurl = Convert.ToString(csv[FieldMapping[nameField]]);
                            productInStrings.Add(ProductFields.Fields.ParamSynonym, rewurl);
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Title);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            productInStrings.Add(ProductFields.Fields.Title, Convert.ToString(csv[FieldMapping[nameField]]));
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.MetaKeywords);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            productInStrings.Add(ProductFields.Fields.MetaKeywords, Convert.ToString(csv[FieldMapping[nameField]]));
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.MetaDescription);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            productInStrings.Add(ProductFields.Fields.MetaDescription, Convert.ToString(csv[FieldMapping[nameField]]));
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Photos);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            productInStrings.Add(ProductFields.Fields.Photos, Convert.ToString(csv[FieldMapping[nameField]]));
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Markers);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            productInStrings.Add(ProductFields.Fields.Markers, Convert.ToString(csv[FieldMapping[nameField]]));
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Properties);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            productInStrings.Add(ProductFields.Fields.Properties, Convert.ToString(csv[FieldMapping[nameField]]));
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Producer);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            productInStrings.Add(ProductFields.Fields.Producer, Convert.ToString(csv[FieldMapping[nameField]]));
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.OrderByRequest);
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            string orderbyrequest = Convert.ToString(csv[FieldMapping[nameField]]);
                            productInStrings.Add(ProductFields.Fields.OrderByRequest, orderbyrequest);
                        }

                        nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Category).Trim('*');
                        if (FieldMapping.ContainsKey(nameField))
                        {
                            var parentCategory = Convert.ToString(csv[FieldMapping[nameField]]);
                            if (!string.IsNullOrEmpty(parentCategory))
                            {
                                productInStrings.Add(ProductFields.Fields.Category, parentCategory);
                            }
                        }



                        ImportProduct.UpdateInsertProduct(productInStrings, false);
                    }
                    catch (Exception ex)
                    {
                        LogInvalidData("Ex  " + ex.Message + DateTime.Now.ToString());
                    }
                }


                //All amounts to zero. except that was updated 0.02 = 30 minutes before and SubBrandID != -2 (tools.by)
                string script = "UPDATE Catalog.Offer SET Amount = 0 FROM Catalog.Product INNER JOIN Catalog.Offer ON Catalog.Product.ProductId = Catalog.Offer.ProductID WHERE (Catalog.Product.DateModified < GETDATE() - 0.02) AND Amount < 9000 ";
                ExecuteScript(script);

                LogInvalidData("Amounts of products that was not updated to zero" + DateTime.Now.ToString());

                LogInvalidData(" CategoryService.RecalculateProductsCountManual() before " + DateTime.Now.ToString());
                CategoryService.RecalculateProductsCountManual();
                LogInvalidData(" CategoryService.RecalculateProductsCountManual() after " + DateTime.Now.ToString());
            }

            try
            {
                LogInvalidData("  LuceneSearch.CreateAllIndexInBackground(); " + DateTime.Now.ToString());
                LuceneSearch.CreateAllIndexInBackground();
                CacheManager.Clean();
                LogInvalidData("   File.Cop file:" + _fullPath + DateTime.Now.ToString());
                //  File.Copy(_fullPath, _fullPath.Replace("ostatki.csv", "ostatki_done_" + DateTime.Now.ToString("M-d-yyyy-HH-mm") + ".csv"));

                FileHelpers.DeleteFile(_fullPath.Replace("ostatki.csv", "Instrument_opt_by__ostatki.csv"));
                File.Copy(_fullPath, _fullPath.Replace("ostatki.csv", "Instrument_opt_by__ostatki.csv"));
                FileHelpers.DeleteFile(_fullPath);
                //UPdate Sorting
                LogInvalidData("   //UPdate Sorting " + DateTime.Now.ToString());
                AdvantShop.Core.SQLDataAccess.ExecuteNonQuery("[Catalog].[sp_UpdateSortingInCategories]", CommandType.StoredProcedure);
                LogInvalidData("   All Done:  " + DateTime.Now.ToString());
            }
            catch (Exception ex)
            {
                LogInvalidData("Ex 2 " + ex.Message + DateTime.Now.ToString());
            }
        }
Exemplo n.º 3
0
    private void ProcessCsv(string fullPath)
    {
        ImportStatistic.Init();
        ImportStatistic.IsRun = true;

        var fieldMapping = new Dictionary <string, int>();

        using (var csv = new CsvHelper.CsvReader(new StreamReader(fullPath, Encoding.UTF8)))
        {
            csv.Configuration.Delimiter       = ';';
            csv.Configuration.HasHeaderRecord = false;
            csv.Read();
            for (int i = 0; i < csv.CurrentRecord.Length; i++)
            {
                if (csv.CurrentRecord[i] == ProductFields.GetStringNameByEnum(ProductFields.Fields.None))
                {
                    continue;
                }
                if (!fieldMapping.ContainsKey(csv.CurrentRecord[i]))
                {
                    fieldMapping.Add(csv.CurrentRecord[i], i);
                }
            }
        }

        using (var csv = new CsvHelper.CsvReader(new StreamReader(fullPath, Encoding.UTF8)))
        {
            csv.Configuration.Delimiter       = ';';
            csv.Configuration.HasHeaderRecord = true;

            while (csv.Read())
            {
                if (!ImportStatistic.IsRun)
                {
                    csv.Dispose();
                    FileHelpers.DeleteFile(fullPath);
                    return;
                }

                ImportStatistic.RowPosition++;
                try
                {
                    // Step by rows
                    var productInStrings = new Dictionary <ProductFields.Fields, string>();

                    string nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Sku);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Sku, Convert.ToString(csv[fieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Name).Trim('*');
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        var name = Convert.ToString(csv[fieldMapping[nameField]]);
                        if (!string.IsNullOrEmpty(name))
                        {
                            productInStrings.Add(ProductFields.Fields.Name, name);
                        }
                        else
                        {
                            Log(string.Format(Resource.Admin_ImportCsv_CanNotEmpty, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Name), ImportStatistic.RowPosition + 2), "InvalidData");
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Enabled).Trim('*');
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        string enabled = Convert.ToString(csv[fieldMapping[nameField]]);
                        productInStrings.Add(ProductFields.Fields.Enabled, enabled);
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Discount);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        string discount = Convert.ToString(csv[fieldMapping[nameField]]);
                        if (string.IsNullOrEmpty(discount))
                        {
                            discount = "0";
                        }
                        decimal tmp;
                        if (decimal.TryParse(discount, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Discount, tmp.ToString());
                        }
                        else if (decimal.TryParse(discount, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Discount, tmp.ToString());
                        }
                        else
                        {
                            Log(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Discount), ImportStatistic.RowPosition + 2), "InvalidData");
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Weight);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        string weight = Convert.ToString(csv[fieldMapping[nameField]]);
                        if (string.IsNullOrEmpty(weight))
                        {
                            weight = "0";
                        }
                        decimal tmp;
                        if (decimal.TryParse(weight, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Weight, tmp.ToString());
                        }
                        else if (decimal.TryParse(weight, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Weight, tmp.ToString());
                        }
                        else
                        {
                            Log(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Weight), ImportStatistic.RowPosition + 2), "InvalidData");
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Size);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Size, Convert.ToString(csv[fieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.BriefDescription);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.BriefDescription, Convert.ToString(csv[fieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Description);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Description, Convert.ToString(csv[fieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Price).Trim('*');
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        string price = Convert.ToString(csv[fieldMapping[nameField]]);
                        if (string.IsNullOrEmpty(price))
                        {
                            price = "0";
                        }
                        decimal tmp;
                        if (decimal.TryParse(price, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Price, tmp.ToString());
                        }
                        else if (decimal.TryParse(price, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Price, tmp.ToString());
                        }
                        else
                        {
                            Log(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Price), ImportStatistic.RowPosition + 2), "InvalidData");
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.PurchasePrice);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        string sypplyprice = Convert.ToString(csv[fieldMapping[nameField]]);
                        if (string.IsNullOrEmpty(sypplyprice))
                        {
                            sypplyprice = "0";
                        }
                        decimal tmp;
                        if (decimal.TryParse(sypplyprice, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.PurchasePrice, tmp.ToString());
                        }
                        else if (decimal.TryParse(sypplyprice, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.PurchasePrice, tmp.ToString());
                        }
                        else
                        {
                            Log(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.PurchasePrice), ImportStatistic.RowPosition + 2), "InvalidData");
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.ShippingPrice);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        string shippingPrice = Convert.ToString(csv[fieldMapping[nameField]]);
                        if (string.IsNullOrEmpty(shippingPrice))
                        {
                            shippingPrice = "0";
                        }
                        decimal tmp;
                        if (decimal.TryParse(shippingPrice, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.ShippingPrice, tmp.ToString());
                        }
                        else if (decimal.TryParse(shippingPrice, NumberStyles.Any, CultureInfo.InvariantCulture, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.ShippingPrice, tmp.ToString());
                        }
                        else
                        {
                            Log(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.ShippingPrice), ImportStatistic.RowPosition + 2), "InvalidData");
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Amount);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        string amount = Convert.ToString(csv[fieldMapping[nameField]]);
                        if (string.IsNullOrEmpty(amount))
                        {
                            amount = "0";
                        }
                        int tmp;
                        if (int.TryParse(amount, out tmp))
                        {
                            productInStrings.Add(ProductFields.Fields.Amount, amount);
                        }
                        else
                        {
                            Log(string.Format(Resource.Admin_ImportCsv_MustBeNumber, ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Amount), ImportStatistic.RowPosition + 2), "InvalidData");
                            continue;
                        }
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Unit);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Unit, Convert.ToString(csv[fieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.ParamSynonym);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        string rewurl = Convert.ToString(csv[fieldMapping[nameField]]);
                        productInStrings.Add(ProductFields.Fields.ParamSynonym, rewurl);
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Title);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Title, Convert.ToString(csv[fieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.MetaKeywords);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.MetaKeywords, Convert.ToString(csv[fieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.MetaDescription);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.MetaDescription, Convert.ToString(csv[fieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Photos);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Photos, Convert.ToString(csv[fieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Markers);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Markers, Convert.ToString(csv[fieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Properties);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Properties, Convert.ToString(csv[fieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Producer);
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        productInStrings.Add(ProductFields.Fields.Producer, Convert.ToString(csv[fieldMapping[nameField]]));
                    }

                    nameField = ProductFields.GetStringNameByEnum(ProductFields.Fields.Category).Trim('*');
                    if (fieldMapping.ContainsKey(nameField))
                    {
                        var parentCategory = Convert.ToString(csv[fieldMapping[nameField]]);
                        if (!string.IsNullOrEmpty(parentCategory))
                        {
                            productInStrings.Add(ProductFields.Fields.Category, parentCategory);
                        }
                    }

                    ImportProduct.UpdateInsertProduct(productInStrings);
                }
                catch (Exception ex)
                {
                    Log(ex.Message, "InvalidData");
                }
            }
            CategoryService.RecalculateProductsCountManual();
        }
        ImportStatistic.IsRun = false;
        FileHelpers.DeleteFile(fullPath);
    }