public void DoImport(Stream backupStream, Action<ExportImportProgressInfo> progressCallback)
		{
			var backupObject = backupStream.DeserializeJson<BackupObject>();

			backupObject.FulfillmentCenters.ForEach(x => _commerceService.UpsertFulfillmentCenter(x));
			progressCallback(new ExportImportProgressInfo("update fulfillmentCenters done"));
		}
        public void DoImport(Stream backupStream, Action<ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson<BackupObject>();
			var originalObject = GetBackupObject(progressCallback);

			var progressInfo = new ExportImportProgressInfo();

			progressInfo.Description = String.Format("{0} promotions importing...", backupObject.Promotions.Count());
			progressCallback(progressInfo);
			UpdatePromotions(originalObject.Promotions, backupObject.Promotions);

			progressInfo.Description = String.Format("{0} folders importing...", backupObject.ContentFolders.Count());
			progressCallback(progressInfo);
            UpdateContentFolders(originalObject.ContentFolders, backupObject.ContentFolders);

			progressInfo.Description = String.Format("{0} places importing...", backupObject.ContentPlaces.Count());
			progressCallback(progressInfo);
            UpdateContentPlaces(originalObject.ContentPlaces, backupObject.ContentPlaces);

			progressInfo.Description = String.Format("{0} contents importing...", backupObject.ContentItems.Count());
			progressCallback(progressInfo);
            UpdateContentItems(originalObject.ContentItems, backupObject.ContentItems);

			progressInfo.Description = String.Format("{0} publications importing...", backupObject.ContentPublications.Count());
			progressCallback(progressInfo);
            UpdateContentPublications(originalObject.ContentPublications, backupObject.ContentPublications);

        }
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject   = backupStream.DeserializeJson <BackupObject>();
            var originalObject = GetBackupObject(progressCallback);

            var progressInfo = new ExportImportProgressInfo();

            progressInfo.Description = String.Format("{0} promotions importing...", backupObject.Promotions.Count());
            progressCallback(progressInfo);
            UpdatePromotions(originalObject.Promotions, backupObject.Promotions);

            progressInfo.Description = String.Format("{0} folders importing...", backupObject.ContentFolders.Count());
            progressCallback(progressInfo);
            UpdateContentFolders(originalObject.ContentFolders, backupObject.ContentFolders);

            progressInfo.Description = String.Format("{0} places importing...", backupObject.ContentPlaces.Count());
            progressCallback(progressInfo);
            UpdateContentPlaces(originalObject.ContentPlaces, backupObject.ContentPlaces);

            progressInfo.Description = String.Format("{0} contents importing...", backupObject.ContentItems.Count());
            progressCallback(progressInfo);
            UpdateContentItems(originalObject.ContentItems, backupObject.ContentItems);

            progressInfo.Description = String.Format("{0} publications importing...", backupObject.ContentPublications.Count());
            progressCallback(progressInfo);
            UpdateContentPublications(originalObject.ContentPublications, backupObject.ContentPublications);
        }
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson <BackupObject>();

            backupObject.FulfillmentCenters.ForEach(x => _commerceService.UpsertFulfillmentCenter(x));
            progressCallback(new ExportImportProgressInfo("update fulfillmentCenters done"));
        }
        public void DoImport(Stream backupStream, Action<ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson<BackupObject>();

            _inventoryService.UpsertInventories(backupObject.InventoryInfos);
            progressCallback(new ExportImportProgressInfo("update inventory done"));
        }
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson <BackupObject>();

            _inventoryService.UpsertInventories(backupObject.InventoryInfos);
            progressCallback(new ExportImportProgressInfo("update inventory done"));
        }
示例#7
0
        public void DoImport(Stream backupStream, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback)
        {
            if (manifest == null)
            {
                throw new ArgumentNullException(nameof(manifest));
            }

            var backupObject   = backupStream.DeserializeJson <BackupObject>();
            var originalObject = GetBackupObject(progressCallback, false);

            var progressInfo = new ExportImportProgressInfo
            {
                Description = String.Format("{0} menu link lists importing...", backupObject.MenuLinkLists.Count())
            };

            progressCallback(progressInfo);
            UpdateMenuLinkLists(backupObject.MenuLinkLists);

            if (manifest.HandleBinaryData)
            {
                progressInfo.Description = String.Format("importing binary data:  themes and pages importing...");
                progressCallback(progressInfo);
                foreach (var folder in backupObject.ContentFolders)
                {
                    SaveContentFolderRecursive(folder, progressCallback);
                }
            }
        }
        public virtual void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson <BackupObject>();
            var progressInfo = new ExportImportProgressInfo();

            progressInfo.Description = $"{backupObject.Promotions.Count} promotions importing...";
            progressCallback(progressInfo);

            //legacy promotion compatability
            foreach (var promotion in backupObject.Promotions)
            {
                if (promotion.StoreIds.IsNullOrEmpty())
                {
                    promotion.StoreIds = new List <string>();
                }

                if (!promotion.Store.IsNullOrEmpty() && !promotion.StoreIds.Contains(promotion.Store))
                {
                    promotion.StoreIds.Add(promotion.Store);
                }
            }

            SavePromotions(backupObject.Promotions.ToArray());

            progressInfo.Description = $"{backupObject.ContentFolders.Count} folders importing...";
            progressCallback(progressInfo);
            SaveFolders(backupObject.ContentFolders.ToArray());

            progressInfo.Description = $"{backupObject.ContentPlaces.Count} places importing...";
            progressCallback(progressInfo);
            SavePlaces(backupObject.ContentPlaces.ToArray());

            progressInfo.Description = $"{backupObject.ContentItems.Count} contents importing...";
            progressCallback(progressInfo);
            SaveContentItems(backupObject.ContentItems.ToArray());

            progressInfo.Description = $"{backupObject.ContentPublications.Distinct().Count()} publications importing...";
            progressCallback(progressInfo);
            SavePublications(backupObject.ContentPublications.Distinct().ToArray());

            var pageSize     = 500;
            var couponsTotal = backupObject.Coupons.Count;

            Paginate(couponsTotal, pageSize, (x) =>
            {
                progressInfo.Description = $"{Math.Min(x * pageSize, couponsTotal)} of {couponsTotal} coupons imported";
                progressCallback(progressInfo);
                SaveCoupons(backupObject.Coupons.Skip((x - 1) * pageSize).Take(pageSize).ToArray());
            });

            var usagesTotal = backupObject.Usages.Count;

            Paginate(usagesTotal, pageSize, (x) =>
            {
                progressInfo.Description = $"{Math.Min(x * pageSize, usagesTotal)} of {usagesTotal} usages imported";
                progressCallback(progressInfo);
                SaveUsages(backupObject.Usages.Skip((x - 1) * pageSize).Take(pageSize).ToArray());
            });
        }
		public void DoImport(Stream backupStream, PlatformExportManifest manifest, Action<ExportImportProgressInfo> progressCallback)
		{
			var progressInfo = new ExportImportProgressInfo();

			var backupObject = backupStream.DeserializeJson<BackupObject>();
			var originalObject = GetBackupObject(progressCallback, false);

			progressInfo.Description = String.Format("{0} catalogs importing...", backupObject.Catalogs.Count());
			progressCallback(progressInfo);

			UpdateCatalogs(originalObject.Catalogs, backupObject.Catalogs);

			progressInfo.Description = String.Format("{0} categories importing...", backupObject.Categories.Count());
			progressCallback(progressInfo);
			//Categories should be sorted right way 
            //first need to create virtual categories
			var orderedCategories = backupObject.Categories.Where(x=>x.Catalog.Virtual)
                                                             .OrderBy(x => x.Parents != null ? x.Parents.Count() : 0)
															 .ToList();
            //second need to create physical categories
            orderedCategories.AddRange(backupObject.Categories.Where(x => !x.Catalog.Virtual)
                                                             .OrderBy(x => x.Parents != null ? x.Parents.Count() : 0));

            backupObject.Products = backupObject.Products.OrderBy(x => x.MainProductId).ToList();
			UpdateCategories(originalObject.Categories, orderedCategories);
			UpdateProperties(originalObject.Properties, backupObject.Properties);

			//Binary data
			if (manifest.HandleBinaryData)
			{
				var allBackupImages = backupObject.Products.SelectMany(x => x.Images);
				allBackupImages = allBackupImages.Concat(backupObject.Categories.SelectMany(x => x.Images));
				allBackupImages = allBackupImages.Concat(backupObject.Products.SelectMany(x => x.Variations).SelectMany(x => x.Images));

				var allOrigImages = originalObject.Products.SelectMany(x => x.Images);
				allOrigImages = allOrigImages.Concat(originalObject.Categories.SelectMany(x => x.Images));
				allOrigImages = allOrigImages.Concat(originalObject.Products.SelectMany(x => x.Variations).SelectMany(x => x.Images));

				var allNewImages = allBackupImages.Where(x => !allOrigImages.Contains(x)).Where(x=>x.BinaryData != null);
				var index = 0;
				var progressTemplate = "{0} of " + allNewImages.Count() + " images uploading";
				foreach (var image in allNewImages)
				{
					progressInfo.Description = String.Format(progressTemplate, index);
					progressCallback(progressInfo);
					using (var stream = new MemoryStream(image.BinaryData))
					{
						image.Url = _blobStorageProvider.Upload(new UploadStreamInfo { FileByteStream = stream, FileName = image.Name, FolderName = "catalog" });
					}

					index++;
				}
			}

			progressInfo.Description = String.Format("{0} products importing...", backupObject.Products.Count());
			progressCallback(progressInfo);
			UpdateCatalogProducts(originalObject.Products, backupObject.Products);
		}
示例#10
0
        public void DoImport(Stream backupStream, Action<ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson<BackupObject>();

            var progressInfo = new ExportImportProgressInfo();
            progressInfo.Description = String.Format("{0} RFQs importing", backupObject.QuoteRequests.Count());
            progressCallback(progressInfo);
            _quoteRequestService.SaveChanges(backupObject.QuoteRequests.ToArray());
        }
        public void DoImport(Stream backupStream, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback)
        {
            var progressInfo = new ExportImportProgressInfo();

            var backupObject   = backupStream.DeserializeJson <BackupObject>();
            var originalObject = GetBackupObject(progressCallback, false);

            progressInfo.Description = String.Format("{0} catalogs importing...", backupObject.Catalogs.Count());
            progressCallback(progressInfo);

            UpdateCatalogs(originalObject.Catalogs, backupObject.Catalogs);

            progressInfo.Description = String.Format("{0} categories importing...", backupObject.Categories.Count());
            progressCallback(progressInfo);
            //Categories should be sorted right way (because it have a hierarchy structure and links to virtual categories)
            backupObject.Categories = backupObject.Categories.Where(x => x.Links == null || !x.Links.Any())
                                      .OrderBy(x => x.Parents != null ? x.Parents.Count() : 0)
                                      .Concat(backupObject.Categories.Where(x => x.Links != null && x.Links.Any()))
                                      .ToList();
            backupObject.Products = backupObject.Products.OrderBy(x => x.MainProductId).ToList();
            UpdateCategories(originalObject.Categories, backupObject.Categories);
            UpdateProperties(originalObject.Properties, backupObject.Properties);

            //Binary data
            if (manifest.HandleBinaryData)
            {
                var allBackupImages = backupObject.Products.SelectMany(x => x.Images);
                allBackupImages = allBackupImages.Concat(backupObject.Categories.SelectMany(x => x.Images));
                allBackupImages = allBackupImages.Concat(backupObject.Products.SelectMany(x => x.Variations).SelectMany(x => x.Images));

                var allOrigImages = originalObject.Products.SelectMany(x => x.Images);
                allOrigImages = allOrigImages.Concat(originalObject.Categories.SelectMany(x => x.Images));
                allOrigImages = allOrigImages.Concat(originalObject.Products.SelectMany(x => x.Variations).SelectMany(x => x.Images));

                var allNewImages     = allBackupImages.Where(x => !allOrigImages.Contains(x)).Where(x => x.BinaryData != null);
                var index            = 0;
                var progressTemplate = "{0} of " + allNewImages.Count() + " images uploading";
                foreach (var image in allNewImages)
                {
                    progressInfo.Description = String.Format(progressTemplate, index);
                    progressCallback(progressInfo);
                    using (var stream = new MemoryStream(image.BinaryData))
                    {
                        image.Url = _blobStorageProvider.Upload(new UploadStreamInfo {
                            FileByteStream = stream, FileName = image.Name, FolderName = "catalog"
                        });
                    }

                    index++;
                }
            }

            progressInfo.Description = String.Format("{0} products importing...", backupObject.Products.Count());
            progressCallback(progressInfo);
            UpdateCatalogProducts(originalObject.Products, backupObject.Products);
        }
示例#12
0
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson <BackupObject>();

            var progressInfo = new ExportImportProgressInfo();

            progressInfo.Description = String.Format("{0} RFQs importing", backupObject.QuoteRequests.Count());
            progressCallback(progressInfo);
            _quoteRequestService.SaveChanges(backupObject.QuoteRequests.ToArray());
        }
        public void DoImport(Stream backupStream, Action<ExportImportProgressInfo> progressCallback)
        {
            var prodgressInfo = new ExportImportProgressInfo { Description = "loading data..." };
            progressCallback(prodgressInfo);

            var backupObject = backupStream.DeserializeJson<BackupObject>();
            var originalObject = GetBackupObject();

            UpdateStores(originalObject.Stores, backupObject.Stores);
        }
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson <BackupObject>();
            var progressInfo = new ExportImportProgressInfo();

            progressInfo.Description = String.Format("{0} tagged items importing...", backupObject.TaggedItems.Count);
            progressCallback(progressInfo);

            _taggedItemService.SaveTaggedItems(backupObject.TaggedItems.ToArray());
        }
示例#15
0
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject   = backupStream.DeserializeJson <BackupObject>();
            var originalObject = GetBackupObject(progressCallback);

            var progressInfo = new ExportImportProgressInfo();

            progressInfo.Description = String.Format("{0} members importing...", backupObject.Members.Count());
            progressCallback(progressInfo);
            _memberService.CreateOrUpdate(backupObject.Members.OrderByDescending(x => x.MemberType).ToArray());
        }
示例#16
0
        /* ----------------------------------------------------------------- */
        ///
        /// Deserialize
        ///
        /// <summary>
        /// 指定されたストリームの内容をデシリアライズします。
        /// </summary>
        ///
        /// <param name="format">シリアライズ・フォーマット</param>
        /// <param name="src">読み込みストリーム</param>
        ///
        /// <returns>デシリアライズされたオブジェクト</returns>
        ///
        /* ----------------------------------------------------------------- */
        public static T Deserialize <T>(this Format format, Stream src)
        {
            switch (format)
            {
            case Format.Xml:  return(src.DeserializeXml <T>());

            case Format.Json: return(src.DeserializeJson <T>());

            default: throw new ArgumentException($"{format}:cannot deserialize from stream");
            }
        }
        public void DoImport(Stream backupStream, Action<ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson<BackupObject>();
			var originalObject = GetBackupObject(progressCallback);

			var progressInfo = new ExportImportProgressInfo();
			progressInfo.Description = String.Format("{0} members importing...", backupObject.Members.Count());
            progressCallback(progressInfo);
            _memberService.CreateOrUpdate(backupObject.Members.OrderByDescending(x => x.MemberType).ToArray());

        }
示例#18
0
        public void DoImport(Stream backupStream, Action<ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson<BackupObject>();
			var originalObject = GetBackupObject(progressCallback);

			var progressInfo = new ExportImportProgressInfo();
			progressInfo.Description = String.Format("{0} stores importing...", backupObject.Stores.Count());
			progressCallback(progressInfo);

            UpdateStores(originalObject.Stores, backupObject.Stores);
        }
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject   = backupStream.DeserializeJson <BackupObject>();
            var originalObject = GetBackupObject(progressCallback);

            var progressInfo = new ExportImportProgressInfo();

            progressInfo.Description = String.Format("{0} stores importing...", backupObject.Stores.Count());
            progressCallback(progressInfo);

            UpdateStores(originalObject.Stores, backupObject.Stores);
        }
示例#20
0
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var prodgressInfo = new ExportImportProgressInfo {
                Description = "loading data..."
            };

            progressCallback(prodgressInfo);

            var backupObject   = backupStream.DeserializeJson <BackupObject>();
            var originalObject = GetBackupObject();

            UpdateOrders(originalObject.CustomerOrders, backupObject.CustomerOrders);
        }
        public void DoImport(Stream backupStream, Action<ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson<BackupObject>();
			var originalObject = GetBackupObject(progressCallback);

			var progressInfo = new ExportImportProgressInfo();
			progressInfo.Description = String.Format("{0} organizations importing...", backupObject.Organizations.Count());
			progressCallback(progressInfo);
            UpdateOrganizations(originalObject.Organizations, backupObject.Organizations);

			progressInfo.Description = String.Format("{0} contacts importing...", backupObject.Contacts.Count());
			progressCallback(progressInfo);
            UpdateContacts(originalObject.Contacts, backupObject.Contacts);
        }
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson <BackupObject>();

            progressCallback(new ExportImportProgressInfo("importing currencies"));
            if (backupObject.Currencies != null)
            {
                _commerceService.UpsertCurrencies(backupObject.Currencies);
            }
            progressCallback(new ExportImportProgressInfo("importing package types"));
            if (backupObject.PackageTypes != null)
            {
                _commerceService.UpsertPackageTypes(backupObject.PackageTypes);
            }
        }
		public void DoImport(Stream backupStream, Action<ExportImportProgressInfo> progressCallback)
		{
			var backupObject = backupStream.DeserializeJson<BackupObject>();
            progressCallback(new ExportImportProgressInfo("importing fulfillmentCenters"));
            if (backupObject.FulfillmentCenters != null)
            {
                backupObject.FulfillmentCenters.ForEach(x => _commerceService.UpsertFulfillmentCenter(x));
            }
            progressCallback(new ExportImportProgressInfo("imporing currencies"));
            if (backupObject.Currencies != null)
            {
                _commerceService.UpsertCurrencies(backupObject.Currencies);
            }

        }
示例#24
0
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson <BackupObject>();

            progressCallback(new ExportImportProgressInfo("importing fulfillmentCenters"));
            if (backupObject.FulfillmentCenters != null)
            {
                backupObject.FulfillmentCenters.ForEach(x => _commerceService.UpsertFulfillmentCenter(x));
            }
            progressCallback(new ExportImportProgressInfo("imporing currencies"));
            if (backupObject.Currencies != null)
            {
                _commerceService.UpsertCurrencies(backupObject.Currencies);
            }
        }
示例#25
0
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject   = backupStream.DeserializeJson <BackupObject>();
            var originalObject = GetBackupObject(progressCallback);

            var progressInfo = new ExportImportProgressInfo();

            progressInfo.Description = String.Format("{0} organizations importing...", backupObject.Organizations.Count());
            progressCallback(progressInfo);
            UpdateOrganizations(originalObject.Organizations, backupObject.Organizations);

            progressInfo.Description = String.Format("{0} contacts importing...", backupObject.Contacts.Count());
            progressCallback(progressInfo);
            UpdateContacts(originalObject.Contacts, backupObject.Contacts);
        }
示例#26
0
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson <BackupObject>();

            var progressInfo = new ExportImportProgressInfo();
            var totalCount   = backupObject.CustomerOrders.Count();
            var take         = 20;

            for (int skip = 0; skip < totalCount; skip += take)
            {
                _customerOrderService.SaveChanges(backupObject.CustomerOrders.Skip(skip).Take(take).ToArray());

                progressInfo.Description = String.Format("{0} of {1} orders imported", Math.Min(skip + take, totalCount), totalCount);
                progressCallback(progressInfo);
            }
        }
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject   = backupStream.DeserializeJson <BackupObject>();
            var originalObject = GetBackupObject(progressCallback);

            var progressInfo = new ExportImportProgressInfo();

            progressInfo.Description = String.Format("{0} promotions importing...", backupObject.Promotions.Count());
            progressCallback(progressInfo);
            _promotionService.SavePromotions(backupObject.Promotions.ToArray());

            progressInfo.Description = String.Format("{0} folders importing...", backupObject.ContentFolders.Count());
            progressCallback(progressInfo);
            _dynamicContentService.SaveFolders(backupObject.ContentFolders.ToArray());

            progressInfo.Description = String.Format("{0} places importing...", backupObject.ContentPlaces.Count());
            progressCallback(progressInfo);
            _dynamicContentService.SavePlaces(backupObject.ContentPlaces.ToArray());

            progressInfo.Description = String.Format("{0} contents importing...", backupObject.ContentItems.Count());
            progressCallback(progressInfo);
            _dynamicContentService.SaveContentItems(backupObject.ContentItems.ToArray());

            progressInfo.Description = String.Format("{0} publications importing...", backupObject.ContentPublications.Distinct().Count());
            progressCallback(progressInfo);
            _dynamicContentService.SavePublications(backupObject.ContentPublications.Distinct().ToArray());

            var pageSize     = 500;
            var couponsTotal = backupObject.Coupons.Count();

            Paginate(couponsTotal, pageSize, (x) =>
            {
                progressInfo.Description = String.Format($"{Math.Min(x * pageSize, couponsTotal)} of {couponsTotal} coupons imported");
                progressCallback(progressInfo);
                _couponService.SaveCoupons(backupObject.Coupons.Skip((x - 1) * pageSize).Take(pageSize).ToArray());
            });

            var usagesTotal = backupObject.Usages.Count();

            Paginate(usagesTotal, pageSize, (x) =>
            {
                progressInfo.Description = String.Format($"{Math.Min(x * pageSize, usagesTotal)} of {usagesTotal} usages imported");
                progressCallback(progressInfo);
                _usageService.SaveUsages(backupObject.Usages.Skip((x - 1) * pageSize).Take(pageSize).ToArray());
            });
        }
示例#28
0
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson <BackupObject>();

            progressCallback(new ExportImportProgressInfo($"The {backupObject.FulfillmentCenters.Count()} fulfilmentCenters are importing"));
            _fulfillmentCenterService.SaveChanges(backupObject.FulfillmentCenters);
            progressCallback(new ExportImportProgressInfo($"The {backupObject.FulfillmentCenters.Count()} fulfilmentCenters has been imported"));

            const int batchSize  = 50;
            var       totalCount = backupObject.InventoryInfos.Count();

            progressCallback(new ExportImportProgressInfo($"The {totalCount} inventories are importing"));
            for (int i = 0; i < totalCount; i += batchSize)
            {
                _inventoryService.UpsertInventories(backupObject.InventoryInfos.Skip(i).Take(batchSize));
                progressCallback(new ExportImportProgressInfo($"{i} of {totalCount} inventories records have been imported"));
            }
            progressCallback(new ExportImportProgressInfo("The inventory module data has been imported"));
        }
示例#29
0
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var prodgressInfo = new ExportImportProgressInfo {
                Description = "loading data..."
            };

            progressCallback(prodgressInfo);

            var backupObject   = backupStream.DeserializeJson <BackupObject>();
            var originalObject = GetBackupObject();

            UpdateContentFolders(originalObject.ContentFolders, backupObject.ContentFolders);
            UpdateContentPlaces(originalObject.ContentPlaces, backupObject.ContentPlaces);
            UpdateContentItems(originalObject.ContentItems, backupObject.ContentItems);
            UpdateContentPublications(originalObject.ContentPublications, backupObject.ContentPublications);

            ////UpdateCoupons(originalObject.Coupons, backupObject.Coupons);
            UpdatePromotions(originalObject.Promotions, backupObject.Promotions);
        }
示例#30
0
        public static async Task <T> ReadJsonAsync <T>(this HttpContent content)
        {
            Stream stream = null;

            try
            {
                stream = await content.ReadAsStreamAsync();

                var result = stream.DeserializeJson <T>();
                return(result);
            }
            finally
            {
                if (stream != null)
                {
                    stream.Dispose();
                }
            }
        }
        public void DoImport(Stream backupStream, PlatformExportManifest manifest, Action<ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson<BackupObject>();
            var originalObject = GetBackupObject(progressCallback, false);

            var progressInfo = new ExportImportProgressInfo();
            progressInfo.Description = String.Format("{0} menu link lists importing...", backupObject.MenuLinkLists.Count());
            progressCallback(progressInfo);
            UpdateMenuLinkLists(backupObject.MenuLinkLists);

            if (manifest.HandleBinaryData)
            {
                progressInfo.Description = String.Format("importing binary data:  themes and pages importing...");
                progressCallback(progressInfo);
                foreach (var folder in backupObject.ContentFolders)
                {
                    SaveContentFolderRecursive(folder);
                }
            }
        }
示例#32
0
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var prodgressInfo = new ExportImportProgressInfo {
                Description = "loading data..."
            };

            progressCallback(prodgressInfo);

            var backupObject   = backupStream.DeserializeJson <BackupObject>();
            var originalObject = GetBackupObject(progressCallback);

            UpdateCatalogs(originalObject.Catalogs, backupObject.Catalogs);

            //Categories should be sorted right way (because it have a hierarchy structure and links to virtual categories)
            backupObject.Categories = backupObject.Categories.Where(x => x.Links == null || !x.Links.Any())
                                      .OrderBy(x => x.Parents != null ? x.Parents.Count() : 0)
                                      .Concat(backupObject.Categories.Where(x => x.Links != null && x.Links.Any()))
                                      .ToList();
            UpdateCategories(originalObject.Categories, backupObject.Categories);
            UpdateProperties(originalObject.Properties, backupObject.Properties);
            UpdateCatalogProducts(originalObject.Products, backupObject.Products);
        }
		public void DoImport(Stream backupStream, PlatformExportManifest manifest, Action<ExportImportProgressInfo> progressCallback)
		{
			var backupObject = backupStream.DeserializeJson<BackupObject>();
			var originalObject = GetBackupObject(progressCallback, manifest.HandleBinaryData);

			var progressInfo = new ExportImportProgressInfo();
			progressInfo.Description = String.Format("{0} menu link lists importing...", backupObject.MenuLinkLists.Count());
			progressCallback(progressInfo);

			UpdateMenuLinkLists(originalObject.MenuLinkLists, backupObject.MenuLinkLists);
			if (manifest.HandleBinaryData)
			{
				progressInfo.Description = String.Format("importing binary data: {0} pages importing...", backupObject.Pages.Count());
				progressCallback(progressInfo);

				UpdatePages(originalObject.Pages, backupObject.Pages);

				progressInfo.Description = String.Format("importing binary data: {0} theme assets importing...", backupObject.ThemeAssets.Count());
				progressCallback(progressInfo);

				UpdateThemeAssets(originalObject.ThemeAssets, backupObject.ThemeAssets);
			}
		}
示例#34
0
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson <BackupObject>();
            var progressInfo = new ExportImportProgressInfo();

            progressInfo.Description = String.Format("{0} price lists importing...", backupObject.Pricelists.Count());
            progressCallback(progressInfo);

            _pricingService.SavePricelists(backupObject.Pricelists.ToArray());
            _pricingService.SavePricelistAssignments(backupObject.Assignments.ToArray());

            progressInfo.TotalCount = backupObject.Prices.Count();
            var chunkSize = 500;

            for (int i = 0; i <= backupObject.Prices.Count(); i += chunkSize)
            {
                var prices = backupObject.Prices.Skip(i).Take(chunkSize).ToArray();
                _pricingService.SavePrices(prices);
                progressInfo.ProcessedCount += prices.Count();
                progressInfo.Description     = string.Format("Prices: {0} of {1} importing...", progressInfo.ProcessedCount, progressInfo.TotalCount);
                progressCallback(progressInfo);
            }
        }
示例#35
0
        public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject = backupStream.DeserializeJson <BackupObject>();

            var progressInfo = new ExportImportProgressInfo();
            var totalCount   = backupObject.Subscriptions.Count();
            var take         = 20;

            for (int skip = 0; skip < totalCount; skip += take)
            {
                _subscriptionService.SaveSubscriptions(backupObject.Subscriptions.Skip(skip).Take(take).ToArray());
                progressInfo.Description = String.Format("{0} of {1} subscriptions imported", Math.Min(skip + take, totalCount), totalCount);
                progressCallback(progressInfo);
            }

            totalCount = backupObject.PaymentPlans.Count();
            for (int skip = 0; skip < totalCount; skip += take)
            {
                _paymentPlanService.SavePlans(backupObject.PaymentPlans.Skip(skip).Take(take).ToArray());
                progressInfo.Description = String.Format("{0} of {1} payment plans imported", Math.Min(skip + take, totalCount), totalCount);
                progressCallback(progressInfo);
            }
        }
        public void DoImport(Stream backupStream, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback)
        {
            var backupObject   = backupStream.DeserializeJson <BackupObject>();
            var originalObject = GetBackupObject(progressCallback, manifest.HandleBinaryData);

            var progressInfo = new ExportImportProgressInfo();

            progressInfo.Description = String.Format("{0} menu link lists importing...", backupObject.MenuLinkLists.Count());
            progressCallback(progressInfo);

            UpdateMenuLinkLists(originalObject.MenuLinkLists, backupObject.MenuLinkLists);
            if (manifest.HandleBinaryData)
            {
                progressInfo.Description = String.Format("importing binary data: {0} pages importing...", backupObject.Pages.Count());
                progressCallback(progressInfo);

                UpdatePages(originalObject.Pages, backupObject.Pages);

                progressInfo.Description = String.Format("importing binary data: {0} theme assets importing...", backupObject.ThemeAssets.Count());
                progressCallback(progressInfo);

                UpdateThemeAssets(originalObject.ThemeAssets, backupObject.ThemeAssets);
            }
        }
示例#37
0
        public void DoImport(Stream backupStream, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback)
        {
            var progressInfo = new ExportImportProgressInfo();

            var backupObject = backupStream.DeserializeJson <BackupObject>();

            foreach (var category in backupObject.Categories)
            {
                category.Catalog = backupObject.Catalogs.FirstOrDefault(x => x.Id == category.CatalogId);
                if (category.Parents != null)
                {
                    category.Level = category.Parents.Count();
                }
            }
            var originalObject = GetBackupObject(progressCallback, false);

            progressInfo.Description = String.Format("{0} catalogs importing...", backupObject.Catalogs.Count());
            progressCallback(progressInfo);

            UpdateCatalogs(originalObject.Catalogs, backupObject.Catalogs);

            progressInfo.Description = String.Format("{0} categories importing...", backupObject.Categories.Count());
            progressCallback(progressInfo);

            backupObject.Products = backupObject.Products.OrderBy(x => x.MainProductId).ToList();
            UpdateCategories(originalObject.Categories, backupObject.Categories);
            UpdateProperties(originalObject.Properties, backupObject.Properties);

            //Binary data
            if (manifest.HandleBinaryData)
            {
                var allBackupImages = backupObject.Products.SelectMany(x => x.Images);
                allBackupImages = allBackupImages.Concat(backupObject.Categories.SelectMany(x => x.Images));
                allBackupImages = allBackupImages.Concat(backupObject.Products.SelectMany(x => x.Variations).SelectMany(x => x.Images));

                var allOrigImages = originalObject.Products.SelectMany(x => x.Images);
                allOrigImages = allOrigImages.Concat(originalObject.Categories.SelectMany(x => x.Images));
                allOrigImages = allOrigImages.Concat(originalObject.Products.SelectMany(x => x.Variations).SelectMany(x => x.Images));
                //Import only new images
                var allNewImages     = allBackupImages.Where(x => !allOrigImages.Contains(x));
                var index            = 0;
                var progressTemplate = "{0} of " + allNewImages.Count() + " images uploading";
                foreach (var image in allNewImages)
                {
                    progressInfo.Description = String.Format(progressTemplate, index);
                    progressCallback(progressInfo);
                    try
                    {
                        //do not save images with external url
                        if (image.Url != null && !image.Url.IsAbsoluteUrl())
                        {
                            using (var sourceStream = new MemoryStream(image.BinaryData))
                                using (var targetStream = _blobStorageProvider.OpenWrite(image.Url))
                                {
                                    sourceStream.CopyTo(targetStream);
                                }
                        }
                    }
                    catch (Exception ex)
                    {
                        progressInfo.Errors.Add(String.Format("{0}: {1}", "CatalogModule", ex.ExpandExceptionMessage()));
                        progressCallback(progressInfo);
                    }

                    index++;
                }
            }

            progressInfo.Description = String.Format("{0} products importing...", backupObject.Products.Count());
            progressCallback(progressInfo);
            UpdateCatalogProducts(originalObject.Products, backupObject.Products);
        }
示例#38
0
 public static T DeserializeJson <T>(this Stream stream) where T : class, new()
 {
     return(stream.DeserializeJson <T>(GetDefaultSerializer()));
 }
		public void DoImport(Stream backupStream, Action<ExportImportProgressInfo> progressCallback)
		{
			var prodgressInfo = new ExportImportProgressInfo { Description = "loading data..." };
			progressCallback(prodgressInfo);

			var backupObject = backupStream.DeserializeJson<BackupObject>();
			var originalObject = GetBackupObject(progressCallback);

			UpdateCatalogs(originalObject.Catalogs, backupObject.Catalogs);

			//Categories should be sorted right way (because it have a hierarchy structure and links to virtual categories)
			backupObject.Categories = backupObject.Categories.Where(x => x.Links == null || !x.Links.Any())
															.OrderBy(x => x.Parents != null ? x.Parents.Count() : 0)
															.Concat(backupObject.Categories.Where(x => x.Links != null && x.Links.Any()))
															.ToList();
			UpdateCategories(originalObject.Categories, backupObject.Categories);
			UpdateProperties(originalObject.Properties, backupObject.Properties);
			UpdateCatalogProducts(originalObject.Products, backupObject.Products);


		}
        public void DoImport(Stream backupStream, PlatformExportManifest manifest, Action<ExportImportProgressInfo> progressCallback)
        {
            var progressInfo = new ExportImportProgressInfo();

            var backupObject = backupStream.DeserializeJson<BackupObject>();
            foreach(var category in backupObject.Categories)
            {
                category.Catalog = backupObject.Catalogs.FirstOrDefault(x => x.Id == category.CatalogId);
                if(category.Parents != null)
                {
                    category.Level = category.Parents.Count();
                }
            }
            var originalObject = GetBackupObject(progressCallback, false);

            progressInfo.Description = String.Format("{0} catalogs importing...", backupObject.Catalogs.Count());
            progressCallback(progressInfo);

            UpdateCatalogs(originalObject.Catalogs, backupObject.Catalogs);

            progressInfo.Description = String.Format("{0} categories importing...", backupObject.Categories.Count());
            progressCallback(progressInfo);
          
            backupObject.Products = backupObject.Products.OrderBy(x => x.MainProductId).ToList();
            UpdateCategories(originalObject.Categories, backupObject.Categories);
            UpdateProperties(originalObject.Properties, backupObject.Properties);

            //Binary data
            if (manifest.HandleBinaryData)
            {
                var allBackupImages = backupObject.Products.SelectMany(x => x.Images);
                allBackupImages = allBackupImages.Concat(backupObject.Categories.SelectMany(x => x.Images));
                allBackupImages = allBackupImages.Concat(backupObject.Products.SelectMany(x => x.Variations).SelectMany(x => x.Images));

                var allOrigImages = originalObject.Products.SelectMany(x => x.Images);
                allOrigImages = allOrigImages.Concat(originalObject.Categories.SelectMany(x => x.Images));
                allOrigImages = allOrigImages.Concat(originalObject.Products.SelectMany(x => x.Variations).SelectMany(x => x.Images));
                //Import only new images
                var allNewImages = allBackupImages.Where(x => !allOrigImages.Contains(x));
                var index = 0;
                var progressTemplate = "{0} of " + allNewImages.Count() + " images uploading";
                foreach (var image in allNewImages)
                {
                    progressInfo.Description = String.Format(progressTemplate, index);
                    progressCallback(progressInfo);
                    try
                    {
                        //do not save images with external url
                        if (image.Url != null && !image.Url.IsAbsoluteUrl())
                        {
                            using (var sourceStream = new MemoryStream(image.BinaryData))
                            using (var targetStream = _blobStorageProvider.OpenWrite(image.Url))
                            {
                                sourceStream.CopyTo(targetStream);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        progressInfo.Errors.Add(String.Format("{0}: {1}", "CatalogModule", ex.ExpandExceptionMessage()));
                        progressCallback(progressInfo);
                    }

                    index++;
                }
            }

            progressInfo.Description = String.Format("{0} products importing...", backupObject.Products.Count());
            progressCallback(progressInfo);
            UpdateCatalogProducts(originalObject.Products, backupObject.Products);
        }
示例#41
0
        public void DoImport(Stream backupStream, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback)
        {
            var progressInfo = new ExportImportProgressInfo();

            var backupObject = backupStream.DeserializeJson <BackupObject>();

            foreach (var category in backupObject.Categories)
            {
                category.Catalog = backupObject.Catalogs.FirstOrDefault(x => x.Id == category.CatalogId);
                if (category.Parents != null)
                {
                    category.Level = category.Parents.Count();
                }
            }
            var originalObject = GetBackupObject(progressCallback, false);

            progressInfo.Description = String.Format("{0} catalogs importing...", backupObject.Catalogs.Count());
            progressCallback(progressInfo);

            UpdateCatalogs(originalObject.Catalogs, backupObject.Catalogs);

            progressInfo.Description = String.Format("{0} categories importing...", backupObject.Categories.Count());
            progressCallback(progressInfo);
            //Categories should be sorted right way
            //first need to create virtual categories
            var orderedCategories = backupObject.Categories.Where(x => x.Catalog.Virtual)
                                    .OrderBy(x => x.Level)
                                    .ToList();

            //second need to create physical categories
            orderedCategories.AddRange(backupObject.Categories.Where(x => !x.Catalog.Virtual)
                                       .OrderBy(x => x.Level));

            backupObject.Products = backupObject.Products.OrderBy(x => x.MainProductId).ToList();
            UpdateCategories(originalObject.Categories, orderedCategories);
            UpdateProperties(originalObject.Properties, backupObject.Properties);

            //Binary data
            if (manifest.HandleBinaryData)
            {
                var allBackupImages = backupObject.Products.SelectMany(x => x.Images);
                allBackupImages = allBackupImages.Concat(backupObject.Categories.SelectMany(x => x.Images));
                allBackupImages = allBackupImages.Concat(backupObject.Products.SelectMany(x => x.Variations).SelectMany(x => x.Images));

                var allOrigImages = originalObject.Products.SelectMany(x => x.Images);
                allOrigImages = allOrigImages.Concat(originalObject.Categories.SelectMany(x => x.Images));
                allOrigImages = allOrigImages.Concat(originalObject.Products.SelectMany(x => x.Variations).SelectMany(x => x.Images));

                var allNewImages     = allBackupImages.Where(x => !allOrigImages.Contains(x)).Where(x => x.BinaryData != null);
                var index            = 0;
                var progressTemplate = "{0} of " + allNewImages.Count() + " images uploading";
                foreach (var image in allNewImages)
                {
                    progressInfo.Description = String.Format(progressTemplate, index);
                    progressCallback(progressInfo);
                    image.Url = "catalog/" + image.Name;
                    using (var sourceStream = new MemoryStream(image.BinaryData))
                        using (var targetStream = _blobStorageProvider.OpenWrite(image.Url))
                        {
                            sourceStream.CopyTo(targetStream);
                        }

                    index++;
                }
            }

            progressInfo.Description = String.Format("{0} products importing...", backupObject.Products.Count());
            progressCallback(progressInfo);
            UpdateCatalogProducts(originalObject.Products, backupObject.Products);
        }