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 DoExport(Stream backupStream, Action<ExportImportProgressInfo> progressCallback) { var prodgressInfo = new ExportImportProgressInfo { Description = "loading data..." }; progressCallback(prodgressInfo); var backupObject = GetBackupObject(); backupObject.SerializeJson(backupStream); }
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); }
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()); }
private BackupObject GetBackupObject(Action<ExportImportProgressInfo> progressCallback) { var progressInfo = new ExportImportProgressInfo("stores loading..."); progressCallback(progressInfo); return new BackupObject { Stores = _storeService.SearchStores(new SearchCriteria { Take = int.MaxValue }).Stores }; }
private BackupObject GetBackupObject(Action<ExportImportProgressInfo> progressCallback) { var progressInfo = new ExportImportProgressInfo("stores loading..."); progressCallback(progressInfo); return new BackupObject { Stores = _storeService.GetStoreList().Select(x => x.Id).Select(x => _storeService.GetById(x)).ToArray() }; }
private BackupObject GetBackupObject(Action<ExportImportProgressInfo> progressCallback) { var allPricelistIds = _pricingService.GetPriceLists().Select(x => x.Id); var progressInfo = new ExportImportProgressInfo { Description = String.Format("{0} price lists loading..." , allPricelistIds.Count())}; progressCallback(progressInfo); return new BackupObject { Pricelists = allPricelistIds.Select(x => _pricingService.GetPricelistById(x)).ToList() }; }
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 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 ProgressNotifier(string notifyPattern, int totalCount, Action<ExportImportProgressInfo> progressCallback) { _notifyPattern = notifyPattern; _progressCallback = progressCallback; _progressInfo = new ExportImportProgressInfo { TotalCount = totalCount, Description = String.Format(notifyPattern, totalCount, 0), ProcessedCount = 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()); }
public void DoExport(Stream backupStream, Action<ExportImportProgressInfo> progressCallback) { var prodgressInfo = new ExportImportProgressInfo { Description = "loading data..." }; progressCallback(prodgressInfo); var backupObject = GetBackupObject(); //Remove from backup non active methods backupObject.Stores.ForEach(x => x.PaymentMethods = x.PaymentMethods.Where(s => s.IsActive).ToList()); backupObject.Stores.ForEach(x => x.ShippingMethods = x.ShippingMethods.Where(s => s.IsActive).ToList()); backupObject.SerializeJson(backupStream); }
public BackupObject GetBackupObject(Action<ExportImportProgressInfo> progressCallback) { var progressInfo = new ExportImportProgressInfo(); progressInfo.Description = "loading members..."; progressCallback(progressInfo); var members = _memberSearchService.SearchMembers(new MembersSearchCriteria { DeepSearch = true, Take = int.MaxValue }).Members; var result = new BackupObject(); result.Members = _memberService.GetByIds(members.Select(x => x.Id).ToArray()).OrderByDescending(x=> x.MemberType).ToArray(); return result; }
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); }
private BackupObject GetBackupObject(Action<ExportImportProgressInfo> progressCallback) { var retVal = new BackupObject(); var progressInfo = new ExportImportProgressInfo(); var searchResponse = _quoteRequestService.Search(new QuoteRequestSearchCriteria { Count = int.MaxValue }); progressInfo.Description = String.Format("{0} RFQs loading", searchResponse.QuoteRequests.Count()); progressCallback(progressInfo); retVal.QuoteRequests = _quoteRequestService.GetByIds(searchResponse.QuoteRequests.Select(x => x.Id).ToArray()).ToList(); return retVal; }
private BackupObject GetBackupObject(Action<ExportImportProgressInfo> progressCallback) { var retVal = new BackupObject(); var progressInfo = new ExportImportProgressInfo(); const CustomerOrderResponseGroup responseGroup = CustomerOrderResponseGroup.WithAddresses | CustomerOrderResponseGroup.WithItems | CustomerOrderResponseGroup.WithShipments | CustomerOrderResponseGroup.WithInPayments; var searchResponse = _customerOrderSearchService.Search(new SearchCriteria { Count = int.MaxValue }); progressInfo.Description = String.Format("{0} orders loading", searchResponse.CustomerOrders.Count()); progressCallback(progressInfo); retVal.CustomerOrders = searchResponse.CustomerOrders.Select((x) => _customerOrderService.GetById(x.Id, responseGroup)).ToList(); return retVal; }
public void DoImport(Stream inputStream, CsvImportInfo importInfo, Action<ExportImportProgressInfo> progressCallback) { var csvProducts = new List<CsvProduct>(); var progressInfo = new ExportImportProgressInfo { Description = "Reading products from csv..." }; progressCallback(progressInfo); using (var reader = new CsvReader(new StreamReader(inputStream))) { reader.Configuration.Delimiter = importInfo.Configuration.Delimiter; reader.Configuration.RegisterClassMap(new CsvProductMap(importInfo.Configuration)); reader.Configuration.WillThrowOnMissingField = false; while (reader.Read()) { try { var csvProduct = reader.GetRecord<CsvProduct>(); csvProducts.Add(csvProduct); } catch (Exception ex) { var error = ex.Message; if (ex.Data.Contains("CsvHelper")) { error += ex.Data["CsvHelper"]; } progressInfo.Errors.Add(error); progressCallback(progressInfo); } } } var catalog = _catalogService.GetById(importInfo.CatalogId); SaveCategoryTree(catalog, csvProducts, progressInfo, progressCallback); SaveProducts(catalog, csvProducts, progressInfo, progressCallback); }
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); } } }
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); } }
private BackupObject GetBackupObject(Action<ExportImportProgressInfo> progressCallback, bool handleBynaryData) { var progressInfo = new ExportImportProgressInfo(); progressInfo.Description = "cms content loading..."; progressCallback(progressInfo); var stores = _storeService.GetStoreList(); var menuLinkLists = new List<MenuLinkList>(); var contentItems = new List<coreModels.ThemeAsset>(); var contentPages = new List<coreModels.Page>(); foreach(var store in stores) { var storeLists = _menuService.GetListsByStoreId(store.Id); menuLinkLists.AddRange(storeLists.Select(s => ConvertToExportModel(s))); if (handleBynaryData) { var storePages = _pagesService.GetPages(store.Id, null); contentPages.AddRange(storePages); var storeThemes = _themeService.GetThemes(store.Id).ToArray(); foreach (var storeTheme in storeThemes) { var themeContentItems = _themeService.GetThemeAssets(store.Id, storeTheme.Name, null).ToArray(); contentItems.AddRange(themeContentItems); } } } return new BackupObject { MenuLinkLists = menuLinkLists, ThemeAssets = contentItems, Pages = contentPages }; }
public void DoExport(Stream outStream, CsvExportInfo exportInfo, Action<ExportImportProgressInfo> progressCallback) { var prodgressInfo = new ExportImportProgressInfo { Description = "loading products..." }; var streamWriter = new StreamWriter(outStream, Encoding.UTF8, 1024, true); streamWriter.AutoFlush = true; using (var csvWriter = new CsvWriter(streamWriter)) { //Notification progressCallback(prodgressInfo); //Load all products to export var products = LoadProducts(exportInfo.CatalogId, exportInfo.CategoryIds, exportInfo.ProductIds); var allProductIds = products.Select(x => x.Id).ToArray(); //Load prices for products var allProductPrices = new List<Price>(); prodgressInfo.Description = "loading prices..."; progressCallback(prodgressInfo); var priceEvalContext = new PriceEvaluationContext { ProductIds = allProductIds, PricelistIds = exportInfo.PriceListId == null ? null : new string[] { exportInfo.PriceListId }, Currency = exportInfo.Currency }; allProductPrices = _pricingService.EvaluateProductPrices(priceEvalContext).ToList(); //Load inventories var allProductInventories = new List<InventoryInfo>(); prodgressInfo.Description = "loading inventory information..."; progressCallback(prodgressInfo); allProductInventories = _inventoryService.GetProductsInventoryInfos(allProductIds).Where(x => exportInfo.FulfilmentCenterId == null ? true : x.FulfillmentCenterId == exportInfo.FulfilmentCenterId).ToList(); //Export configuration exportInfo.Configuration.PropertyCsvColumns = products.SelectMany(x => x.PropertyValues).Select(x => x.PropertyName).Distinct().ToArray(); csvWriter.Configuration.Delimiter = exportInfo.Configuration.Delimiter; csvWriter.Configuration.RegisterClassMap(new CsvProductMap(exportInfo.Configuration)); //Write header csvWriter.WriteHeader<CsvProduct>(); prodgressInfo.TotalCount = products.Count(); var notifyProductSizeLimit = 50; var counter = 0; foreach (var product in products) { try { var csvProduct = new CsvProduct(product, _blobUrlResolver, allProductPrices.FirstOrDefault(x => x.ProductId == product.Id), allProductInventories.FirstOrDefault(x => x.ProductId == product.Id)); csvWriter.WriteRecord(csvProduct); } catch (Exception ex) { prodgressInfo.Errors.Add(ex.ToString()); progressCallback(prodgressInfo); } //Raise notification each notifyProductSizeLimit products counter++; prodgressInfo.ProcessedCount = counter; prodgressInfo.Description = string.Format("{0} of {1} products processed", prodgressInfo.ProcessedCount, prodgressInfo.TotalCount); if (counter % notifyProductSizeLimit == 0 || counter == prodgressInfo.TotalCount) { progressCallback(prodgressInfo); } } } }
public BackupObject GetBackupObject(Action<ExportImportProgressInfo> progressCallback) { var progressInfo = new ExportImportProgressInfo(); progressInfo.Description = "loading organizations and contacts..."; progressCallback(progressInfo); var rootOrganization = GetOrganizations(null); var organizations = rootOrganization != null ? rootOrganization.Traverse(ChildrenForOrganization).ToArray() : null; var result = new BackupObject(); if (organizations != null) { result.Contacts = organizations.SelectMany(x => x.Contacts).Select(x => _contactService.GetById(x.Id)).ToArray(); result.Organizations = organizations.SelectMany(x => x.Organizations).Select(x=> _organizationService.GetById(x.Id)).ToArray(); } return result; }
private BackupObject GetBackupObject(Action<ExportImportProgressInfo> progressCallback, bool handleBynaryData) { var retVal = new BackupObject(); var progressInfo = new ExportImportProgressInfo(); progressInfo.Description = "cms content loading..."; progressCallback(progressInfo); retVal.MenuLinkLists = _menuService.GetAllLinkLists().Select(x => x.ToWebModel()).ToList(); if (handleBynaryData) { var result = _contentStorageProvider.Search("/", null); foreach (var blobFolder in result.Folders.Where(x => _exportedFolders.Contains(x.Name))) { var contentFolder = new ContentFolder { Url = blobFolder.Url }; ReadContentFoldersRecurive(contentFolder); retVal.ContentFolders.Add(contentFolder); } } return retVal; }
private BackupObject GetBackupObject(Action<ExportImportProgressInfo> progressCallback, bool loadBinaryData) { var progressInfo = new ExportImportProgressInfo { Description = "loading data..." }; progressCallback(progressInfo); const ResponseGroup responseGroup = ResponseGroup.WithCatalogs | ResponseGroup.WithCategories | ResponseGroup.WithProducts; var searchResponse = _catalogSearchService.Search(new SearchCriteria { Count = int.MaxValue, GetAllCategories = true, Start = 0, ResponseGroup = responseGroup }); var retVal = new BackupObject(); progressInfo.Description = String.Format("{0} catalogs loading", searchResponse.Catalogs.Count()); progressCallback(progressInfo); //Catalogs retVal.Catalogs = searchResponse.Catalogs.Select(x => _catalogService.GetById(x.Id)).ToList(); progressInfo.Description = String.Format("{0} categories loading", searchResponse.Categories.Count()); progressCallback(progressInfo); //Categories retVal.Categories = searchResponse.Categories.Select(x => _categoryService.GetById(x.Id)).ToList(); //Products for (int i = 0; i < searchResponse.Products.Count(); i += 50) { var products = _itemService.GetByIds(searchResponse.Products.Skip(i).Take(50).Select(x => x.Id).ToArray(), ItemResponseGroup.ItemMedium | ItemResponseGroup.Variations | ItemResponseGroup.Seo); retVal.Products.AddRange(products); progressInfo.Description = String.Format("{0} of {1} products loaded", Math.Min(searchResponse.TotalCount, i), searchResponse.TotalCount); progressCallback(progressInfo); } //Binary data if (loadBinaryData) { var allImages = retVal.Products.SelectMany(x => x.Images); allImages = allImages.Concat(retVal.Categories.SelectMany(x => x.Images)); allImages = allImages.Concat(retVal.Products.SelectMany(x => x.Variations).SelectMany(x => x.Images)); var index = 0; var progressTemplate = "{0} of " + allImages.Count() + " images downloading"; foreach (var image in allImages) { progressInfo.Description = String.Format(progressTemplate, index); progressCallback(progressInfo); try { image.BinaryData = _blobStorageProvider.OpenReadOnly(image.Url).ReadFully(); } catch(Exception ex) { progressInfo.Errors.Add(ex.ToString()); progressCallback(progressInfo); } index++; } } //Properties var catalogsPropertiesIds = retVal.Catalogs.SelectMany(x => _propertyService.GetCatalogProperties(x.Id)).Select(x => x.Id).ToArray(); var categoriesPropertiesIds = retVal.Categories.SelectMany(x => _propertyService.GetCategoryProperties(x.Id)).Select(x => x.Id).ToArray(); var propertiesIds = catalogsPropertiesIds.Concat(categoriesPropertiesIds).Distinct().ToArray(); progressInfo.Description = String.Format("{0} properties loading", propertiesIds.Count()); progressCallback(progressInfo); retVal.Properties = propertiesIds.Select(x => _propertyService.GetById(x)).ToList(); return retVal; }
private void ReadContentFoldersRecurive(ContentFolder folder, Action<ExportImportProgressInfo> progressCallback) { var result = _contentStorageProvider.Search(folder.Url, null); foreach (var blobFolder in result.Folders) { //Do not export default theme its will distributed with code if (blobFolder.Url != "/Themes/default") { var contentFolder = new ContentFolder() { Url = blobFolder.Url }; ReadContentFoldersRecurive(contentFolder, progressCallback); folder.Folders.Add(contentFolder); } } foreach (var blobItem in result.Items) { var progressInfo = new ExportImportProgressInfo(); progressInfo.Description = String.Format("Read {0}", blobItem.Url); progressCallback(progressInfo); var contentFile = new ContentFile { Url = blobItem.Url }; using (var stream = _contentStorageProvider.OpenRead(blobItem.Url)) { contentFile.Data = stream.ReadFully(); } folder.Files.Add(contentFile); } }
private void ExportModulesInternal(Package package, PlatformExportManifest manifest, Action<ExportImportProgressInfo> progressCallback) { var progressInfo = new ExportImportProgressInfo(); foreach (var module in manifest.Modules) { var moduleDescriptor = InnerGetModulesWithInterface(typeof(ISupportExportImportModule)).FirstOrDefault(x => x.Id == module.Id); if (moduleDescriptor != null) { //Create part for module var modulePartUri = PackUriHelper.CreatePartUri(new Uri(module.Id + ".json", UriKind.Relative)); var modulePart = package.CreatePart(modulePartUri, System.Net.Mime.MediaTypeNames.Application.Octet, CompressionOption.Normal); Action<ExportImportProgressInfo> modulePorgressCallback = (x) => { progressInfo.Description = String.Format("{0}: {1}", module.Id, x.Description); progressCallback(progressInfo); }; progressInfo.Description = String.Format("{0}: exporting...", module.Id); progressCallback(progressInfo); try { ((ISupportExportImportModule)moduleDescriptor.ModuleInfo.ModuleInstance).DoExport(modulePart.GetStream(), manifest, modulePorgressCallback); } catch (Exception ex) { progressInfo.Errors.Add(ex.ExpandExceptionMessage()); progressCallback(progressInfo); } module.PartUri = modulePartUri.ToString(); } } }
private void ImportModulesInternal(Package package, PlatformExportManifest manifest, Action<ExportImportProgressInfo> progressCallback) { var progressInfo = new ExportImportProgressInfo(); foreach (var moduleInfo in manifest.Modules) { var moduleDescriptor = InnerGetModulesWithInterface(typeof(ISupportExportImportModule)).FirstOrDefault(x => x.Id == moduleInfo.Id); if (moduleDescriptor != null) { var modulePart = package.GetPart(new Uri(moduleInfo.PartUri, UriKind.Relative)); using (var modulePartStream = modulePart.GetStream()) { Action<ExportImportProgressInfo> modulePorgressCallback = (x) => { progressInfo.Description = String.Format("{0}: {1}", moduleInfo.Id, x.Description); progressCallback(progressInfo); }; try { ((ISupportExportImportModule)moduleDescriptor.ModuleInfo.ModuleInstance).DoImport(modulePartStream, manifest, modulePorgressCallback); } catch (Exception ex) { progressInfo.Errors.Add(ex.ExpandExceptionMessage()); progressCallback(progressInfo); } } } } }
private void ExportPlatformEntriesInternal(Package package, PlatformExportManifest manifest, Action<ExportImportProgressInfo> progressCallback) { var progressInfo = new ExportImportProgressInfo(); var platformExportObj = new PlatformExportEntries(); if (manifest.HandleSecurity) { //Roles platformExportObj.Roles = _roleManagementService.SearchRoles(new RoleSearchRequest { SkipCount = 0, TakeCount = int.MaxValue }).Roles; //users var usersResult = _securityService.SearchUsersAsync(new UserSearchRequest { TakeCount = int.MaxValue }).Result; progressInfo.Description = String.Format("Security: {0} users exporting...", usersResult.Users.Count()); progressCallback(progressInfo); foreach (var user in usersResult.Users) { platformExportObj.Users.Add(_securityService.FindByIdAsync(user.Id, UserDetails.Export).Result); } } //Export setting for selected modules if (manifest.HandleSettings) { progressInfo.Description = String.Format("Settings: selected modules settings exporting..."); progressCallback(progressInfo); platformExportObj.Settings = manifest.Modules.SelectMany(x => _settingsManager.GetModuleSettings(x.Id)).ToList(); } //Dynamic properties var allTypes = _dynamicPropertyService.GetAvailableObjectTypeNames(); progressInfo.Description = String.Format("Dynamic properties: load properties..."); progressCallback(progressInfo); platformExportObj.DynamicProperties = allTypes.SelectMany(x => _dynamicPropertyService.GetProperties(x)).ToList(); platformExportObj.DynamicPropertyDictionaryItems = platformExportObj.DynamicProperties.Where(x => x.IsDictionary).SelectMany(x => _dynamicPropertyService.GetDictionaryItems(x.Id)).ToList(); //Create part for platform entries var platformEntiriesPart = package.CreatePart(_platformEntriesPartUri, System.Net.Mime.MediaTypeNames.Application.Octet, CompressionOption.Normal); using (var partStream = platformEntiriesPart.GetStream()) { platformExportObj.SerializeJson<PlatformExportEntries>(partStream); } }
private void ImportPlatformEntriesInternal(Package package, PlatformExportManifest manifest, Action<ExportImportProgressInfo> progressCallback) { var progressInfo = new ExportImportProgressInfo(); var platformEntriesPart = package.GetPart(_platformEntriesPartUri); if (platformEntriesPart != null) { PlatformExportEntries platformEntries; using (var stream = platformEntriesPart.GetStream()) { platformEntries = stream.DeserializeJson<PlatformExportEntries>(); } //Import security objects if (manifest.HandleSecurity) { progressInfo.Description = String.Format("Import {0} users with roles...", platformEntries.Users.Count()); progressCallback(progressInfo); //First need import roles foreach (var role in platformEntries.Roles) { _roleManagementService.AddOrUpdateRole(role); } //Next create or update users foreach (var user in platformEntries.Users) { if (_securityService.FindByIdAsync(user.Id, UserDetails.Reduced).Result != null) { _securityService.UpdateAsync(user); } else { _securityService.CreateAsync(user); } } } //Import dynamic properties _dynamicPropertyService.SaveProperties(platformEntries.DynamicProperties.ToArray()); foreach (var propDicGroup in platformEntries.DynamicPropertyDictionaryItems.GroupBy(x => x.PropertyId)) { _dynamicPropertyService.SaveDictionaryItems(propDicGroup.Key, propDicGroup.ToArray()); } //Import modules settings if (manifest.HandleSettings) { foreach (var module in manifest.Modules) { _settingsManager.SaveSettings(platformEntries.Settings.Where(x => x.ModuleId == module.Id).ToArray()); } } } }
public void Import(Stream stream, PlatformExportManifest manifest, Action<ExportImportProgressInfo> progressCallback) { if (manifest == null) { throw new ArgumentNullException("manifest"); } var progressInfo = new ExportImportProgressInfo(); progressInfo.Description = "Starting platform import..."; progressCallback(progressInfo); using (var package = ZipPackage.Open(stream, FileMode.Open)) { //Import selected platform entries ImportPlatformEntriesInternal(package, manifest, progressCallback); //Import selected modules ImportModulesInternal(package, manifest, progressCallback); } }