Esempio n. 1
0
        private void ParseProductPrices(VendorAssortment assortment)
        {
            #region VendorPrice
            VendorPrice vendorPrice = (from vp in _vendorPrices
                                       where vp.VendorAssortmentID == assortment.VendorAssortmentID &&
                                       vp.MinimumQuantity == (_record.Field <int>("MinimumQuantity") > 0 ? _record.Field <int>("MinimumQuantity") : 0)
                                       select vp).FirstOrDefault();
            if (vendorPrice == null)
            {
                vendorPrice = new VendorPrice()
                {
                    VendorAssortment = assortment,
                    MinimumQuantity  = (_record.Field <int>("MinimumQuantity") > 0 ? _record.Field <int>("MinimumQuantity") : 0)
                };
                _vendorPrices.Add(vendorPrice);
                _unit.Scope.Repository <VendorPrice>().Add(vendorPrice);
            }

            vendorPrice.Price     = _record.Field <decimal>("UnitPrice");
            vendorPrice.CostPrice = _record.Table.Columns.Contains("CostPrice") ? _record.Field <decimal?>("CostPrice") : null;
            if (!vendorPrice.CostPrice.HasValue)
            {
                vendorPrice.CostPrice = _record.Table.Columns.Contains("CostPriceDC10") ? _record.Field <decimal?>("CostPriceDC10") : null;
            }

            vendorPrice.TaxRate              = (decimal)(_record.Field <double>("TaxRate"));
            vendorPrice.CommercialStatus     = _record.Field <string>("CommercialStatus");
            vendorPrice.ConcentratorStatusID = UpdateVendorStatuses(_record.Field <string>("CommercialStatus"));
            #endregion
        }
        public void UpdatePrice(OutletVendorModel model)
        {
            int OutletId = getOutletId();

            for (int i = 0; i < model.MenuOutletId.Length; i++)
            {
                VendorPrice tbdelete = new VendorPrice();
                int         menuId   = model.MenuOutletId[i];
                tbdelete = entities.VendorPrices.Where(a => a.MenuOutletId == menuId && a.VendorId == model.VendorId).FirstOrDefault();
                if (tbdelete != null)
                {
                    entities.Entry(tbdelete).State = EntityState.Deleted;
                    entities.SaveChanges();
                }
                VendorPrice tb = new VendorPrice();
                tb.MenuOutletId = model.MenuOutletId[i];
                tb.Price        = model.Price[i];
                tb.VendorId     = model.VendorId;
                entities.VendorPrices.Add(tb);
                entities.SaveChanges();
            }
        }
Esempio n. 3
0
        private void ParseDocuments(IUnitOfWork unit, XDocument[] products, XDocument cont)
        {
            #region Xml Data

            //products = new XDocument[1];
            //products[0] = XDocument.Load(@"C:\Lenmar\test.xml");

            var itemContent = (from content in cont.Root.Elements("item")
                               let attributes = content.Elements().Where(x => AttributeMapping.Contains(x.Name.LocalName))
                                                where content.Element("LenmarSKU") != null && content.Element("Description") != null && content.Element("Manufacturer") != null
                                                select new
            {
                LenmarSKU = content.Element("LenmarSKU").Value,
                ShortContentDescription = content.Element("Description").Value,
                GroupCode = content.Element("Manufacturer").Value,
                CostPrice = content.Element("BC_euro_cost") != null ? content.Element("BC_euro_cost").Value : "0",
                dynamic = attributes
            }).ToList();
            XNamespace xName = "http://logictec.com/schemas/internaldocuments";


            var itemProducts = (from d in products
                                from itemproduct in d.Elements(xName + "Envelope").Elements("Messages").Elements(xName + "Price")
                                let c = itemContent.Where(x => x.LenmarSKU == itemproduct.Element("SupplierSku").Value).FirstOrDefault()
                                        select new
            {
                VendorBrandCode = itemproduct.Element("MfgName").Value,
                VendorName = itemproduct.Element("MfgName").Value,
                SupplierSKU = itemproduct.Element("SupplierSku").Value,
                CustomItemNr = itemproduct.Element("MfgSKU").Value,
                ShortDescription = itemproduct.Element("ProductName").Value,
                Price = itemproduct.Element("MSRP").Value,
                Status = itemproduct.Element("Active").Value,
                CostPrice = c != null ? c.CostPrice : itemproduct.Element("Price").Value,
                QuantityOnHand = itemproduct.Element("Inventory").Value,
                VendorProductGroupCode1 = itemproduct.Element("Category1").Value,
                VendorProductGroupCode2 = itemproduct.Element("Category2").Value,
                VendorProductGroupCode3 = itemproduct.Element("Category3").Value,
                VendorProductGroupCode4 = itemproduct.Element("Category4").Value,
                VendorProductGroupCode5 = itemproduct.Element("Category5").Value,
                Barcode = itemproduct.Element("UPCCode").Value,
                ShortContentDescription = c != null ? c.ShortContentDescription : string.Empty
            }).ToList();

            #endregion

            var _brandVendorRepo       = unit.Scope.Repository <BrandVendor>();
            var _productRepo           = unit.Scope.Repository <Product>();
            var _assortmentRepo        = unit.Scope.Repository <VendorAssortment>();
            var productGroupVendorRepo = unit.Scope.Repository <ProductGroupVendor>();
            var _prodDescriptionRepo   = unit.Scope.Repository <ProductDescription>();
            var _attrGroupRepo         = unit.Scope.Repository <ProductAttributeGroupMetaData>();
            var _attrGroupName         = unit.Scope.Repository <ProductAttributeGroupName>();
            var _attrRepo      = unit.Scope.Repository <ProductAttributeMetaData>();
            var _attrNameRepo  = unit.Scope.Repository <ProductAttributeName>();
            var _attrValueRepo = unit.Scope.Repository <ProductAttributeValue>();
            var _mediaRepo     = unit.Scope.Repository <ProductMedia>();
            var _priceRepo     = unit.Scope.Repository <VendorPrice>();
            var _stockRepo     = unit.Scope.Repository <VendorStock>();
            var _barcodeRepo   = unit.Scope.Repository <ProductBarcode>();

            var brands                     = _brandVendorRepo.GetAll(bv => bv.VendorID == VendorID).ToList();
            var productGroups              = productGroupVendorRepo.GetAll(g => g.VendorID == VendorID).ToList();
            var productAttributes          = _attrRepo.GetAll(g => g.VendorID == VendorID).ToList();
            var productAttributeGroups     = _attrGroupRepo.GetAll().ToList();
            var currentProductGroupVendors = productGroupVendorRepo.GetAll(g => g.VendorID == VendorID).ToList();

            ProductStatusVendorMapper mapper = new ProductStatusVendorMapper(unit.Scope.Repository <VendorProductStatus>(), VendorID);

            var unusedVendorAssortmentItems = _assortmentRepo.GetAll(x => x.VendorID == VendorID && x.IsActive == true).ToList();

            int counter = 0;
            int total   = itemProducts.Count();
            int totalNumberOfProductsToProcess = total;
            log.InfoFormat("Start import {0} products", total);

            foreach (var product in itemProducts)
            {
                if (counter == 50)
                {
                    counter = 0;
                    log.InfoFormat("Still need to process {0} of {1}; {2} done;", totalNumberOfProductsToProcess, total, total - totalNumberOfProductsToProcess);
                }
                totalNumberOfProductsToProcess--;
                counter++;

                try
                {
                    #region BrandVendor

                    Product prod = null;
                    //check if brandvendor exists in db
                    var brandVendor = brands.FirstOrDefault(vb => vb.VendorBrandCode == product.VendorBrandCode);

                    if (brandVendor == null) //if brandvendor does not exist
                    {
                        //create new brandVendor
                        brandVendor = new BrandVendor
                        {
                            BrandID         = unmappedID,
                            VendorID        = VendorID,
                            VendorBrandCode = product.VendorBrandCode,
                            Name            = product.VendorBrandCode
                        };
                        _brandVendorRepo.Add(brandVendor);
                        brands.Add(brandVendor);
                    }

                    //use BrandID to create product and retreive ProductID

                    var BrandID = brandVendor.BrandID;

                    var prods = _productRepo.GetAll(p => p.VendorItemNumber == product.SupplierSKU && (p.BrandID == BrandID || p.BrandID < 0)).ToList();
                    prod = prods.OrderByDescending(x => x.BrandID).FirstOrDefault();

                    if (prods.Count() > 1)
                    {
                        try
                        {
                            _stockRepo.Delete(prods.Where(x => x.BrandID < 0).SelectMany(x => x.VendorStocks));
                            unit.Save();
                            _productRepo.Delete(prods.Where(x => x.BrandID < 0));
                            unit.Save();
                        }
                        catch (Exception ex)
                        {
                        }
                    }

                    //if product does not exist (usually true)
                    if (prod == null)
                    {
                        prod = new Product
                        {
                            VendorItemNumber = product.SupplierSKU,
                            SourceVendorID   = VendorID
                        };
                        _productRepo.Add(prod);
                    }
                    prod.BrandID = BrandID;
                    unit.Save();

                    #endregion

                    #region VendorAssortMent

                    var productID = prod.ProductID;

                    if (prod.VendorAssortments == null)
                    {
                        prod.VendorAssortments = new List <VendorAssortment>();
                    }
                    var vendorAssortment = prod.VendorAssortments.FirstOrDefault(va => va.VendorID == VendorID);

                    //if vendorAssortMent does not exist
                    if (vendorAssortment == null)
                    {
                        //create vendorAssortMent with productID
                        vendorAssortment = new VendorAssortment
                        {
                            Product          = prod,
                            CustomItemNumber = product.CustomItemNr,
                            VendorID         = VendorID
                        };
                        _assortmentRepo.Add(vendorAssortment);
                    }
                    vendorAssortment.IsActive         = true;
                    vendorAssortment.ShortDescription =
                        product.ShortDescription.Length > 150
                                       ? product.ShortDescription.Substring(0, 150)
                                       : product.ShortDescription;
                    vendorAssortment.LongDescription = "";

                    unusedVendorAssortmentItems.Remove(vendorAssortment);

                    #endregion

                    #region VendorPrice

                    if (vendorAssortment.VendorPrices == null)
                    {
                        vendorAssortment.VendorPrices = new List <VendorPrice>();
                    }
                    var vendorPrice = vendorAssortment.VendorPrices.FirstOrDefault();
                    //create vendorPrice with vendorAssortmentID
                    if (vendorPrice == null)
                    {
                        vendorPrice = new VendorPrice
                        {
                            VendorAssortment = vendorAssortment
                        };
                        _priceRepo.Add(vendorPrice);
                    }

                    vendorPrice.Price                = Decimal.Parse(product.Price) / 119;
                    vendorPrice.TaxRate              = (Decimal)19.00;
                    vendorPrice.CommercialStatus     = product.Status;
                    vendorPrice.MinimumQuantity      = 0;
                    vendorPrice.CostPrice            = Decimal.Parse(product.CostPrice) / 100;
                    vendorPrice.ConcentratorStatusID = mapper.SyncVendorStatus(product.Status, -1);

                    #endregion

                    #region VendorStock

                    //var vendorStock = vendorAssortment.VendorStock.FirstOrDefault();
                    var vendorStock = _stockRepo.GetSingle(c => c.ProductID == vendorAssortment.ProductID && c.VendorID == vendorAssortment.VendorID);
                    //create vendorStock with productID
                    if (vendorStock == null)
                    {
                        vendorStock = new VendorStock
                        {
                            Product = prod
                        };
                        _stockRepo.Add(vendorStock);
                    }

                    vendorStock.StockStatus          = product.Status;
                    vendorStock.QuantityOnHand       = int.Parse(product.QuantityOnHand);
                    vendorStock.VendorID             = VendorID;
                    vendorStock.VendorStockTypeID    = 1;
                    vendorStock.VendorStatus         = product.Status;
                    vendorStock.ConcentratorStatusID = mapper.SyncVendorStatus(product.Status, -1);

                    #endregion

                    #region ProductGroupVendor

                    //var vendorProductGroupAssortments = (from c in context.VendorProductGroupAssortments
                    //                                     where
                    //                                       c.VendorAssortment == vendorAssortment
                    //                                     select c).ToList();

                    //create vendorGroup five times, each time with a different VendorProductGroupCode on a different level if not exist
                    string vendorProductGroupCode1 = string.IsNullOrEmpty(product.VendorProductGroupCode1) ? "Battery" : product.VendorProductGroupCode1;

                    var productGroupVendor1 =
                        productGroups.FirstOrDefault(pg => pg.VendorProductGroupCode1 == vendorProductGroupCode1);

                    if (productGroupVendor1 == null)
                    {
                        productGroupVendor1 = new ProductGroupVendor
                        {
                            ProductGroupID          = unmappedID,
                            VendorID                = VendorID,
                            VendorName              = product.VendorName,
                            VendorProductGroupCode1 = vendorProductGroupCode1,

                            VendorAssortments = new List <VendorAssortment>()
                        };
                        productGroupVendorRepo.Add(productGroupVendor1);
                        productGroups.Add(productGroupVendor1);
                    }


                    #region sync

                    if (currentProductGroupVendors.Contains(productGroupVendor1))
                    {
                        currentProductGroupVendors.Remove(productGroupVendor1);
                    }
                    #endregion



                    if (!productGroupVendor1.VendorAssortments.Any(c => c == vendorAssortment))
                    {
                        productGroupVendor1.VendorAssortments.Add(vendorAssortment);
                    }

                    if (!string.IsNullOrEmpty(product.VendorProductGroupCode2))
                    {
                        var productGroupVendor2 =
                            productGroups.FirstOrDefault(pg => pg.VendorProductGroupCode2 == product.VendorProductGroupCode2);

                        if (productGroupVendor2 == null)
                        {
                            productGroupVendor2 = new ProductGroupVendor
                            {
                                ProductGroupID          = unmappedID,
                                VendorID                = VendorID,
                                VendorName              = product.VendorName,
                                VendorProductGroupCode2 = product.VendorProductGroupCode2,
                                VendorAssortments       = new List <VendorAssortment>()
                            };

                            productGroupVendorRepo.Add(productGroupVendor2);
                            productGroups.Add(productGroupVendor2);
                        }


                        #region sync

                        if (currentProductGroupVendors.Contains(productGroupVendor2))
                        {
                            currentProductGroupVendors.Remove(productGroupVendor2);
                        }
                        #endregion

                        var vendorProductGroupAssortment2 =
                            productGroupVendor2.VendorAssortments.FirstOrDefault(c => c.VendorAssortmentID == vendorAssortment.VendorAssortmentID);

                        if (vendorProductGroupAssortment2 == null)
                        {
                            productGroupVendor2.VendorAssortments.Add(vendorAssortment);
                        }
                    }

                    if (!string.IsNullOrEmpty(product.VendorProductGroupCode3))
                    {
                        var productGroupVendor3 =
                            productGroups.FirstOrDefault(pg => pg.VendorProductGroupCode3 == product.VendorProductGroupCode3);

                        if (productGroupVendor3 == null)
                        {
                            productGroupVendor3 = new ProductGroupVendor
                            {
                                ProductGroupID          = unmappedID,
                                VendorID                = VendorID,
                                VendorName              = product.VendorName,
                                VendorProductGroupCode3 = product.VendorProductGroupCode3,
                                VendorAssortments       = new List <VendorAssortment>()
                            };

                            productGroupVendorRepo.Add(productGroupVendor3);
                            productGroups.Add(productGroupVendor3);
                        }


                        #region sync

                        if (currentProductGroupVendors.Contains(productGroupVendor3))
                        {
                            currentProductGroupVendors.Remove(productGroupVendor3);
                        }
                        #endregion

                        var vendorProductGroupAssortment3 =
                            productGroupVendor3.VendorAssortments.FirstOrDefault(c => c.VendorAssortmentID == vendorAssortment.VendorAssortmentID);

                        if (vendorProductGroupAssortment3 == null)
                        {
                            productGroupVendor3.VendorAssortments.Add(vendorAssortment);
                        }
                    }

                    if (!string.IsNullOrEmpty(product.VendorProductGroupCode4))
                    {
                        var productGroupVendor4 =
                            productGroups.FirstOrDefault(pg => pg.VendorProductGroupCode4 == product.VendorProductGroupCode4);

                        if (productGroupVendor4 == null)
                        {
                            productGroupVendor4 = new ProductGroupVendor
                            {
                                ProductGroupID          = unmappedID,
                                VendorID                = VendorID,
                                VendorName              = product.VendorName,
                                VendorProductGroupCode4 = product.VendorProductGroupCode4,
                                VendorAssortments       = new List <VendorAssortment>()
                            };

                            productGroupVendorRepo.Add(productGroupVendor4);
                            productGroups.Add(productGroupVendor4);
                        }


                        #region sync

                        if (currentProductGroupVendors.Contains(productGroupVendor4))
                        {
                            currentProductGroupVendors.Remove(productGroupVendor4);
                        }
                        #endregion

                        var vendorProductGroupAssortment4 =
                            productGroupVendor4.VendorAssortments.FirstOrDefault(c => c.VendorAssortmentID == vendorAssortment.VendorAssortmentID);

                        if (vendorProductGroupAssortment4 == null)
                        {
                            productGroupVendor4.VendorAssortments.Add(vendorAssortment);
                        }
                    }

                    if (!string.IsNullOrEmpty(product.VendorProductGroupCode5))
                    {
                        var productGroupVendor5 =
                            productGroups.FirstOrDefault(pg => pg.VendorProductGroupCode5 == product.VendorProductGroupCode5);

                        if (productGroupVendor5 == null)
                        {
                            productGroupVendor5 = new ProductGroupVendor
                            {
                                ProductGroupID          = unmappedID,
                                VendorID                = VendorID,
                                VendorName              = product.VendorName,
                                VendorProductGroupCode5 = product.VendorProductGroupCode5,
                                VendorAssortments       = new List <VendorAssortment>()
                            };

                            productGroupVendorRepo.Add(productGroupVendor5);
                            productGroups.Add(productGroupVendor5);
                        }


                        #region sync

                        if (currentProductGroupVendors.Contains(productGroupVendor5))
                        {
                            currentProductGroupVendors.Remove(productGroupVendor5);
                        }

                        #endregion
                        var vendorProductGroupAssortment5 =
                            productGroupVendor5.VendorAssortments.FirstOrDefault(c => c.VendorAssortmentID == vendorAssortment.VendorAssortmentID);

                        if (vendorProductGroupAssortment5 == null)
                        {
                            productGroupVendor5.VendorAssortments.Add(vendorAssortment);
                        }
                    }

                    if (!string.IsNullOrEmpty(product.VendorBrandCode))
                    {
                        var brandProductGroupvendor =
                            productGroups.FirstOrDefault(pg => pg.BrandCode == product.VendorBrandCode && pg.VendorProductGroupCode1 == null && pg.VendorProductGroupCode2 == null && pg.VendorProductGroupCode3 == null && pg.VendorProductGroupCode4 == null && pg.VendorProductGroupCode5 == null);

                        if (brandProductGroupvendor == null)
                        {
                            brandProductGroupvendor = new ProductGroupVendor
                            {
                                ProductGroupID = unmappedID,
                                VendorID       = VendorID,
                                VendorName     = product.VendorName,
                                BrandCode      = product.VendorBrandCode
                            };

                            productGroupVendorRepo.Add(brandProductGroupvendor);
                            productGroups.Add(brandProductGroupvendor);
                        }


                        #region sync

                        if (currentProductGroupVendors.Contains(brandProductGroupvendor))
                        {
                            currentProductGroupVendors.Remove(brandProductGroupvendor);
                        }

                        #endregion
                        var brandProductGroupAssortment =
                            brandProductGroupvendor.VendorAssortments.FirstOrDefault(c => c.VendorAssortmentID == vendorAssortment.VendorAssortmentID);

                        if (brandProductGroupAssortment == null)
                        {
                            brandProductGroupvendor.VendorAssortments.Add(vendorAssortment);
                        }
                    }

                    #endregion

                    #region ProductBarcode
                    if (prod.ProductBarcodes == null)
                    {
                        prod.ProductBarcodes = new List <ProductBarcode>();
                    }
                    if (!prod.ProductBarcodes.Any(pb => pb.Barcode.Trim() == product.Barcode))
                    {
                        //create ProductBarcode if not exists
                        _barcodeRepo.Add(new ProductBarcode
                        {
                            Product     = prod,
                            Barcode     = product.Barcode,
                            VendorID    = VendorID,
                            BarcodeType = (int)BarcodeTypes.Default
                        });
                    }

                    #endregion

                    #region ProductDescription
                    if (prod.ProductDescriptions == null)
                    {
                        prod.ProductDescriptions = new List <ProductDescription>();
                    }
                    var productDescription =
                        prod.ProductDescriptions.FirstOrDefault(pd => pd.LanguageID == languageID && pd.VendorID == VendorID);

                    if (productDescription == null)
                    {
                        //create ProductDescription
                        productDescription = new ProductDescription
                        {
                            Product    = prod,
                            LanguageID = languageID,
                            VendorID   = VendorID
                        };

                        _prodDescriptionRepo.Add(productDescription);
                    }
                    productDescription.ShortContentDescription = product.ShortContentDescription;

                    #endregion

                    foreach (var content in itemContent.Where(x => x.LenmarSKU == product.SupplierSKU))
                    {
                        #region ProductAttributeGroupMetaData

                        var productAttributeGroupMetaData =
                            productAttributeGroups.FirstOrDefault(c => c.GroupCode == content.GroupCode);
                        //create ProductAttributeGroupMetaData if not exists
                        if (productAttributeGroupMetaData == null)
                        {
                            productAttributeGroupMetaData = new ProductAttributeGroupMetaData
                            {
                                Index     = 0,
                                GroupCode = content.GroupCode,
                                VendorID  = VendorID
                            };
                            _attrGroupRepo.Add(productAttributeGroupMetaData);
                            productAttributeGroups.Add(productAttributeGroupMetaData);
                        }
                        #endregion

                        #region ProductAttributeGroupName
                        if (productAttributeGroupMetaData.ProductAttributeGroupNames == null)
                        {
                            productAttributeGroupMetaData.ProductAttributeGroupNames = new List <ProductAttributeGroupName>();
                        }
                        var productAttributeGroupName =
                            productAttributeGroupMetaData.ProductAttributeGroupNames.FirstOrDefault(c => c.LanguageID == languageID);
                        //create ProductAttributeGroupName if not exists
                        if (productAttributeGroupName == null)
                        {
                            productAttributeGroupName = new ProductAttributeGroupName
                            {
                                Name = "General",
                                ProductAttributeGroupMetaData = productAttributeGroupMetaData,
                                LanguageID = languageID
                            };
                            _attrGroupName.Add(productAttributeGroupName);
                        }

                        #endregion

                        #region ProductAttributeMetaData

                        //create ProductAttributeMetaData as many times that there are entrys in content.dynamic
                        foreach (var element in content.dynamic)
                        {
                            var productAttributeMetaData =
                                productAttributes.FirstOrDefault(c => c.AttributeCode == element.Name.ToString());
                            //create ProductAttributeMetaData if not exists
                            if (productAttributeMetaData == null)
                            {
                                productAttributeMetaData = new ProductAttributeMetaData
                                {
                                    ProductAttributeGroupMetaData = productAttributeGroupMetaData,
                                    AttributeCode = element.Name.ToString(),
                                    Index         = 0,
                                    IsVisible     = true,
                                    NeedsUpdate   = true,
                                    VendorID      = VendorID,
                                    IsSearchable  = false
                                };
                                _attrRepo.Add(productAttributeMetaData);
                                productAttributes.Add(productAttributeMetaData);
                            }

                            #endregion

                            #region ProductAttributeName
                            if (productAttributeMetaData.ProductAttributeNames == null)
                            {
                                productAttributeMetaData.ProductAttributeNames = new List <ProductAttributeName>();
                            }
                            var productAttributeName =
                                productAttributeMetaData.ProductAttributeNames.FirstOrDefault(c => c.LanguageID == languageID);
                            //create ProductAttributeName with generated productAttributeMetaData.AttributeID if not exists
                            if (productAttributeName == null)
                            {
                                productAttributeName = new ProductAttributeName
                                {
                                    ProductAttributeMetaData = productAttributeMetaData,
                                    LanguageID = languageID,
                                    Name       = element.Name.ToString()
                                };
                                _attrNameRepo.Add(productAttributeName);
                            }

                            #endregion

                            #region ProductAttributeValue

                            if (productAttributeMetaData.ProductAttributeValues == null)
                            {
                                productAttributeMetaData.ProductAttributeValues = new List <ProductAttributeValue>();
                            }
                            var productAttributeValue =
                                productAttributeMetaData.ProductAttributeValues.FirstOrDefault(c => c.ProductID == prod.ProductID);
                            //create ProductAttributeValue with generated productAttributeMetaData.AttributeID
                            if (productAttributeValue == null)
                            {
                                productAttributeValue = new ProductAttributeValue
                                {
                                    ProductAttributeMetaData = productAttributeMetaData,
                                    Product    = prod,
                                    Value      = element.Value,
                                    LanguageID = languageID
                                };
                                _attrValueRepo.Add(productAttributeValue);
                            }

                            #endregion
                        }
                    }
                    unit.Save();
                }
                catch (Exception ex)
                {
                    log.ErrorFormat("product: {0} error: {1}", product.SupplierSKU, ex.StackTrace);
                }
            }
            #region delete unused vendorProductGroups
            foreach (var vProdVendor in currentProductGroupVendors)
            {
                if (vProdVendor.ProductGroupID == -1)
                {
                    productGroupVendorRepo.Add(vProdVendor);
                }
            }
            unit.Save();

            unusedVendorAssortmentItems.ForEach(x => x.IsActive = false);
            unit.Save();

            #endregion
        }
        private void DoProcess(List <TrdPartyProductModel> data, List <Attributes> atts, Objects.DataAccess.UnitOfWork.IUnitOfWork unit)
        {
            var config = GetConfiguration();

            var vendorID_NL = vendors.First(x => x.Value == "NL").Key;
            var vendorID_BE = vendors.First(x => x.Value == "BE").Key;

            var repoBrandVendor = unit.Scope.Repository <BrandVendor>();

            var prodRepo = unit.Scope.Repository <Product>().Include(c => c.ProductMedias, c => c.ProductBarcodes, c => c.ProductDescriptions);
            var productAttributeGroups = unit.Scope.Repository <ProductAttributeGroupMetaData>().GetAll(g => g.VendorID == vendorID_NL || g.VendorID == vendorID_BE).ToList();
            var repoAssortment         = unit.Scope.Repository <VendorAssortment>().Include(c => c.VendorPrices);
            var stockRepo                = unit.Scope.Repository <VendorStock>();
            var repoAttributeGroup       = unit.Scope.Repository <ProductAttributeGroupMetaData>();
            var repoAttributeGroupName   = unit.Scope.Repository <ProductAttributeGroupName>();
            var repoAttributeValue       = unit.Scope.Repository <ProductAttributeValue>();
            var repotAttributeName       = unit.Scope.Repository <ProductAttributeName>();
            var repoAttribute            = unit.Scope.Repository <ProductAttributeMetaData>().Include(c => c.ProductAttributeNames, c => c.ProductAttributeValues);
            var repoVendor               = unit.Scope.Repository <ProductGroupVendor>();
            var prodDescriptionRepo      = unit.Scope.Repository <ProductDescription>();
            var priceRepo                = unit.Scope.Repository <VendorPrice>();
            var productGroupLanguageRepo = unit.Scope.Repository <ProductGroupLanguage>();
            var productGroupMappingRepo  = unit.Scope.Repository <ProductGroupMapping>();

            //var products = prodRepo.GetAll(x => x.SourceVendorID == VendorID).ToList();
            var vendorassortments = repoAssortment.GetAll(x => x.VendorID == vendorID_NL || x.VendorID == vendorID_BE).ToList();
            var productAttributes = repoAttribute.GetAll(g => g.VendorID == vendorID_NL || g.VendorID == vendorID_BE).ToList();

            var productGroupVendorRecords = repoVendor.GetAll(pc => pc.VendorID == vendorID_NL || pc.VendorID == vendorID_BE).ToList();
            var brands              = repoBrandVendor.GetAll(bv => bv.VendorID == vendorID_NL || bv.VendorID == vendorID_BE).ToList();
            var brandEnts           = unit.Scope.Repository <Brand>().GetAll();
            var products            = prodRepo.GetAll(x => x.SourceVendorID == vendorID_NL || x.SourceVendorID == vendorID_BE).ToList();
            var vendorStock         = stockRepo.GetAll(x => x.VendorID == vendorID_NL || x.VendorID == vendorID_BE).ToList();
            var productDescriptions = prodDescriptionRepo.GetAll().ToList();

            var productGroupLanguages = productGroupLanguageRepo.GetAll().ToList();
            var prodAttributeGroups   = repoAttributeGroup.GetAll(g => g.VendorID == vendorID_NL || g.VendorID == vendorID_BE).ToList();
            var productGroupMapping   = productGroupMappingRepo.GetAll(x => x.ConnectorID == 2).ToList();

            int counter = 0;
            int total   = data.Count();
            int totalNumberOfProductsToProcess = total;

            log.InfoFormat("Start import {0} products", total);
            bool firstVendor = true;

            foreach (var VendorID in vendors.Keys)
            {
                ProductStatusVendorMapper mapper = new ProductStatusVendorMapper(unit.Scope.Repository <VendorProductStatus>(), VendorID);
                var vendor = unit.Scope.Repository <Vendor>().GetSingle(x => x.VendorID == VendorID);

                foreach (var product in data)
                {
                    if (string.IsNullOrEmpty(product.Artnr))
                    {
                        continue;
                    }
                    try
                    {
                        if (counter == 100)
                        {
                            counter = 0;
                            log.InfoFormat("Still need to process {0} of {1}; {2} done for {3};", totalNumberOfProductsToProcess, total, total - totalNumberOfProductsToProcess, VendorID);
                        }

                        totalNumberOfProductsToProcess--;
                        counter++;

                        var brand   = brandEnts.FirstOrDefault(c => c.Name.ToLower() == product.BrandName.Trim().ToLower());
                        int brandID = 0;

                        if (brand == null)
                        {
                            var vbrand = brands.FirstOrDefault(vb => vb.VendorBrandCode.Trim() == product.BrandName.Trim());

                            if (vbrand == null)
                            {
                                vbrand = new BrandVendor
                                {
                                    VendorID        = VendorID,
                                    VendorBrandCode = product.BrandName.Trim(),
                                    BrandID         = unmappedID,
                                    Name            = product.BrandName.Trim()
                                };

                                brands.Add(vbrand);

                                repoBrandVendor.Add(vbrand);
                            }
                            brandID = vbrand.BrandID;
                        }
                        else
                        {
                            brandID = brand.BrandID;
                        }

                        var item = products.FirstOrDefault(p => p.VendorItemNumber.Trim() == product.Artnr.Trim() && p.BrandID == brandID);
                        if (item == null)
                        {
                            item = new Product
                            {
                                VendorItemNumber = product.Artnr.Trim(),
                                BrandID          = brandID,
                                SourceVendorID   = VendorID
                            };
                            prodRepo.Add(item);
                            products.Add(item);
                            unit.Save();
                        }

                        if (firstVendor)
                        {
                            var productDescription = productDescriptions.FirstOrDefault(pd => pd.Product.VendorItemNumber == item.VendorItemNumber && pd.LanguageID == 1 && (pd.VendorID == vendor.VendorID || (vendor.ParentVendorID.HasValue && pd.VendorID == vendor.VendorID)));

                            if (productDescription == null)
                            {
                                //create ProductDescription
                                productDescription = new ProductDescription
                                {
                                    Product    = item,
                                    LanguageID = languageID,
                                    VendorID   = VendorID,
                                };

                                prodDescriptionRepo.Add(productDescription);
                                productDescriptions.Add(productDescription);
                            }

                            if (string.IsNullOrEmpty(productDescription.ProductName))
                            {
                                productDescription.ProductName = product.Product;
                                productDescription.ModelName   = product.Product;
                            }

                            if (!string.IsNullOrEmpty(product.ShortDescription))
                            {
                                productDescription.ShortContentDescription = product.ShortDescription.Cap(1000);
                            }

                            if (string.IsNullOrEmpty(productDescription.LongContentDescription))
                            {
                                productDescription.LongContentDescription = product.LongDescription;
                            }

                            if (string.IsNullOrEmpty(productDescription.LongSummaryDescription))
                            {
                                productDescription.LongSummaryDescription = product.LongDescription;
                            }
                        }

                        var assortment = vendorassortments.FirstOrDefault(x => x.Product.VendorItemNumber == item.VendorItemNumber.Trim() && x.VendorID == VendorID);
                        if (assortment == null)
                        {
                            assortment = new VendorAssortment
                            {
                                VendorID         = VendorID,
                                Product          = item,
                                ShortDescription = product.Try(c => c.ShortDescription.Cap(1000), string.Empty),//.ShortDescription // .Length > 150 ? product.ShortDescription.Substring(0, 150) : product.ShortDescription,
                                CustomItemNumber = product.Artnr.Trim(),
                                IsActive         = true,
                                LongDescription  = product.LongDescription
                            };
                            vendorassortments.Add(assortment);
                            repoAssortment.Add(assortment);
                        }

                        var productGroups = new string[4];
                        productGroups[0] = product.BrandName;
                        productGroups[1] = product.Chapter;
                        productGroups[2] = product.Category;
                        productGroups[3] = product.Subcategory;

                        var pgvs = assortment.ProductGroupVendors != null?assortment.ProductGroupVendors.ToList() : new List <ProductGroupVendor>();

                        ProductGroupMapping parentpgm = null;

                        for (int i = 0; i < productGroups.Length; i++)
                        {
                            var groupCode = productGroups[i];

                            if (string.IsNullOrEmpty(groupCode))
                            {
                                continue;
                            }

                            var productGroup = productGroupLanguages.FirstOrDefault(x => x.Name == groupCode.Trim());
                            if (productGroup == null)
                            {
                                var pg = new Concentrator.Objects.Models.Products.ProductGroup()
                                {
                                    Score = 0
                                };

                                unit.Scope.Repository <Concentrator.Objects.Models.Products.ProductGroup>().Add(pg);

                                productGroup = new ProductGroupLanguage()
                                {
                                    ProductGroup = pg,
                                    LanguageID   = 1,
                                    Name         = groupCode.Trim()
                                };

                                productGroupLanguages.Add(productGroup);
                                productGroupLanguageRepo.Add(productGroup);
                                unit.Save();
                            }

                            //var productGroupVendor = productGroupVendorRecords.Where(pg => pg.GetType().GetProperty(string.Format("VendorProductGroupCode{0}", i + 1)).GetValue(pg, null) != null
                            //        && pg.GetType().GetProperty(string.Format("VendorProductGroupCode{0}", i + 1)).GetValue(pg, null).ToString() == groupCode.Trim()).FirstOrDefault();

                            var productGroupVendor = productGroupVendorRecords.FirstOrDefault(x => x.ProductGroupID == productGroup.ProductGroupID);

                            if (productGroupVendor == null)
                            {
                                productGroupVendor = new ProductGroupVendor
                                {
                                    ProductGroupID = productGroup.ProductGroupID,
                                    VendorID       = VendorID,
                                    VendorName     = groupCode.Trim(),
                                };

                                productGroupVendor.GetType().GetProperty(string.Format("VendorProductGroupCode{0}", i + 1)).SetValue(productGroupVendor, groupCode.Trim().Cap(50), null);

                                repoVendor.Add(productGroupVendor);
                                productGroupVendorRecords.Add(productGroupVendor);
                            }

                            if (productGroupVendor.VendorAssortments == null)
                            {
                                productGroupVendor.VendorAssortments = new List <VendorAssortment>();
                            }

                            var assortmentRelation = productGroupVendor.VendorAssortments.Count == 0 ? null : productGroupVendor.VendorAssortments.Where(c => c.Product != null && c.Product.VendorItemNumber == item.VendorItemNumber.Trim() && c.VendorID == VendorID).FirstOrDefault();
                            if (assortmentRelation == null)
                            {
                                productGroupVendor.VendorAssortments.Add(assortment);
                            }
                            else
                            {
                                pgvs.Remove(productGroupVendor);
                            }

                            if (productGroupVendor.ProductGroupID > 0)
                            {
                                ProductGroupMapping pgm = null;

                                if (parentpgm != null)
                                {
                                    pgm = productGroupMapping.FirstOrDefault(x => x.ProductGroupID == productGroupVendor.ProductGroupID && x.ParentProductGroupMappingID == parentpgm.ProductGroupMappingID);
                                }
                                else
                                {
                                    pgm = productGroupMapping.FirstOrDefault(x => x.ProductGroupID == productGroupVendor.ProductGroupID);
                                }

                                if (pgm == null)
                                {
                                    pgm = new ProductGroupMapping()
                                    {
                                        ConnectorID         = 2,
                                        ProductGroupID      = productGroupVendor.ProductGroupID,
                                        FlattenHierarchy    = false,
                                        FilterByParentGroup = parentpgm != null ? true : false,
                                        Depth = i,
                                        Score = 0
                                    };

                                    if (parentpgm != null)
                                    {
                                        pgm.ParentProductGroupMappingID = parentpgm.ProductGroupMappingID;
                                    }

                                    unit.Scope.Repository <ProductGroupMapping>().Add(pgm);
                                    unit.Save();
                                    productGroupMapping.Add(pgm);
                                }
                                parentpgm = pgm;
                            }
                        }

                        pgvs.ForEach(pg =>
                        {
                            productGroupVendorRecords.Remove(pg);
                        });

                        if (firstVendor)
                        {
                            if (!string.IsNullOrEmpty(product.PriceGroup))
                            {
                                atts.Add(new Attributes()
                                {
                                    AttArtnr = product.Artnr.Trim(),
                                    Feature  = "PriceGroup",
                                    Value    = product.PriceGroup
                                });
                            }

                            if (!string.IsNullOrEmpty(product.Features))
                            {
                                atts.Add(new Attributes()
                                {
                                    AttArtnr = product.Artnr.Trim(),
                                    Feature  = "Features",
                                    Value    = product.Features
                                });
                            }

                            if (!string.IsNullOrEmpty(product.NEW))
                            {
                                atts.Add(new Attributes()
                                {
                                    AttArtnr = product.Artnr.Trim(),
                                    Feature  = "New",
                                    Value    = product.NEW
                                });
                            }

                            var attributes = atts.Where(x => x.AttArtnr != null && (x.AttArtnr.Trim() == product.Artnr.Trim())).ToList();

                            if (attributes != null && attributes.Count > 0)
                            {
                                foreach (var att in attributes)
                                {
                                    string AttributeCode        = "General",
                                             AttributeGroupCode = att.Feature,
                                             AttributeValue     = att.Value;

                                    if (!string.IsNullOrEmpty(AttributeGroupCode) && !string.IsNullOrEmpty(AttributeValue))
                                    {
                                        var productAttributeMetadata = productAttributes.FirstOrDefault(c => c.ProductAttributeNames.Any(l => l.Name == AttributeGroupCode) && c.VendorID == VendorID);
                                        if (productAttributeMetadata == null)
                                        {
                                            productAttributeMetadata = new ProductAttributeMetaData
                                            {
                                                AttributeCode = att.Feature,
                                                Index         = 0,
                                                IsVisible     = true,
                                                NeedsUpdate   = true,
                                                VendorID      = VendorID,
                                                IsSearchable  = false
                                            };
                                            productAttributes.Add(productAttributeMetadata);
                                            repoAttribute.Add(productAttributeMetadata);
                                        }

                                        var attributeGroup = productAttributeMetadata.ProductAttributeGroupMetaData;
                                        if (attributeGroup == null)
                                        {
                                            attributeGroup = new ProductAttributeGroupMetaData
                                            {
                                                Index     = 0,
                                                GroupCode = "TechnicalData",
                                                VendorID  = VendorID
                                            };
                                            repoAttributeGroup.Add(attributeGroup);
                                            productAttributeMetadata.ProductAttributeGroupMetaData = attributeGroup;
                                        }
                                        productAttributeMetadata.ProductAttributeGroupID = attributeGroup.ProductAttributeGroupID;

                                        var attributeGroupName = attributeGroup.ProductAttributeGroupNames.FirstOrDefault(c => c.LanguageID == 1);
                                        if (attributeGroupName == null)
                                        {
                                            attributeGroupName = new ProductAttributeGroupName
                                            {
                                                Name       = AttributeCode,
                                                LanguageID = languageID,
                                                ProductAttributeGroupMetaData = attributeGroup
                                            };
                                            repoAttributeGroupName.Add(attributeGroupName);
                                            attributeGroup.ProductAttributeGroupNames.Add(attributeGroupName);
                                        }



                                        var attributeName = productAttributeMetadata.ProductAttributeNames.FirstOrDefault(c => c.LanguageID == 1);
                                        if (attributeName == null)
                                        {
                                            attributeName = new ProductAttributeName
                                            {
                                                ProductAttributeMetaData = productAttributeMetadata,
                                                LanguageID = 1,
                                                Name       = AttributeGroupCode
                                            };
                                            repotAttributeName.Add(attributeName);
                                            productAttributeMetadata.ProductAttributeNames.Add(attributeName);
                                        }

                                        var attributeValue = productAttributeMetadata.ProductAttributeValues.FirstOrDefault(c => c.Value == AttributeValue && c.ProductID == item.ProductID);
                                        if (attributeValue == null && !string.IsNullOrEmpty(AttributeValue))
                                        {
                                            attributeValue = new ProductAttributeValue
                                            {
                                                Value = AttributeValue,
                                                ProductAttributeMetaData = productAttributeMetadata,
                                                LanguageID = 1,
                                                Product    = item
                                            };
                                            productAttributeMetadata.ProductAttributeValues.Add(attributeValue);
                                            repoAttributeValue.Add(attributeValue);
                                        }
                                    }
                                }
                            }
                        }

                        var stock = vendorStock.FirstOrDefault(c => c.Product.VendorItemNumber == item.VendorItemNumber.Trim() && c.VendorID == VendorID);

                        if (stock == null)
                        {
                            stock = new VendorStock
                            {
                                Product           = item,
                                QuantityOnHand    = 0,
                                VendorID          = VendorID,
                                VendorStockTypeID = 1
                            };
                            vendorStock.Add(stock);
                            stockRepo.Add(stock);
                        }



                        if (assortment.VendorPrices == null)
                        {
                            assortment.VendorPrices = new List <VendorPrice>();
                        }


                        var vendorPrice = assortment.VendorPrices.FirstOrDefault();
                        //create vendorPrice with vendorAssortmentID
                        if (vendorPrice == null)
                        {
                            vendorPrice = new VendorPrice
                            {
                                VendorAssortment = assortment,
                                CommercialStatus = "S",
                                MinimumQuantity  = 0
                            };
                            priceRepo.Add(vendorPrice);
                            assortment.VendorPrices.Add(vendorPrice);
                        }

                        decimal taxRate   = 19;
                        decimal price     = 0;
                        decimal costPrice = 0;

                        switch (vendors[VendorID])
                        {
                        case "NL":
                            taxRate = 19;
                            Decimal.TryParse(product.VATExclNL, out costPrice);
                            Decimal.TryParse(product.NLincl, out price);
                            break;

                        case "BE":
                            taxRate = 21;
                            Decimal.TryParse(product.VATExclBE, out costPrice);
                            Decimal.TryParse(product.BEincl, out price);
                            break;
                        }

                        vendorPrice.Price     = price;
                        vendorPrice.CostPrice = costPrice;
                        vendorPrice.TaxRate   = taxRate;

                        if (product.Image != null)
                        {
                            if (item.ProductMedias == null)
                            {
                                item.ProductMedias = new List <ProductMedia>();
                            }
                            if (!item.ProductMedias.Any(pi => pi.VendorID == VendorID && pi.MediaUrl == product.Image))
                            {
                                unit.Scope.Repository <ProductMedia>().Add(new ProductMedia
                                {
                                    VendorID = VendorID,
                                    MediaUrl = product.Image,
                                    TypeID   = 1, // image
                                    Product  = item,
                                    Sequence = 0
                                });
                            }
                        }


                        if (product.EAN != null || product.Barcode != null)
                        {
                            if (item.ProductBarcodes == null)
                            {
                                item.ProductBarcodes = new List <ProductBarcode>();
                            }
                            if (!item.ProductBarcodes.Any(pb => pb.Barcode.Trim() == product.EAN.Trim()))
                            {
                                unit.Scope.Repository <ProductBarcode>().Add(new ProductBarcode
                                {
                                    Product     = item,
                                    Barcode     = product.EAN != null ? product.EAN : product.Barcode != null ? product.Barcode : "",
                                    BarcodeType = (int)BarcodeTypes.Default,
                                    VendorID    = VendorID
                                });
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        log.AuditError("Error import products for Sennheiser 3rdParty", ex);
                    }
                }
                firstVendor = false;
            }
        }
Esempio n. 5
0
        private void ParseDocuments(IUnitOfWork unit, int vendorID, DataSet excel, bool firstRun)
        {
            var content = (from p in excel.Tables[0].AsEnumerable().Skip(1)
                           let vpn = p.Field <string>(0)
                                     select new
            {
                UnpaddedVendorItemNumber = vpn,
                PaddedVendorItemNumber = vpn.Length <= 6 ? vpn.PadLeft(6, '0') : vpn,
                Price = p.Field <String>(3),
                PriceGroup = p.Field <String>(1),
                EAN = p.Field <String>(2)
            }).ToList();

            int counter = 0;
            int total   = content.Count();
            int totalNumberOfProductsToProcess = total;

            log.InfoFormat("Start import {0} products", total);
            var attribute = unit.Scope.Repository <ProductAttributeMetaData>().GetSingle(x => x.AttributeCode == "PriceGroup");

            foreach (var item in content)
            {
                try
                {
                    if (counter == 50)
                    {
                        counter = 0;
                        log.InfoFormat("Still need to process {0} of {1}; {2} done;", totalNumberOfProductsToProcess, total, total - totalNumberOfProductsToProcess);
                    }
                    totalNumberOfProductsToProcess--;
                    counter++;

                    decimal dec = 0;
                    decimal.TryParse(item.Price, NumberStyles.Any, CultureInfo.InvariantCulture, out dec);

                    if (dec <= 0)
                    {
                        continue;
                    }

                    if (item.Price == String.Empty)
                    {
                        continue;
                    }

                    var _vendorAssortment = unit.Scope.Repository <VendorAssortment>().GetSingle(x => (x.Product.VendorItemNumber == item.PaddedVendorItemNumber || x.Product.VendorItemNumber == item.UnpaddedVendorItemNumber) && x.VendorID == vendorID);

                    if (_vendorAssortment == null)
                    {
                        _vendorAssortment = unit.Scope.Repository <VendorAssortment>().GetSingle(x => (x.Product.VendorItemNumber == item.PaddedVendorItemNumber || x.Product.VendorItemNumber == item.UnpaddedVendorItemNumber));
                        if (_vendorAssortment == null)
                        {
                            continue;
                        }
                        else
                        {
                            var va = new VendorAssortment()
                            {
                                VendorID            = vendorID,
                                ProductID           = _vendorAssortment.ProductID,
                                CustomItemNumber    = _vendorAssortment.CustomItemNumber,
                                ShortDescription    = _vendorAssortment.ShortDescription,
                                LongDescription     = _vendorAssortment.LongDescription,
                                IsActive            = false,
                                ProductGroupVendors = _vendorAssortment.ProductGroupVendors
                            };
                            unit.Scope.Repository <VendorAssortment>().Add(va);
                            unit.Save();
                            _vendorAssortment = va;
                        }
                    }

                    var _vendorPrice = unit.Scope.Repository <VendorPrice>().GetSingle(x => x.VendorAssortmentID == _vendorAssortment.VendorAssortmentID);

                    // Remove trailing zeros and Parsing
                    //String currencyFormat = String.Format("{0:C4}", Decimal.Parse(item.Price.Replace('.', ',')));
                    var costPrice    = dec; //Decimal.Parse(currencyFormat, NumberStyles.Currency);
                    var priceWithTax = (costPrice * _taxCalculation);

                    if (_vendorPrice == null)
                    {
                        VendorPrice price = new VendorPrice()
                        {
                            VendorAssortmentID = _vendorAssortment.VendorAssortmentID,
                            Price           = priceWithTax,
                            MinimumQuantity = 0,
                            CostPrice       = costPrice,
                            TaxRate         = _taxRate
                        };

                        unit.Scope.Repository <VendorPrice>().Add(price);
                    }
                    else
                    {
                        _vendorPrice.CostPrice = costPrice;
                        _vendorPrice.TaxRate   = _taxRate;
                        _vendorPrice.Price     = null;
                    }

                    var _vendorStock = unit.Scope.Repository <VendorStock>().GetSingle(x => x.ProductID == _vendorAssortment.ProductID && x.VendorID == vendorID);

                    if (_vendorStock == null)
                    {
                        VendorStock stock = new VendorStock()
                        {
                            ProductID         = _vendorAssortment.ProductID,
                            VendorID          = vendorID,
                            QuantityOnHand    = 0,
                            VendorStockTypeID = 1
                        };

                        unit.Scope.Repository <VendorStock>().Add(stock);
                    }

                    if (firstRun)
                    {
                        #region Attribute
                        if (!string.IsNullOrEmpty(item.PriceGroup))
                        {
                            if (attribute == null)
                            {
                                log.AuditCritical("PriceGroup attribute Removed");
                            }
                            else
                            {
                                var attributevalue = attribute.ProductAttributeValues.FirstOrDefault(x => x.ProductID == _vendorAssortment.ProductID);

                                if (attributevalue == null)
                                {
                                    attributevalue = new ProductAttributeValue()
                                    {
                                        LanguageID  = 1,
                                        AttributeID = attribute.AttributeID,
                                        ProductID   = _vendorAssortment.ProductID
                                    };
                                    unit.Scope.Repository <ProductAttributeValue>().Add(attributevalue);
                                }
                                attributevalue.Value = item.PriceGroup;
                            }
                        }
                        #endregion

                        //#region Barcode
                        //var productBarcode = unit.Scope.Repository<ProductBarcode>().GetSingle(x => x.ProductID == _vendorAssortment.ProductID && x.BarcodeType == 1);

                        //if (productBarcode == null)
                        //{
                        //  productBarcode = new ProductBarcode()
                        //  {
                        //    ProductID = _vendorAssortment.ProductID,
                        //    BarcodeType = (int)BarcodeTypes.EAN,
                        //    VendorID = vendorID
                        //  };
                        //  unit.Scope.Repository<ProductBarcode>().Add(productBarcode);
                        //}
                        //productBarcode.Barcode = item.EAN;

                        //#endregion
                    }
                    unit.Save();
                }
                catch (Exception ex)
                {
                    log.AuditError("Error update price", ex);
                }
            }
        }
Esempio n. 6
0
        private void ParseDocuments(IUnitOfWork unit, XDocument prods, DataTable cont, DataTable statuses, DataTable taxTable)
        {
            #region Xml Data

            var taxList = (from tax in taxTable.AsEnumerable()
                           select new
            {
                ID = tax[1].ToString(),
                Tax = tax[2].ToString()
            }).ToList();

            var vendorStatuses = (from status in statuses.AsEnumerable()
                                  select new
            {
                Code = status[0].ToString(),
                Name = status[1].ToString()
            });

            var itemContent = (from content in cont.AsEnumerable()
                               select new
            {
                Code = content[0].ToString(),
                Name = content[2].ToString(),
                Level = content[1].ToString()
            }).ToList();

            var itemProducts = (from itemproduct in prods.Element("XMLOUT_pricelist_01").Elements("item")
                                let content = itemContent
                                              select new
            {
                VendorName = itemproduct.Element("vendor").Value,
                CustomItemNr = itemproduct.Element("item_id").Value,
                VendorItemNr = itemproduct.Element("vendor_id").Value,
                Longdescription = itemproduct.Element("long_desc").Value,
                Price = itemproduct.Element("price").Value,
                Tax = taxList.FirstOrDefault(x => x.ID == itemproduct.Element("item_id").Value),
                Status = vendorStatuses.FirstOrDefault(x => x.Code == itemproduct.Element("status").Value),
                QuantityOnHand = itemproduct.Element("stock").Value,
                VendorProductGroupCode1 = content.FirstOrDefault(x => x.Code.StartsWith(itemproduct.Element("item_group").Value.Substring(0, 2)) && Int32.Parse(x.Level) == 1),
                VendorProductGroupCode2 = content.FirstOrDefault(x => x.Code.StartsWith(itemproduct.Element("item_group").Value.Substring(0, 2)) && Int32.Parse(x.Level) == 2),
                VendorProductGroupCode3 = content.FirstOrDefault(x => x.Code.StartsWith(itemproduct.Element("item_group").Value.Substring(0, 2)) && Int32.Parse(x.Level) == 3),
                VendorProductGroupCode4 = content.FirstOrDefault(x => x.Code.StartsWith(itemproduct.Element("item_group").Value.Substring(0, 2)) && Int32.Parse(x.Level) == 4),
                VendorProductGroupCode5 = content.FirstOrDefault(x => x.Code.StartsWith(itemproduct.Element("item_group").Value.Substring(0, 2)) && Int32.Parse(x.Level) == 5),
                Barcode = itemproduct.Element("EAN_code").Value,
                ShortContentDescription = ""
            }).ToList();

            #endregion

            var repoBrandVendor = unit.Scope.Repository <BrandVendor>();

            var prodRepo = unit.Scope.Repository <Product>().Include(c => c.ProductMedias, c => c.ProductBarcodes, c => c.ProductDescriptions);
            var productAttributeGroups = unit.Scope.Repository <ProductAttributeGroupMetaData>().GetAll(g => g.VendorID == VendorID).ToList();
            var repoAssortment         = unit.Scope.Repository <VendorAssortment>().Include(c => c.VendorPrices);
            var stockRepo              = unit.Scope.Repository <VendorStock>();
            var repoAttributeGroup     = unit.Scope.Repository <ProductAttributeGroupMetaData>();
            var repoAttributeGroupName = unit.Scope.Repository <ProductAttributeGroupName>();
            var repoAttribute          = unit.Scope.Repository <ProductAttributeMetaData>().Include(c => c.ProductAttributeNames, c => c.ProductAttributeValues);
            var repoVendor             = unit.Scope.Repository <ProductGroupVendor>();
            var prodDescriptionRepo    = unit.Scope.Repository <ProductDescription>();

            var products                   = prodRepo.GetAll(x => x.SourceVendorID == VendorID).ToList();
            var vendorassortments          = repoAssortment.GetAll(x => x.VendorID == VendorID).ToList();
            var productAttributes          = repoAttribute.GetAll(g => g.VendorID == VendorID).ToList();
            var currentProductGroupVendors = repoVendor.GetAll(v => v.Vendor.VendorID == VendorID).ToList();
            var productGroupVendorRecords  = repoVendor.GetAll(pc => pc.VendorID == VendorID).ToList();
            var brands = repoBrandVendor.GetAll(bv => bv.VendorID == VendorID).ToList();

            var vendorStock      = stockRepo.GetAll(x => x.VendorID == VendorID).ToList();
            var prodDescriptions = prodDescriptionRepo.GetAll().ToList();

            var prodAttributeGroups = repoAttributeGroup.GetAll(g => g.VendorID == VendorID).ToList();

            ProductStatusVendorMapper mapper = new ProductStatusVendorMapper(unit.Scope.Repository <VendorProductStatus>(), VendorID);

            int counter = 0;
            int total   = itemProducts.Count();
            int totalNumberOfProductsToProcess = total;
            log.InfoFormat("Start import {0} products", total);

            foreach (var product in itemProducts)
            {
                try
                {
                    if (counter == 100)
                    {
                        counter = 0;
                        log.InfoFormat("Still need to process {0} of {1}; {2} done;", totalNumberOfProductsToProcess, total, total - totalNumberOfProductsToProcess);
                    }

                    totalNumberOfProductsToProcess--;
                    counter++;

                    #region Brand

                    var vbrand = brands.FirstOrDefault(vb => vb.VendorBrandCode == product.VendorProductGroupCode1.Code);

                    if (vbrand == null)
                    {
                        vbrand = new BrandVendor
                        {
                            VendorID        = VendorID,
                            VendorBrandCode = product.VendorProductGroupCode1.Code,
                            BrandID         = UnMappedID
                        };

                        brands.Add(vbrand);

                        repoBrandVendor.Add(vbrand);
                    }

                    vbrand.Name = product.VendorName;

                    #endregion Brand

                    #region Product

                    var item = products.FirstOrDefault(p => p.VendorItemNumber == product.VendorItemNr && p.BrandID == vbrand.BrandID);
                    if (item == null)
                    {
                        item = new Product
                        {
                            VendorItemNumber = product.VendorItemNr,
                            BrandID          = vbrand.BrandID,
                            SourceVendorID   = VendorID
                        };
                        prodRepo.Add(item);
                        products.Add(item);
                        unit.Save();
                    }
                    else
                    {
                        if (item.BrandID < 0)
                        {
                            item.BrandID = vbrand.BrandID;
                        }
                    }

                    #endregion Product

                    #region Vendor assortment


                    //if (item.VendorAssortments == null) item.VendorAssortments = new List<VendorAssortment>();

                    var assortment = vendorassortments.FirstOrDefault(x => x.ProductID == item.ProductID);
                    if (assortment == null)
                    {
                        assortment = new VendorAssortment
                        {
                            VendorID = VendorID,
                            Product  = item
                        };
                        vendorassortments.Add(assortment);
                        repoAssortment.Add(assortment);
                    }

                    assortment.ShortDescription = product.Longdescription.Length > 150 ? product.Longdescription.Substring(0, 150) : product.Longdescription;
                    assortment.CustomItemNumber = product.CustomItemNr;
                    assortment.IsActive         = true;
                    assortment.LongDescription  = product.Longdescription;


                    #region Product group
                    try
                    {
                        var brndCode = product.Try(x => x.VendorProductGroupCode1, null);

                        if (brndCode != null)
                        {
                            var productGroupVendor = productGroupVendorRecords.Where(pg => pg.GetType().GetProperty("BrandCode").GetValue(pg, null) != null &&
                                                                                     pg.GetType().GetProperty("BrandCode").GetValue(pg, null).ToString() == brndCode.Code.Trim()).FirstOrDefault();

                            if (productGroupVendor == null)
                            {
                                productGroupVendor = new ProductGroupVendor
                                {
                                    ProductGroupID = UnMappedID,
                                    VendorID       = VendorID,
                                    VendorName     = brndCode.Name.Trim()
                                };

                                productGroupVendor.GetType().GetProperty("BrandCode").SetValue(productGroupVendor, brndCode.Code.Trim(), null);

                                repoVendor.Add(productGroupVendor);
                                productGroupVendorRecords.Add(productGroupVendor);
                            }

                            #region sync
                            if (currentProductGroupVendors.Contains(productGroupVendor))
                            {
                                currentProductGroupVendors.Remove(productGroupVendor);
                            }
                            #endregion
                        }
                        for (int i = 2; i <= 4; i++)
                        {
                            var category = i == 2 ? product.Try(x => x.VendorProductGroupCode2, null) : i == 3 ? product.Try(x => x.VendorProductGroupCode3, null) : i == 4 ? product.Try(x => x.VendorProductGroupCode4, null) : null;

                            if (category != null)
                            {
                                var productGroupVendor = productGroupVendorRecords.Where(pg => pg.GetType().GetProperty("VendorProductGroupCode" + i).GetValue(pg, null) != null &&
                                                                                         pg.GetType().GetProperty("VendorProductGroupCode" + i).GetValue(pg, null).ToString() == category.Code.Trim()).FirstOrDefault();

                                if (productGroupVendor == null)
                                {
                                    productGroupVendor = new ProductGroupVendor
                                    {
                                        ProductGroupID = UnMappedID,
                                        VendorID       = VendorID,
                                        VendorName     = category.Name.Trim()
                                    };

                                    productGroupVendor.GetType().GetProperty("VendorProductGroupCode" + i).SetValue(productGroupVendor, category.Code.Trim(), null);

                                    repoVendor.Add(productGroupVendor);
                                    productGroupVendorRecords.Add(productGroupVendor);
                                }

                                #region sync
                                if (currentProductGroupVendors.Contains(productGroupVendor))
                                {
                                    currentProductGroupVendors.Remove(productGroupVendor);
                                }
                                #endregion
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        log.Error("Failed productgroups", ex);
                    }
                    #endregion

                    #region Vendor Product Group Assortment

                    string brandCode = product.VendorProductGroupCode1.Code;
                    /// string groupCode1 = product.VendorProductGroupCode1.Code;
                    string groupCode1 = product.VendorProductGroupCode2.Code;
                    string groupCode2 = product.VendorProductGroupCode3.Code;
                    string groupCode3 = product.VendorProductGroupCode4.Code;

                    var records = (from l in productGroupVendorRecords
                                   where
                                   ((brandCode != null && l.BrandCode.Trim() == brandCode) || l.BrandCode == null)
                                   &&
                                   ((groupCode1 != null && l.VendorProductGroupCode1 != null &&
                                     l.VendorProductGroupCode1.Trim() == groupCode1) || l.VendorProductGroupCode1 == null)
                                   &&
                                   ((groupCode2 != null && l.VendorProductGroupCode2 != null &&
                                     l.VendorProductGroupCode2.Trim() == groupCode2) || l.VendorProductGroupCode2 == null)
                                   &&
                                   ((groupCode3 != null && l.VendorProductGroupCode3 != null &&
                                     l.VendorProductGroupCode3.Trim() == groupCode3) || l.VendorProductGroupCode3 == null)
                                   select l).ToList();


                    List <int> existingProductGroupVendors = new List <int>();

                    foreach (ProductGroupVendor prodGroupVendor in records)
                    {
                        existingProductGroupVendors.Add(prodGroupVendor.ProductGroupVendorID);

                        if (prodGroupVendor.VendorAssortments == null)
                        {
                            prodGroupVendor.VendorAssortments = new List <VendorAssortment>();
                        }
                        if (prodGroupVendor.VendorAssortments.Any(x => x.VendorAssortmentID == assortment.VendorAssortmentID))
                        { // only add new rows
                            continue;
                        }
                        prodGroupVendor.VendorAssortments.Add(assortment);
                    }

                    var unusedPGV = new List <ProductGroupVendor>();
                    assortment.ProductGroupVendors.ForEach((pgv, id) =>
                    {
                        if (!existingProductGroupVendors.Contains(pgv.ProductGroupVendorID))
                        {
                            unusedPGV.Add(pgv);
                        }
                    });

                    unusedPGV.ForEach((pg) => { assortment.ProductGroupVendors.Remove(pg); });

                    #endregion

                    #endregion Vendor assortment

                    #region Stock

                    var stock = vendorStock.FirstOrDefault(c => c.ProductID == assortment.ProductID && c.VendorID == assortment.VendorID);

                    if (stock == null)
                    {
                        stock = new VendorStock
                        {
                            VendorID          = VendorID,
                            Product           = item,
                            VendorStockTypeID = 1
                        };
                        vendorStock.Add(stock);
                        stockRepo.Add(stock);
                    }
                    stock.QuantityOnHand = Int32.Parse(product.QuantityOnHand);
                    stock.StockStatus    = product.Status == null ? null : product.Status.Name;
                    if (product.Status != null)
                    {
                        stock.ConcentratorStatusID = mapper.SyncVendorStatus(product.Status.Name, -1);
                    }

                    #endregion Stock

                    #region Price

                    if (assortment.VendorPrices == null)
                    {
                        assortment.VendorPrices = new List <VendorPrice>();
                    }
                    var price = assortment.VendorPrices.FirstOrDefault();
                    if (price == null)
                    {
                        price = new VendorPrice
                        {
                            VendorAssortment = assortment,
                            MinimumQuantity  = 0
                        };

                        unit.Scope.Repository <VendorPrice>().Add(price);
                    }
                    price.CommercialStatus = product.Status == null ? null : product.Status.Name;
                    price.BasePrice        = Decimal.Parse(product.Price);
                    if (product.Tax != null)
                    {
                        price.TaxRate = Decimal.Parse(product.Tax.Tax) / Decimal.Parse(product.Price);
                    }
                    price.ConcentratorStatusID = stock.ConcentratorStatusID;

                    #endregion Price

                    #region Barcode

                    if (!String.IsNullOrEmpty(product.Barcode))
                    {
                        if (item.ProductBarcodes == null)
                        {
                            item.ProductBarcodes = new List <ProductBarcode>();
                        }
                        if (!item.ProductBarcodes.Any(pb => pb.Barcode.Trim() == product.Barcode.Trim()))
                        {
                            unit.Scope.Repository <ProductBarcode>().Add(new ProductBarcode
                            {
                                Product     = item,
                                Barcode     = product.Barcode.Trim(),
                                BarcodeType = (int)BarcodeTypes.Default,
                                VendorID    = VendorID
                            });
                        }
                    }

                    #endregion Barcode
                    unit.Save();
                }
                catch (Exception ex)
                {
                    log.Error("Error import products for Copaco", ex);
                }
            }
            #region delete unused productgroupvendor records
            foreach (var vProdGroup in currentProductGroupVendors)
            {
                if (vProdGroup.ProductGroupID == -1)
                {
                    unit.Scope.Repository <ProductGroupVendor>().Delete(vProdGroup);
                }
            }
            #endregion
        }