Пример #1
0
        public void Process()
        {
            var config = GetConfiguration().AppSettings.Settings;

            var ftp = new FtpManager(config["VSNFtpUrl"].Value, "pub3/",
                                     config["VSNUser"].Value, config["VSNPassword"].Value, false, true, log);

            using (var unit = GetUnitOfWork())
            {
                //DataLoadOptions options = new DataLoadOptions();
                //options.LoadWith<Product>(p => p.Media);
                //options.LoadWith<Product>(p => p.ProductDescription);
                //options.LoadWith<Product>(p => p.ProductBarcodes);
                //options.LoadWith<Product>(p => p.VendorAssortment);
                //options.LoadWith<VendorAssortment>(va => va.VendorPrice);
                //options.LoadWith<VendorAssortment>(va => va.VendorStock);
                //ctx.LoadOptions = options;

                ProductGroupSyncer        syncer       = new ProductGroupSyncer(VendorID, unit.Scope.Repository <ProductGroupVendor>());
                ProductStatusVendorMapper statusMapper = new ProductStatusVendorMapper(unit.Scope.Repository <VendorProductStatus>(), VendorID);

                BrandVendor brandVendor = null;
                List <ProductAttributeMetaData> attributes;
                SetupBrandAndAttributes(unit, out attributes, out brandVendor);

                using (var prodFile = ftp.OpenFile("7ExportProduct.xml"))
                {
                    using (DataSet ds = new DataSet())
                    {
                        ds.ReadXml(prodFile.Data);

                        ProcessProductsTable(ds.Tables[0], brandVendor.BrandID, attributes, syncer, statusMapper, null);
                    }
                }
            }
            log.AuditComplete("Finished partial VSN product import", "VSN Product Import");
        }
Пример #2
0
        private void ProcessCsv(CsvParser parser)
        {
            using (var unit = GetUnitOfWork())
            {
                RelatedProductTypes relatedProductTypes = new RelatedProductTypes(unit.Scope.Repository <RelatedProductType>());
                var relatedProductType = relatedProductTypes.SyncRelatedProductTypes("CompatibleProducts");

                //there are products with repeating vendoritemnumbers
                List <string> vendorItemNumbers = unit.Scope.Repository <Product>().GetAll(p => p.SourceVendorID == VendorID).Select(c => c.VendorItemNumber).ToList();

                var vendor        = unit.Scope.Repository <Vendor>().GetSingle(x => x.VendorID == VendorID);
                int couterProduct = 0;

                int logCount         = 0;
                var importedproducts = parser.ToList();
                int totalProducts    = importedproducts.Count();

                ProductStatusVendorMapper mapper = new ProductStatusVendorMapper(unit.Scope.Repository <VendorProductStatus>(), VendorID);
                List <Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorAssortmentItem> assortmentList = new List <Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorAssortmentItem>();

                //Used for VendorImportAttributeValues
                var productAttributes = unit.Scope.Repository <ProductAttributeMetaData>().GetAll(c => c.VendorID == VendorID).ToList();
                var attributeList     = productAttributes.ToDictionary(x => x.AttributeCode, y => y.AttributeID);

                foreach (Dictionary <string, string> record in importedproducts)
                {
                    couterProduct++;
                    logCount++;
                    if (logCount == 250)
                    {
                        log.DebugFormat("Products Processed : {0}/{1} for Vendor {2}", couterProduct, totalProducts, vendor.Name);
                        logCount = 0;
                    }

                    int      concentratorStatusID = -1;
                    DateTime backorderDate        = DateTime.Now;

                    if (!string.IsNullOrEmpty(record.Get(TechDataColumnDefs.BackorderDate.ToString())) &&
                        DateTime.TryParseExact(record.Get(TechDataColumnDefs.BackorderDate.ToString()), "dd/MM/yyyy", null, DateTimeStyles.None, out backorderDate) &&
                        DateTime.Compare(backorderDate, DateTime.Now) > 0)
                    {
                        concentratorStatusID = mapper.SyncVendorStatus("BackOrder", -1);
                    }
                    else
                    {
                        concentratorStatusID = mapper.SyncVendorStatus("InStock", -1);
                    }

                    string vendorItemNumber = record.Get(TechDataColumnDefs.VendorItemNumber.ToString()).Trim();

                    //if already an item with this vendor item number exists --> do nothing
                    if (vendorItemNumbers.Contains(vendorItemNumber.Trim()))
                    {
                        continue;
                    }

                    Decimal price = decimal.Parse(record.Get(TechDataColumnDefs.Price.ToString()));

                    string customItemNumber            = record.Get(TechDataColumnDefs.CustomItemNumber.ToString()).Trim();
                    string productGroupCode            = record.Get(TechDataColumnDefs.GrandChildVendorProductGroupCode.ToString());
                    string parentProductGroupCode      = record.Get(TechDataColumnDefs.ChildVendorProductGroupCode.ToString());
                    string grandParentProductGroupCode = record.Get(TechDataColumnDefs.ParentVendorProductGroupCode.ToString());

                    var assortment = new Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorAssortmentItem
                    {
                        #region BrandVendor
                        BrandVendors = new List <VendorAssortmentBulk.VendorImportBrand>()
                        {
                            new VendorAssortmentBulk.VendorImportBrand()
                            {
                                VendorID        = VendorID,
                                VendorBrandCode = record.Get(TechDataColumnDefs.Brand.ToString()).Trim().ToLower(),
                                ParentBrandCode = null,
                                Name            = record.Get(TechDataColumnDefs.Brand.ToString()).Trim().ToLower(),
                            }
                        },
                        #endregion

                        #region GeneralProductInfo
                        VendorProduct = new VendorAssortmentBulk.VendorProduct
                        {
                            VendorItemNumber            = vendorItemNumber,
                            CustomItemNumber            = customItemNumber,
                            ShortDescription            = record.Get(TechDataColumnDefs.Description.ToString()),
                            LongDescription             = record.Get(TechDataColumnDefs.Description.ToString()),
                            LineType                    = null,
                            LedgerClass                 = null,
                            ProductDesk                 = null,
                            ExtendedCatalog             = null,
                            VendorID                    = VendorID,
                            DefaultVendorID             = DefaultVendorID,
                            VendorBrandCode             = record.Get(TechDataColumnDefs.Brand.ToString()).Trim().ToLower(),
                            Barcode                     = record.Get(TechDataColumnDefs.EanCode.ToString()),
                            VendorProductGroupCode1     = grandParentProductGroupCode,
                            VendorProductGroupCodeName1 = null,
                            VendorProductGroupCode2     = parentProductGroupCode,
                            VendorProductGroupCodeName2 = null,
                            VendorProductGroupCode3     = productGroupCode,
                            VendorProductGroupCodeName3 = null
                        },
                        #endregion

                        #region RelatedProducts
                        RelatedProducts = new List <VendorAssortmentBulk.VendorImportRelatedProduct>()
                        {
                            new Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorImportRelatedProduct
                            {
                                VendorID                = VendorID,
                                DefaultVendorID         = DefaultVendorID,
                                CustomItemNumber        = customItemNumber,
                                RelatedProductType      = relatedProductType.Type,
                                RelatedCustomItemNumber = vendorItemNumber
                            }
                        },
                        #endregion

                        #region Attributes
                        VendorImportAttributeValues = new List <VendorAssortmentBulk.VendorImportAttributeValue>(),
                        //VendorImportAttributeValues = (from attr in enumValList
                        //                               let prop = record.Equals(attr)
                        //                               let attributeID = attributeList.ContainsKey(attr) ? attributeList[attr] : 2 //TODO set as -1
                        //                               let value = prop.ToString()
                        //                               where !string.IsNullOrEmpty(value)
                        //                               select new Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorImportAttributeValue
                        //                               {
                        //                                 VendorID = VendorID,
                        //                                 DefaultVendorID = DefaultVendorID,
                        //                                 CustomItemNumber = customItemNumber,
                        //                                 AttributeID = attributeID,
                        //                                 Value = value,
                        //                                 LanguageID = "1",
                        //                                 AttributeCode = attr,
                        //                               }).ToList(),
                        #endregion

                        #region Prices
                        VendorImportPrices = new List <Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorImportPrice>()
                        {
                            new Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorImportPrice()
                            {
                                VendorID         = VendorID,
                                DefaultVendorID  = DefaultVendorID,
                                CustomItemNumber = customItemNumber,
                                Price            = price.ToString("0.00", CultureInfo.InvariantCulture),
                                CostPrice        = price.ToString("0.00", CultureInfo.InvariantCulture),
                                TaxRate          = "19",
                                MinimumQuantity  = 0,
                                CommercialStatus = "SR"
                            }
                        },
                        #endregion

                        #region Stock
                        VendorImportStocks = new List <Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorImportStock>()
                        {
                            new Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorImportStock()
                            {
                                VendorID         = VendorID,
                                DefaultVendorID  = DefaultVendorID,
                                CustomItemNumber = customItemNumber,
                                QuantityOnHand   = 0,
                                StockType        = "Assortment",
                                StockStatus      = "S"
                            }
                        },
                        #endregion
                    };

                    assortmentList.Add(assortment);
                }

                using (var vendorAssortmentBulk = new VendorAssortmentBulk(assortmentList, VendorID, VendorID))
                {
                    vendorAssortmentBulk.Init(unit.Context);
                    vendorAssortmentBulk.Sync(unit.Context);
                }
            }
        }
Пример #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
        }
Пример #4
0
        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;
            }
        }
Пример #5
0
        protected void ProcessProductsTable(DataTable table, int vendorBrandID, IEnumerable <ProductAttributeMetaData> productAttributes, ProductGroupSyncer syncer, ProductStatusVendorMapper mapper, Dictionary <int, VendorAssortment> inactiveAss)
        {
            var products = (from r in table.Rows.Cast <DataRow>()
                            where !String.IsNullOrEmpty(r.Field <string>("EANNumber"))
                            group r by r.Field <string>("EANNumber")
                            into grp
                            let r = grp.First()
                                    select new
            {
                ProductID = r.Field <string>("ProductCode"),
                EAN = r.Field <string>("EANNumber"),
                EAN_Alt = r.Field <string>("EANNumberAlternative"),
                Description = r.Field <string>("ProductName"),
                TagLine = r.Field <string>("TagLine"),
                Title = r.Field <string>("Title"),
                ProductionYear = r.Field <int?>("ProductionYear"),
                RunningTime = r.Field <int?>("RunningTime"),
                CountryName = r.Field <string>("CountryName"),
                UsrReleaseDate = r.Field <string>("UsrReleaseDate"),
                ProductStatusID = r.Field <long?>("ProductStatusID"),
                ProductStatus = r.Field <string>("ProductStatus").Trim(),
                SalesPrice = r.Field <decimal?>("SalesPrice"),
                RetailPrice = ((r.Field <decimal?>("RetailPrice") ?? 0) / (decimal)1.19),
                ListRetailPrice = r.Field <decimal?>("ListRetailPrice"),
                ListSalesPrice = r.Field <decimal?>("ListSalesPrice"),
                InStock = r.Field <int?>("InStock"),
                GenreID = r.Field <long?>("GenreID"),
                GenreName = r.Field <string>("GenreName"),
                ProductGroupCode = r.Field <string>("ProductGroupCode"),
                ProductGroup = r.Field <string>("ProductGroup"),
                SubProductGroupCode = r.Field <string>("SubProductGroupCode"),
                SubProductGroup = r.Field <string>("SubProductGroup"),
                SubGenreID = r.Field <long?>("SubGenreID"),
                SubGenreName = r.Field <string>("SubGenreName"),
                RatingAge = r.Field <string>("RatingAge"),
                MediaType = r.Field <string>("MediaType"),
                MediaTypeID = r.Field <long?>("MediaTypeID"),
                Artist = r.Field <string>("Artist"),
                MediaDescription = r.Field <string>("MediaDescription")
            }).ToList();

            using (IUnitOfWork unit = GetUnitOfWork())
            {
                //DataLoadOptions options = new DataLoadOptions();
                //options.LoadWith<ProductGroupVendor>(x => x.VendorProductGroupAssortments);
                //options.LoadWith<VendorAssortment>(x => x.VendorPrice);
                //options.LoadWith<Product>(x => x.ProductBarcodes);
                //ctx.LoadOptions = options;

                List <Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorAssortmentItem> assortmentList = new List <Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorAssortmentItem>();

                RelatedProductTypes relatedProductTypes = new RelatedProductTypes(unit.Scope.Repository <RelatedProductType>());
                var relatedProductType = relatedProductTypes.SyncRelatedProductTypes("CompatibleProducts");

                var productGroupVendorRepo = unit.Scope.Repository <ProductGroupVendor>().Include(c => c.VendorAssortments);
                var assortmentRepo         = unit.Scope.Repository <VendorAssortment>().Include(c => c.VendorPrices);
                var stockRepo   = unit.Scope.Repository <VendorStock>();
                var productRepo = unit.Scope.Repository <Product>().Include(c => c.ProductBarcodes);
                var priceRepo   = unit.Scope.Repository <VendorPrice>();


                var productGroupVendorRecords = productGroupVendorRepo.GetAll(c => c.VendorID == VendorID).ToList();

                int step = 1000;
                int todo = products.Count();
                int done = 0;

                var languages = new[] { (int)LanguageTypes.English, (int)LanguageTypes.Netherlands };

                var vendorAssortment = assortmentRepo.GetAll(x => x.VendorID == VendorID).ToDictionary(x => x.ProductID, y => y);
                var attributeList    = productAttributes.ToDictionary(x => x.AttributeCode, y => y.AttributeID);

                var vendorStock = stockRepo.GetAll(x => x.VendorID == VendorID).ToDictionary(x => x.ProductID, y => y);

                var prodType = products.First().GetType();

                var currentProductGroupVendors = productGroupVendorRepo.GetAll(v => v.VendorID == VendorID).ToList();

                log.InfoFormat(todo + " products to be processed");

                while (done < todo)
                {
                    log.DebugFormat("{0} products to be processed", todo - done);

                    var toProcess = products.OrderByDescending(x => x.UsrReleaseDate).Skip(done).Take(step);

                    foreach (var product in toProcess)
                    {
                        try
                        {
                            if (product.ProductGroupCode != "GAMES" && product.ProductGroupCode != "HARDWARE")
                            {
                                continue;
                            }

                            //#if DEBUG
                            //          if (product.EAN != "8714025503775")
                            //            continue;
                            //#endif
                            //log.DebugFormat("{0} products to be processed in batch", toProcess.Count());

                            var assortment = new Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorAssortmentItem
                            {
                                #region BrandVendor
                                BrandVendors = new List <VendorAssortmentBulk.VendorImportBrand>()
                                {
                                    new VendorAssortmentBulk.VendorImportBrand()
                                    {
                                        VendorID        = VendorID,
                                        VendorBrandCode = BrandVendorCode,
                                        ParentBrandCode = null,
                                        Name            = product.GenreName
                                    }
                                },
                                #endregion

                                #region GeneralProductInfo
                                VendorProduct = new VendorAssortmentBulk.VendorProduct
                                {
                                    VendorItemNumber            = product.EAN,
                                    CustomItemNumber            = product.ProductID,
                                    ShortDescription            = product.Description.Length > 150 ? product.Description.Substring(0, 150) : product.Description,
                                    LongDescription             = product.Description,
                                    LineType                    = "S",
                                    LedgerClass                 = null,
                                    ProductDesk                 = null,
                                    ExtendedCatalog             = null,
                                    VendorID                    = VendorID,
                                    DefaultVendorID             = DefaultVendorID,
                                    VendorBrandCode             = BrandVendorCode,
                                    Barcode                     = product.EAN,
                                    VendorProductGroupCode1     = product.ProductGroupCode,
                                    VendorProductGroupCodeName1 = product.ProductGroup,
                                    VendorProductGroupCode2     = product.SubProductGroupCode,
                                    VendorProductGroupCodeName2 = product.SubProductGroup,
                                    VendorProductGroupCode3     = product.GenreName
                                                                  //VendorProductGroupCodeName3 = product.SubProductGroup
                                },
                                #endregion

                                #region RelatedProducts
                                RelatedProducts = new List <VendorAssortmentBulk.VendorImportRelatedProduct>()
                                {
                                    new Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorImportRelatedProduct
                                    {
                                        VendorID                = VendorID,
                                        DefaultVendorID         = DefaultVendorID,
                                        CustomItemNumber        = product.ProductID,
                                        RelatedProductType      = relatedProductType.Type,
                                        RelatedCustomItemNumber = product.EAN
                                    }
                                },
                                #endregion

                                #region Attributes
                                VendorImportAttributeValues = (from attr in AttributeMapping
                                                               let prop = product.Equals(attr)//d.Field<object>(attr)
                                                                          let attributeID = attributeList.ContainsKey(attr) ? attributeList[attr] : -1
                                                                                            let value = prop.ToString()
                                                                                                        where !string.IsNullOrEmpty(value)
                                                                                                        select new Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorImportAttributeValue
                                {
                                    VendorID = VendorID,
                                    DefaultVendorID = DefaultVendorID,
                                    CustomItemNumber = product.ProductID,
                                    AttributeID = attributeID,
                                    Value = value,
                                    LanguageID = "1",
                                    AttributeCode = attr,
                                }).ToList(),
                                #endregion

                                #region Prices
                                VendorImportPrices = new List <Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorImportPrice>()
                                {
                                    new Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorImportPrice()
                                    {
                                        VendorID         = VendorID,
                                        DefaultVendorID  = DefaultVendorID,
                                        CustomItemNumber = product.ProductID,
                                        Price            = decimal.Round(product.RetailPrice, 4).ToString("0.00", CultureInfo.InvariantCulture),
                                        CostPrice        = decimal.Round(product.SalesPrice.Value, 4).ToString("0.00", CultureInfo.InvariantCulture),
                                        TaxRate          = "19", //TODO: Calculate this!
                                        MinimumQuantity  = 1,
                                        CommercialStatus = product.ProductStatus
                                    }
                                },
                                #endregion

                                #region Stock
                                VendorImportStocks = new List <Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorImportStock>()
                                {
                                    new Concentrator.Objects.Vendors.Bulk.VendorAssortmentBulk.VendorImportStock()
                                    {
                                        VendorID         = VendorID,
                                        DefaultVendorID  = DefaultVendorID,
                                        CustomItemNumber = product.ProductID,
                                        QuantityOnHand   = 0,
                                        StockType        = "Assortment",
                                        StockStatus      = product.ProductStatus
                                    }
                                },
                                #endregion
                            };

                            assortmentList.Add(assortment);
                        }
                        catch (Exception ex)
                        {
                            log.WarnFormat("Batch update failed with message : {0}", ex.Message);
                        }
                    }
                    done += toProcess.Count();
                }

                #region delete unused
                foreach (var vProdVendor in currentProductGroupVendors)
                {
                    if (vProdVendor.ProductGroupID == -1)
                    {
                        //productGroupVendorRepo.Delete(vProdVendor);
                    }
                }
                #endregion

                // Creates a new instance of VendorAssortmentBulk(Passes in the AssortmentList defined above, vendorID and DefaultVendorID)
                using (var vendorAssortmentBulk = new VendorAssortmentBulk(assortmentList, VendorID, VendorID))
                {
                    vendorAssortmentBulk.Init(unit.Context);
                    vendorAssortmentBulk.Sync(unit.Context);
                }


                log.AuditInfo("Products processing finished. Processed " + done + " products");
            }
        }
Пример #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
        }
        public void Process()
        {
            var config = GetConfiguration().AppSettings.Settings;


            var ftp = new FtpManager(config["VSNFtpUrl"].Value, "pub3/", config["VSNUser"].Value, config["VSNPassword"].Value, false, true, log);


            using (var unit = GetUnitOfWork())
            {
                //DataLoadOptions options = new DataLoadOptions();
                //options.LoadWith<Product>(p => p.ProductImages);
                //options.LoadWith<Product>(p => p.ProductDescription);
                //options.LoadWith<Product>(p => p.ProductBarcodes);
                //options.LoadWith<Product>(p => p.VendorAssortment);
                //options.LoadWith<VendorAssortment>(va => va.VendorPrice);
                //options.LoadWith<VendorAssortment>(va => va.VendorStock);

                //options.LoadWith<ProductAttributeMetaData>(p => p.ProductAttributeValues);
                //options.LoadWith<ProductGroupVendor>(x=>x.VendorProductGroupAssortments);
                //options.LoadWith<VendorAssortment>(x => x.VendorPrice);
                //options.LoadWith<VendorAssortment>(va => va.VendorStock);

                //ctx.LoadOptions = options;
                ProductStatusVendorMapper mapper = new ProductStatusVendorMapper(unit.Scope.Repository <VendorProductStatus>(), VendorID);
                ProductGroupSyncer        syncer = new ProductGroupSyncer(VendorID, unit.Scope.Repository <ProductGroupVendor>());

                BrandVendor brandVendor = null;
                List <ProductAttributeMetaData> attributes;
                SetupBrandAndAttributes(unit, out attributes, out brandVendor);

//#if DEBUG
//        if (File.Exists("ExportProduct.xml"))
//        {
//          DataSet ds2 = new DataSet();
//          ds2.ReadXml("ExportProduct.xml");

//          ProcessProductsTable(ds2.Tables[0], brandVendor.BrandID, attributes, syncer, mapper);
//        }
//#endif
                var inactiveAss = unit.Scope.Repository <VendorAssortment>().GetAll(x => x.VendorID == VendorID).ToDictionary(x => x.VendorAssortmentID, y => y);

                using (var prodFile = ftp.OpenFile("XMLExportProduct.zip"))
                {
                    using (var zipProc = new ZipProcessor(prodFile.Data))
                    {
                        foreach (var file in zipProc)
                        {
                            using (file)
                            {
#if DEBUG
                                using (System.IO.FileStream fs = new FileStream(file.FileName, FileMode.OpenOrCreate))
                                {
                                    file.Data.WriteTo(fs);
                                    fs.Close();
                                }
#endif
                                using (DataSet ds = new DataSet())
                                {
                                    ds.ReadXml(file.Data);

                                    ProcessProductsTable(ds.Tables[0], brandVendor.BrandID, attributes, syncer, mapper, inactiveAss);
                                }
                            }
                        }
                    }
                }

                inactiveAss.Values.ForEach((x, idx) =>
                {
                    x.IsActive = false;
                });
                unit.Save();
            }
            log.AuditComplete("Finished full VSN product import", "VSN Product Import");
        }