Пример #1
0
            private void CreateListing(IEnumerable <BonanzaEntry> entries)
            {
                ListingDto listingDto = new ListingDto();

                listingDto.Brand           = entries.First(p => !string.IsNullOrWhiteSpace(p.Brand)).Brand;
                listingDto.FullDescription = entries.First(p => !string.IsNullOrWhiteSpace(p.FullDescription)).FullDescription;

                if (entries.Count() > 1)
                {
                    listingDto.Sku = entries.First(p => !string.IsNullOrWhiteSpace(p.ClassName)).ClassName;

                    BonanzaEntry entry = entries.First(p => !string.IsNullOrWhiteSpace(p.Title));
                    listingDto.Title       = GetParentTitle(entry);;
                    listingDto.IsVariation = true;
                }
                else
                {
                    listingDto.Sku         = entries.First().Sku;
                    listingDto.Title       = entries.First().Title;
                    listingDto.IsVariation = false;
                }

                foreach (BonanzaEntry entry in entries)
                {
                    ListingItemDto listingItem = new ListingItemDto();

                    listingItem.Sku   = entry.Sku;
                    listingItem.Qty   = entry.Q;
                    listingItem.Price = entry.P;

                    listingDto.Items.Add(listingItem);
                }

                _services.Publish(_marketplace.ID, listingDto);
            }
        private void CreateListing(IEnumerable <EbayEntry> entries, bool isVariation)
        {
            ListingDto listingDto = new ListingDto();

            listingDto.Brand           = entries.First(p => !string.IsNullOrWhiteSpace(p.Brand)).Brand;
            listingDto.Duration        = entries.First(p => !string.IsNullOrWhiteSpace(p.Format)).GetDuration();
            listingDto.Format          = entries.First(p => !string.IsNullOrWhiteSpace(p.Format)).GetFormat();
            listingDto.FullDescription = entries.First(p => !string.IsNullOrWhiteSpace(p.FullDescription)).FullDescription;
            listingDto.IsVariation     = isVariation;


            if (isVariation)
            {
                listingDto.Title = GetParentTitle(entries.First(p => !string.IsNullOrWhiteSpace(p.Title)));
            }
            else
            {
                listingDto.Title = entries.First(p => !string.IsNullOrWhiteSpace(p.Title)).Title;
            }

            if (entries.Any(p => !string.IsNullOrWhiteSpace(p.Template)))
            {
                listingDto.Template = entries.First(p => !string.IsNullOrWhiteSpace(p.Template)).Template;
            }

            if (entries.Any(p => !string.IsNullOrWhiteSpace(p.Design)))
            {
                listingDto.Design = entries.First(p => !string.IsNullOrWhiteSpace(p.Design)).Design;
            }

            if (entries.Any(p => p.StartDate != null))
            {
                listingDto.ScheduleTime = entries.First(p => p.StartDate != null).StartDate;
            }



            if (isVariation)
            {
                listingDto.Sku = entries.First(p => !string.IsNullOrWhiteSpace(p.ClassName)).ClassName;
            }
            else
            {
                listingDto.Sku = entries.First().Sku;

                if (entries.First().BIN != null && listingDto.Format.Equals(EbayMarketplace.FORMAT_AUCTION))
                {
                    listingDto.BinPrice = entries.First().BIN;
                }
            }

            foreach (EbayEntry entry in entries)
            {
                ListingItemDto listingItem = new ListingItemDto();

                listingItem.Sku   = entry.Sku;
                listingItem.Qty   = entry.Q;
                listingItem.Price = entry.P;
                listingDto.Items.Add(listingItem);
            }

            _ebayServices.Publish(_marketplace.ID, listingDto, "Publisher");
        }
        private void UpdateListing(EbayListing listing, IEnumerable <EbayEntry> entries)
        {
            ListingDto listingDto = new ListingDto();

            listingDto.Code        = listing.Code;
            listingDto.Format      = entries.First(p => !string.IsNullOrWhiteSpace(p.Format)).GetFormat();
            listingDto.Brand       = entries.First(p => !string.IsNullOrWhiteSpace(p.Brand)).Brand;
            listingDto.IsVariation = (bool)listing.IsVariation;

            if (entries.Any(p => !string.IsNullOrWhiteSpace(p.Template)))
            {
                listingDto.Template = entries.First(p => !string.IsNullOrWhiteSpace(p.Template)).Template;
            }

            if (entries.Any(p => !string.IsNullOrWhiteSpace(p.Design)))
            {
                listingDto.Design = entries.First(p => !string.IsNullOrWhiteSpace(p.Design)).Design;
            }

            if (entries.Any(p => !string.IsNullOrWhiteSpace(p.FullDescription)))
            {
                listingDto.FullDescription = entries.First(p => !string.IsNullOrWhiteSpace(p.FullDescription)).FullDescription;
            }

            if (entries.Any(p => !string.IsNullOrWhiteSpace(p.Title)))
            {
                if ((bool)listing.IsVariation)
                {
                    listingDto.Title = GetParentTitle(entries.First(p => !string.IsNullOrWhiteSpace(p.Title)));
                }
                else
                {
                    listingDto.Title = entries.First(p => !string.IsNullOrWhiteSpace(p.Title)).Title;
                }
            }

            foreach (EbayEntry entry in entries)
            {
                ListingItemDto listingItemDto = new ListingItemDto();
                listingItemDto.Sku   = entry.Sku;
                listingItemDto.Qty   = entry.Q;
                listingItemDto.Price = entry.P;
                listingDto.Items.Add(listingItemDto);
            }

            var activeListingItems = listing.ListingItems.Where(p => p.Quantity != 0);

            foreach (EbayListingItem listingItem in activeListingItems)
            {
                if (!listingDto.Items.Any(p => p.Sku.Equals(listingItem.Sku)))
                {
                    ListingItemDto listingItemDto = new ListingItemDto();
                    listingItemDto.Sku   = listingItem.Sku;
                    listingItemDto.Qty   = listingItem.Quantity;
                    listingItemDto.Price = listingItem.Price;
                    listingDto.Items.Add(listingItemDto);
                }
            }

            var activeSkus = activeListingItems.Select(p => p.Item.ItemLookupCode);

            bool mustIncludeProductData = listingDto.Items.Any(p => !activeSkus.Any(s => s.Equals(p.Sku)));

            bool includeTemplate = entries.Any(p => p.GetUpdateFlags().Any(s => s.Trim().ToUpper().Equals("TEMPLATE")));

            bool includeProductData = entries.Any(p => p.GetUpdateFlags().Any(s => s.Trim().ToUpper().Equals("PRODUCTDATA"))) || mustIncludeProductData;

            if (listingDto.Items.All(p => p.Qty == 0))
            {
                _ebayServices.End(_marketplace.ID, listing.Code, "Publisher");
            }
            else
            {
                _ebayServices.Revise(_marketplace.ID, listingDto, includeProductData, includeTemplate, "Publisher");
            }
        }
Пример #4
0
        public async override void Publish(IEnumerable <ListingEntry> entries)
        {
            _processingEntries.AddRange(entries.Cast <AmznEntry>());

            List <ListingItemDto> listingItems = new List <ListingItemDto>();

            foreach (AmznEntry entry in entries)
            {
                ListingItemDto listingItem = new ListingItemDto();

                listingItem.Sku = entry.Sku;

                listingItem.Title = entry.Title;

                var existingListingItem = _dataContext.AmznListingItems.SingleOrDefault(p => p.IsActive && p.Item != null && p.Item.ItemLookupCode.Equals(entry.Sku) && p.MarketplaceID == _marketplace.ID);

                listingItem.IncludeProductData = existingListingItem == null || entry.GetUpdateFlags().Any(p => p.Equals("PRODUCTDATA"));

                listingItem.Qty   = entry.Q;
                listingItem.Price = entry.P;

                if (entry.SalePrice.HasValue && entry.SaleStart.HasValue && entry.SaleEnd.HasValue)
                {
                    listingItem.SaleData = new SaleData()
                    {
                        SalePrice = entry.SalePrice.Value, StartDate = entry.SaleStart.Value, EndDate = entry.SaleEnd.Value
                    };
                }

                listingItems.Add(listingItem);

                entry.Status = StatusCode.Processing;
            }

            BerkeleyEntities.Amazon.AmazonServices services = new BerkeleyEntities.Amazon.AmazonServices();

            services.Result += Publisher_Result;

            await Task.Run(() => services.Publish(_marketplace.ID, listingItems, "Publisher"));

            while (_pendingResubmission.Count > 0)
            {
                var results = _pendingResubmission.Dequeue();

                RepublishDataWindow republishForm = new RepublishDataWindow();
                republishForm.DataContext = CollectionViewSource.GetDefaultView(results);
                republishForm.ShowDialog();

                if ((bool)republishForm.DialogResult)
                {
                    foreach (var result in results)
                    {
                        AmznEntry entry = _processingEntries.Single(p => p.Sku.Equals(result.Data.Sku));
                        entry.Status = StatusCode.Processing;
                    }

                    await Task.Run(() => services.Publish(_marketplace.ID, results.Select(p => p.Data), "Publisher"));
                }
            }

            this.RaisePublishCompleted();
        }
Пример #5
0
            private void UpdateListing(BonanzaListing listing, IEnumerable <BonanzaEntry> entries)
            {
                ListingDto listingDto = new ListingDto();

                listingDto.Code        = listing.Code;
                listingDto.Brand       = entries.First(p => !string.IsNullOrWhiteSpace(p.Brand)).Brand;
                listingDto.IsVariation = (bool)listing.IsVariation;

                if ((bool)listing.IsVariation)
                {
                    listingDto.IsVariation = true;
                    listingDto.Sku         = entries.First(p => !string.IsNullOrWhiteSpace(p.ClassName)).ClassName;
                }
                else
                {
                    listingDto.IsVariation = false;
                    listingDto.Sku         = listingDto.Sku = entries.First().Sku;
                }

                if (entries.Any(p => !string.IsNullOrWhiteSpace(p.FullDescription)))
                {
                    listingDto.FullDescription = entries.First(p => !string.IsNullOrWhiteSpace(p.FullDescription)).FullDescription;
                }

                foreach (BonanzaEntry entry in entries)
                {
                    BonanzaListingItem listingItem = listing.ListingItems.SingleOrDefault(p => p.Item.ItemLookupCode.Equals(entry.Sku));

                    ListingItemDto listingItemDto = new ListingItemDto();
                    listingItemDto.Sku   = entry.Sku;
                    listingItemDto.Qty   = entry.Q;
                    listingItemDto.Price = entry.P;

                    listingDto.Items.Add(listingItemDto);
                }

                var activeSkus = listing.ListingItems.Where(p => p.Quantity != 0).Select(p => p.Item.ItemLookupCode);

                bool mustIncludeProductData = listingDto.Items.Any(p => !activeSkus.Any(s => s.Equals(p.Sku)));

                foreach (BonanzaListingItem listingItem in listing.ListingItems)
                {
                    if (!listingDto.Items.Any(p => p.Sku.Equals(listingItem.Item.ItemLookupCode)))
                    {
                        ListingItemDto listingItemDto = new ListingItemDto();
                        listingItemDto.Qty   = listingItem.Quantity;
                        listingItemDto.Price = listingItem.Price;

                        listingDto.Items.Add(listingItemDto);
                    }
                }

                bool includeTemplate = entries.Any(p => p.GetUpdateFlags().Any(s => s.Trim().ToUpper().Equals("TEMPLATE")));

                bool includeProductData = entries.Any(p => p.GetUpdateFlags().Any(s => s.Trim().ToUpper().Equals("PRODUCTDATA"))) || mustIncludeProductData;

                if (listingDto.Items.All(p => p.Qty == 0))
                {
                    _services.End(_marketplace.ID, listing.Code);
                }
                else
                {
                    _services.Revise(_marketplace.ID, listingDto, includeProductData, includeTemplate);
                }
            }