Пример #1
0
        private IQueryable <Product> ApplyFilter(IQueryable <Product> queryProducts,
                                                 ProductFields fieldFilter, string fieldValue)
        {
            switch (fieldFilter)
            {
            case ProductFields.productCode:
                queryProducts = queryProducts.Where(x => x.productCode.Contains(fieldValue));
                break;

            case ProductFields.productDescription:
                queryProducts = queryProducts.Where(x => x.productDescription.Contains(fieldValue));
                break;

            case ProductFields.productGTIN:
                queryProducts = queryProducts.Where(x => x.productGTIN.Contains(fieldValue));
                break;

            case ProductFields.productName:
                queryProducts = queryProducts.Where(x => x.productName.Contains(fieldValue));
                break;

            default:
                break;
            }
            return(queryProducts);
        }
Пример #2
0
    private void InitializeShopComponent(ProductFields product, int i)
    {
        var clone = Instantiate(ProductPrefab, Vector3.zero, Quaternion.identity, ContentShop) as Product;

        clone.Instantiate(product.name, product.count, product.price, product.image);
        ProductToBuy.Add(clone);
        clone._buy_button.onClick.AddListener(delegate { Buy(product, i); });
    }
Пример #3
0
        private IQueryable <Product> ApplyOrder(IQueryable <Product> queryProducts,
                                                ProductFields orderField, OrderEnum order)
        {
            switch (orderField)
            {
            case ProductFields.productCode:
                if (order == OrderEnum.Ascending)
                {
                    queryProducts = queryProducts.OrderBy(x => x.productCode);
                }
                else
                {
                    queryProducts = queryProducts.OrderByDescending(x => x.productCode);
                }
                break;

            case ProductFields.productDescription:
                if (order == OrderEnum.Ascending)
                {
                    queryProducts = queryProducts.OrderBy(x => x.productDescription);
                }
                else
                {
                    queryProducts = queryProducts.OrderByDescending(x => x.productDescription);
                }
                break;

            case ProductFields.productGTIN:
                if (order == OrderEnum.Ascending)
                {
                    queryProducts = queryProducts.OrderBy(x => x.productGTIN);
                }
                else
                {
                    queryProducts = queryProducts.OrderByDescending(x => x.productGTIN);
                }
                break;

            case ProductFields.productName:
                if (order == OrderEnum.Ascending)
                {
                    queryProducts = queryProducts.OrderBy(x => x.productName);
                }
                else
                {
                    queryProducts = queryProducts.OrderByDescending(x => x.productName);
                }
                break;

            default:
                queryProducts = queryProducts.OrderBy(x => x.productId);
                break;
            }
            return(queryProducts);
        }
Пример #4
0
    public static ProductFields Initialize(ProductData data, int i)
    {
        ProductFields product = new ProductFields();

        product.content  = data.content;
        product.BuyCount = data.BuyCount;
        product.image    = data.image;
        product.price    = data.price;
        product.name     = data.name;
        product.count    = data.count;
        product.index    = i;
        return(product);
    }
Пример #5
0
 private void Buy(ProductFields product, int i)
 {
     if (gold >= product.price && product.count > 0)
     {
         product.count--;
         product.BuyCount++;
         gold     -= product.price;
         Gold.text = gold.ToString();
         ProductToBuy[i].Instantiate(product.name, product.count, product.price, product.image);
         onButtonBuy(product.name, product.BuyCount, product.image, product.content);
         _ProductData[product.index].BuyCount++;
         _ProductData[product.index].count--;
     }
 }
Пример #6
0
 public void RemoveFieldFromProduct(ProductFields productField)
 {
     using (var db = new ESportDbContext())
         try
         {
             var entityToRemove = db.ProductFields.Attach(productField);
             db.ProductFields.Remove(entityToRemove);
             db.SaveChanges();
         }
         catch (Exception e)
         {
             throw new RepositoryException("Error al eliminar campo en producto", e);
         }
 }
Пример #7
0
 public void UpdateProductField(ProductFields productField)
 {
     using (var db = new ESportDbContext())
         try
         {
             var entityToUpdate = db.ProductFields.Attach(productField);
             entityToUpdate.Value           = productField.Value;
             db.Entry(entityToUpdate).State = System.Data.Entity.EntityState.Modified;
             db.SaveChanges();
         }
         catch (Exception e)
         {
             throw new RepositoryException("Error al eliminar campo en producto", e);
         }
 }
        public ActionResult Search(string query)
        {
            if (!Request.IsAjaxRequest())
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var products = productSearchManager.Search(new SearchOptions
            {
                Query        = query,
                ResultFields = ProductFields.AllExcept(ProductFields.Description),
                PageSize     = AppConfiguration.SearchDropdownItemsLimit
            });

            var model = Mapper.Map <IEnumerable <ProductListItemViewModel> >(products.Items);

            return(PartialView("_SearchResults", model));
        }
        public ActionResult SearchPage(ProductsListViewModel model)
        {
            var searchResults = productSearchManager.Search(new SearchOptions
            {
                Query        = model.Query,
                PageNumber   = model.PageNumber,
                ResultFields = ProductFields.AllExcept(ProductFields.Description),
                PageSize     = model.PageSize,
                InverseSort  = model.InverseSort,
                SortField    = model.SortField
            });

            model.RelevantSortTypeAvailable = true;

            model.Items           = Mapper.Map <IList <ProductListItemViewModel> >(searchResults.Items);
            model.TotalItemsCount = searchResults.TotalCount;
            return(View("List", model));
        }
Пример #10
0
        public async Task <(List <Product>, int)> getProducts(int startat, int quantity,
                                                              ProductFields fieldFilter, string fieldValue, ProductFields orderField, OrderEnum order)
        {
            var queryProducts = _context.Products
                                .Where(x => x.enabled == true);

            queryProducts = ApplyFilter(queryProducts, fieldFilter, fieldValue);
            queryProducts = ApplyOrder(queryProducts, orderField, order);
            var products = await queryProducts.Include(x => x.additionalInformation)
                           .Skip(startat).Take(quantity).ToListAsync();

            var queryCount = _context.Products
                             .Where(x => x.enabled == true);

            queryCount = ApplyFilter(queryCount, fieldFilter, fieldValue);
            queryCount = ApplyOrder(queryCount, orderField, order);
            var totalCount = queryCount.Count();

            return(products, totalCount);
        }
Пример #11
0
        public void Sort(ProductFields sortField, bool isAscending)
        {
            switch (sortField)
            {
            case ProductFields.LongTitle:
                InnerList.Sort(new LongTitleComparer());
                break;

            case ProductFields.RecordUpdateDate:
                InnerList.Sort(new RecordUpdateDateComparer());
                break;

            case ProductFields.RevisedDate:
                InnerList.Sort(new RevisedDateComparer());
                break;
            }
            if (!isAscending)
            {
                InnerList.Reverse();
            }
        }
Пример #12
0
 public void AddFieldInProduct(ProductFields productField)
 {
     using (var db = new ESportDbContext())
         try
         {
             if (productField.Product != null)
             {
                 db.Entry(productField.Product).State = EntityState.Unchanged;
             }
             if (productField.Field != null)
             {
                 db.Entry(productField.Field).State = EntityState.Unchanged;
             }
             db.ProductFields.Add(productField);
             db.SaveChanges();
         }
         catch (Exception e)
         {
             throw new RepositoryException("Error al agregar campo en producto", e);
         }
 }
Пример #13
0
    private void InitializeShopCategories(ProductData data, int i)
    {
        ProductType type = data.type;

        switch (type)
        {
        case ProductType.Armor:
            _armor.Add(ProductFields.Initialize(data, i));
            break;

        case ProductType.Magick:
            _magick.Add(ProductFields.Initialize(data, i));
            break;

        case ProductType.Utility:
            _utility.Add(ProductFields.Initialize(data, i));
            break;

        case ProductType.Weapon:
            _weapons.Add(ProductFields.Initialize(data, i));
            break;
        }
    }
Пример #14
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Mobile" /> class.
 /// </summary>
 public Mobile() : base(CLASS_NAME)
 {
     mFields  = new MobileFields(this);
     mProduct = new ProductFields(this);
 }
Пример #15
0
 /// <summary>
 /// Initializes a new instance of the <see cref="FilterPack" /> class.
 /// </summary>
 public FilterPack() : base(CLASS_NAME)
 {
     mFields  = new FilterPackFields(this);
     mProduct = new ProductFields(this);
 }
Пример #16
0
 /// <summary>
 /// Initializes a new instance of the <see cref="LearningProductType" /> class.
 /// </summary>
 public LearningProductType() : base(CLASS_NAME)
 {
     mFields  = new LearningProductTypeFields(this);
     mProduct = new ProductFields(this);
 }
Пример #17
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ElectricGrinder" /> class.
 /// </summary>
 public ElectricGrinder() : base(CLASS_NAME)
 {
     mFields  = new ElectricGrinderFields(this);
     mProduct = new ProductFields(this);
 }
Пример #18
0
 public void RemoveFieldFromProduct(ProductFields productField)
 {
     currentProduct.Fields.Remove(productField);
 }
        private void ProcessOptPrices(string optPricesFilePath)
        {
            using (var csv = new CsvHelper.CsvReader(new StreamReader(optPricesFilePath, Encoding.UTF8)))// Encodings.GetEncoding())))
            {
                LogInvalidData(string.Format("ProcessOptPrices Start 1: Encoding: {0}, File: {1}, Time: {2}", Encodings.GetEncoding(), optPricesFilePath, DateTime.Now));

                csv.Configuration.Delimiter       = Separators.GetCharSeparator();
                csv.Configuration.HasHeaderRecord = true;
                Product product;

                bool firstRead = true;

                //      LogInvalidData(string.Format("ProcessOptPrices Start 2: Encoding: {0}, File: {1}, Time: {2}", Encodings.GetEncoding(), optPricesFilePath, DateTime.Now));

                while (csv.Read())
                {
                    try
                    {
                        //           LogInvalidData(string.Format("ProcessOptPrices Start 3: csv: {0}, File: {1}, Time: {2}", Encodings.GetEncoding(), optPricesFilePath, DateTime.Now));
                        if (firstRead)
                        {
                            for (int i = 0; i < csv.FieldHeaders.Length; i++)
                            {
                                FieldMapping.Add(csv.FieldHeaders[i], i);
                            }
                            firstRead = false;
                        }

                        //           LogInvalidData(string.Format("ProcessOptPrices Start 4: csv: {0}, File: {1}, Time: {2}", Encodings.GetEncoding(), optPricesFilePath, DateTime.Now));


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

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

                        //sku;amount;priceOpt1;priceOpt2;priceAkc1;priceAkc2;priceSpec;priceEur

                        product = ProductService.GetProduct(Convert.ToString(csv[FieldMapping[artNo]]));
                        decimal priceOpt1;
                        decimal priceOpt2;

                        decimal priceAkc1;
                        decimal priceAkc2;

                        decimal priceSpec;
                        decimal priceEur;

                        decimal.TryParse(csv["priceOpt1"].ToString().Replace(" ", ""), out priceOpt1);
                        decimal.TryParse(csv["priceOpt2"].ToString().Replace(" ", ""), out priceOpt2);
                        decimal.TryParse(csv["priceAkc1"].ToString().Replace(" ", ""), out priceAkc1);
                        decimal.TryParse(csv["priceAkc2"].ToString().Replace(" ", ""), out priceAkc2);
                        decimal.TryParse(csv["priceSpec"].ToString().Replace(" ", ""), out priceSpec);

                        decimal.TryParse(csv["priceEur"].ToString().Replace(" ", ""), out priceEur);
                        if (priceEur == 0 && csv["priceEur"].ToString().Contains("."))
                        {
                            decimal.TryParse(csv["priceEur"].ToString().Replace(" ", "").Replace(".", ","), out priceEur);
                        }
                        string briefDescription = csv["BriefDescription"].ToString();
                        product.BriefDescription = briefDescription;

                        product.Offers.Add(new Offer
                        {
                            Amount        = product.Offers[0].Amount,
                            OfferListId   = 9,
                            Price         = priceOpt1,
                            ShippingPrice = 0,
                            SupplyPrice   = 0,
                            Unit          = product.Offers[0].Unit,
                            Multiplicity  = product.Offers[0].Multiplicity
                        });

                        product.Offers.Add(new Offer
                        {
                            Amount        = product.Offers[0].Amount,
                            OfferListId   = 12,
                            Price         = priceOpt2,
                            ShippingPrice = 0,
                            SupplyPrice   = 0,
                            Unit          = product.Offers[0].Unit,
                            Multiplicity  = product.Offers[0].Multiplicity
                        });

                        product.Offers.Add(new Offer
                        {
                            Amount        = product.Offers[0].Amount,
                            OfferListId   = 13,
                            Price         = priceAkc1,
                            ShippingPrice = 0,
                            SupplyPrice   = 0,
                            Unit          = product.Offers[0].Unit,
                            Multiplicity  = product.Offers[0].Multiplicity
                        });

                        product.Offers.Add(new Offer
                        {
                            Amount        = product.Offers[0].Amount,
                            OfferListId   = 14,
                            Price         = priceAkc2,
                            ShippingPrice = 0,
                            SupplyPrice   = 0,
                            Unit          = product.Offers[0].Unit,
                            Multiplicity  = product.Offers[0].Multiplicity
                        });

                        product.Offers.Add(new Offer
                        {
                            Amount        = product.Offers[0].Amount,
                            OfferListId   = 15,
                            Price         = priceSpec,
                            ShippingPrice = 0,
                            SupplyPrice   = 0,
                            Unit          = product.Offers[0].Unit,
                            Multiplicity  = product.Offers[0].Multiplicity
                        });

                        product.Offers.Add(new Offer
                        {
                            Amount        = product.Offers[0].Amount,
                            OfferListId   = 16,
                            Price         = priceEur,
                            ShippingPrice = 0,
                            SupplyPrice   = 0,
                            Unit          = product.Offers[0].Unit,
                            Multiplicity  = product.Offers[0].Multiplicity
                        });

                        //            LogInvalidData(string.Format("ProcessOptPrices Start 5: csv: {0}, File: {1}, Time: {2}", product.ArtNo, optPricesFilePath, DateTime.Now));

                        ProductService.UpdateProduct(product, false);

                        //             LogInvalidData(string.Format("ProcessOptPrices Start 6: csv: {0}, File: {1}, Time: {2}", product.ArtNo, optPricesFilePath, DateTime.Now));
                    }
                    catch (Exception ex)
                    {
                        LogInvalidData("Ex  " + ex.Message + DateTime.Now.ToString());
                    }
                }
            }
            try
            {
                File.Copy(optPricesFilePath, optPricesFilePath.Replace("OstatkiWseCeny.csv", string.Format("OstatkiWseCeny_done{0}.csv", DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss"))));
                FileHelpers.DeleteFile(optPricesFilePath);
            }
            catch (Exception ex)
            {
                LogInvalidData("Ex File.Copy(...  " + ex.Message + DateTime.Now.ToString());
            }
        }
        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());
            }
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="Coffee" /> class.
 /// </summary>
 public Coffee() : base(CLASS_NAME)
 {
     mFields  = new CoffeeFields(this);
     mProduct = new ProductFields(this);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="Laptop" /> class.
 /// </summary>
 public Laptop() : base(CLASS_NAME)
 {
     mFields  = new LaptopFields(this);
     mProduct = new ProductFields(this);
 }
Пример #23
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ManualGrinder" /> class.
 /// </summary>
 public ManualGrinder() : base(CLASS_NAME)
 {
     mFields  = new ManualGrinderFields(this);
     mProduct = new ProductFields(this);
 }
Пример #24
0
 /// <summary>
 /// Initializes a new instance of the <see cref="CMSproduct" /> class.
 /// </summary>
 public CMSproduct() : base(CLASS_NAME)
 {
     mFields  = new CMSproductFields(this);
     mProduct = new ProductFields(this);
 }
Пример #25
0
    protected void Page_Init(object sender, EventArgs e)
    {
        CommonHelper.DisableBrowserCache();
        choseDiv.Visible     = !ExportStatistic.IsRun;
        divAction.Visible    = !ExportStatistic.IsRun;
        divbtnAction.Visible = !ExportStatistic.IsRun;

        LoadFirstProduct();
        var tbl = new Table()
        {
            ID = "tblValues"
        };
        var ddlRow = new TableRow {
            ID = "ddlRow"
        };
        var lblRow = new TableRow {
            ID = "lblRow", BackColor = ColorTranslator.FromHtml("#EFF0F2")
        };
        var cellM = new TableCell {
            ID = "cellM"
        };

        cellM.Attributes.Add("style", "vertical-align:top; width:150px");
        cellM.Controls.Add(new Label {
            Text = Resources.Resource.Admin_ExportCsv_Column
        });
        ddlRow.Cells.Add(cellM);

        var cellL = new TableCell {
            ID = "cellL"
        };

        cellL.Attributes.Add("style", "vertical-align:top; width:150px");
        cellL.Controls.Add(new Label {
            Text = Resources.Resource.Admin_ExportCsv_SampleOfData
        });
        var div4 = new Panel {
            Width = 110
        };

        cellL.Controls.Add(div4);
        lblRow.Cells.Add(cellL);

        foreach (var item in Enum.GetValues(typeof(ProductFields.Fields)))
        {
            // none and photo in export by default no need
            if ((ProductFields.Fields)item == ProductFields.Fields.None)
            {
                continue;
            }
            var cell = new TableCell {
                ID = "cell" + ((int)item).ToString()
            };
            cell.Attributes.Add("style", "vertical-align:top");
            var ddl = new DropDownList {
                ID = "ddlType" + ((int)item).ToString(), Width = 150
            };
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.None), ((int)ProductFields.Fields.None).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Sku), ((int)ProductFields.Fields.Sku).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Name), ((int)ProductFields.Fields.Name).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.ParamSynonym), ((int)ProductFields.Fields.ParamSynonym).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Category), ((int)ProductFields.Fields.Category).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Enabled), ((int)ProductFields.Fields.Enabled).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Price), ((int)ProductFields.Fields.Price).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.PurchasePrice), ((int)ProductFields.Fields.PurchasePrice).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Amount), ((int)ProductFields.Fields.Amount).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Unit), ((int)ProductFields.Fields.Unit).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Discount), ((int)ProductFields.Fields.Discount).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.ShippingPrice), ((int)ProductFields.Fields.ShippingPrice).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Weight), ((int)ProductFields.Fields.Weight).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Size), ((int)ProductFields.Fields.Size).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.BriefDescription), ((int)ProductFields.Fields.BriefDescription).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Description), ((int)ProductFields.Fields.Description).ToString()));

            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Title), ((int)ProductFields.Fields.Title).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.MetaKeywords), ((int)ProductFields.Fields.MetaKeywords).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.MetaDescription), ((int)ProductFields.Fields.MetaDescription).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Photos), ((int)ProductFields.Fields.Photos).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Markers), ((int)ProductFields.Fields.Markers).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Properties), ((int)ProductFields.Fields.Properties).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.Producer), ((int)ProductFields.Fields.Producer).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.OrderByRequest), ((int)ProductFields.Fields.OrderByRequest).ToString()));

            //Added By Evgeni
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.EAN), ((int)ProductFields.Fields.EAN).ToString()));
            ddl.Items.Add(new ListItem(ProductFields.GetDisplayNameByEnum(ProductFields.Fields.SubBrandId), ((int)ProductFields.Fields.SubBrandId).ToString()));
            //

            if (!string.IsNullOrEmpty(Request["state"]) && Request["state"].ToLower() == "select")
            {
                ddl.SelectedValue = ((int)item).ToString();
            }
            var lb = new Label {
                ID = "lbProduct" + ((int)item).ToString(), Text = ddlProduct.Items.Count > 0 && Request["state"] == "select" ? ddlProduct.Items[(int)item].Text : string.Empty
            };
            lb.Attributes.Add("style", "display:block");
            ddl.Attributes.Add("onchange", string.Format("Change(this)"));
            cell.Controls.Add(ddl);
            //cell.Controls.Add(lb);
            ddlRow.Cells.Add(cell);
            var cellLbl = new TableCell {
                ID = "cellLbl" + ((int)item).ToString()
            };
            cellLbl.Controls.Add(lb);
            lblRow.Cells.Add(cellLbl);
        }

        tbl.Rows.Add(ddlRow);
        tbl.Rows.Add(lblRow);
        choseDiv.Controls.Add(tbl);
    }
Пример #26
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Tableware" /> class.
 /// </summary>
 public Tableware() : base(CLASS_NAME)
 {
     mFields  = new TablewareFields(this);
     mProduct = new ProductFields(this);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="Car" /> class.
 /// </summary>
 public Car() : base(CLASS_NAME)
 {
     mFields  = new CarFields(this);
     mProduct = new ProductFields(this);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="CampaignsProduct" /> class.
 /// </summary>
 public CampaignsProduct() : base(CLASS_NAME)
 {
     mFields  = new CampaignsProductFields(this);
     mProduct = new ProductFields(this);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="Brewer" /> class.
 /// </summary>
 public Brewer() : base(CLASS_NAME)
 {
     mFields  = new BrewerFields(this);
     mProduct = new ProductFields(this);
 }
Пример #30
0
        public static ProductFieldStatus Status(this ProductFields enumValue)
        {
            var attrValue = AttributeHelper.GetAttributeValue <ProductFieldsStatusAttribute, ProductFieldStatus>(enumValue);

            return(attrValue);
        }